#include <glib/gi18n.h>

#include <dbus/dbus-glib.h>

#include <libupower-glib/upower.h>

#include "gpm-button.h"

UpClient *client;

GpmBrightness *brightness;

GpmButton *button;

GtkWidget *popup;

GpmControl *control;

GpmDpms *dpms;

return FALSE;

}

if (do_laptop_lcd == FALSE) {

egg_warning ("policy is no dimming");

return FALSE;

NULL);

/* reduce if on battery power if we should */

if (on_battery && battery_reduce) {

if (value > 100) {

egg_warning ("cannot use battery brightness value %i, correcting to 50", value);

value = 50;

/* reduce if system is momentarily idle */

if (!on_battery)

else

if (enable_action && backlight->priv->system_is_idle) {

if (value > 100) {

egg_warning ("cannot use idle brightness value %i, correcting to 50", value);

value = 50;

}

/**

*

**/

static void

{

gboolean on_battery;

/* get battery status */

g_object_get (backlight->priv->client,

"on-battery", &on_battery,

NULL);

gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);

gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);

gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);

gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->priv->idle_dim_timeout);

} else {

}

}

gboolean hw_changed;

egg_debug ("Button press event type=%s", type);

/* go up one step */

ret = gpm_brightness_up (backlight->priv->brightness, &hw_changed);

egg_debug ("emitting brightness-changed : %i", percentage);

g_signal_emit (backlight, signals [BRIGHTNESS_CHANGED], 0, percentage);

}

/* go up down step */

ret = gpm_brightness_down (backlight->priv->brightness, &hw_changed);

egg_debug ("emitting brightness-changed : %i", percentage);

g_signal_emit (backlight, signals [BRIGHTNESS_CHANGED], 0, percentage);

}

/* make sure we undim when we lift the lid */

gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);

if (elapsed > 2*60) {

/* reset back to our default dimming */

backlight->priv->idle_dim_timeout =

egg_debug ("resetting idle dim time to %is", backlight->priv->idle_dim_timeout);

gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->priv->idle_dim_timeout);

}

gboolean ret;

GError *error = NULL;

gboolean on_battery;

GpmDpmsMode dpms_mode;

/* don't dim or undim the screen when the lid is closed */

"on-battery", &on_battery,

NULL);

if (!on_battery)

else

/* check if method is valid */

if (dpms_mode == GPM_DPMS_MODE_UNKNOWN || dpms_mode == GPM_DPMS_MODE_ON) {

dpms_mode = GPM_DPMS_MODE_OFF;

}

g_error_free (error);

}

}

}

g_object_unref (backlight->priv->dpms);

g_object_unref (backlight->priv->control);

g_object_unref (backlight->priv->client);

g_object_unref (backlight->priv->button);

g_object_unref (backlight->priv->idle);

backlight->priv->can_dim = gpm_brightness_has_hw (backlight->priv->brightness);

/* watch for dim value changes */

/* set the main brightness, this is designed to be updated if the user changes the

* brightness so we can undim to the 'correct' value */

/* watch for brightness up and down buttons and also check lid state */

backlight->priv->button = gpm_button_new ();

/* assumption */

backlight->priv->system_is_idle = FALSE;

gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->priv->idle_dim_timeout);

/* use a visual widget */

}

/**

* gpm_help_display:

* @link_id: Subsection of mate-power-manager help section

**/

#define GPM_NAME _("Power Manager")

#define GPM_DESCRIPTION _("Power Manager for the MATE desktop")

/* actions */

/* backlight stuff */

/* buttons */

/* general */

/* lock */

/* disks */

/* notify */

/* thresholds */

/* timeout */

/* ui */

typedef enum {

GPM_ICON_POLICY_ALWAYS,

} GpmActionPolicy;

gchar *gpm_get_timestring (guint time);

void gpm_help_display (const gchar *link_id);

#ifdef EGG_TEST

void gpm_common_test (gpointer data);

struct GpmControlPrivate

{

MateConfClient *conf;

UpClient *client;

};

/**

* gpm_control_get_lock_policy:

* @control: This class instance

*

* This function finds out if we should lock the screen when we do an

* action. It is required as we can either use the mate-screensaver policy

{

gboolean do_lock;

gboolean use_ss_setting;

with a system default set in mate-screensaver.

See bug #331164 for all the juicy details. :-) */

