gnome-power-manager r3371 - in trunk: . data src
- From: rhughes svn gnome org
- To: svn-commits-list gnome org
- Subject: gnome-power-manager r3371 - in trunk: . data src
- Date: Mon, 23 Mar 2009 14:17:50 +0000 (UTC)
Author: rhughes
Date: Mon Mar 23 14:17:50 2009
New Revision: 3371
URL: http://svn.gnome.org/viewvc/gnome-power-manager?rev=3371&view=rev
Log:
2009-03-23 Richard Hughes <richard hughsie com>
* src/gpm-dpms.h:
* src/gpm-dpms.c: (gpm_dpms_error_quark), (gpm_dpms_x11_get_mode),
(gpm_dpms_x11_set_mode), (gpm_dpms_mode_from_string),
(gpm_dpms_mode_to_string), (gpm_dpms_set_mode),
(gpm_dpms_get_mode), (gpm_dpms_poll_mode_cb),
(gpm_dpms_class_init), (gpm_dpms_init), (gpm_dpms_finalize),
(gpm_dpms_test):
Rewrite the DPMS class to have 1% of the complexity. Don't try and sync
with the XServer, as each distro seems to default to doing different
things, and if XOrg is managing DPMS then we disagree when the idle
point happens. We can't rely of the XServer to tell us a changed signal
for policy, as it's only polled once every 10 seconds.
In this new model we just tell the server to turn on and off when
required.
Should fix #576169.
* data/gnome-power-manager.schemas.in:
Change the default DPMS off mode to off.
* src/gpm-backlight.c: (gpm_backlight_set_mode),
(gpm_backlight_get_mode), (gpm_conf_gconf_key_changed_cb),
(gpm_backlight_button_pressed_cb), (idle_changed_cb),
(control_resume_cb), (gpm_backlight_finalize),
(gpm_backlight_init):
* src/gpm-idle.c: (gpm_idle_set_mode), (gpm_idle_evaluate),
(gpm_idle_idletime_alarm_expired_cb), (gpm_idle_idletime_reset_cb),
(gpm_idle_finalize), (gpm_idle_init):
Make sure the backlight mode is scheduled, as a typo prevented it from
activating in 2.26.x code, and IDLETIME was reset with the DPMS request
which made the server come straight back to life.
Basically, it was terminally broken, and it's now fixed.
* src/gpm-manager.c: (gpm_manager_blank_screen),
(gpm_manager_unblank_screen), (idle_changed_cb),
(update_dpms_throttle), (screensaver_auth_request_cb):
Trivial method renames.
* src/gpm-prefs-core.c: (gpm_prefs_sleep_slider_changed_cb),
(gpm_prefs_setup_sleep_slider),
(gpm_prefs_brightness_slider_changed_cb), (prefs_setup_ac),
(prefs_setup_battery), (prefs_setup_ups):
We don't base our DPMS off on the session idle anymore, so don't add
the session idle timeout to DPMS sliders.
* src/gpm-self-test.c: (main):
Add some unit tests for the DPMS code.
Modified:
trunk/ChangeLog
trunk/data/gnome-power-manager.schemas.in
trunk/src/gpm-backlight.c
trunk/src/gpm-dpms.c
trunk/src/gpm-dpms.h
trunk/src/gpm-idle.c
trunk/src/gpm-manager.c
trunk/src/gpm-prefs-core.c
trunk/src/gpm-self-test.c
Modified: trunk/data/gnome-power-manager.schemas.in
==============================================================================
--- trunk/data/gnome-power-manager.schemas.in (original)
+++ trunk/data/gnome-power-manager.schemas.in Mon Mar 23 14:17:50 2009
@@ -215,10 +215,10 @@
<key>/schemas/apps/gnome-power-manager/backlight/dpms_method_ac</key>
<applyto>/apps/gnome-power-manager/backlight/dpms_method_ac</applyto>
<type>string</type>
- <default>default</default>
+ <default>off</default>
<locale name="C">
<short>Method used to blank screen on AC</short>
- <long>The DPMS method used to blank the screen when on AC power. Possible values are "default", "standby", "suspend" and "off".</long>
+ <long>The DPMS method used to blank the screen when on AC power. Possible values are "standby", "suspend" and "off".</long>
</locale>
</schema>
@@ -226,10 +226,10 @@
<key>/schemas/apps/gnome-power-manager/backlight/dpms_method_battery</key>
<applyto>/apps/gnome-power-manager/backlight/dpms_method_battery</applyto>
<type>string</type>
- <default>default</default>
+ <default>off</default>
<locale name="C">
<short>Method used to blank screen on battery</short>
- <long>The DPMS method used to blank the screen when on battery power. Possible values are "default", "standby", "suspend" and "off".</long>
+ <long>The DPMS method used to blank the screen when on battery power. Possible values are "standby", "suspend" and "off".</long>
</locale>
</schema>
Modified: trunk/src/gpm-backlight.c
==============================================================================
--- trunk/src/gpm-backlight.c (original)
+++ trunk/src/gpm-backlight.c Mon Mar 23 14:17:50 2009
@@ -73,7 +73,6 @@
GpmLightSensor *light_sensor;
gboolean can_dim;
gboolean can_sense;
- gboolean can_dpms;
gboolean is_laptop;
gboolean system_is_idle;
GTimer *idle_timer;
@@ -105,107 +104,6 @@
return quark;
}
-/**
- * gpm_backlight_sync_policy:
- * @backlight: This class instance
- *
- * Sync the BACKLIGHT policy with what we have set in gconf.
- **/
-static void
-gpm_backlight_sync_policy (GpmBacklight *backlight)
-{
- GError *error;
- gboolean res;
- guint timeout = 0;
- guint standby = 0;
- guint suspend = 0;
- guint off = 0;
- gchar *dpms_method;
- GpmDpmsMethod method;
- gboolean on_ac;
-
- /* no point processing if we can't do the dpms action */
- if (!backlight->priv->can_dpms)
- return;
-
- /* get the ac state */
- on_ac = gpm_ac_adapter_is_present (backlight->priv->ac_adapter);
-
- error = NULL;
-
- if (on_ac) {
- timeout = gconf_client_get_int (backlight->priv->conf, GPM_CONF_TIMEOUT_SLEEP_DISPLAY_AC, NULL);
- dpms_method = gconf_client_get_string (backlight->priv->conf, GPM_CONF_BACKLIGHT_DPMS_METHOD_AC, NULL);
- } else {
- timeout = gconf_client_get_int (backlight->priv->conf, GPM_CONF_TIMEOUT_SLEEP_DISPLAY_BATT, NULL);
- dpms_method = gconf_client_get_string (backlight->priv->conf, GPM_CONF_BACKLIGHT_DPMS_METHOD_BATT, NULL);
- }
-
- /* convert the string types to standard types */
- method = gpm_dpms_method_from_string (dpms_method);
- g_free (dpms_method);
-
- /* check if method is valid */
- if (method == GPM_DPMS_METHOD_UNKNOWN) {
- egg_warning ("BACKLIGHT method unknown. Possible schema problem!");
- return;
- }
-
- /* choose a sensible default */
- if (method == GPM_DPMS_METHOD_DEFAULT) {
- egg_debug ("choosing sensible default");
- if (backlight->priv->is_laptop) {
- egg_debug ("laptop, so use GPM_DPMS_METHOD_OFF");
- method = GPM_DPMS_METHOD_OFF;
- } else {
- egg_debug ("not laptop, so use GPM_BACKLIGHT_METHOD_STAGGER");
- method = GPM_DPMS_METHOD_STAGGER;
- }
- }
-
- /* Some monitors do not support certain suspend states, so we have to
- * provide a way to only use the one that works. */
- if (method == GPM_DPMS_METHOD_STAGGER) {
- /* suspend after one timeout, turn off after another */
- standby = timeout;
- suspend = timeout;
- off = timeout * 2;
- } else if (method == GPM_DPMS_METHOD_STANDBY) {
- standby = timeout;
- suspend = 0;
- off = 0;
- } else if (method == GPM_DPMS_METHOD_SUSPEND) {
- standby = 0;
- suspend = timeout;
- off = 0;
- } else if (method == GPM_DPMS_METHOD_OFF) {
- standby = 0;
- suspend = 0;
- off = timeout;
- } else {
- /* wtf? */
- egg_warning ("unknown backlight mode!");
- }
-
- egg_debug ("BACKLIGHT parameters %d %d %d, method '%i'", standby, suspend, off, method);
-
- error = NULL;
- res = gpm_dpms_set_enabled (backlight->priv->dpms, TRUE, &error);
- if (error) {
- egg_warning ("Unable to enable BACKLIGHT: %s", error->message);
- g_error_free (error);
- return;
- }
-
- error = NULL;
- res = gpm_dpms_set_timeouts (backlight->priv->dpms, standby, suspend, off, &error);
- if (error) {
- egg_warning ("Unable to get BACKLIGHT timeouts: %s", error->message);
- g_error_free (error);
- return;
- }
-}
-
/* dbus methods shouldn't use enumerated types, but should use textual descriptors */
gboolean
gpm_backlight_set_mode (GpmBacklight *backlight, const gchar *mode_str, GError **error)
@@ -215,18 +113,9 @@
g_return_val_if_fail (GPM_IS_BACKLIGHT (backlight), FALSE);
- /* check if we have the hw */
- if (backlight->priv->can_dpms == FALSE) {
- *error = g_error_new (gpm_backlight_error_quark (),
- GPM_BACKLIGHT_ERROR_HARDWARE_NOT_PRESENT,
- "DPMS capable hardware not present");
- return FALSE;
- }
-
/* convert mode to an enumerated type */
mode = gpm_dpms_mode_from_string (mode_str);
-
- ret = gpm_dpms_set_mode_enum (backlight->priv->dpms, mode, error);
+ ret = gpm_dpms_set_mode (backlight->priv->dpms, mode, error);
return ret;
}
@@ -242,15 +131,7 @@
g_return_val_if_fail (GPM_IS_BACKLIGHT (backlight), FALSE);
g_return_val_if_fail (mode_str != NULL, FALSE);
- /* check if we have the hw */
- if (backlight->priv->can_dpms == FALSE) {
- *error = g_error_new (gpm_backlight_error_quark (),
- GPM_BACKLIGHT_ERROR_HARDWARE_NOT_PRESENT,
- "DPMS capable hardware not present");
- return FALSE;
- }
-
- ret = gpm_dpms_get_mode_enum (backlight->priv->dpms, &mode, error);
+ ret = gpm_dpms_get_mode (backlight->priv->dpms, &mode, error);
if (ret)
*mode_str = g_strdup (gpm_dpms_mode_to_string (mode));
return ret;
@@ -484,11 +365,6 @@
strcmp (entry->key, GPM_CONF_BACKLIGHT_IDLE_BRIGHTNESS) == 0) {
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);
- } else if (strcmp (entry->key, GPM_CONF_TIMEOUT_SLEEP_DISPLAY_BATT) == 0 ||
- strcmp (entry->key, GPM_CONF_TIMEOUT_SLEEP_DISPLAY_AC) == 0 ||
- strcmp (entry->key, GPM_CONF_BACKLIGHT_DPMS_METHOD_AC) == 0 ||
- strcmp (entry->key, GPM_CONF_BACKLIGHT_DPMS_METHOD_BATT) == 0) {
- gpm_backlight_sync_policy (backlight);
} else if (strcmp (entry->key, GPM_CONF_BACKLIGHT_IDLE_DIM_TIME) == 0) {
backlight->priv->idle_dim_timeout = gconf_value_get_int (value);
gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->priv->idle_dim_timeout);
@@ -521,8 +397,9 @@
static void
gpm_backlight_button_pressed_cb (GpmButton *button, const gchar *type, GpmBacklight *backlight)
{
- guint percentage;
gboolean ret;
+ GError *error;
+ guint percentage;
gboolean hw_changed;
egg_debug ("Button press event type=%s", type);
@@ -561,7 +438,13 @@
} else if (strcmp (type, GPM_BUTTON_LID_OPEN) == 0) {
/* make sure we undim when we lift the lid */
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);
- gpm_backlight_sync_policy (backlight);
+
+ /* ensure backlight is on */
+ ret = gpm_dpms_set_mode (backlight->priv->dpms, GPM_DPMS_MODE_ON, &error);
+ if (!ret) {
+ egg_warning ("failed to turn on DPMS: %s", error->message);
+ g_error_free (error);
+ }
}
}
@@ -628,53 +511,71 @@
static void
idle_changed_cb (GpmIdle *idle, GpmIdleMode mode, GpmBacklight *backlight)
{
+ gboolean ret;
GError *error;
+ gboolean on_ac;
+ gchar *dpms_method;
+ GpmDpmsMode dpms_mode;
/* don't dim or undim the screen when the lid is closed */
if (gpm_button_is_lid_closed (backlight->priv->button))
return;
if (mode == GPM_IDLE_MODE_NORMAL) {
- /* deactivate display power management */
- if (backlight->priv->can_dpms) {
- error = NULL;
- gpm_dpms_set_active (backlight->priv->dpms, FALSE, &error);
- if (error) {
- egg_debug ("Unable to set DPMS not active: %s", error->message);
- g_error_free (error);
- }
- }
-
/* sync lcd brightness */
gpm_backlight_notify_system_idle_changed (backlight, FALSE);
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);
- /* sync timeouts */
- gpm_backlight_sync_policy (backlight);
-
- } else if (mode == GPM_IDLE_MODE_BLANK) {
- /* activate display power management */
- if (backlight->priv->can_dpms) {
- error = NULL;
- gpm_dpms_set_active (backlight->priv->dpms, TRUE, &error);
- if (error) {
- egg_debug ("Unable to set DPMS active: %s", error->message);
- g_error_free (error);
- }
+ /* ensure backlight is on */
+ ret = gpm_dpms_set_mode (backlight->priv->dpms, GPM_DPMS_MODE_ON, &error);
+ if (!ret) {
+ egg_warning ("failed to turn on DPMS: %s", error->message);
+ g_error_free (error);
}
+ } else if (mode == GPM_IDLE_MODE_DIM) {
+
/* sync lcd brightness */
- gpm_backlight_notify_system_idle_changed (backlight, FALSE);
+ gpm_backlight_notify_system_idle_changed (backlight, TRUE);
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);
- /* sync timeouts */
- gpm_backlight_sync_policy (backlight);
+ /* ensure backlight is on */
+ ret = gpm_dpms_set_mode (backlight->priv->dpms, GPM_DPMS_MODE_ON, &error);
+ if (!ret) {
+ egg_warning ("failed to turn on DPMS: %s", error->message);
+ g_error_free (error);
+ }
- } else if (mode == GPM_IDLE_MODE_DIM) {
+ } else if (mode == GPM_IDLE_MODE_BLANK) {
/* sync lcd brightness */
gpm_backlight_notify_system_idle_changed (backlight, TRUE);
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);
+
+ /* get the DPMS state we're supposed to use on the power state */
+ on_ac = gpm_ac_adapter_is_present (backlight->priv->ac_adapter);
+ if (on_ac)
+ dpms_method = gconf_client_get_string (backlight->priv->conf, GPM_CONF_BACKLIGHT_DPMS_METHOD_AC, NULL);
+ else
+ dpms_method = gconf_client_get_string (backlight->priv->conf, GPM_CONF_BACKLIGHT_DPMS_METHOD_BATT, NULL);
+
+ /* convert the string types to standard types */
+ dpms_mode = gpm_dpms_mode_from_string (dpms_method);
+
+ /* check if method is valid */
+ if (dpms_mode == GPM_DPMS_MODE_UNKNOWN || dpms_mode == GPM_DPMS_MODE_ON) {
+ egg_warning ("BACKLIGHT method %s unknown. Using OFF.", dpms_method);
+ dpms_mode = GPM_DPMS_MODE_OFF;
+ }
+
+ /* turn backlight off */
+ ret = gpm_dpms_set_mode (backlight->priv->dpms, dpms_mode, &error);
+ if (!ret) {
+ egg_warning ("failed to change DPMS: %s", error->message);
+ g_error_free (error);
+ }
+
+ g_free (dpms_method);
}
}
@@ -741,7 +642,15 @@
static void
control_resume_cb (GpmControl *control, GpmControlAction action, GpmBacklight *backlight)
{
- gpm_backlight_sync_policy (backlight);
+ gboolean ret;
+ GError *error;
+
+ /* ensure backlight is on */
+ ret = gpm_dpms_set_mode (backlight->priv->dpms, GPM_DPMS_MODE_ON, &error);
+ if (!ret) {
+ egg_warning ("failed to turn on DPMS: %s", error->message);
+ g_error_free (error);
+ }
}
/**
@@ -757,10 +666,8 @@
g_timer_destroy (backlight->priv->idle_timer);
- if (backlight->priv->dpms != NULL)
- g_object_unref (backlight->priv->dpms);
- if (backlight->priv->control != NULL)
- g_object_unref (backlight->priv->control);
+ g_object_unref (backlight->priv->dpms);
+ g_object_unref (backlight->priv->control);
g_object_unref (backlight->priv->light_sensor);
g_object_unref (backlight->priv->feedback);
g_object_unref (backlight->priv->conf);
@@ -834,7 +741,6 @@
/* gets caps */
backlight->priv->can_dim = gpm_brightness_has_hw (backlight->priv->brightness);
- backlight->priv->can_dpms = gpm_dpms_has_hw ();
backlight->priv->can_sense = gpm_light_sensor_has_hw (backlight->priv->light_sensor);
/* we use hal to see if we are a laptop */
@@ -890,23 +796,20 @@
gpm_feedback_set_icon_name (backlight->priv->feedback,
GPM_STOCK_BRIGHTNESS_LCD);
- if (backlight->priv->can_dpms) {
- /* DPMS mode poll class */
- backlight->priv->dpms = gpm_dpms_new ();
- g_signal_connect (backlight->priv->dpms, "mode-changed",
- G_CALLBACK (mode_changed_cb), backlight);
-
- /* we refresh DPMS on resume */
- backlight->priv->control = gpm_control_new ();
- g_signal_connect (backlight->priv->control, "resume",
- G_CALLBACK (control_resume_cb), backlight);
- }
+ /* DPMS mode poll class */
+ backlight->priv->dpms = gpm_dpms_new ();
+ g_signal_connect (backlight->priv->dpms, "mode-changed",
+ G_CALLBACK (mode_changed_cb), backlight);
+
+ /* we refresh DPMS on resume */
+ backlight->priv->control = gpm_control_new ();
+ g_signal_connect (backlight->priv->control, "resume",
+ G_CALLBACK (control_resume_cb), backlight);
/* sync at startup */
gpm_light_sensor_get_absolute (backlight->priv->light_sensor, &value);
backlight->priv->ambient_sensor_value = value / 100.0f;
gpm_backlight_brightness_evaluate_and_set (backlight, FALSE);
- gpm_backlight_sync_policy (backlight);
}
/**
Modified: trunk/src/gpm-dpms.c
==============================================================================
--- trunk/src/gpm-dpms.c (original)
+++ trunk/src/gpm-dpms.c Mon Mar 23 14:17:50 2009
@@ -1,6 +1,7 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Copyright (C) 2005 William Jon McCann <mccann jhu edu>
+ * Copyright (C) 2006-2009 Richard Hughes <richard hughsie com>
*
* Licensed under the GNU General Public License Version 2
*
@@ -42,11 +43,10 @@
#include <X11/extensions/dpmsstr.h>
#endif
-#include <gconf/gconf-client.h>
#include "egg-debug.h"
#include "gpm-dpms.h"
-static void gpm_dpms_finalize (GObject *object);
+static void gpm_dpms_finalize (GObject *object);
#define GPM_DPMS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GPM_TYPE_DPMS, GpmDpmsPrivate))
@@ -55,17 +55,8 @@
struct GpmDpmsPrivate
{
- gboolean enabled;
- gboolean active;
gboolean dpms_capable;
-
- guint standby_timeout;
- guint suspend_timeout;
- guint off_timeout;
-
- GConfClient *conf;
GpmDpmsMode mode;
-
guint timer_id;
};
@@ -74,132 +65,30 @@
LAST_SIGNAL
};
-enum {
- PROP_0,
- PROP_STANDBY_TIMEOUT,
- PROP_SUSPEND_TIMEOUT,
- PROP_OFF_TIMEOUT
-};
-
static guint signals [LAST_SIGNAL] = { 0 };
static gpointer gpm_dpms_object = NULL;
G_DEFINE_TYPE (GpmDpms, gpm_dpms, G_TYPE_OBJECT)
+/**
+ * gpm_dpms_error_quark:
+ **/
GQuark
gpm_dpms_error_quark (void)
{
static GQuark quark = 0;
if (!quark)
quark = g_quark_from_static_string ("gpm_dpms_error");
-
return quark;
}
-gboolean
-gpm_dpms_has_hw (void)
-{
-#ifdef HAVE_DPMS_EXTENSION
- return TRUE;
-#else
- return FALSE;
-#endif
-}
-
-/* the following function is derived from
- xscreensaver Copyright (C) Jamie Zawinski
-*/
-static gboolean
-x11_sync_server_dpms_settings (Display *dpy,
- gboolean enabled,
- guint standby_secs,
- guint suspend_secs,
- guint off_secs,
- GError **error)
-{
-#ifdef HAVE_DPMS_EXTENSION
- BOOL o_enabled = FALSE;
- CARD16 o_power = 0;
- CARD16 o_standby = 0;
- CARD16 o_suspend = 0;
- CARD16 o_off = 0;
-
- egg_debug ("Syncing DPMS settings enabled=%d timeouts=%d %d %d",
- enabled, standby_secs, suspend_secs, off_secs);
-
- if (! DPMSInfo (dpy, &o_power, &o_enabled)) {
- egg_debug ("unable to get DPMS state.");
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
- "Unable to get DPMS state");
-
- return FALSE;
- }
-
- if (o_enabled != enabled) {
- int res;
-
- if (enabled) {
- res = DPMSEnable (dpy);
- } else {
- res = DPMSDisable (dpy);
- }
-
- if (! res) {
- egg_debug ("unable to set DPMS state.");
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
- "Unable to set DPMS state");
-
- return FALSE;
- } else {
- egg_debug ("turned DPMS %s", enabled ? "ON" : "OFF");
- }
- }
-
- if (! DPMSGetTimeouts (dpy, &o_standby, &o_suspend, &o_off)) {
- egg_debug ("unable to get DPMS timeouts.");
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
- "Unable to get DPMS timeouts");
-
- return FALSE;
- }
-
- if (o_standby != standby_secs ||
- o_suspend != suspend_secs ||
- o_off != off_secs) {
- if (! DPMSSetTimeouts (dpy, standby_secs, suspend_secs, off_secs)) {
- egg_debug ("unable to set DPMS timeouts.");
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
- "Unable to set DPMS timeouts");
-
- return FALSE;
- } else {
- egg_debug ("set DPMS timeouts: %d %d %d.",
- standby_secs, suspend_secs, off_secs);
- }
- }
-
- return TRUE;
-# else /* !HAVE_DPMS_EXTENSION */
-
- egg_debug ("DPMS support not compiled in.");
- return FALSE;
-# endif /* HAVE_DPMS_EXTENSION */
-}
-
#ifdef HAVE_DPMS_EXTENSION
+/**
+ * gpm_dpms_x11_get_mode:
+ **/
static gboolean
-x11_get_mode (GpmDpms *dpms,
- GpmDpmsMode *mode,
- GError **error)
+gpm_dpms_x11_get_mode (GpmDpms *dpms, GpmDpmsMode *mode, GError **error)
{
GpmDpmsMode result;
BOOL enabled = FALSE;
@@ -208,72 +97,67 @@
if (dpms->priv->dpms_capable == FALSE) {
/* Server or monitor can't DPMS -- assume the monitor is on. */
result = GPM_DPMS_MODE_ON;
- } else {
- DPMSInfo (GDK_DISPLAY (), &state, &enabled);
- if (! enabled) {
- /* Server says DPMS is disabled -- so the monitor is on. */
- result = GPM_DPMS_MODE_ON;
- } else {
- switch (state) {
- case DPMSModeOn:
- result = GPM_DPMS_MODE_ON;
- break;
- case DPMSModeStandby:
- result = GPM_DPMS_MODE_STANDBY;
- break;
- case DPMSModeSuspend:
- result = GPM_DPMS_MODE_SUSPEND;
- break;
- case DPMSModeOff:
- result = GPM_DPMS_MODE_OFF;
- break;
- default:
- result = GPM_DPMS_MODE_ON;
- break;
- }
- }
+ goto out;
}
- if (mode) {
- *mode = result;
+ DPMSInfo (GDK_DISPLAY (), &state, &enabled);
+ if (!enabled) {
+ /* Server says DPMS is disabled -- so the monitor is on. */
+ result = GPM_DPMS_MODE_ON;
+ goto out;
}
+ switch (state) {
+ case DPMSModeOn:
+ result = GPM_DPMS_MODE_ON;
+ break;
+ case DPMSModeStandby:
+ result = GPM_DPMS_MODE_STANDBY;
+ break;
+ case DPMSModeSuspend:
+ result = GPM_DPMS_MODE_SUSPEND;
+ break;
+ case DPMSModeOff:
+ result = GPM_DPMS_MODE_OFF;
+ break;
+ default:
+ result = GPM_DPMS_MODE_ON;
+ break;
+ }
+out:
+ if (mode)
+ *mode = result;
return TRUE;
}
+/**
+ * gpm_dpms_x11_set_mode:
+ **/
static gboolean
-x11_set_mode (GpmDpms *dpms,
- GpmDpmsMode mode,
- GError **error)
+gpm_dpms_x11_set_mode (GpmDpms *dpms, GpmDpmsMode mode, GError **error)
{
GpmDpmsMode current_mode;
CARD16 state;
CARD16 current_state;
BOOL current_enabled;
- if (dpms->priv->dpms_capable == FALSE) {
+ if (!dpms->priv->dpms_capable) {
egg_debug ("not DPMS capable");
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
"Display is not DPMS capable");
return FALSE;
}
- if (! DPMSInfo (GDK_DISPLAY (), ¤t_state, ¤t_enabled)) {
+ if (!DPMSInfo (GDK_DISPLAY (), ¤t_state, ¤t_enabled)) {
egg_debug ("couldn't get DPMS info");
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
"Unable to get DPMS state");
return FALSE;
}
- if (! current_enabled) {
+ if (!current_enabled) {
egg_debug ("DPMS not enabled");
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
"DPMS is not enabled");
return FALSE;
}
@@ -296,17 +180,13 @@
break;
}
- x11_get_mode (dpms, ¤t_mode, NULL);
-
+ gpm_dpms_x11_get_mode (dpms, ¤t_mode, NULL);
if (current_mode != mode) {
if (! DPMSForceLevel (GDK_DISPLAY (), state)) {
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
"Could not change DPMS mode");
return FALSE;
}
-
XSync (GDK_DISPLAY (), FALSE);
}
@@ -315,215 +195,50 @@
#else /* HAVE_DPMS_EXTENSION */
+/**
+ * gpm_dpms_x11_get_mode:
+ **/
static gboolean
-x11_get_mode (GpmDpms *dpms,
- GpmDpmsMode *mode,
- GError **error)
+gpm_dpms_x11_get_mode (GpmDpms *dpms, GpmDpmsMode *mode, GError **error)
{
- if (mode) {
+ if (mode)
*mode = GPM_DPMS_MODE_ON;
- }
-
return TRUE;
}
+/**
+ * gpm_dpms_x11_set_mode:
+ **/
static gboolean
-x11_set_mode (GpmDpms *dpms,
- GpmDpmsMode mode,
- GError **error)
+gpm_dpms_x11_set_mode (GpmDpms *dpms, GpmDpmsMode mode, GError **error)
{
return FALSE;
}
#endif /* !HAVE_DPMS_EXTENSION */
-static gboolean
-sync_settings (GpmDpms *dpms,
- GError **error)
-{
- guint standby;
- guint suspend;
- guint off;
-
- if (dpms->priv->active) {
- standby = dpms->priv->standby_timeout;
- suspend = dpms->priv->suspend_timeout;
- off = dpms->priv->off_timeout;
- } else {
- standby = 0;
- suspend = 0;
- off = 0;
- }
-
- if (dpms->priv->dpms_capable == FALSE) {
- egg_debug ("Display is not DPMS capable");
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
- "Display is not DPMS capable");
-
- return FALSE;
- }
-
- /* We always try to keep the DPMS enabled so that
- we can use set the mode manually. We will
- use zero values for the timeouts when the
- we aren't active in order to prevent it
- from activating. */
- return x11_sync_server_dpms_settings (GDK_DISPLAY (),
- dpms->priv->enabled,
- standby,
- suspend,
- off,
- error);
-}
-
-gboolean
-gpm_dpms_get_enabled (GpmDpms *dpms,
- gboolean *enabled,
- GError **error)
-{
- g_return_val_if_fail (GPM_IS_DPMS (dpms), FALSE);
-
- if (enabled) {
- *enabled = dpms->priv->enabled;
- }
-
- return TRUE;
-}
-
-gboolean
-gpm_dpms_set_enabled (GpmDpms *dpms,
- gboolean enabled,
- GError **error)
-{
- gboolean ret;
-
- g_return_val_if_fail (GPM_IS_DPMS (dpms), FALSE);
-
- ret = FALSE;
- if (dpms->priv->enabled != enabled) {
- egg_debug ("setting DPMS enabled: %d", enabled);
-
- dpms->priv->enabled = enabled;
-
- ret = sync_settings (dpms, error);
- }
-
- return ret;
-}
-
-gboolean
-gpm_dpms_get_active (GpmDpms *dpms,
- gboolean *active,
- GError **error)
-{
- g_return_val_if_fail (GPM_IS_DPMS (dpms), FALSE);
-
- if (active) {
- *active = dpms->priv->active;
- }
-
- return TRUE;
-}
-
-gboolean
-gpm_dpms_set_active (GpmDpms *dpms,
- gboolean active,
- GError **error)
-{
- gboolean ret;
-
- g_return_val_if_fail (GPM_IS_DPMS (dpms), FALSE);
-
- ret = FALSE;
- if (dpms->priv->active != active) {
- egg_debug ("setting DPMS active: %d", active);
-
- dpms->priv->active = active;
-
- ret = sync_settings (dpms, error);
- }
-
- return ret;
-}
-
-/* time specified in seconds */
-gboolean
-gpm_dpms_set_timeouts (GpmDpms *dpms,
- guint standby,
- guint suspend,
- guint off,
- GError **error)
-{
- gboolean ret;
-
- g_return_val_if_fail (GPM_IS_DPMS (dpms), FALSE);
-
- dpms->priv->standby_timeout = standby;
- dpms->priv->suspend_timeout = suspend;
- dpms->priv->off_timeout = off;
-
- ret = sync_settings (dpms, error);
-
- return ret;
-}
-
/**
- * gpm_dpms_method_from_string:
- * @dpms_method: Method type, e.g. "off" or "staggered"
- *
- * Convert descriptive types to enumerated values.
+ * gpm_dpms_mode_from_string:
**/
-GpmDpmsMethod
-gpm_dpms_method_from_string (const gchar *dpms_method)
-{
- GpmDpmsMethod method;
-
- /* default to unknown */
- method = GPM_DPMS_METHOD_UNKNOWN;
- if (dpms_method == NULL) {
- return method;
- }
-
- /* convert descriptive types to enumerated values */
- if (strcmp (dpms_method, "default") == 0) {
- method = GPM_DPMS_METHOD_DEFAULT;
- } else if (strcmp (dpms_method, "stagger") == 0) {
- method = GPM_DPMS_METHOD_STAGGER;
- } else if (strcmp (dpms_method, "standby") == 0) {
- method = GPM_DPMS_METHOD_STANDBY;
- } else if (strcmp (dpms_method, "suspend") == 0) {
- method = GPM_DPMS_METHOD_SUSPEND;
- } else if (strcmp (dpms_method, "off") == 0) {
- method = GPM_DPMS_METHOD_OFF;
- } else {
- egg_warning ("dpms_method '%s' not recognised", dpms_method);
- }
-
- return method;
-}
-
GpmDpmsMode
gpm_dpms_mode_from_string (const gchar *str)
{
- if (str == NULL) {
+ if (str == NULL)
return GPM_DPMS_MODE_UNKNOWN;
- }
-
- if (strcmp (str, "on") == 0) {
+ if (strcmp (str, "on") == 0)
return GPM_DPMS_MODE_ON;
- } else if (strcmp (str, "standby") == 0) {
+ if (strcmp (str, "standby") == 0)
return GPM_DPMS_MODE_STANDBY;
- } else if (strcmp (str, "suspend") == 0) {
+ if (strcmp (str, "suspend") == 0)
return GPM_DPMS_MODE_SUSPEND;
- } else if (strcmp (str, "off") == 0) {
+ if (strcmp (str, "off") == 0)
return GPM_DPMS_MODE_OFF;
- } else {
- return GPM_DPMS_MODE_UNKNOWN;
- }
+ return GPM_DPMS_MODE_UNKNOWN;
}
+/**
+ * gpm_dpms_mode_to_string:
+ **/
const gchar *
gpm_dpms_mode_to_string (GpmDpmsMode mode)
{
@@ -546,14 +261,14 @@
str = NULL;
break;
}
-
return str;
}
+/**
+ * gpm_dpms_set_mode:
+ **/
gboolean
-gpm_dpms_set_mode_enum (GpmDpms *dpms,
- GpmDpmsMode mode,
- GError **error)
+gpm_dpms_set_mode (GpmDpms *dpms, GpmDpmsMode mode, GError **error)
{
gboolean ret;
@@ -561,224 +276,80 @@
if (mode == GPM_DPMS_MODE_UNKNOWN) {
egg_debug ("mode unknown");
- g_set_error (error,
- GPM_DPMS_ERROR,
- GPM_DPMS_ERROR_GENERAL,
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
"Unknown DPMS mode");
return FALSE;
}
- ret = x11_set_mode (dpms, mode, error);
-
+ ret = gpm_dpms_x11_set_mode (dpms, mode, error);
return ret;
}
+/**
+ * gpm_dpms_get_mode:
+ **/
gboolean
-gpm_dpms_get_mode_enum (GpmDpms *dpms,
- GpmDpmsMode *mode,
- GError **error)
+gpm_dpms_get_mode (GpmDpms *dpms, GpmDpmsMode *mode, GError **error)
{
gboolean ret;
-
- if (mode) {
+ if (mode)
*mode = GPM_DPMS_MODE_UNKNOWN;
- }
-
- ret = x11_get_mode (dpms, mode, error);
-
+ ret = gpm_dpms_x11_get_mode (dpms, mode, error);
return ret;
}
-static void
-gpm_dpms_set_standby_timeout (GpmDpms *dpms,
- guint timeout)
-{
- g_return_if_fail (GPM_IS_DPMS (dpms));
-
- if (dpms->priv->standby_timeout != timeout) {
- dpms->priv->standby_timeout = timeout;
- sync_settings (dpms, NULL);
- }
-}
-
-static void
-gpm_dpms_set_suspend_timeout (GpmDpms *dpms,
- guint timeout)
-{
- g_return_if_fail (GPM_IS_DPMS (dpms));
-
- if (dpms->priv->suspend_timeout != timeout) {
- dpms->priv->suspend_timeout = timeout;
- sync_settings (dpms, NULL);
- }
-}
-
-static void
-gpm_dpms_set_off_timeout (GpmDpms *dpms,
- guint timeout)
-{
- g_return_if_fail (GPM_IS_DPMS (dpms));
-
- if (dpms->priv->off_timeout != timeout) {
- dpms->priv->off_timeout = timeout;
- sync_settings (dpms, NULL);
- }
-}
-
-static void
-gpm_dpms_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
-{
- GpmDpms *self;
-
- self = GPM_DPMS (object);
-
- switch (prop_id) {
- case PROP_STANDBY_TIMEOUT:
- gpm_dpms_set_standby_timeout (self, g_value_get_uint (value));
- break;
- case PROP_SUSPEND_TIMEOUT:
- gpm_dpms_set_suspend_timeout (self, g_value_get_uint (value));
- break;
- case PROP_OFF_TIMEOUT:
- gpm_dpms_set_off_timeout (self, g_value_get_uint (value));
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-static void
-gpm_dpms_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
-{
- GpmDpms *self;
-
- self = GPM_DPMS (object);
-
- switch (prop_id) {
- case PROP_STANDBY_TIMEOUT:
- g_value_set_uint (value, self->priv->standby_timeout);
- break;
- case PROP_SUSPEND_TIMEOUT:
- g_value_set_uint (value, self->priv->suspend_timeout);
- break;
- case PROP_OFF_TIMEOUT:
- g_value_set_uint (value, self->priv->off_timeout);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- break;
- }
-}
-
-static void
-gpm_dpms_class_init (GpmDpmsClass *klass)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
- object_class->finalize = gpm_dpms_finalize;
- object_class->get_property = gpm_dpms_get_property;
- object_class->set_property = gpm_dpms_set_property;
-
- signals [MODE_CHANGED] =
- g_signal_new ("mode-changed",
- G_TYPE_FROM_CLASS (object_class),
- G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GpmDpmsClass, mode_changed),
- NULL,
- NULL,
- g_cclosure_marshal_VOID__INT,
- G_TYPE_NONE,
- 1, G_TYPE_INT);
-
- g_object_class_install_property (object_class,
- PROP_STANDBY_TIMEOUT,
- g_param_spec_uint ("standby-timeout",
- NULL,
- NULL,
- 0,
- G_MAXUINT,
- 0,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class,
- PROP_SUSPEND_TIMEOUT,
- g_param_spec_uint ("suspend-timeout",
- NULL,
- NULL,
- 0,
- G_MAXUINT,
- 0,
- G_PARAM_READWRITE));
- g_object_class_install_property (object_class,
- PROP_OFF_TIMEOUT,
- g_param_spec_uint ("off-timeout",
- NULL,
- NULL,
- 0,
- G_MAXUINT,
- 0,
- G_PARAM_READWRITE));
-
- g_type_class_add_private (klass, sizeof (GpmDpmsPrivate));
-}
-
+/**
+ * gpm_dpms_poll_mode_cb:
+ **/
static gboolean
-poll_dpms_mode (GpmDpms *dpms)
+gpm_dpms_poll_mode_cb (GpmDpms *dpms)
{
- gboolean res;
+ gboolean ret;
GpmDpmsMode mode;
- GError *error;
+ GError *error = NULL;
#ifndef HAVE_DPMS_EXTENSION
return FALSE;
#endif
- error = NULL;
- res = x11_get_mode (dpms, &mode, &error);
-
/* Try again */
- if (! res) {
+ ret = gpm_dpms_x11_get_mode (dpms, &mode, &error);
+ if (!ret) {
g_clear_error (&error);
-
return TRUE;
}
if (mode != dpms->priv->mode) {
dpms->priv->mode = mode;
-
- g_signal_emit (dpms,
- signals [MODE_CHANGED],
- 0,
- mode);
+ g_signal_emit (dpms, signals [MODE_CHANGED], 0, mode);
}
- /* FIXME: check that we are on console? */
-
return TRUE;
}
+/**
+ * gpm_dpms_class_init:
+ **/
static void
-remove_poll_timer (GpmDpms *dpms)
+gpm_dpms_class_init (GpmDpmsClass *klass)
{
- if (dpms->priv->timer_id != 0) {
- g_source_remove (dpms->priv->timer_id);
- dpms->priv->timer_id = 0;
- }
-}
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
-static void
-add_poll_timer (GpmDpms *dpms,
- glong timeout)
-{
- dpms->priv->timer_id = g_timeout_add_seconds (timeout, (GSourceFunc)poll_dpms_mode, dpms);
+ object_class->finalize = gpm_dpms_finalize;
+
+ signals [MODE_CHANGED] =
+ g_signal_new ("mode-changed",
+ G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GpmDpmsClass, mode_changed),
+ NULL, NULL, g_cclosure_marshal_VOID__UINT,
+ G_TYPE_NONE, 1, G_TYPE_UINT);
+
+ g_type_class_add_private (klass, sizeof (GpmDpmsPrivate));
}
+/**
+ * gpm_dpms_init:
+ **/
static void
gpm_dpms_init (GpmDpms *dpms)
{
@@ -786,10 +357,12 @@
/* DPMSCapable() can never change for a given display */
dpms->priv->dpms_capable = DPMSCapable (GDK_DISPLAY ());
-
- add_poll_timer (dpms, GPM_DPMS_POLL_TIME);
+ dpms->priv->timer_id = g_timeout_add_seconds (GPM_DPMS_POLL_TIME, (GSourceFunc)gpm_dpms_poll_mode_cb, dpms);
}
+/**
+ * gpm_dpms_finalize:
+ **/
static void
gpm_dpms_finalize (GObject *object)
{
@@ -802,11 +375,15 @@
g_return_if_fail (dpms->priv != NULL);
- remove_poll_timer (dpms);
+ if (dpms->priv->timer_id != 0)
+ g_source_remove (dpms->priv->timer_id);
G_OBJECT_CLASS (gpm_dpms_parent_class)->finalize (object);
}
+/**
+ * gpm_dpms_new:
+ **/
GpmDpms *
gpm_dpms_new (void)
{
@@ -818,3 +395,87 @@
}
return GPM_DPMS (gpm_dpms_object);
}
+
+
+/***************************************************************************
+ *** MAKE CHECK TESTS ***
+ ***************************************************************************/
+#ifdef EGG_TEST
+#include "egg-test.h"
+
+void
+gpm_dpms_test (gpointer data)
+{
+ GpmDpms *dpms;
+ gboolean ret;
+ GError *error = NULL;
+ EggTest *test = (EggTest *) data;
+
+ if (!egg_test_start (test, "GpmDpms"))
+ return;
+
+ /************************************************************/
+ egg_test_title (test, "get object");
+ dpms = gpm_dpms_new ();
+ if (dpms != NULL)
+ egg_test_success (test, NULL);
+ else
+ egg_test_failed (test, "got no object");
+
+ /************************************************************/
+ egg_test_title (test, "set on");
+ ret = gpm_dpms_set_mode (dpms, GPM_DPMS_MODE_ON, &error);
+ if (ret)
+ egg_test_success (test, NULL);
+ else
+ egg_test_failed (test, "failed: %s", error->message);
+
+ g_usleep (2*1000*1000);
+
+ /************************************************************/
+ egg_test_title (test, "set STANDBY");
+ ret = gpm_dpms_set_mode (dpms, GPM_DPMS_MODE_STANDBY, &error);
+ if (ret)
+ egg_test_success (test, NULL);
+ else
+ egg_test_failed (test, "failed: %s", error->message);
+
+ g_usleep (2*1000*1000);
+
+ /************************************************************/
+ egg_test_title (test, "set SUSPEND");
+ ret = gpm_dpms_set_mode (dpms, GPM_DPMS_MODE_SUSPEND, &error);
+ if (ret)
+ egg_test_success (test, NULL);
+ else
+ egg_test_failed (test, "failed: %s", error->message);
+
+ g_usleep (2*1000*1000);
+
+ /************************************************************/
+ egg_test_title (test, "set OFF");
+ ret = gpm_dpms_set_mode (dpms, GPM_DPMS_MODE_OFF, &error);
+ if (ret)
+ egg_test_success (test, NULL);
+ else
+ egg_test_failed (test, "failed: %s", error->message);
+
+ g_usleep (2*1000*1000);
+
+ /************************************************************/
+ egg_test_title (test, "set on");
+ ret = gpm_dpms_set_mode (dpms, GPM_DPMS_MODE_ON, &error);
+ if (ret)
+ egg_test_success (test, NULL);
+ else
+ egg_test_failed (test, "failed: %s", error->message);
+
+ g_usleep (2*1000*1000);
+
+ g_object_unref (dpms);
+
+ egg_test_end (test);
+}
+
+#endif
+
Modified: trunk/src/gpm-dpms.h
==============================================================================
--- trunk/src/gpm-dpms.h (original)
+++ trunk/src/gpm-dpms.h Mon Mar 23 14:17:50 2009
@@ -1,6 +1,7 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Copyright (C) 2004-2005 William Jon McCann <mccann jhu edu>
+ * Copyright (C) 2006-2009 Richard Hughes <richard hughsie com>
*
* Licensed under the GNU General Public License Version 2
*
@@ -39,15 +40,6 @@
GPM_DPMS_MODE_UNKNOWN
} GpmDpmsMode;
-typedef enum {
- GPM_DPMS_METHOD_DEFAULT,
- GPM_DPMS_METHOD_STAGGER,
- GPM_DPMS_METHOD_STANDBY,
- GPM_DPMS_METHOD_SUSPEND,
- GPM_DPMS_METHOD_OFF,
- GPM_DPMS_METHOD_UNKNOWN
-} GpmDpmsMethod;
-
typedef struct GpmDpmsPrivate GpmDpmsPrivate;
typedef struct
@@ -73,40 +65,15 @@
GQuark gpm_dpms_error_quark (void);
GType gpm_dpms_get_type (void);
GpmDpms *gpm_dpms_new (void);
-gboolean gpm_dpms_has_hw (void);
-
-gboolean gpm_dpms_get_active (GpmDpms *dpms,
- gboolean *active,
- GError **error);
-gboolean gpm_dpms_set_active (GpmDpms *dpms,
- gboolean active,
- GError **error);
-
-gboolean gpm_dpms_get_enabled (GpmDpms *dpms,
- gboolean *enabled,
- GError **error);
-gboolean gpm_dpms_set_enabled (GpmDpms *dpms,
- gboolean enabled,
- GError **error);
-
-gboolean gpm_dpms_set_timeouts (GpmDpms *dpms,
- guint standby,
- guint suspend,
- guint off,
- GError **error);
-
-/* Direct manipulation */
-gboolean gpm_dpms_get_mode_enum (GpmDpms *dpms,
+gboolean gpm_dpms_get_mode (GpmDpms *dpms,
GpmDpmsMode *mode,
GError **error);
-gboolean gpm_dpms_set_mode_enum (GpmDpms *dpms,
+gboolean gpm_dpms_set_mode (GpmDpms *dpms,
GpmDpmsMode mode,
GError **error);
-
const gchar *gpm_dpms_mode_to_string (GpmDpmsMode mode);
GpmDpmsMode gpm_dpms_mode_from_string (const gchar *mode);
-
-GpmDpmsMethod gpm_dpms_method_from_string (const gchar *dpms_method);
+void gpm_dpms_test (gpointer data);
G_END_DECLS
Modified: trunk/src/gpm-idle.c
==============================================================================
--- trunk/src/gpm-idle.c (original)
+++ trunk/src/gpm-idle.c Mon Mar 23 14:17:50 2009
@@ -47,9 +47,10 @@
/* Sets the idle percent limit, i.e. how hard the computer can work
while considered "at idle" */
-#define GPM_IDLE_CPU_LIMIT 5
-
-#define GPM_IDLE_IDLETIME_ALARM_ID 1
+#define GPM_IDLE_CPU_LIMIT 5
+#define GPM_IDLE_IDLETIME_ALARM_ID 1
+#define GPM_IDLE_IDLETIME_IGNORE_ID 2
+#define GPM_IDLE_TIMEOUT_IGNORE_DPMS_CHANGE 1.0f /* seconds */
struct GpmIdlePrivate
{
@@ -64,6 +65,7 @@
guint timeout_sleep_id;
gboolean x_idle;
gboolean check_type_cpu;
+ GTimer *timer;
};
enum {
@@ -105,7 +107,12 @@
if (mode != idle->priv->mode) {
idle->priv->mode = mode;
- egg_debug ("Doing a state transition: %s", gpm_idle_mode_to_text (mode));
+
+ /* we save the time of the last state, so we can ignore the X11
+ * timer reset when we change brightness or do DPMS actions */
+ g_timer_reset (idle->priv->timer);
+
+ egg_warning ("Doing a state transition: %s", gpm_idle_mode_to_text (mode));
g_signal_emit (idle, signals [IDLE_CHANGED], 0, mode);
}
}
@@ -187,17 +194,25 @@
is_inhibited = gpm_session_get_inhibited (idle->priv->session);
egg_debug ("is_idle=%i, is_inhibited=%i", is_idle, is_inhibited);
- if (idle->priv->x_idle) {
- if (is_inhibited)
- gpm_idle_set_mode (idle, GPM_IDLE_MODE_NORMAL);
- else
- gpm_idle_set_mode (idle, GPM_IDLE_MODE_DIM);
- } else {
+ /* check we are really idle */
+ if (!idle->priv->x_idle) {
gpm_idle_set_mode (idle, GPM_IDLE_MODE_NORMAL);
+ egg_debug ("X not idle");
+ if (idle->priv->timeout_blank_id != 0) {
+ g_source_remove (idle->priv->timeout_blank_id);
+ idle->priv->timeout_blank_id = 0;
+ }
+ if (idle->priv->timeout_sleep_id != 0) {
+ g_source_remove (idle->priv->timeout_sleep_id);
+ idle->priv->timeout_sleep_id = 0;
+ }
+ goto out;
}
- /* normal */
- if (!is_idle) {
+ /* are we inhibited */
+ if (is_inhibited) {
+ egg_debug ("inhibited, so using normal state");
+ gpm_idle_set_mode (idle, GPM_IDLE_MODE_NORMAL);
if (idle->priv->timeout_blank_id != 0) {
g_source_remove (idle->priv->timeout_blank_id);
idle->priv->timeout_blank_id = 0;
@@ -206,22 +221,30 @@
g_source_remove (idle->priv->timeout_sleep_id);
idle->priv->timeout_sleep_id = 0;
}
- /* don't reset DIM state */
- if (idle->priv->mode == GPM_IDLE_MODE_BLANK ||
- idle->priv->mode == GPM_IDLE_MODE_SLEEP)
- gpm_idle_set_mode (idle, GPM_IDLE_MODE_NORMAL);
+ goto out;
}
- /* if there are any inhibits, clear the dim timeout */
+ /* normal to dim */
+ if (idle->priv->mode == GPM_IDLE_MODE_NORMAL) {
+ egg_debug ("normal to dim");
+ gpm_idle_set_mode (idle, GPM_IDLE_MODE_DIM);
+ }
+
+ /* set up blank callback even when session is not idle */
+ if (idle->priv->timeout_blank_id == 0) {
+ egg_debug ("setting up blank callback");
+ idle->priv->timeout_blank_id = g_timeout_add_seconds (idle->priv->timeout_blank, (GSourceFunc) gpm_idle_blank_cb, idle);
+ }
+
+ /* only do the sleep timeout when the session is idle */
if (is_idle) {
- /* normal to dim */
- if (idle->priv->mode == GPM_IDLE_MODE_NORMAL)
- gpm_idle_set_mode (idle, GPM_IDLE_MODE_DIM);
- if (idle->priv->timeout_blank_id != 0)
- idle->priv->timeout_blank_id = g_timeout_add_seconds (idle->priv->timeout_blank, (GSourceFunc) gpm_idle_blank_cb, idle);
- if (idle->priv->timeout_sleep_id != 0)
+ if (idle->priv->timeout_sleep_id == 0) {
+ egg_debug ("setting up sleep callback = %i", idle->priv->timeout_blank);
idle->priv->timeout_sleep_id = g_timeout_add_seconds (idle->priv->timeout_sleep, (GSourceFunc) gpm_idle_sleep_cb, idle);
+ }
}
+out:
+ return;
}
/**
@@ -305,23 +328,57 @@
/**
* gpm_idle_idletime_alarm_expired_cb:
+ *
+ * We're idle, something timed out
**/
static void
gpm_idle_idletime_alarm_expired_cb (EggIdletime *idletime, guint alarm_id, GpmIdle *idle)
{
+ gboolean ret;
+
+ egg_debug ("idletime alarm: %i", alarm_id);
+
+ /* this must be out 500ms ignored timer */
+ if (idle->priv->x_idle) {
+ egg_warning ("removing ignored timer");
+ ret = egg_idletime_alarm_remove (idle->priv->idletime, GPM_IDLE_IDLETIME_IGNORE_ID);
+ if (!ret)
+ egg_warning ("failed to remove timer %i", GPM_IDLE_IDLETIME_IGNORE_ID);
+ return;
+ }
+
/* set again */
- egg_debug ("idletime alarm");
idle->priv->x_idle = TRUE;
gpm_idle_evaluate (idle);
}
/**
* gpm_idle_idletime_reset_cb:
+ *
+ * We're no longer idle, the user moved
**/
static void
gpm_idle_idletime_reset_cb (EggIdletime *idletime, GpmIdle *idle)
{
- egg_debug ("idletime reset");
+ guint id;
+ gboolean ret;
+ gdouble elapsed;
+ elapsed = g_timer_elapsed (idle->priv->timer, NULL);
+
+ id = egg_idletime_alarm_get (idle->priv->idletime);
+ egg_debug ("idletime reset: %i", id);
+
+ /* have we just chaged state? */
+ if (idle->priv->mode == GPM_IDLE_MODE_BLANK &&
+ elapsed < GPM_IDLE_TIMEOUT_IGNORE_DPMS_CHANGE) {
+ egg_warning ("ignoring reset, as we've just done a state change");
+ /* make sure we trigger a short 1ms timeout so we can get the expired signal */
+ ret = egg_idletime_alarm_set (idle->priv->idletime, GPM_IDLE_IDLETIME_IGNORE_ID, 500);
+ if (!ret)
+ egg_error ("failed to set timer %i", GPM_IDLE_IDLETIME_IGNORE_ID);
+ return;
+ }
+
idle->priv->x_idle = FALSE;
gpm_idle_evaluate (idle);
}
@@ -347,6 +404,7 @@
if (idle->priv->timeout_sleep_id != 0)
g_source_remove (idle->priv->timeout_sleep_id);
+ g_timer_destroy (idle->priv->timer);
g_object_unref (idle->priv->load);
g_object_unref (idle->priv->session);
g_object_unref (idle->priv->idletime);
@@ -395,6 +453,7 @@
idle->priv->timeout_blank_id = 0;
idle->priv->timeout_sleep_id = 0;
idle->priv->x_idle = FALSE;
+ idle->priv->timer = g_timer_new ();
idle->priv->load = gpm_load_new ();
idle->priv->session = gpm_session_new ();
g_signal_connect (idle->priv->session, "idle-changed", G_CALLBACK (gpm_idle_session_idle_changed_cb), idle);
Modified: trunk/src/gpm-manager.c
==============================================================================
--- trunk/src/gpm-manager.c (original)
+++ trunk/src/gpm-manager.c Mon Mar 23 14:17:50 2009
@@ -337,7 +337,7 @@
if (!gpm_screensaver_lock (manager->priv->screensaver))
egg_debug ("Could not lock screen via gnome-screensaver");
}
- gpm_dpms_set_mode_enum (manager->priv->dpms, GPM_DPMS_MODE_OFF, &error);
+ gpm_dpms_set_mode (manager->priv->dpms, GPM_DPMS_MODE_OFF, &error);
if (error) {
egg_debug ("Unable to set DPMS mode: %s", error->message);
g_error_free (error);
@@ -362,7 +362,7 @@
GError *error;
error = NULL;
- gpm_dpms_set_mode_enum (manager->priv->dpms, GPM_DPMS_MODE_ON, &error);
+ gpm_dpms_set_mode (manager->priv->dpms, GPM_DPMS_MODE_ON, &error);
if (error) {
egg_debug ("Unable to set DPMS mode: %s", error->message);
g_error_free (error);
@@ -704,7 +704,7 @@
* @mode: The idle mode, e.g. GPM_IDLE_MODE_BLANK
* @manager: This class instance
*
- * This callback is called when gnome-screensaver detects that the idle state
+ * This callback is called when the idle class detects that the idle state
* has changed. GPM_IDLE_MODE_BLANK is when the session has become inactive,
* and GPM_IDLE_MODE_SLEEP is where the session has become inactive, AND the
* session timeout has elapsed for the idle action.
@@ -732,10 +732,10 @@
egg_debug ("Idle state changed: NORMAL");
gpm_brightness_kbd_undim (manager->priv->brightness_kbd);
} else if (mode == GPM_IDLE_MODE_BLANK) {
- egg_debug ("Idle state changed: SESSION");
+ egg_debug ("Idle state changed: BLANK");
gpm_brightness_kbd_dim (manager->priv->brightness_kbd);
} else if (mode == GPM_IDLE_MODE_SLEEP) {
- egg_debug ("Idle state changed: SYSTEM");
+ egg_debug ("Idle state changed: SLEEP");
if (gpm_manager_is_inhibit_valid (manager, FALSE, "timeout action") == FALSE)
return;
idle_do_sleep (manager);
@@ -810,7 +810,7 @@
update_dpms_throttle (GpmManager *manager)
{
GpmDpmsMode mode;
- gpm_dpms_get_mode_enum (manager->priv->dpms, &mode, NULL);
+ gpm_dpms_get_mode (manager->priv->dpms, &mode, NULL);
/* Throttle the manager when DPMS is active since we can't see it anyway */
if (mode == GPM_DPMS_MODE_ON) {
@@ -1125,7 +1125,7 @@
/* We turn on the monitor unconditionally, as we may be using
* a smartcard to authenticate and DPMS might still be on.
* See #350291 for more details */
- gpm_dpms_set_mode_enum (manager->priv->dpms, GPM_DPMS_MODE_ON, &error);
+ gpm_dpms_set_mode (manager->priv->dpms, GPM_DPMS_MODE_ON, &error);
if (error != NULL) {
egg_warning ("Failed to turn on DPMS: %s", error->message);
g_error_free (error);
Modified: trunk/src/gpm-prefs-core.c
==============================================================================
--- trunk/src/gpm-prefs-core.c (original)
+++ trunk/src/gpm-prefs-core.c Mon Mar 23 14:17:50 2009
@@ -300,8 +300,10 @@
{
int value;
char *gpm_pref_key;
+ gboolean sleep_prefix;
value = (int) gtk_range_get_value (range);
+ sleep_prefix = (gboolean) GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (range), "sleep-prefix"));
if (value == NEVER_TIME_ON_SLIDER) {
/* power manager interprets 0 as Never */
@@ -310,7 +312,8 @@
/* We take away the g-s idle time as the slider represents
* global time but we only do our timeout from when gnome-session
* declares the session idle */
- value -= prefs->priv->idle_delay;
+ if (sleep_prefix)
+ value -= prefs->priv->idle_delay;
/* policy is in seconds, slider is in minutes */
value *= 60;
@@ -328,7 +331,7 @@
* @gpm_pref_key: The GConf key for this preference setting.
**/
static GtkWidget *
-gpm_prefs_setup_sleep_slider (GpmPrefs *prefs, const gchar *widget_name, const gchar *gpm_pref_key)
+gpm_prefs_setup_sleep_slider (GpmPrefs *prefs, const gchar *widget_name, const gchar *gpm_pref_key, gboolean sleep_prefix)
{
GtkWidget *widget;
gint value;
@@ -349,9 +352,12 @@
} else {
/* policy is in seconds, slider is in minutes */
value /= 60;
- value += prefs->priv->idle_delay;
+ if (sleep_prefix)
+ value += prefs->priv->idle_delay;
}
+ g_object_set_data (G_OBJECT (widget), "sleep-prefix", GUINT_TO_POINTER (sleep_prefix));
+
/* set upper */
adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));
gtk_adjustment_set_upper (adjustment, NEVER_TIME_ON_SLIDER);
@@ -373,8 +379,7 @@
* @gpm_pref_key: The GConf key for this preference setting.
**/
static void
-gpm_prefs_brightness_slider_changed_cb (GtkRange *range,
- GpmPrefs *prefs)
+gpm_prefs_brightness_slider_changed_cb (GtkRange *range, GpmPrefs *prefs)
{
gdouble value;
gchar *gpm_pref_key;
@@ -785,9 +790,9 @@
GPM_CONF_BUTTON_LID_AC,
button_lid_actions);
gpm_prefs_setup_sleep_slider (prefs, "hscale_ac_computer",
- GPM_CONF_TIMEOUT_SLEEP_COMPUTER_AC);
+ GPM_CONF_TIMEOUT_SLEEP_COMPUTER_AC, TRUE);
gpm_prefs_setup_sleep_slider (prefs, "hscale_ac_display",
- GPM_CONF_TIMEOUT_SLEEP_DISPLAY_AC);
+ GPM_CONF_TIMEOUT_SLEEP_DISPLAY_AC, FALSE);
gpm_prefs_setup_brightness_slider (prefs, "hscale_ac_brightness",
GPM_CONF_BACKLIGHT_BRIGHTNESS_AC);
@@ -795,7 +800,6 @@
GPM_CONF_BACKLIGHT_IDLE_DIM_AC);
set_idle_hscale_stops (prefs, "hscale_ac_computer", prefs->priv->idle_delay);
- set_idle_hscale_stops (prefs, "hscale_ac_display", prefs->priv->idle_delay);
if (prefs->priv->has_button_lid == FALSE) {
widget = glade_xml_get_widget (prefs->priv->glade_xml, "hbox_ac_lid");
@@ -845,9 +849,9 @@
GPM_CONF_ACTIONS_CRITICAL_BATT,
battery_critical_actions);
gpm_prefs_setup_sleep_slider (prefs, "hscale_battery_computer",
- GPM_CONF_TIMEOUT_SLEEP_COMPUTER_BATT);
+ GPM_CONF_TIMEOUT_SLEEP_COMPUTER_BATT, TRUE);
gpm_prefs_setup_sleep_slider (prefs, "hscale_battery_display",
- GPM_CONF_TIMEOUT_SLEEP_DISPLAY_BATT);
+ GPM_CONF_TIMEOUT_SLEEP_DISPLAY_BATT, FALSE);
/* set up the battery reduce checkbox */
gpm_prefs_setup_checkbox (prefs, "checkbutton_battery_display_reduce",
@@ -862,7 +866,6 @@
}
set_idle_hscale_stops (prefs, "hscale_battery_computer", prefs->priv->idle_delay);
- set_idle_hscale_stops (prefs, "hscale_battery_display", prefs->priv->idle_delay);
if (prefs->priv->has_button_lid == FALSE) {
widget = glade_xml_get_widget (prefs->priv->glade_xml, "hbox_battery_lid");
@@ -902,7 +905,7 @@
GPM_CONF_ACTIONS_CRITICAL_UPS,
ups_low_actions);
gpm_prefs_setup_sleep_slider (prefs, "hscale_ups_computer",
- GPM_CONF_TIMEOUT_SLEEP_COMPUTER_BATT);
+ GPM_CONF_TIMEOUT_SLEEP_COMPUTER_BATT, TRUE);
set_idle_hscale_stops (prefs, "hscale_ups_computer", prefs->priv->idle_delay);
}
Modified: trunk/src/gpm-self-test.c
==============================================================================
--- trunk/src/gpm-self-test.c (original)
+++ trunk/src/gpm-self-test.c Mon Mar 23 14:17:50 2009
@@ -40,6 +40,7 @@
void gpm_cell_test_array (EggTest *test);
void gpm_inhibit_test (EggTest *test);
void gpm_phone_test (EggTest *test);
+void gpm_dpms_test (EggTest *test);
void gpm_graph_widget_test (EggTest *test);
void gpm_proxy_test (EggTest *test);
void gpm_hal_device_power_test (EggTest *test);
@@ -69,6 +70,7 @@
gpm_common_test (test);
gpm_inhibit_test (test);
gpm_phone_test (test);
+// gpm_dpms_test (test);
// gpm_graph_widget_test (test);
#if 0
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
