egg-console-kit.c \

gpm-common.h \

gpm-common.c \

gpm-marshal.h \

gpm-marshal.c \

gpm-upower.c \

gpm-phone.c \

gpm-backlight.h \

gpm-backlight.c \

gpm-idle.h \

gpm-idle.c \

gpm-load.h \

gpm-control.c \

gpm-button.h \

gpm-button.c \

gpm-main.c \

gpm-manager.h \

gpm-manager.c \

egg-array-float.c \

egg-console-kit.h \

egg-console-kit.c \

gpm-control.h \

gpm-control.c \

gpm-networkmanager.h \

#include <glib/gi18n.h>

#include <dbus/dbus-glib.h>

#include <libupower-glib/upower.h>

#include "gpm-button.h"

#include "gpm-idle.h"

#include "gpm-marshal.h"

#include "gpm-stock-icons.h"

#include "egg-console-kit.h"

#define GPM_BACKLIGHT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GPM_TYPE_BACKLIGHT, GpmBacklightPrivate))

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);

static void

gpm_backlight_init (GpmBacklight *backlight)

{

backlight->priv = GPM_BACKLIGHT_GET_PRIVATE (backlight);

/* record our idle time */

/* gets caps */

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:

#define GPM_DBUS_INTERFACE_BACKLIGHT "org.mate.PowerManager.Backlight"

#define GPM_DBUS_PATH "/org/mate/PowerManager"

#define GPM_DBUS_PATH_BACKLIGHT "/org/mate/PowerManager/Backlight"

/* common descriptions of this program */

#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);

#include <dbus/dbus-glib.h>

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

#include <mate-keyring.h>

#include <libupower-glib/upower.h>

#include "egg-debug.h"

struct GpmControlPrivate

{

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. :-) */

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 ();

g_return_if_fail (GPM_IS_CONTROL (object));

control = GPM_CONTROL (object);

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 ();

}

/**

}

/**

* 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"

#include "gpm-marshal.h"

#include "gpm-engine.h"

#include "gpm-stock-icons.h"

#include "gpm-phone.h"

static void gpm_engine_finalize (GObject *object);

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);

gpm_engine_coldplug_idle_cb (GpmEngine *engine)

{

guint i;

UpDevice *device;

gboolean ret;

GError *error = NULL;

g_error_free (error);

goto out;

}

/* connected mobile phones */

gpm_phone_coldplug (engine->priv->phone);

gpm_engine_recalculate_state (engine);

/* add to database */

for (i=0;i<array->len;i++) {

gpm_engine_device_add (engine, device);

gpm_engine_check_recall (engine, device);

}

out:

/* never repeat */

return FALSE;

}

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

gpm_idle_session_idle_changed_cb (GpmSession *session, gboolean is_idle, GpmIdle *idle)

{

egg_debug ("Received mate session idle changed: %i", is_idle);

gpm_idle_evaluate (idle);

}

#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>

#include "gpm-manager.h"

#include "gpm-screensaver.h"

#include "gpm-backlight.h"

#include "gpm-session.h"

#include "gpm-stock-icons.h"

#include "gpm-tray-icon.h"

#include "gpm-engine.h"

#include "gpm-upower.h"

struct GpmManagerPrivate

{

GpmButton *button;

GpmDisks *disks;

GpmDpms *dpms;

GpmIdle *idle;

GpmControl *control;

GpmScreensaver *screensaver;

GpmTrayIcon *tray_icon;

GpmEngine *engine;

GpmBacklight *backlight;

EggConsoleKit *console;

guint32 screensaver_ac_throttle_id;

guint32 screensaver_dpms_throttle_id;

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 */

* Turn off the backlight of the LCD when we shut the lid, and lock

* if required. This is required because some laptops do not turn off the

* LCD backlight when the lid is closed.

*

* Return value: Success.

**/

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;

}

/**

* gpm_manager_idle_do_sleep:

* @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);

}

/**

* gpm_manager_perhaps_recall_response_cb:

*/

/* 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 */

gboolean check_type_cpu;

gint timeout;

DBusGConnection *connection;

GError *error = NULL;

manager->priv = GPM_MANAGER_GET_PRIVATE (manager);

connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);

/* init to unthrottled */

manager->priv->screensaver_ac_throttle_id = 0;