if (use_ss_setting) {

egg_debug ("Using ScreenSaver settings (%i)", do_lock);

} else {

egg_debug ("Using custom locking settings (%i)", do_lock);

}

return do_lock;

}

/* we should perhaps lock keyrings when sleeping #375681 */

if (lock_mate_keyring) {

keyres = mate_keyring_lock_all_sync ();

if (keyres != MATE_KEYRING_RESULT_OK)

egg_warning ("could not lock keyring");

}

if (do_lock) {

throttle_cookie = gpm_screensaver_add_throttle (screensaver, "suspend");

gpm_screensaver_lock (screensaver);

}

if (nm_sleep)

gpm_networkmanager_sleep ();

gpm_screensaver_remove_throttle (screensaver, throttle_cookie);

}

if (nm_sleep)

gpm_networkmanager_wake ();

}

/* we should perhaps lock keyrings when sleeping #375681 */

if (lock_mate_keyring) {

keyres = mate_keyring_lock_all_sync ();

if (keyres != MATE_KEYRING_RESULT_OK) {

}

}

if (do_lock) {

throttle_cookie = gpm_screensaver_add_throttle (screensaver, "hibernate");

gpm_screensaver_lock (screensaver);

}

if (nm_sleep)

gpm_networkmanager_sleep ();

gpm_screensaver_remove_throttle (screensaver, throttle_cookie);

}

if (nm_sleep)

gpm_networkmanager_wake ();

control = GPM_CONTROL (object);

g_object_unref (control->priv->conf);

g_object_unref (control->priv->client);

g_return_if_fail (control->priv != NULL);

control->priv = GPM_CONTROL_GET_PRIVATE (control);

control->priv->client = up_client_new ();

control->priv->conf = mateconf_client_get_default ();

}

}

/**

* gpm_dpms_set_mode:

**/

gboolean

gboolean gpm_dpms_set_mode (GpmDpms *dpms,

GpmDpmsMode mode,

GError **error);

void gpm_dpms_test (gpointer data);

G_END_DECLS

#include <string.h>

#include <glib.h>

#include <glib/gi18n.h>

#include <libupower-glib/upower.h>

#include "egg-debug.h"

struct GpmEnginePrivate

{

UpClient *client;

UpDevice *battery_composite;

GPtrArray *array;

}

/**

**/

static void

