1 files changed, 474 insertions, 0 deletions
diff --git a/src/gpm-dpms.c b/src/gpm-dpms.c
new file mode 100644
index 0000000..13928f9
--- /dev/null
+++ b/src/gpm-dpms.c
@@ -0,0 +1,474 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2005 William Jon McCann <[email protected]>
+ * Copyright (C) 2006-2009 Richard Hughes <[email protected]>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <errno.h>
+
+#include <string.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif /* HAVE_UNISTD_H */
+
+#include <gdk/gdk.h>
+#include <gdk/gdkx.h>
+
+#include <X11/Xproto.h>
+#include <X11/extensions/dpms.h>
+
+#include "egg-debug.h"
+#include "gpm-dpms.h"
+
+static void gpm_dpms_finalize (GObject *object);
+
+#define GPM_DPMS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GPM_TYPE_DPMS, GpmDpmsPrivate))
+
+/* until we get a nice event-emitting DPMS extension, we have to poll... */
+#define GPM_DPMS_POLL_TIME 10
+
+struct GpmDpmsPrivate
+{
+ gboolean dpms_capable;
+ GpmDpmsMode mode;
+ guint timer_id;
+ Display *display;
+};
+
+enum {
+ MODE_CHANGED,
+ LAST_SIGNAL
+};
+
+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;
+}
+
+/**
+ * gpm_dpms_x11_get_mode:
+ **/
+static gboolean
+gpm_dpms_x11_get_mode (GpmDpms *dpms, GpmDpmsMode *mode, GError **error)
+{
+ GpmDpmsMode result;
+ BOOL enabled = FALSE;
+ CARD16 state;
+
+ if (dpms->priv->dpms_capable == FALSE) {
+ /* Server or monitor can't DPMS -- assume the monitor is on. */
+ result = GPM_DPMS_MODE_ON;
+ goto out;
+ }
+
+ DPMSInfo (dpms->priv->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
+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) {
+ egg_debug ("not DPMS capable");
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
+ "Display is not DPMS capable");
+ return FALSE;
+ }
+
+ if (!DPMSInfo (dpms->priv->display, &current_state, &current_enabled)) {
+ egg_debug ("couldn't get DPMS info");
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
+ "Unable to get DPMS state");
+ return FALSE;
+ }
+
+ if (!current_enabled) {
+ egg_debug ("DPMS not enabled");
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
+ "DPMS is not enabled");
+ return FALSE;
+ }
+
+ switch (mode) {
+ case GPM_DPMS_MODE_ON:
+ state = DPMSModeOn;
+ break;
+ case GPM_DPMS_MODE_STANDBY:
+ state = DPMSModeStandby;
+ break;
+ case GPM_DPMS_MODE_SUSPEND:
+ state = DPMSModeSuspend;
+ break;
+ case GPM_DPMS_MODE_OFF:
+ state = DPMSModeOff;
+ break;
+ default:
+ state = DPMSModeOn;
+ break;
+ }
+
+ gpm_dpms_x11_get_mode (dpms, &current_mode, NULL);
+ if (current_mode != mode) {
+ if (! DPMSForceLevel (dpms->priv->display, state)) {
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
+ "Could not change DPMS mode");
+ return FALSE;
+ }
+ XSync (dpms->priv->display, FALSE);
+ }
+
+ return TRUE;
+}
+
+/**
+ * gpm_dpms_mode_from_string:
+ **/
+GpmDpmsMode
+gpm_dpms_mode_from_string (const gchar *str)
+{
+ if (str == NULL)
+ return GPM_DPMS_MODE_UNKNOWN;
+ if (strcmp (str, "on") == 0)
+ return GPM_DPMS_MODE_ON;
+ if (strcmp (str, "standby") == 0)
+ return GPM_DPMS_MODE_STANDBY;
+ if (strcmp (str, "suspend") == 0)
+ return GPM_DPMS_MODE_SUSPEND;
+ if (strcmp (str, "off") == 0)
+ return GPM_DPMS_MODE_OFF;
+ return GPM_DPMS_MODE_UNKNOWN;
+}
+
+/**
+ * gpm_dpms_mode_to_string:
+ **/
+const gchar *
+gpm_dpms_mode_to_string (GpmDpmsMode mode)
+{
+ const gchar *str = NULL;
+
+ switch (mode) {
+ case GPM_DPMS_MODE_ON:
+ str = "on";
+ break;
+ case GPM_DPMS_MODE_STANDBY:
+ str = "standby";
+ break;
+ case GPM_DPMS_MODE_SUSPEND:
+ str = "suspend";
+ break;
+ case GPM_DPMS_MODE_OFF:
+ str = "off";
+ break;
+ default:
+ str = NULL;
+ break;
+ }
+ return str;
+}
+
+/**
+ * gpm_dpms_set_mode:
+ **/
+gboolean
+gpm_dpms_set_mode (GpmDpms *dpms, GpmDpmsMode mode, GError **error)
+{
+ gboolean ret;
+
+ g_return_val_if_fail (GPM_IS_DPMS (dpms), FALSE);
+
+ if (mode == GPM_DPMS_MODE_UNKNOWN) {
+ egg_debug ("mode unknown");
+ g_set_error (error, GPM_DPMS_ERROR, GPM_DPMS_ERROR_GENERAL,
+ "Unknown DPMS mode");
+ return FALSE;
+ }
+
+ ret = gpm_dpms_x11_set_mode (dpms, mode, error);
+ return ret;
+}
+
+/**
+ * gpm_dpms_get_mode:
+ **/
+gboolean
+gpm_dpms_get_mode (GpmDpms *dpms, GpmDpmsMode *mode, GError **error)
+{
+ gboolean ret;
+ if (mode)
+ *mode = GPM_DPMS_MODE_UNKNOWN;
+ ret = gpm_dpms_x11_get_mode (dpms, mode, error);
+ return ret;
+}
+
+/**
+ * gpm_dpms_poll_mode_cb:
+ **/
+static gboolean
+gpm_dpms_poll_mode_cb (GpmDpms *dpms)
+{
+ gboolean ret;
+ GpmDpmsMode mode;
+ GError *error = NULL;
+
+ /* Try again */
+ 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);
+ }
+
+ return TRUE;
+}
+
+/**
+ * gpm_dpms_clear_timeouts:
+ **/
+static gboolean
+gpm_dpms_clear_timeouts (GpmDpms *dpms)
+{
+ gboolean ret = FALSE;
+
+ /* never going to work */
+ if (!dpms->priv->dpms_capable) {
+ egg_debug ("not DPMS capable");
+ goto out;
+ }
+
+ egg_debug ("set timeouts to zero");
+ ret = DPMSSetTimeouts (dpms->priv->display, 0, 0, 0);
+
+out:
+ return ret;
+}
+
+/**
+ * gpm_dpms_class_init:
+ **/
+static void
+gpm_dpms_class_init (GpmDpmsClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ 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)
+{
+ dpms->priv = GPM_DPMS_GET_PRIVATE (dpms);
+
+ /* DPMSCapable() can never change for a given display */
+ dpms->priv->display = GDK_DISPLAY_XDISPLAY (gdk_display_get_default());
+ dpms->priv->dpms_capable = DPMSCapable (dpms->priv->display);
+ dpms->priv->timer_id = g_timeout_add_seconds (GPM_DPMS_POLL_TIME, (GSourceFunc)gpm_dpms_poll_mode_cb, dpms);
+
+ /* ensure we clear the default timeouts (Standby: 1200s, Suspend: 1800s, Off: 2400s) */
+ gpm_dpms_clear_timeouts (dpms);
+}
+
+/**
+ * gpm_dpms_finalize:
+ **/
+static void
+gpm_dpms_finalize (GObject *object)
+{
+ GpmDpms *dpms;
+
+ g_return_if_fail (object != NULL);
+ g_return_if_fail (GPM_IS_DPMS (object));
+
+ dpms = GPM_DPMS (object);
+
+ g_return_if_fail (dpms->priv != NULL);
+
+ 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)
+{
+ if (gpm_dpms_object != NULL) {
+ g_object_ref (gpm_dpms_object);
+ } else {
+ gpm_dpms_object = g_object_new (GPM_TYPE_DPMS, NULL);
+ g_object_add_weak_pointer (gpm_dpms_object, &gpm_dpms_object);
+ }
+ 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
+