/* don't apply policy when not active, so listen to ConsoleKit */

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

manager->priv->notification_general = NULL;

manager->priv->notification_warning_low = NULL;

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,

/* try and start an interactive service */

manager->priv->screensaver = gpm_screensaver_new ();

/* try an start an interactive service */

manager->priv->backlight = gpm_backlight_new ();

G_OBJECT (manager->priv->backlight));

}

manager->priv->idle = gpm_idle_new ();

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

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);

g_object_unref (manager->priv->engine);

g_object_unref (manager->priv->tray_icon);

g_object_unref (manager->priv->screensaver);

g_object_unref (manager->priv->control);

g_object_unref (manager->priv->button);

g_object_unref (manager->priv->backlight);

g_object_unref (manager->priv->console);

g_object_unref (manager->priv->client);

g_object_unref (manager->priv->status_icon);

gboolean gpm_manager_can_hibernate (GpmManager *manager,

gboolean *can_hibernate,

GError **error);

G_END_DECLS

#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"

#include "gpm-common.h"

#include "gpm-prefs-core.h"

#include "gpm-stock-icons.h"

static void gpm_prefs_finalize (GObject *object);

gboolean can_shutdown;

gboolean can_suspend;

gboolean can_hibernate;

EggConsoleKit *console;

};

}

/**

* gpm_prefs_help_cb:

* @widget: The GtkWidget object

* @prefs: This prefs class instance

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) {

} 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:

{

GtkWidget *main_window;

GtkWidget *widget;

guint retval;

GError *error = NULL;

prefs->priv = GPM_PREFS_GET_PRIVATE (prefs);

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

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

/* are we allowed to shutdown? */

prefs->priv->can_shutdown = TRUE;

egg_console_kit_can_stop (prefs->priv->console, &prefs->priv->can_shutdown, NULL);

/* get values from UpClient */

g_object_get (prefs->priv->client,

prefs->priv->builder = gtk_builder_new ();

prefs = GPM_PREFS (object);

prefs->priv = GPM_PREFS_GET_PRIVATE (prefs);

g_object_unref (prefs->priv->client);

g_object_unref (prefs->priv->console);

#include <glib.h>

#include <glib/gi18n.h>

#include <dbus/dbus-glib.h>

#include "gpm-screensaver.h"

#include "gpm-common.h"

struct GpmScreensaverPrivate

{

DBusGProxy *proxy;

};

static gpointer gpm_screensaver_object = NULL;

G_DEFINE_TYPE (GpmScreensaver, gpm_screensaver, G_TYPE_OBJECT)

/**

* gpm_screensaver_lock

* @screensaver: This class instance

object_class->finalize = gpm_screensaver_finalize;

g_type_class_add_private (klass, sizeof (GpmScreensaverPrivate));

}

/**

GS_LISTENER_SERVICE,

GS_LISTENER_PATH,

GS_LISTENER_INTERFACE);

}

/**

screensaver = GPM_SCREENSAVER (object);

screensaver->priv = GPM_SCREENSAVER_GET_PRIVATE (screensaver);

g_object_unref (screensaver->priv->proxy);

G_OBJECT_CLASS (gpm_screensaver_parent_class)->finalize (object);

#ifdef EGG_TEST

#include "egg-test.h"

void

gpm_screensaver_test (gpointer data)

{

screensaver = gpm_screensaver_new ();

egg_test_assert (test, (screensaver != NULL));

/************************************************************/

egg_test_title (test, "lock screensaver");

ret = gpm_screensaver_lock (screensaver);

typedef struct

{

GObjectClass parent_class;

} GpmScreensaverClass;

GType gpm_screensaver_get_type (void);

void gpm_screensaver_test (gpointer data);

gboolean gpm_screensaver_lock (GpmScreensaver *screensaver);

guint32 gpm_screensaver_add_throttle (GpmScreensaver *screensaver,

const gchar *reason);

gboolean gpm_screensaver_remove_throttle (GpmScreensaver *screensaver,

#include <gtk/gtk.h>

#include <dbus/dbus-glib.h>

#include <libupower-glib/upower.h>

#include "egg-debug.h"

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);

}

<?xml version="1.0" encoding="UTF-8"?>

<node name="/">

<interface name="org.mate.PowerManager">

</interface>

</node>