{

/* do we want to display the icon in the tray */

/* perhaps change icon */

gpm_engine_recalculate_state_icon (engine);

if (capacity < 1.0f)

return FALSE;

if (ret) {

egg_debug ("** EMIT: low-capacity");

g_signal_emit (engine, signals [LOW_CAPACITY], 0, device);

static void

gpm_engine_init (GpmEngine *engine)

{

engine->priv = GPM_ENGINE_GET_PRIVATE (engine);

g_signal_connect (engine->priv->client, "device-changed",

G_CALLBACK (gpm_engine_device_changed_cb), engine);

engine->priv->phone = gpm_phone_new ();

g_signal_connect (engine->priv->phone, "device-added",

engine->priv->previous_summary = NULL;

/* do we want to display the icon in the tray */

/* get percentage policy */

/* get time policy */

/* we can disable this if the time remaining is inaccurate or just plain wrong */

if (engine->priv->use_time_primary)

egg_debug ("Using per-time notification policy");

else

#include <gtk/gtk.h>

#include <dbus/dbus-glib.h>

#include <dbus/dbus-glib-lowlevel.h>

#include <canberra-gtk.h>

#include <libupower-glib/upower.h>

#include <libmatenotify/notify.h>

struct GpmManagerPrivate

{

GpmButton *button;

GpmDisks *disks;

GpmDpms *dpms;

GpmIdle *idle;

gint retval;

ca_context *context;

if (!ret && !force) {

egg_debug ("ignoring sound due to policy");

return FALSE;

gint retval;

ca_context *context;

if (!ret && !force) {

egg_debug ("ignoring sound due to policy");

return FALSE;

guint sleep_computer;

if (!manager->priv->on_battery) {

} else {

}

/* set the new sleep (inactivity) value */

GError *error = NULL;

do_lock = gpm_control_get_lock_policy (manager->priv->control,

if (do_lock) {

if (!gpm_screensaver_lock (manager->priv->screensaver))

egg_debug ("Could not lock screen via mate-screensaver");

ret = FALSE;

}

if (do_lock)

gpm_screensaver_poke (manager->priv->screensaver);

return ret;

/* user clicked the help button */

if (response_id == GTK_RESPONSE_HELP) {

screen = gdk_screen_get_default();

ret = gtk_show_uri (screen, uri, gtk_get_current_event_time (), &error);

if (!ret) {

const gchar *icon;

GtkWidget *dialog;

egg_debug ("sleep failed");

gpm_manager_play (manager, GPM_MANAGER_SOUND_SUSPEND_ERROR, TRUE);

if (!show_sleep_failed)

goto out;

gtk_window_set_icon_name (GTK_WINDOW(dialog), icon);

/* show a button? */

if (uri != NULL && uri[0] != '\0') {

/* TRANSLATORS: button text, visit the suspend help website */

gtk_dialog_add_button (GTK_DIALOG (dialog), _("Visit help page"), GTK_RESPONSE_HELP);

* @policy: The policy that we should do, e.g. "suspend"

* @reason: The reason we are performing the policy action, e.g. "battery critical"

*

**/

static gboolean

gpm_manager_perform_policy (GpmManager *manager, const gchar *policy_key, const gchar *reason)

{

GpmActionPolicy policy;

/* are we inhibited? */

if (gpm_manager_is_inhibit_valid (manager, FALSE, "policy action") == FALSE)

return FALSE;

if (policy == GPM_ACTION_POLICY_NOTHING) {

egg_debug ("doing nothing, reason: %s", reason);

gpm_session_logout (session);

g_object_unref (session);

} else {

}

return TRUE;

}

* @manager: This class instance

*

* This callback is called when we want to sleep. Use the users

**/

static void

gpm_manager_idle_do_sleep (GpmManager *manager)

{

gboolean ret;

GError *error = NULL;

GpmActionPolicy policy;

if (!manager->priv->on_battery)

else

if (policy == GPM_ACTION_POLICY_NOTHING) {

egg_debug ("doing nothing as system idle action");

}

}

}

}

/**

if (!manager->priv->on_battery) {

egg_debug ("Performing AC policy");

"The lid has been closed on ac power.");

return;

}

egg_debug ("Performing battery policy");

"The lid has been closed on battery power.");

}

}

if (g_strcmp0 (type, GPM_BUTTON_POWER) == 0) {

} else if (g_strcmp0 (type, GPM_BUTTON_SLEEP) == 0) {

} else if (g_strcmp0 (type, GPM_BUTTON_SUSPEND) == 0) {

} else if (g_strcmp0 (type, GPM_BUTTON_HIBERNATE) == 0) {

} else if (g_strcmp0 (type, GPM_BUTTON_LID_OPEN) == 0) {

gpm_manager_lid_button_pressed (manager, FALSE);

} else if (g_strcmp0 (type, GPM_BUTTON_LID_CLOSED) == 0) {

/* get policy */

if (!manager->priv->on_battery) {

} else {

}

if (!enabled)

timeout = 0;

/* We do the lid close on battery action if the ac adapter is removed

when the laptop is closed and on battery. Fixes #331655 */

/* We keep track of the lid state so we can do the

lid close on battery action if the ac adapter is removed when the laptop

is closed. Fixes #331655 */

if (event_when_closed && on_battery && lid_is_closed) {

"The lid has been closed, and the ac adapter "

}

}

if (manager->priv->critical_alert_timeout_id)

gpm_manager_play_loop_stop (manager);

return FALSE;

}

}

/**

*

**/

static void

{

gpm_manager_sync_policy_sleep (manager);

}

/* don't show this again */

if (response_id == GTK_RESPONSE_CANCEL) {

goto out;

}

}

/* already shown, and dismissed */

if (!ret) {

return;

}

guint plural = 1;

const gchar *title;

if (!ret) {

egg_debug ("no notification");

goto out;

gchar *icon = NULL;

const gchar *kind_desc;

if (!ret) {

egg_debug ("no notification");

goto out;

{

const gchar *title = NULL;

gchar *message = NULL;

gchar *icon = NULL;

UpDeviceKind kind;

gdouble percentage;

}

/* we have to do different warnings depending on the policy */

/* use different text for different actions */

if (policy == GPM_ACTION_POLICY_NOTHING) {

message = g_strdup_printf (_("Computer will shutdown very soon unless it is plugged in."));

}

} else if (kind == UP_DEVICE_KIND_UPS) {

gchar *remaining_text;

gpm_manager_engine_charge_action_cb (GpmEngine *engine, UpDevice *device, GpmManager *manager)

{

const gchar *title = NULL;

gchar *message = NULL;

gchar *icon = NULL;

UpDeviceKind kind;

title = _("Laptop battery critically low");

/* we have to do different warnings depending on the policy */

/* use different text for different actions */

if (policy == GPM_ACTION_POLICY_NOTHING) {

"this computer is about to shutdown."));

}

/* wait 20 seconds for user-panic */

g_timeout_add_seconds (20, (GSourceFunc) manager_critical_action_do, manager);

title = _("UPS critically low");

/* we have to do different warnings depending on the policy */

/* use different text for different actions */

if (policy == GPM_ACTION_POLICY_NOTHING) {

/* wait 20 seconds for user-panic */

g_timeout_add_seconds (20, (GSourceFunc) manager_critical_action_do, manager);

}

/* not all types have actions */

gint timeout;

DBusGConnection *connection;

GError *error = NULL;

manager->priv = GPM_MANAGER_GET_PRIVATE (manager);

connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);

manager->priv->notification_discharging = NULL;

manager->priv->notification_fully_charged = NULL;

manager->priv->disks = gpm_disks_new ();

manager->priv->client = up_client_new ();

g_signal_connect (manager->priv->client, "changed",

G_CALLBACK (gpm_manager_client_changed_cb), manager);

/* use libmatenotify */

notify_init (GPM_NAME);

/* coldplug so we are in the correct state at startup */

g_object_get (manager->priv->client,

"on-battery", &manager->priv->on_battery,

G_CALLBACK (gpm_manager_idle_changed_cb), manager);

/* set up the check_type_cpu, so we can disable the CPU load check */

gpm_idle_set_check_cpu (manager->priv->idle, check_type_cpu);

manager->priv->dpms = gpm_dpms_new ();

if (manager->priv->critical_alert_timeout_id != 0)

g_source_remove (manager->priv->critical_alert_timeout_id);

g_object_unref (manager->priv->disks);

g_object_unref (manager->priv->dpms);

g_object_unref (manager->priv->idle);

#include <glib/gi18n.h>

#include <dbus/dbus-glib.h>

#include "gpm-phone.h"

#include "egg-debug.h"

#include "gpm-marshal.h"

#include <dbus/dbus-glib.h>

#include <math.h>

#include <string.h>

#include <libupower-glib/upower.h>

#include "egg-debug.h"

gboolean can_shutdown;

gboolean can_suspend;

gboolean can_hibernate;

EggConsoleKit *console;

};

static void

gpm_prefs_icon_radio_cb (GtkWidget *widget, GpmPrefs *prefs)

{

gint policy;

policy = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "policy"));

}

/**

}

/**

* gpm_prefs_action_combo_changed_cb:

**/

static void

GpmActionPolicy policy;

const GpmActionPolicy *actions;

const gchar *gpm_pref_key;

guint active;

actions = (const GpmActionPolicy *) g_object_get_data (G_OBJECT (widget), "actions");

active = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));

policy = actions[active];

}

/**

guint active;

values = (const gint *) g_object_get_data (G_OBJECT (widget), "values");

active = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));

value = values[active];

egg_debug ("Changing %s to %i", gpm_pref_key, value);

}

/**

* gpm_prefs_setup_action_combo:

* @prefs: This prefs class instance

* @widget_name: The GtkWidget name

* @actions: The actions to associate in an array.

**/

static void

gpm_prefs_setup_action_combo (GpmPrefs *prefs, const gchar *widget_name,

const gchar *gpm_pref_key, const GpmActionPolicy *actions)

{

gint i;

gboolean is_writable;

GtkWidget *widget;

widget = GTK_WIDGET (gtk_builder_get_object (prefs->priv->builder, widget_name));

gpm_prefs_set_combo_simple_text (widget);

gtk_widget_set_sensitive (widget, is_writable);

array = g_ptr_array_new ();

g_signal_connect (G_OBJECT (widget), "changed",

G_CALLBACK (gpm_prefs_action_combo_changed_cb), prefs);

g_ptr_array_add (array, GINT_TO_POINTER (policy));

#endif

} else if (policy == GPM_ACTION_POLICY_NOTHING) {

if (value == GPM_ACTION_POLICY_NOTHING) {

#if GTK_CHECK_VERSION (2, 24, 0)

gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT (widget), _("Do nothing"));

#endif

}

} else {

}

}

g_object_set_data_full (G_OBJECT (widget), "actions", (gpointer) actions_added, (GDestroyNotify) gpm_prefs_actions_destroy_cb);

for (i=0; actions_added[i] != -1; i++) {

policy = actions_added[i];

if (value == policy)

gtk_combo_box_set_active (GTK_COMBO_BOX (widget), i);

}

g_ptr_array_unref (array);

}

/**

* gpm_prefs_setup_time_combo:

* @prefs: This prefs class instance

* @widget_name: The GtkWidget name

* @actions: The actions to associate in an array.

**/

static void

widget = GTK_WIDGET (gtk_builder_get_object (prefs->priv->builder, widget_name));

gpm_prefs_set_combo_simple_text (widget);

gtk_widget_set_sensitive (widget, is_writable);

g_object_set_data (G_OBJECT (widget), "values", (gpointer) values);

/* add each time */

}

/**

* gpm_prefs_close_cb:

* @widget: The GtkWidget object

* @prefs: This prefs class instance

return FALSE;

}

/** setup the notification page */

static void

prefs_setup_notification (GpmPrefs *prefs)

{

gint icon_policy;

GtkWidget *radiobutton_icon_always;

GtkWidget *radiobutton_icon_present;

GtkWidget *radiobutton_icon_never;

gboolean is_writable;

radiobutton_icon_always = GTK_WIDGET (gtk_builder_get_object (prefs->priv->builder,

"radiobutton_notification_always"));

radiobutton_icon_never = GTK_WIDGET (gtk_builder_get_object (prefs->priv->builder,

"radiobutton_notification_never"));

gtk_widget_set_sensitive (radiobutton_icon_always, is_writable);

gtk_widget_set_sensitive (radiobutton_icon_present, is_writable);

gtk_widget_set_sensitive (radiobutton_icon_charge, is_writable);

g_object_set_data (G_OBJECT (radiobutton_icon_never), "policy",

GINT_TO_POINTER (GPM_ICON_POLICY_NEVER));

* keys gets written to (for a split second), and the icon flickers. */

g_signal_connect (radiobutton_icon_always, "clicked",

G_CALLBACK (gpm_prefs_icon_radio_cb), prefs);

-1};

gpm_prefs_setup_time_combo (prefs, "combobox_ac_computer",

computer_times);

gpm_prefs_setup_time_combo (prefs, "combobox_ac_display",

display_times);

gpm_prefs_setup_action_combo (prefs, "combobox_ac_lid",

button_lid_actions);

if (prefs->priv->has_button_lid == FALSE) {

widget = GTK_WIDGET (gtk_builder_get_object (prefs->priv->builder, "hbox_ac_lid"));

-1};

gpm_prefs_setup_time_combo (prefs, "combobox_battery_computer",

computer_times);

gpm_prefs_setup_time_combo (prefs, "combobox_battery_display",

display_times);

if (prefs->priv->has_batteries == FALSE) {

}

gpm_prefs_setup_action_combo (prefs, "combobox_battery_lid",

button_lid_actions);

gpm_prefs_setup_action_combo (prefs, "combobox_battery_critical",

battery_critical_actions);

if (prefs->priv->has_button_lid == FALSE) {

widget = GTK_WIDGET (gtk_builder_get_object (prefs->priv->builder, "hbox_battery_lid"));

-1};

gpm_prefs_setup_time_combo (prefs, "combobox_ups_computer",

computer_times);

gpm_prefs_setup_time_combo (prefs, "combobox_ups_display",

display_times);

if (prefs->priv->has_ups == FALSE) {

}

gpm_prefs_setup_action_combo (prefs, "combobox_ups_low",

ups_low_actions);

gpm_prefs_setup_action_combo (prefs, "combobox_ups_critical",

ups_low_actions);

}

-1};

gpm_prefs_setup_action_combo (prefs, "combobox_general_power",

power_button_actions);

gpm_prefs_setup_action_combo (prefs, "combobox_general_suspend",

suspend_button_actions);

if (prefs->priv->has_button_suspend == FALSE) {

}

}

/**

* gpm_prefs_set_defaults_cb:

**/

g_object_unref (proxy);

}

/**

* gpm_prefs_init:

prefs->priv->client = up_client_new ();

prefs->priv->console = egg_console_kit_new ();

/* are we allowed to shutdown? */

prefs->priv->can_shutdown = TRUE;

prefs = GPM_PREFS (object);

prefs->priv = GPM_PREFS_GET_PRIVATE (prefs);

g_object_unref (prefs->priv->client);

g_object_unref (prefs->priv->console);

{

gboolean enabled;

g_return_val_if_fail (GPM_IS_SCREENSAVER (screensaver), FALSE);

return enabled;

}

static const gchar *history_type;

static const gchar *stats_type;

static guint history_time;

static gfloat sigma_smoothing = 0.0f;

static UpWakeups *wakeups = NULL;

static GtkWidget *graph_history = NULL;

widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_stats"));

gpm_stats_set_title (GTK_WINDOW (widget), page_num);

if (current_device == NULL)

return;

g_free (current_device);

gtk_tree_model_get (model, &iter, GPM_DEVICES_COLUMN_ID, &current_device, -1);

/* show transaction_id */

egg_debug ("selected row is: %s", current_device);

gpm_stats_button_update_ui ();

}

/**

gpm_stats_button_update_ui ();

}

/**

else

g_assert (FALSE);

gpm_stats_button_update_ui ();

}

{

gboolean checked;

checked = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));

gpm_stats_button_update_ui ();

}

{

gboolean checked;

checked = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));

gpm_stats_button_update_ui ();

}

{

gboolean checked;

checked = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));

gpm_stats_button_update_ui ();

}

{

gboolean checked;

checked = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));

gpm_stats_button_update_ui ();

}

gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (),

GPM_DATA G_DIR_SEPARATOR_S "icons");

/* get UI */

builder = gtk_builder_new ();

G_CALLBACK (gpm_stats_button_help_cb), NULL);

widget = GTK_WIDGET (gtk_builder_get_object (builder, "checkbutton_smooth_history"));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), checked);

g_signal_connect (widget, "clicked",

G_CALLBACK (gpm_stats_smooth_checkbox_history_cb), NULL);

widget = GTK_WIDGET (gtk_builder_get_object (builder, "checkbutton_smooth_stats"));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), checked);

g_signal_connect (widget, "clicked",

G_CALLBACK (gpm_stats_smooth_checkbox_stats_cb), NULL);

widget = GTK_WIDGET (gtk_builder_get_object (builder, "checkbutton_points_history"));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), checked);

g_signal_connect (widget, "clicked",

G_CALLBACK (gpm_stats_points_checkbox_history_cb), NULL);

widget = GTK_WIDGET (gtk_builder_get_object (builder, "checkbutton_points_stats"));

gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), checked);

g_signal_connect (widget, "clicked",

G_CALLBACK (gpm_stats_points_checkbox_stats_cb), NULL);

widget = GTK_WIDGET (gtk_builder_get_object (builder, "notebook1"));

gtk_notebook_set_current_page (GTK_NOTEBOOK (widget), page);

g_signal_connect (widget, "switch-page",

G_CALLBACK (gpm_stats_notebook_changed_cb), NULL);

gpm_stats_add_wakeups_columns (GTK_TREE_VIEW (widget));

gtk_tree_view_columns_autosize (GTK_TREE_VIEW (widget)); /* show */

if (history_type == NULL)

history_type = GPM_HISTORY_CHARGE_VALUE;

if (history_time == 0)

history_time = GPM_HISTORY_HOUR_VALUE;

if (stats_type == NULL)

stats_type = GPM_STATS_CHARGE_DATA_VALUE;

}

if (last_device == NULL)

/* has capability to measure wakeups */

ret = up_wakeups_get_has_capability (wakeups);

gtk_main ();

out:

g_object_unref (client);

g_object_unref (wakeups);

g_object_unref (builder);

#include <glib/gi18n.h>

#include <gtk/gtk.h>

#include <libupower-glib/upower.h>

#include "egg-debug.h"

struct GpmTrayIconPrivate

{

GpmEngine *engine;

GtkStatusIcon *status_icon;

gboolean show_actions;

}

/**

*

**/

static void

{

gboolean allowed_in_menu;

gpm_tray_icon_enable_actions (icon, allowed_in_menu);

}

}

icon->priv->engine = gpm_engine_new ();

icon->priv->status_icon = gtk_status_icon_new ();

g_signal_connect_object (G_OBJECT (icon->priv->status_icon),

G_CALLBACK (gpm_tray_icon_activate_cb),

icon, 0);

gpm_tray_icon_enable_actions (icon, allowed_in_menu);

}