gpm-backlight-kbd.h				\

	gpm-backlight-kbd.c				\

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-

 *

 * Copyright (C) 2010 Alex Murray <murray.alex@gmail.com>

 * Copyright (C) 2005-2009 Richard Hughes <richard@hughsie.com>

 * Copyright (C) 2005 William Jon McCann <mccann@jhu.edu>

 *

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

 */

#ifdef HAVE_CONFIG_H

#  include <config.h>

#endif

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <errno.h>

#include <string.h>

#include <sys/time.h>

#include <sys/types.h>

#include <math.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif /* HAVE_UNISTD_H */

#include <glib/gi18n.h>

#include <dbus/dbus-glib.h>

#include <gconf/gconf-client.h>

#include <libupower-glib/upower.h>

#include "gpm-button.h"

#include "gpm-backlight-kbd.h"

#include "gpm-control.h"

#include "gpm-common.h"

#include "egg-debug.h"

#include "gsd-media-keys-window.h"

#include "gpm-dpms.h"

#include "gpm-idle.h"

#include "gpm-marshal.h"

#include "gpm-stock-icons.h"

#include "gpm-prefs-server.h"

#include "egg-console-kit.h"

#define GPM_BACKLIGHT_KBD_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GPM_TYPE_BACKLIGHT_KBD, GpmBacklightKbdPrivate))

struct GpmBacklightKbdPrivate

{

	UpClient		*client;

	DBusGProxy		*proxy;

	GpmButton		*button;

	GConfClient		*conf;

	GtkWidget		*popup;

	GpmControl		*control;

	GpmDpms			*dpms;

	GpmIdle			*idle;

	EggConsoleKit		*consolekit;

	gboolean		 system_is_idle;

	GTimer			*idle_timer;

	guint			 idle_dim_timeout;

	gint			 master_percentage;

	gint			 max_brightness;

	gboolean		 off;

};

G_DEFINE_TYPE (GpmBacklightKbd, gpm_backlight_kbd, G_TYPE_OBJECT)

#define BACKLIGHT_KBD_SERVICE     "org.freedesktop.UPower"

#define BACKLIGHT_KBD_PATH        "/org/freedesktop/UPower/KbdBacklight"

#define BACKLIGHT_KBD_INTERFACE   "org.freedesktop.UPower.KbdBacklight"

/**

 * gpm_backlight_kbd_dialog_init:

 *

 * Initialises the popup, and makes sure that it matches the compositing of the screen.

 **/

static void

gpm_backlight_kbd_dialog_init (GpmBacklightKbd *backlight_kbd)

{

	if (backlight_kbd->priv->popup != NULL

	    && !gsd_media_keys_window_is_valid (GSD_MEDIA_KEYS_WINDOW (backlight_kbd->priv->popup))) {

		gtk_widget_destroy (backlight_kbd->priv->popup);

		backlight_kbd->priv->popup = NULL;

	}

	if (backlight_kbd->priv->popup == NULL) {

		backlight_kbd->priv->popup= gsd_media_keys_window_new ();

		gsd_media_keys_window_set_action_custom (GSD_MEDIA_KEYS_WINDOW (backlight_kbd->priv->popup),

							 "gpm-brightness-kbd",

							 TRUE);

		gtk_window_set_position (GTK_WINDOW (backlight_kbd->priv->popup), GTK_WIN_POS_NONE);

	}

}

/**

 * gpm_backlight_kbd_dialog_show:

 *

 * Show the brightness popup, and place it nicely on the screen.

 **/

static void

gpm_backlight_kbd_dialog_show (GpmBacklightKbd *backlight_kbd)

{

	int            orig_w;

	int            orig_h;

	int            screen_w;

	int            screen_h;

	int            x;

	int            y;

	int            pointer_x;

	int            pointer_y;

	GtkRequisition win_req;

	GdkScreen     *pointer_screen;

	GdkRectangle   geometry;

	int            monitor;

	/*

	 * get the window size

	 * if the window hasn't been mapped, it doesn't necessarily

	 * know its true size, yet, so we need to jump through hoops

	 */

	gtk_window_get_default_size (GTK_WINDOW (backlight_kbd->priv->popup), &orig_w, &orig_h);

	gtk_widget_size_request (backlight_kbd->priv->popup, &win_req);

	if (win_req.width > orig_w) {

		orig_w = win_req.width;

	}

	if (win_req.height > orig_h) {

		orig_h = win_req.height;

	}

	pointer_screen = NULL;

	gdk_display_get_pointer (gtk_widget_get_display (backlight_kbd->priv->popup),

				 &pointer_screen,

				 &pointer_x,

				 &pointer_y,

				 NULL);

	monitor = gdk_screen_get_monitor_at_point (pointer_screen,

						   pointer_x,

						   pointer_y);

	gdk_screen_get_monitor_geometry (pointer_screen,

					 monitor,

					 &geometry);

	screen_w = geometry.width;

	screen_h = geometry.height;

	x = ((screen_w - orig_w) / 2) + geometry.x;

	y = geometry.y + (screen_h / 2) + (screen_h / 2 - orig_h) / 2;

	gtk_window_move (GTK_WINDOW (backlight_kbd->priv->popup), x, y);

	gtk_widget_show (backlight_kbd->priv->popup);

	gdk_display_sync (gtk_widget_get_display (backlight_kbd->priv->popup));

}

/**

 * gpm_backlight_kbd_brightness_evaluate_and_set:

 **/

static gboolean

gpm_backlight_kbd_brightness_evaluate_and_set (GpmBacklightKbd *backlight_kbd, gboolean interactive)

{

	gfloat brightness;

	gfloat scale;

	gboolean ret;

	gboolean on_battery;

	gboolean do_laptop_lcd;

	gboolean enable_action;

	gboolean battery_reduce;

	GError *error = NULL;

	gint value;

	gint old_value;

	if (backlight_kbd->priv->proxy == NULL) {

		egg_warning ("no kbd backlight hardware");

		return FALSE;

	}

	do_laptop_lcd = gconf_client_get_bool (backlight_kbd->priv->conf, GPM_CONF_BACKLIGHT_ENABLE, NULL);

	if (do_laptop_lcd == FALSE) {

		egg_warning ("policy is no dimming");

		return FALSE;

	}

	/* get the last set brightness */

	brightness = backlight_kbd->priv->master_percentage / 100.0f;

	egg_debug ("1. main brightness %f", brightness);

	/* get battery status */

	g_object_get (backlight_kbd->priv->client,

		      "on-battery", &on_battery,

		      NULL);

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

	battery_reduce = gconf_client_get_bool (backlight_kbd->priv->conf, GPM_CONF_BACKLIGHT_BATTERY_REDUCE, NULL);

	if (on_battery && battery_reduce) {

		value = gconf_client_get_int (backlight_kbd->priv->conf, GPM_CONF_BACKLIGHT_BRIGHTNESS_DIM_BATT, NULL);

		if (value > 100) {

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

			value = 50;

		}

		scale = (100 - value) / 100.0f;

		brightness *= scale;

	} else {

		scale = 1.0f;

	}

	egg_debug ("2. battery scale %f, brightness %f", scale, brightness);

	/* reduce if system is momentarily idle */

	if (!on_battery)

		enable_action = gconf_client_get_bool (backlight_kbd->priv->conf, GPM_CONF_BACKLIGHT_IDLE_DIM_AC, NULL);

	else

		enable_action = gconf_client_get_bool (backlight_kbd->priv->conf, GPM_CONF_BACKLIGHT_IDLE_DIM_BATT, NULL);

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

		value = gconf_client_get_int (backlight_kbd->priv->conf, GPM_CONF_BACKLIGHT_IDLE_BRIGHTNESS, NULL);

		if (value > 100) {

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

			value = 50;

		}

		scale = value / 100.0f;

		brightness *= scale;

	} else {

		scale = 1.0f;

	}

	egg_debug ("3. idle scale %f, brightness %f", scale, brightness);

	/* convert to percentage */

	value = (gint) ((brightness * 100.0f) + 0.5);

	/* normalize to max brightness */

	value = value * backlight_kbd->priv->max_brightness / 100;

	if (backlight_kbd->priv->off)

		value = 0;

	/* only do stuff if the brightness is different */

	ret = dbus_g_proxy_call (backlight_kbd->priv->proxy,

				 "GetBrightness", &error,

				 G_TYPE_INVALID,

				 G_TYPE_INT, &old_value,

				 G_TYPE_INVALID);

	if (error) {

		egg_debug ("ERROR: %s", error->message);

		g_error_free (error);

	}

	if (!ret) {

		egg_warning ("GetBrightness failed!");

		return FALSE;

	}

	if (old_value == value) {

		egg_debug ("values are the same, no action");

		return FALSE;

	}

	/* only show dialog if interactive */

	if (interactive) {

		gpm_backlight_kbd_dialog_init (backlight_kbd);

		gsd_media_keys_window_set_volume_level (GSD_MEDIA_KEYS_WINDOW (backlight_kbd->priv->popup),

							round (brightness));

		gpm_backlight_kbd_dialog_show (backlight_kbd);

	}

	egg_debug ("Setting brightness to %d", value);

	return dbus_g_proxy_call (backlight_kbd->priv->proxy,

				  "SetBrightness", NULL,

				  G_TYPE_INT, value,

				  G_TYPE_INVALID, G_TYPE_INVALID);

	return TRUE;

}

/**

 * gpm_conf_gconf_key_changed_cb:

 *

 * We might have to do things when the gconf keys change; do them here.

 **/

static void

gpm_conf_gconf_key_changed_cb (GConfClient *client, guint cnxn_id, GConfEntry *entry, GpmBacklightKbd *backlight_kbd)

{

	GConfValue *value;

	gboolean on_battery;

	value = gconf_entry_get_value (entry);

	if (value == NULL)

		return;

	/* get battery status */

	g_object_get (backlight_kbd->priv->client,

		      "on-battery", &on_battery,

		      NULL);

	if (!on_battery && strcmp (entry->key, GPM_CONF_BACKLIGHT_BRIGHTNESS_AC) == 0) {

		backlight_kbd->priv->master_percentage = gconf_value_get_int (value);

		gpm_backlight_kbd_brightness_evaluate_and_set (backlight_kbd, FALSE);

	} else if (on_battery && strcmp (entry->key, GPM_CONF_BACKLIGHT_BRIGHTNESS_DIM_BATT) == 0) {

		gpm_backlight_kbd_brightness_evaluate_and_set (backlight_kbd, FALSE);

	} else if (strcmp (entry->key, GPM_CONF_BACKLIGHT_IDLE_DIM_AC) == 0 ||

		   strcmp (entry->key, GPM_CONF_BACKLIGHT_ENABLE) == 0 ||

		   strcmp (entry->key, GPM_CONF_TIMEOUT_SLEEP_DISPLAY_BATT) == 0 ||

		   strcmp (entry->key, GPM_CONF_BACKLIGHT_BATTERY_REDUCE) == 0 ||

		   strcmp (entry->key, GPM_CONF_BACKLIGHT_IDLE_BRIGHTNESS) == 0) {

		gpm_backlight_kbd_brightness_evaluate_and_set (backlight_kbd, FALSE);

	} else if (strcmp (entry->key, GPM_CONF_BACKLIGHT_IDLE_DIM_TIME) == 0) {

		backlight_kbd->priv->idle_dim_timeout = gconf_value_get_int (value);

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

	} else {

		egg_debug ("unknown key %s", entry->key);

	}

}

/**

 * gpm_backlight_kbd_client_changed_cb:

 * @client: The up_client class instance

 * @backlight_kbd: This class instance

 *

 * Does the actions when the ac power source is inserted/removed.

 **/

static void

gpm_backlight_kbd_client_changed_cb (UpClient *client, GpmBacklightKbd *backlight_kbd)

{

	gpm_backlight_kbd_brightness_evaluate_and_set (backlight_kbd, FALSE);

}

/**

 * gpm_backlight_kbd_button_pressed_cb:

 * @power: The power class instance

 * @type: The button type, e.g. "power"

 * @state: The state, where TRUE is depressed or closed

 * @brightness: This class instance

 **/

static void

gpm_backlight_kbd_button_pressed_cb (GpmButton *button, const gchar *type, GpmBacklightKbd *backlight_kbd)

{

	GError *error = NULL;

	gboolean ret = FALSE;

	gint percentage = -1, brightness;

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

	if (strcmp (type, GPM_BUTTON_KBD_BRIGHT_UP) == 0) {

		percentage = MIN(100, backlight_kbd->priv->master_percentage + 10);

		brightness = percentage * backlight_kbd->priv->max_brightness / 100;

		egg_debug ("Setting brightness to %d", brightness);

		ret = dbus_g_proxy_call (backlight_kbd->priv->proxy,

					 "SetBrightness", &error,

					 G_TYPE_INT, brightness,

					 G_TYPE_INVALID, G_TYPE_INVALID);

	} else if (strcmp (type, GPM_BUTTON_KBD_BRIGHT_DOWN) == 0) {

		percentage = MAX(0, backlight_kbd->priv->master_percentage - 10);

		brightness = percentage * backlight_kbd->priv->max_brightness / 100;

		egg_debug ("Setting brightness to %d", brightness);

		ret = dbus_g_proxy_call (backlight_kbd->priv->proxy,

					 "SetBrightness", &error,

					 G_TYPE_INT, brightness,

					 G_TYPE_INVALID, G_TYPE_INVALID);

	}

	if (ret) {

		gpm_backlight_kbd_dialog_init (backlight_kbd);

		gsd_media_keys_window_set_volume_level (GSD_MEDIA_KEYS_WINDOW (backlight_kbd->priv->popup),

							percentage);

		gpm_backlight_kbd_dialog_show (backlight_kbd);

		/* save the new percentage */

		backlight_kbd->priv->master_percentage = percentage;

	} else if (percentage >= 0) {

		egg_warning ("failed to set brightness to %d: %s", brightness, error->message);

		g_error_free (error);

	}

}

/**

 * gpm_backlight_kbd_notify_system_idle_changed:

 **/

static gboolean

gpm_backlight_kbd_notify_system_idle_changed (GpmBacklightKbd *backlight_kbd, gboolean is_idle)

{

	gdouble elapsed;

	/* no point continuing */

	if (backlight_kbd->priv->system_is_idle == is_idle) {

		egg_debug ("state not changed");

		return FALSE;

	}

	/* get elapsed time and reset timer */

	elapsed = g_timer_elapsed (backlight_kbd->priv->idle_timer, NULL);

	g_timer_reset (backlight_kbd->priv->idle_timer);

	if (is_idle == FALSE) {

		egg_debug ("we have just been idle for %lfs", elapsed);

		/* The user immediatly undimmed the screen!

		 * We should double the timeout to avoid this happening again */

		if (elapsed < 10) {

			/* double the event time */

			backlight_kbd->priv->idle_dim_timeout *= 2.0;

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

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

		}

		/* We reset the dimming after 2 minutes of idle,

		 * as the user will have changed tasks */

		if (elapsed > 2*60) {

			/* reset back to our default dimming */

			backlight_kbd->priv->idle_dim_timeout =

				gconf_client_get_int (backlight_kbd->priv->conf,

						      GPM_CONF_BACKLIGHT_IDLE_DIM_TIME, NULL);

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

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

		}

	} else {

		egg_debug ("we were active for %lfs", elapsed);

	}

	egg_debug ("changing powersave idle status to %i", is_idle);

	backlight_kbd->priv->system_is_idle = is_idle;

	return TRUE;

}

/**

 * idle_changed_cb:

 * @idle: The idle class instance

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

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

 **/

static void

idle_changed_cb (GpmIdle *idle, GpmIdleMode mode, GpmBacklightKbd *backlight_kbd)

{

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

	if (gpm_button_is_lid_closed (backlight_kbd->priv->button))

		return;

	/* don't dim or undim the screen unless we are on the active console */

	if (!egg_console_kit_is_active (backlight_kbd->priv->consolekit)) {

		egg_debug ("ignoring as not on active console");

		return;

	}

	if (mode == GPM_IDLE_MODE_NORMAL ||

	    mode == GPM_IDLE_MODE_DIM ||

	    mode == GPM_IDLE_MODE_BLANK) {

		/* sync brightness */

		gpm_backlight_kbd_notify_system_idle_changed (backlight_kbd,

							      mode != GPM_IDLE_MODE_NORMAL);

		gpm_backlight_kbd_brightness_evaluate_and_set (backlight_kbd, FALSE);

	}

}

/**

 * control_resume_cb:

 * @control: The control class instance

 * @action: The action

 * @backlight_kbd: The keyboard backlight instance

 *

 * We want to ensure the keyboard backlight is on after resume

 */

static void

control_resume_cb (GpmControl *control, GpmControlAction action, GpmBacklightKbd *backlight_kbd)

{

	gpm_backlight_kbd_brightness_evaluate_and_set(backlight_kbd, FALSE);

}

/**

 * dpms_mode_changed_cb:

 * @dpms: The dpms class instance

 * @mode: The dpms mode

 * @backlight_kbd: The keyboard backlight instance

 *

 * We want to stay in sync with screen dpms

 */

static void

dpms_mode_changed_cb (GpmDpms *dpms, GpmDpmsMode mode, GpmBacklightKbd *backlight_kbd)

{

	backlight_kbd->priv->off = (mode != GPM_DPMS_MODE_ON);

	gpm_backlight_kbd_brightness_evaluate_and_set (backlight_kbd, FALSE);

}

/**

 * gpm_backlight_kbd_finalize:

 **/

static void

gpm_backlight_kbd_finalize (GObject *object)

{

	GpmBacklightKbd *backlight_kbd;

	g_return_if_fail (object != NULL);

	g_return_if_fail (GPM_IS_BACKLIGHT_KBD (object));

	backlight_kbd = GPM_BACKLIGHT_KBD (object);

	g_timer_destroy (backlight_kbd->priv->idle_timer);

	gtk_widget_destroy (backlight_kbd->priv->popup);

	g_object_unref (backlight_kbd->priv->dpms);

	g_object_unref (backlight_kbd->priv->control);

	g_object_unref (backlight_kbd->priv->conf);

	g_object_unref (backlight_kbd->priv->client);

	g_object_unref (backlight_kbd->priv->button);

	g_object_unref (backlight_kbd->priv->idle);

	g_object_unref (backlight_kbd->priv->proxy);

	g_object_unref (backlight_kbd->priv->consolekit);

	g_return_if_fail (backlight_kbd->priv != NULL);

	G_OBJECT_CLASS (gpm_backlight_kbd_parent_class)->finalize (object);

}

/**

 * gpm_backlight_kbd_class_init:

 **/

static void

gpm_backlight_kbd_class_init (GpmBacklightKbdClass *klass)

{

	GObjectClass *object_class = G_OBJECT_CLASS (klass);

	object_class->finalize	   = gpm_backlight_kbd_finalize;

	g_type_class_add_private (klass, sizeof (GpmBacklightKbdPrivate));

}

/**

 * gpm_backlight_kbd_init:

 * @brightness: This brightness class instance

 *

 * initialises the brightness class. NOTE: We expect laptop_panel objects

 * to *NOT* be removed or added during the session.

 * We only control the first laptop_panel object if there are more than one.

 **/

static void

gpm_backlight_kbd_init (GpmBacklightKbd *backlight_kbd)

{

	DBusGConnection *connection;

	GError *error = NULL;

	gboolean ret;

	gint brightness;

	backlight_kbd->priv = GPM_BACKLIGHT_KBD_GET_PRIVATE (backlight_kbd);

	/* record our idle time */

	backlight_kbd->priv->idle_timer = g_timer_new ();

	/* we use up_client for the ac-adapter-changed signal */

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

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

			  G_CALLBACK (gpm_backlight_kbd_client_changed_cb), backlight_kbd);

	/* watch for dim value changes */

	backlight_kbd->priv->conf = gconf_client_get_default ();

	/* watch gnome-power-manager keys */

	gconf_client_add_dir (backlight_kbd->priv->conf, GPM_CONF_DIR, GCONF_CLIENT_PRELOAD_RECURSIVE, NULL);

	gconf_client_notify_add (backlight_kbd->priv->conf, GPM_CONF_DIR,

				 (GConfClientNotifyFunc) gpm_conf_gconf_key_changed_cb,

				 backlight_kbd, NULL, NULL);

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

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

	backlight_kbd->priv->master_percentage = gconf_client_get_int (backlight_kbd->priv->conf, GPM_CONF_BACKLIGHT_BRIGHTNESS_AC, NULL);

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

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

	g_signal_connect (backlight_kbd->priv->button, "button-pressed",

			  G_CALLBACK (gpm_backlight_kbd_button_pressed_cb), backlight_kbd);

	/* watch for idle mode changes */

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

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

			  G_CALLBACK (idle_changed_cb), backlight_kbd);

	/* assumption */

	backlight_kbd->priv->system_is_idle = FALSE;

	backlight_kbd->priv->idle_dim_timeout = gconf_client_get_int (backlight_kbd->priv->conf, GPM_CONF_BACKLIGHT_IDLE_DIM_TIME, NULL);

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

	/* use a visual widget */

	backlight_kbd->priv->popup = gsd_media_keys_window_new ();

	gsd_media_keys_window_set_action_custom (GSD_MEDIA_KEYS_WINDOW (backlight_kbd->priv->popup),

						 "gpm-brightness-lcd",

						 TRUE);

	gtk_window_set_position (GTK_WINDOW (backlight_kbd->priv->popup), GTK_WIN_POS_NONE);

	/* DPMS mode poll class */

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

	g_signal_connect (backlight_kbd->priv->dpms, "mode-changed",

			  G_CALLBACK (dpms_mode_changed_cb), backlight_kbd);

	/* we refresh backlight on resume */

	backlight_kbd->priv->control = gpm_control_new ();

	g_signal_connect (backlight_kbd->priv->control, "resume",

			  G_CALLBACK (control_resume_cb), backlight_kbd);

	/* Don't do dimming on inactive console */

	backlight_kbd->priv->consolekit = egg_console_kit_new ();

	connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL);

	backlight_kbd->priv->proxy = dbus_g_proxy_new_for_name (connection,

								BACKLIGHT_KBD_SERVICE,

								BACKLIGHT_KBD_PATH,

								BACKLIGHT_KBD_INTERFACE);

	if (!backlight_kbd->priv->proxy) {

		egg_warning ("Failed to get proxy to kbdbacklight interface");

		return;

	}

	ret = dbus_g_proxy_call (backlight_kbd->priv->proxy,

				 "GetBrightness", &error,

				 G_TYPE_INVALID,

				 G_TYPE_INT, &brightness,

				 G_TYPE_INVALID);

	if (error) {

		egg_debug ("ERROR: %s", error->message);

		g_error_free (error);

	}

	if (!ret) {

		egg_warning ("GetBrightness failed!");

		return;

	}

	ret = dbus_g_proxy_call (backlight_kbd->priv->proxy,

				 "GetMaxBrightness", &error,

				 G_TYPE_INVALID,

				 G_TYPE_INT, &backlight_kbd->priv->max_brightness,

				 G_TYPE_INVALID);

	if (error) {

		egg_debug ("ERROR: %s", error->message);

		g_error_free (error);

	}

	if (!ret) {

		egg_warning ("GetMaxBrightness failed!");

		return;

	}

	brightness = (backlight_kbd->priv->max_brightness *

		      backlight_kbd->priv->master_percentage / 100);

	egg_debug ("Setting brightness to %d", brightness);

	/* set initial brightness to max */

	ret = dbus_g_proxy_call (backlight_kbd->priv->proxy,

				 "SetBrightness", &error,

				 G_TYPE_INT, brightness,

				 G_TYPE_INVALID, G_TYPE_INVALID);

	if (error) {

		egg_debug ("ERROR: %s", error->message);

		g_error_free (error);

	}

	if (!ret) {

		egg_warning ("SetBrightness failed!");

	}

	/* sync at startup */

	gpm_backlight_kbd_brightness_evaluate_and_set (backlight_kbd, FALSE);

}

/**

 * gpm_backlight_kbd_new:

 * Return value: A new brightness class instance.

 **/

GpmBacklightKbd *

gpm_backlight_kbd_new (void)

{

	GpmBacklightKbd *backlight_kbd = g_object_new (GPM_TYPE_BACKLIGHT_KBD, NULL);

	return backlight_kbd;

}

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-

 *

 * Copyright (C) 2010 Alex Murray <murray.alex@gmail.com>

 * Copyright (C) 2005-2007 Richard Hughes <richard@hughsie.com>

 * Copyright (C) 2004-2005 William Jon McCann <mccann@jhu.edu>

 *

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

 */

#ifndef __GPM_BACKLIGHT_KBD_H

#define __GPM_BACKLIGHT_KBD_H

#include <glib-object.h>

G_BEGIN_DECLS

#define GPM_TYPE_BACKLIGHT_KBD		(gpm_backlight_kbd_get_type ())

#define GPM_BACKLIGHT_KBD(o)		(G_TYPE_CHECK_INSTANCE_CAST ((o), GPM_TYPE_BACKLIGHT_KBD, GpmBacklightKbd))

#define GPM_BACKLIGHT_KBD_CLASS(k)		(G_TYPE_CHECK_CLASS_CAST((k), GPM_TYPE_BACKLIGHT_KBD, GpmBacklightKbdClass))

#define GPM_IS_BACKLIGHT_KBD(o)		(G_TYPE_CHECK_INSTANCE_TYPE ((o), GPM_TYPE_BACKLIGHT_KBD))

#define GPM_IS_BACKLIGHT_KBD_CLASS(k)	(G_TYPE_CHECK_CLASS_TYPE ((k), GPM_TYPE_BACKLIGHT_KBD))

#define GPM_BACKLIGHT_KBD_GET_CLASS(o)	(G_TYPE_INSTANCE_GET_CLASS ((o), GPM_TYPE_BACKLIGHT_KBD, GpmBacklightKbdClass))

typedef struct GpmBacklightKbdPrivate GpmBacklightKbdPrivate;

typedef struct

{

	GObject		         parent;

	GpmBacklightKbdPrivate *priv;

} GpmBacklightKbd;

typedef struct

{

	GObjectClass	parent_class;

} GpmBacklightKbdClass;

GType		 gpm_backlight_kbd_get_type			(void);

GpmBacklightKbd	*gpm_backlight_kbd_new			(void);

G_END_DECLS

#endif /* __GPM_BACKLIGHT_KBD_H */

#include "gpm-backlight-kbd.h"

	GpmBacklightKbd		*backlight_kbd;

	manager->priv->backlight_kbd = gpm_backlight_kbd_new ();

	g_object_unref (manager->priv->backlight_kbd);

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-

 *

 * Copyright (C) 2005 William Jon McCann <mccann@jhu.edu>

 * Copyright (C) 2005-2008 Richard Hughes <richard@hughsie.com>

 *

 * 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 <glib/gi18n.h>

#include <gtk/gtk.h>

#include <dbus/dbus-glib.h>

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

#include <gconf/gconf-client.h>

#include <canberra-gtk.h>

#include <libupower-glib/upower.h>

#include <libnotify/notify.h>

#include "egg-debug.h"

#include "egg-console-kit.h"

#include "gpm-button.h"

#include "gpm-control.h"

#include "gpm-common.h"

#include "gpm-dpms.h"

#include "gpm-idle.h"

#include "gpm-manager.h"

#include "gpm-screensaver.h"

#include "gpm-backlight.h"

#include "gpm-session.h"

#include "gpm-stock-icons.h"

#include "gpm-prefs-server.h"

#include "gpm-tray-icon.h"

#include "gpm-engine.h"

#include "gpm-upower.h"

#include "gpm-disks.h"

#include "org.gnome.PowerManager.Backlight.h"

static void     gpm_manager_finalize	(GObject	 *object);

#define GPM_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GPM_TYPE_MANAGER, GpmManagerPrivate))

#define GPM_MANAGER_RECALL_DELAY		30 /* seconds */

#define GPM_MANAGER_NOTIFY_TIMEOUT_NEVER	0 /* ms */

#define GPM_MANAGER_NOTIFY_TIMEOUT_SHORT	10 * 1000 /* ms */

#define GPM_MANAGER_NOTIFY_TIMEOUT_LONG		30 * 1000 /* ms */

#define GPM_MANAGER_CRITICAL_ALERT_TIMEOUT      5 /* seconds */

struct GpmManagerPrivate

{

	GpmButton		*button;

	GConfClient		*conf;

	GpmDisks		*disks;

	GpmDpms			*dpms;

	GpmIdle			*idle;

	GpmPrefsServer		*prefs_server;

	GpmControl		*control;

	GpmScreensaver		*screensaver;

	GpmTrayIcon		*tray_icon;

	GpmEngine		*engine;

	GpmBacklight		*backlight;

	EggConsoleKit		*console;

	guint32			 screensaver_ac_throttle_id;

	guint32			 screensaver_dpms_throttle_id;

	guint32			 screensaver_lid_throttle_id;

	guint32                  critical_alert_timeout_id;

	ca_proplist             *critical_alert_loop_props;

	UpClient		*client;

	gboolean		 on_battery;

	gboolean		 just_resumed;

	GtkStatusIcon		*status_icon;

	NotifyNotification	*notification_general;

	NotifyNotification	*notification_warning_low;

	NotifyNotification	*notification_discharging;

	NotifyNotification	*notification_fully_charged;

};

typedef enum {

	GPM_MANAGER_SOUND_POWER_PLUG,

	GPM_MANAGER_SOUND_POWER_UNPLUG,

	GPM_MANAGER_SOUND_LID_OPEN,

	GPM_MANAGER_SOUND_LID_CLOSE,

	GPM_MANAGER_SOUND_BATTERY_CAUTION,

	GPM_MANAGER_SOUND_BATTERY_LOW,

	GPM_MANAGER_SOUND_BATTERY_FULL,

	GPM_MANAGER_SOUND_SUSPEND_START,

	GPM_MANAGER_SOUND_SUSPEND_RESUME,

	GPM_MANAGER_SOUND_SUSPEND_ERROR,

	GPM_MANAGER_SOUND_LAST

} GpmManagerSound;

G_DEFINE_TYPE (GpmManager, gpm_manager, G_TYPE_OBJECT)

/**

 * gpm_manager_error_quark:

 * Return value: Our personal error quark.

 **/

GQuark

gpm_manager_error_quark (void)

{

	static GQuark quark = 0;

	if (!quark)

		quark = g_quark_from_static_string ("gpm_manager_error");

	return quark;

}

/**

 * gpm_manager_error_get_type:

 **/

#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }

GType

gpm_manager_error_get_type (void)

{

	static GType etype = 0;

	if (etype == 0) {

		static const GEnumValue values[] =

		{

			ENUM_ENTRY (GPM_MANAGER_ERROR_DENIED, "PermissionDenied"),

			ENUM_ENTRY (GPM_MANAGER_ERROR_NO_HW, "NoHardwareSupport"),

			{ 0, 0, 0 }

		};

		etype = g_enum_register_static ("GpmManagerError", values);

	}

	return etype;

}

/**

 * gpm_manager_play_loop_timeout_cb:

 **/

static gboolean

gpm_manager_play_loop_timeout_cb (GpmManager *manager)

{

	ca_context *context;

	context = ca_gtk_context_get_for_screen (gdk_screen_get_default ());

	ca_context_play_full (context, 0,

			      manager->priv->critical_alert_loop_props,

			      NULL,

			      NULL);

	return TRUE;

}

/**

 * gpm_manager_play_loop_stop:

 **/

static gboolean

gpm_manager_play_loop_stop (GpmManager *manager)

{

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

		egg_warning ("no sound loop present to stop");

		return FALSE;

	}

	g_source_remove (manager->priv->critical_alert_timeout_id);

	ca_proplist_destroy (manager->priv->critical_alert_loop_props);

	manager->priv->critical_alert_loop_props = NULL;

	manager->priv->critical_alert_timeout_id = 0;

	return TRUE;

}

/**

 * gpm_manager_play_loop_start:

 **/

static gboolean

gpm_manager_play_loop_start (GpmManager *manager, GpmManagerSound action, gboolean force, guint timeout)

{

	const gchar *id = NULL;

	const gchar *desc = NULL;

	gboolean ret;

	gint retval;

	ca_context *context;

	ret = gconf_client_get_bool (manager->priv->conf, GPM_CONF_UI_ENABLE_SOUND, NULL);

	if (!ret && !force) {

		egg_debug ("ignoring sound due to policy");

		return FALSE;

	}

	if (timeout == 0) {

		egg_warning ("received invalid timeout");

		return FALSE;

	}

	/* if a sound loop is already running, stop the existing loop */

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

		egg_warning ("was instructed to play a sound loop with one already playing");

		gpm_manager_play_loop_stop (manager);

	}

	if (action == GPM_MANAGER_SOUND_BATTERY_LOW) {

		id = "battery-low";

		/* TRANSLATORS: this is the sound description */

		desc = _("Battery is very low");

	}

	/* no match */

	if (id == NULL) {

		egg_warning ("no sound match for %i", action);

		return FALSE;

	}

	ca_proplist_create (&(manager->priv->critical_alert_loop_props));

	ca_proplist_sets (manager->priv->critical_alert_loop_props,

			  CA_PROP_EVENT_ID, id);

	ca_proplist_sets (manager->priv->critical_alert_loop_props,

			  CA_PROP_EVENT_DESCRIPTION, desc);

	manager->priv->critical_alert_timeout_id = g_timeout_add_seconds (timeout,

									  (GSourceFunc) gpm_manager_play_loop_timeout_cb,

									  manager);

	/* play the sound, using sounds from the naming spec */

	context = ca_gtk_context_get_for_screen (gdk_screen_get_default ());

	retval = ca_context_play (context, 0,

				  CA_PROP_EVENT_ID, id,

				  CA_PROP_EVENT_DESCRIPTION, desc, NULL);

	if (retval < 0)

		egg_warning ("failed to play %s: %s", id, ca_strerror (retval));

	return TRUE;

}

/**

 * gpm_manager_play:

 **/

static gboolean

gpm_manager_play (GpmManager *manager, GpmManagerSound action, gboolean force)

{

	const gchar *id = NULL;

	const gchar *desc = NULL;

	gboolean ret;

	gint retval;

	ca_context *context;

	ret = gconf_client_get_bool (manager->priv->conf, GPM_CONF_UI_ENABLE_SOUND, NULL);

	if (!ret && !force) {

		egg_debug ("ignoring sound due to policy");

		return FALSE;

	}

	if (action == GPM_MANAGER_SOUND_POWER_PLUG) {

		id = "power-plug";

		/* TRANSLATORS: this is the sound description */

		desc = _("Power plugged in");

	} else if (action == GPM_MANAGER_SOUND_POWER_UNPLUG) {

		id = "power-unplug";

		/* TRANSLATORS: this is the sound description */

		desc = _("Power unplugged");

	} else if (action == GPM_MANAGER_SOUND_LID_OPEN) {

		id = "lid-open";

		/* TRANSLATORS: this is the sound description */

		desc = _("Lid has opened");

	} else if (action == GPM_MANAGER_SOUND_LID_CLOSE) {

		id = "lid-close";

		/* TRANSLATORS: this is the sound description */

		desc = _("Lid has closed");

	} else if (action == GPM_MANAGER_SOUND_BATTERY_CAUTION) {

		id = "battery-caution";

		/* TRANSLATORS: this is the sound description */

		desc = _("Battery is low");

	} else if (action == GPM_MANAGER_SOUND_BATTERY_LOW) {

		id = "battery-low";

		/* TRANSLATORS: this is the sound description */

		desc = _("Battery is very low");

	} else if (action == GPM_MANAGER_SOUND_BATTERY_FULL) {

		id = "battery-full";

		/* TRANSLATORS: this is the sound description */

		desc = _("Battery is full");

	} else if (action == GPM_MANAGER_SOUND_SUSPEND_START) {

		id = "suspend-start";

		/* TRANSLATORS: this is the sound description */

		desc = _("Suspend started");

	} else if (action == GPM_MANAGER_SOUND_SUSPEND_RESUME) {

		id = "suspend-resume";

		/* TRANSLATORS: this is the sound description */

		desc = _("Resumed");

	} else if (action == GPM_MANAGER_SOUND_SUSPEND_ERROR) {

		id = "suspend-error";

		/* TRANSLATORS: this is the sound description */

		desc = _("Suspend failed");

	}

	/* no match */

	if (id == NULL) {

		egg_warning ("no match");

		return FALSE;

	}

	/* play the sound, using sounds from the naming spec */

	context = ca_gtk_context_get_for_screen (gdk_screen_get_default ());

	retval = ca_context_play (context, 0,

				  CA_PROP_EVENT_ID, id,

				  CA_PROP_EVENT_DESCRIPTION, desc, NULL);

	if (retval < 0)

		egg_warning ("failed to play %s: %s", id, ca_strerror (retval));

	return TRUE;

}

/**

 * gpm_manager_is_inhibit_valid:

 * @manager: This class instance

 * @action: The action we want to do, e.g. "suspend"

 *

 * Checks to see if the specific action has been inhibited by a program.

 *

 * Return value: TRUE if we can perform the action.

 **/

static gboolean

gpm_manager_is_inhibit_valid (GpmManager *manager, gboolean user_action, const char *action)

{

	return TRUE;

}

/**

 * gpm_manager_sync_policy_sleep:

 * @manager: This class instance

 *

 * Changes the policy if required, setting brightness, display and computer

 * timeouts.

 * We have to make sure gnome-screensaver disables screensaving, and enables

 * monitor DPMS instead when on batteries to save power.

 **/

static void

gpm_manager_sync_policy_sleep (GpmManager *manager)

{

	guint sleep_display;

	guint sleep_computer;

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

		sleep_computer = gconf_client_get_int (manager->priv->conf, GPM_CONF_TIMEOUT_SLEEP_COMPUTER_AC, NULL);

		sleep_display = gconf_client_get_int (manager->priv->conf, GPM_CONF_TIMEOUT_SLEEP_DISPLAY_AC, NULL);

	} else {

		sleep_computer = gconf_client_get_int (manager->priv->conf, GPM_CONF_TIMEOUT_SLEEP_COMPUTER_BATT, NULL);

		sleep_display = gconf_client_get_int (manager->priv->conf, GPM_CONF_TIMEOUT_SLEEP_DISPLAY_BATT, NULL);

	}

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

	gpm_idle_set_timeout_blank (manager->priv->idle, sleep_display);

	gpm_idle_set_timeout_sleep (manager->priv->idle, sleep_computer);

}

/**

 * gpm_manager_blank_screen:

 * @manager: This class instance

 *

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

 * See http://bugzilla.gnome.org/show_bug.cgi?id=321313

 *

 * Return value: Success.

 **/

static gboolean

gpm_manager_blank_screen (GpmManager *manager, GError **noerror)

{

	gboolean do_lock;

	gboolean ret = TRUE;

	GError *error = NULL;

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

					       GPM_CONF_LOCK_ON_BLANK_SCREEN);

	if (do_lock) {

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

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

	}

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

		ret = FALSE;

	}

	return ret;

}

/**

 * gpm_manager_unblank_screen:

 * @manager: This class instance

 *

 * Unblank the screen after we have opened the lid of the laptop

 *

 * Return value: Success.

 **/

static gboolean

gpm_manager_unblank_screen (GpmManager *manager, GError **noerror)

{

	gboolean do_lock;

	gboolean ret = TRUE;

	GError *error = NULL;

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

		ret = FALSE;

	}

	do_lock = gpm_control_get_lock_policy (manager->priv->control, GPM_CONF_LOCK_ON_BLANK_SCREEN);

	if (do_lock)

		gpm_screensaver_poke (manager->priv->screensaver);

	return ret;

}

/**

 * gpm_manager_notify_close:

 **/

static gboolean

gpm_manager_notify_close (GpmManager *manager, NotifyNotification *notification)

{

	gboolean ret = FALSE;

	GError *error = NULL;

	/* exists? */

	if (notification == NULL)

		goto out;

	/* try to close */

	ret = notify_notification_close (notification, &error);

	if (!ret) {

		egg_warning ("failed to close notification: %s", error->message);

		g_error_free (error);

		goto out;

	}

out:

	return ret;

}

/**

 * gpm_manager_notification_closed_cb:

 **/

static void

gpm_manager_notification_closed_cb (NotifyNotification *notification, NotifyNotification **notification_class)

{

	egg_debug ("caught notification closed signal %p", notification);

	/* the object is already unreffed in _close_signal_handler */

	*notification_class = NULL;

}

/**

 * gpm_manager_notify:

 **/

static gboolean

gpm_manager_notify (GpmManager *manager, NotifyNotification **notification_class,

		    const gchar *title, const gchar *message,

		    guint timeout, const gchar *icon, NotifyUrgency urgency)

{

	gboolean ret;

	GError *error = NULL;

	NotifyNotification *notification;

	GtkWidget *dialog;

	/* close any existing notification of this class */

	gpm_manager_notify_close (manager, *notification_class);

	/* if the status icon is hidden, don't point at it */

	if (manager->priv->status_icon != NULL &&

	    gtk_status_icon_is_embedded (manager->priv->status_icon))

		notification = notify_notification_new_with_status_icon (title, message, icon, manager->priv->status_icon);

	else

		notification = notify_notification_new (title, message, icon, NULL);

	notify_notification_set_timeout (notification, timeout);

	notify_notification_set_urgency (notification, urgency);

	g_signal_connect (notification, "closed", G_CALLBACK (gpm_manager_notification_closed_cb), notification_class);

	egg_debug ("notification %p: %s : %s", notification, title, message);

	/* try to show */

	ret = notify_notification_show (notification, &error);

	if (!ret) {

		egg_warning ("failed to show notification: %s", error->message);

		g_error_free (error);

		/* show modal dialog as libnotify failed */

		dialog = gtk_message_dialog_new_with_markup (NULL, GTK_DIALOG_DESTROY_WITH_PARENT,

							     GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,

							     "<span size='larger'><b>%s</b></span>", title);

		gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", message);

		/* wait async for close */

		gtk_widget_show (dialog);

		g_signal_connect_swapped (dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog);

		g_object_unref (notification);

		goto out;

	}

	/* save this local instance as the class instance */

	g_object_add_weak_pointer (G_OBJECT (notification), (gpointer) &notification);

	*notification_class = notification;

out:

	return ret;

}

/**

 * gpm_manager_sleep_failure_response_cb:

 **/

static void

gpm_manager_sleep_failure_response_cb (GtkDialog *dialog, gint response_id, GpmManager *manager)

{

	GdkScreen *screen;

	GtkWidget *dialog_error;

	GError *error = NULL;

	gboolean ret;

	gchar *uri = NULL;

	/* user clicked the help button */

	if (response_id == GTK_RESPONSE_HELP) {

		uri = gconf_client_get_string (manager->priv->conf, GPM_CONF_NOTIFY_SLEEP_FAILED_URI, NULL);

		screen = gdk_screen_get_default();

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

		if (!ret) {

			dialog_error = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK,

							       "Failed to show uri %s", error->message);

			gtk_dialog_run (GTK_DIALOG (dialog_error));

			g_error_free (error);

		}

	}

	gtk_widget_destroy (GTK_WIDGET (dialog));

	g_free (uri);

}

/**

 * gpm_manager_sleep_failure:

 **/

static void

gpm_manager_sleep_failure (GpmManager *manager, gboolean is_suspend, const gchar *detail)

{

	gboolean show_sleep_failed;

	GString *string = NULL;

	const gchar *title;

	gchar *uri = NULL;

	const gchar *icon;

	GtkWidget *dialog;

	/* only show this if specified in gconf */

	show_sleep_failed = gconf_client_get_bool (manager->priv->conf, GPM_CONF_NOTIFY_SLEEP_FAILED, NULL);

	egg_debug ("sleep failed");

	gpm_manager_play (manager, GPM_MANAGER_SOUND_SUSPEND_ERROR, TRUE);

	/* only emit if in GConf */

	if (!show_sleep_failed)

		goto out;

	/* TRANSLATORS: window title: there was a problem putting the machine to sleep */

	string = g_string_new ("");

	if (is_suspend) {

		/* TRANSLATORS: message text */

		g_string_append (string, _("Computer failed to suspend."));

		/* TRANSLATORS: title text */

		title = _("Failed to suspend");

		icon = GPM_STOCK_SUSPEND;

	} else {

		/* TRANSLATORS: message text */

		g_string_append (string, _("Computer failed to hibernate."));

		/* TRANSLATORS: title text */

		title = _("Failed to hibernate");

		icon = GPM_STOCK_HIBERNATE;

	}

	/* TRANSLATORS: message text */

	g_string_append_printf (string, "\n\n%s %s", _("Failure was reported as:"), detail);

	/* show modal dialog */

	dialog = gtk_message_dialog_new_with_markup (NULL, GTK_DIALOG_DESTROY_WITH_PARENT,

						     GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,

						     "<span size='larger'><b>%s</b></span>", title);

	gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", string->str);

	gtk_window_set_icon_name (GTK_WINDOW(dialog), icon);

	/* show a button? */

	uri = gconf_client_get_string (manager->priv->conf, GPM_CONF_NOTIFY_SLEEP_FAILED_URI, NULL);

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

	}

	/* wait async for close */

	gtk_widget_show (dialog);

	g_signal_connect (dialog, "response", G_CALLBACK (gpm_manager_sleep_failure_response_cb), manager);

out:

	g_free (uri);

	g_string_free (string, TRUE);

}

/**

 * gpm_manager_action_suspend:

 **/

static gboolean

gpm_manager_action_suspend (GpmManager *manager, const gchar *reason)

{

	gboolean ret;

	GError *error = NULL;

	/* check to see if we are inhibited */

	if (gpm_manager_is_inhibit_valid (manager, FALSE, "suspend") == FALSE)

		return FALSE;

	egg_debug ("suspending, reason: %s", reason);

	ret = gpm_control_suspend (manager->priv->control, &error);

	if (!ret) {

		gpm_manager_sleep_failure (manager, TRUE, error->message);

		g_error_free (error);

	}

	gpm_button_reset_time (manager->priv->button);

	return TRUE;

}

/**

 * gpm_manager_action_hibernate:

 **/

static gboolean

gpm_manager_action_hibernate (GpmManager *manager, const gchar *reason)

{

	gboolean ret;

	GError *error = NULL;

	/* check to see if we are inhibited */

	if (gpm_manager_is_inhibit_valid (manager, FALSE, "hibernate") == FALSE)

		return FALSE;

	egg_debug ("hibernating, reason: %s", reason);

	ret = gpm_control_hibernate (manager->priv->control, &error);

	if (!ret) {

		gpm_manager_sleep_failure (manager, TRUE, error->message);

		g_error_free (error);

	}

	gpm_button_reset_time (manager->priv->button);

	return TRUE;

}

/**

 * gpm_manager_perform_policy:

 * @manager: This class instance

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

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

 *

 * Does one of the policy actions specified in gconf.

 **/

static gboolean

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

{

	gchar *action = NULL;

	GpmActionPolicy policy;

	/* are we inhibited? */

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

		return FALSE;

	action = gconf_client_get_string (manager->priv->conf, policy_key, NULL);

	egg_debug ("action: %s set to %s (%s)", policy_key, action, reason);

	policy = gpm_action_policy_from_string (action);

	if (policy == GPM_ACTION_POLICY_NOTHING) {

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

	} else if (policy == GPM_ACTION_POLICY_SUSPEND) {

		gpm_manager_action_suspend (manager, reason);

	} else if (policy == GPM_ACTION_POLICY_HIBERNATE) {

		gpm_manager_action_hibernate (manager, reason);

	} else if (policy == GPM_ACTION_POLICY_BLANK) {

		gpm_manager_blank_screen (manager, NULL);

	} else if (policy == GPM_ACTION_POLICY_SHUTDOWN) {

		egg_debug ("shutting down, reason: %s", reason);

		gpm_control_shutdown (manager->priv->control, NULL);

	} else if (policy == GPM_ACTION_POLICY_INTERACTIVE) {

		GpmSession *session;

		egg_debug ("logout, reason: %s", reason);

		session = gpm_session_new ();

		gpm_session_logout (session);

		g_object_unref (session);

	} else {

		egg_warning ("unknown action %s", action);

	}

	g_free (action);

	return TRUE;

}

/**

 * gpm_manager_get_preferences_options:

 **/

gboolean

gpm_manager_get_preferences_options (GpmManager *manager, gint *capability, GError **error)

{

	g_return_val_if_fail (manager != NULL, FALSE);

	g_return_val_if_fail (GPM_IS_MANAGER (manager), FALSE);

	return gpm_prefs_server_get_capability (manager->priv->prefs_server, capability);

}

/**

 * gpm_manager_idle_do_sleep:

 * @manager: This class instance

 *

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

 * preference from gconf, but change it if we can't do the action.

 **/

static void

gpm_manager_idle_do_sleep (GpmManager *manager)

{

	gchar *action = NULL;

	gboolean ret;

	GError *error = NULL;

	GpmActionPolicy policy;

	if (!manager->priv->on_battery)

		action = gconf_client_get_string (manager->priv->conf, GPM_CONF_ACTIONS_SLEEP_TYPE_AC, NULL);

	else

		action = gconf_client_get_string (manager->priv->conf, GPM_CONF_ACTIONS_SLEEP_TYPE_BATT, NULL);

	policy = gpm_action_policy_from_string (action);

	if (policy == GPM_ACTION_POLICY_NOTHING) {

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

	} else if (policy == GPM_ACTION_POLICY_SUSPEND) {

		egg_debug ("suspending, reason: System idle");

		ret = gpm_control_suspend (manager->priv->control, &error);

		if (!ret) {

			egg_warning ("cannot suspend (error: %s), so trying hibernate", error->message);

			g_error_free (error);

			error = NULL;

			ret = gpm_control_hibernate (manager->priv->control, &error);

			if (!ret) {

				egg_warning ("cannot suspend or hibernate: %s", error->message);

				g_error_free (error);

			}

		}

	} else if (policy == GPM_ACTION_POLICY_HIBERNATE) {

		egg_debug ("hibernating, reason: System idle");

		ret = gpm_control_hibernate (manager->priv->control, &error);

		if (!ret) {

			egg_warning ("cannot hibernate (error: %s), so trying suspend", error->message);

			g_error_free (error);

			error = NULL;

			ret = gpm_control_suspend (manager->priv->control, &error);

			if (!ret) {

				egg_warning ("cannot suspend or hibernate: %s", error->message);

				g_error_free (error);

			}

		}

	}

	g_free (action);

}

/**

 * gpm_manager_idle_changed_cb:

 * @idle: The idle class instance

 * @mode: The idle mode, e.g. GPM_IDLE_MODE_BLANK

 * @manager: This class instance

 *

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

 **/

static void

gpm_manager_idle_changed_cb (GpmIdle *idle, GpmIdleMode mode, GpmManager *manager)

{

	/* ConsoleKit says we are not on active console */

	if (!egg_console_kit_is_active (manager->priv->console)) {

		egg_debug ("ignoring as not on active console");

		return;

	}

	/* Ignore back-to-NORMAL events when the lid is closed, as the DPMS is

	 * already off, and we don't want to re-enable the screen when the user

	 * moves the mouse on systems that do not support hardware blanking. */

	if (gpm_button_is_lid_closed (manager->priv->button) &&

	    mode == GPM_IDLE_MODE_NORMAL) {

		egg_debug ("lid is closed, so we are ignoring ->NORMAL state changes");

		return;

	}

	if (mode == GPM_IDLE_MODE_SLEEP) {

		egg_debug ("Idle state changed: SLEEP");

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

			return;

		gpm_manager_idle_do_sleep (manager);

	}

}

/**

 * gpm_manager_lid_button_pressed:

 * @manager: This class instance

 * @state: TRUE for closed

 *

 * Does actions when the lid is closed, depending on if we are on AC or

 * battery power.

 **/

static void

gpm_manager_lid_button_pressed (GpmManager *manager, gboolean pressed)

{

	if (pressed)

		gpm_manager_play (manager, GPM_MANAGER_SOUND_LID_CLOSE, FALSE);

	else

		gpm_manager_play (manager, GPM_MANAGER_SOUND_LID_OPEN, FALSE);

	if (pressed == FALSE) {

		/* we turn the lid dpms back on unconditionally */

		gpm_manager_unblank_screen (manager, NULL);

		return;

	}

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

		egg_debug ("Performing AC policy");

		gpm_manager_perform_policy (manager, GPM_CONF_BUTTON_LID_AC,

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

		return;

	}

	egg_debug ("Performing battery policy");

	gpm_manager_perform_policy (manager, GPM_CONF_BUTTON_LID_BATT,

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

}

static void

gpm_manager_update_dpms_throttle (GpmManager *manager)

{

	GpmDpmsMode mode;

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

		if (manager->priv->screensaver_dpms_throttle_id != 0) {

			gpm_screensaver_remove_throttle (manager->priv->screensaver, manager->priv->screensaver_dpms_throttle_id);

			manager->priv->screensaver_dpms_throttle_id = 0;

		}

	} else {

		/* if throttle already exists then remove */

		if (manager->priv->screensaver_dpms_throttle_id != 0) {

			gpm_screensaver_remove_throttle (manager->priv->screensaver, manager->priv->screensaver_dpms_throttle_id);

		}

		/* TRANSLATORS: this is the gnome-screensaver throttle */

		manager->priv->screensaver_dpms_throttle_id = gpm_screensaver_add_throttle (manager->priv->screensaver, _("Display DPMS activated"));

	}

}

static void

gpm_manager_update_ac_throttle (GpmManager *manager)

{

	/* Throttle the manager when we are not on AC power so we don't

	   waste the battery */

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

		if (manager->priv->screensaver_ac_throttle_id != 0) {

			gpm_screensaver_remove_throttle (manager->priv->screensaver, manager->priv->screensaver_ac_throttle_id);

			manager->priv->screensaver_ac_throttle_id = 0;

		}

	} else {

		/* if throttle already exists then remove */

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

			gpm_screensaver_remove_throttle (manager->priv->screensaver, manager->priv->screensaver_ac_throttle_id);

		/* TRANSLATORS: this is the gnome-screensaver throttle */

		manager->priv->screensaver_ac_throttle_id = gpm_screensaver_add_throttle (manager->priv->screensaver, _("On battery power"));

	}

}

static void

gpm_manager_update_lid_throttle (GpmManager *manager, gboolean lid_is_closed)

{

	/* Throttle the screensaver when the lid is close since we can't see it anyway

	   and it may overheat the laptop */

	if (lid_is_closed == FALSE) {

		if (manager->priv->screensaver_lid_throttle_id != 0) {

			gpm_screensaver_remove_throttle (manager->priv->screensaver, manager->priv->screensaver_lid_throttle_id);

			manager->priv->screensaver_lid_throttle_id = 0;

		}

	} else {

		/* if throttle already exists then remove */

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

			gpm_screensaver_remove_throttle (manager->priv->screensaver, manager->priv->screensaver_lid_throttle_id);

		manager->priv->screensaver_lid_throttle_id = gpm_screensaver_add_throttle (manager->priv->screensaver, _("Laptop lid is closed"));

	}

}

/**

 * gpm_manager_button_pressed_cb:

 * @power: The power class instance

 * @type: The button type, e.g. "power"

 * @state: The state, where TRUE is depressed or closed

 * @manager: This class instance

 **/

static void

gpm_manager_button_pressed_cb (GpmButton *button, const gchar *type, GpmManager *manager)

{

	gchar *message;

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

	/* ConsoleKit says we are not on active console */

	if (!egg_console_kit_is_active (manager->priv->console)) {

		egg_debug ("ignoring as not on active console");

		return;

	}

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

		gpm_manager_perform_policy (manager, GPM_CONF_BUTTON_POWER, "The power button has been pressed.");

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

		gpm_manager_perform_policy (manager, GPM_CONF_BUTTON_SUSPEND, "The suspend button has been pressed.");

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

		gpm_manager_perform_policy (manager, GPM_CONF_BUTTON_SUSPEND, "The suspend button has been pressed.");

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

		gpm_manager_perform_policy (manager, GPM_CONF_BUTTON_HIBERNATE, "The hibernate button has been pressed.");

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

		gpm_manager_lid_button_pressed (manager, TRUE);

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

		message = gpm_engine_get_summary (manager->priv->engine);

		gpm_manager_notify (manager, &manager->priv->notification_general,

				    _("Power Information"),

				    message,

				    GPM_MANAGER_NOTIFY_TIMEOUT_LONG,

				    GTK_STOCK_DIALOG_INFO,

				    NOTIFY_URGENCY_NORMAL);

		g_free (message);

	}

	/* really belongs in gnome-screensaver */

	if (g_strcmp0 (type, GPM_BUTTON_LOCK) == 0)

		gpm_screensaver_lock (manager->priv->screensaver);

	/* disable or enable the fancy screensaver, as we don't want

	 * this starting when the lid is shut */

	if (g_strcmp0 (type, GPM_BUTTON_LID_CLOSED) == 0)

		gpm_manager_update_lid_throttle (manager, TRUE);

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

		gpm_manager_update_lid_throttle (manager, FALSE);

}

/**

 * gpm_manager_get_spindown_timeout:

 **/

static gint

gpm_manager_get_spindown_timeout (GpmManager *manager)

{

	gboolean enabled;

	gint timeout;

	/* get policy */

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

		enabled = gconf_client_get_bool (manager->priv->conf, GPM_CONF_DISKS_SPINDOWN_ENABLE_AC, NULL);

		timeout = gconf_client_get_int (manager->priv->conf, GPM_CONF_DISKS_SPINDOWN_TIMEOUT_AC, NULL);

	} else {

		enabled = gconf_client_get_bool (manager->priv->conf, GPM_CONF_DISKS_SPINDOWN_ENABLE_BATT, NULL);

		timeout = gconf_client_get_int (manager->priv->conf, GPM_CONF_DISKS_SPINDOWN_TIMEOUT_BATT, NULL);

	}

	if (!enabled)

		timeout = 0;

	return timeout;

}

/**

 * gpm_manager_client_changed_cb:

 **/

static void

gpm_manager_client_changed_cb (UpClient *client, GpmManager *manager)

{

	gboolean event_when_closed;

	gint timeout;

	gboolean on_battery;

	gboolean lid_is_closed;

	/* get the client state */

	g_object_get (client,

		      "on-battery", &on_battery,

		      "lid-is-closed", &lid_is_closed,

		      NULL);

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

		egg_debug ("same state as before, ignoring");

		return;

	}

	/* close any discharging notifications */

	if (!on_battery) {

		egg_debug ("clearing notify due ac being present");

		gpm_manager_notify_close (manager, manager->priv->notification_warning_low);

		gpm_manager_notify_close (manager, manager->priv->notification_discharging);

	}

	/* if we are playing a critical charge sound loop, stop it */

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

		egg_debug ("stopping alert loop due to ac being present");

		gpm_manager_play_loop_stop (manager);

	}

	/* save in local cache */

	manager->priv->on_battery = on_battery;

	/* ConsoleKit says we are not on active console */

	if (!egg_console_kit_is_active (manager->priv->console)) {

		egg_debug ("ignoring as not on active console");

		return;

	}

	egg_debug ("on_battery: %d", on_battery);

	/* set disk spindown threshold */

	timeout = gpm_manager_get_spindown_timeout (manager);

	gpm_disks_set_spindown_timeout (manager->priv->disks, timeout);

	gpm_manager_sync_policy_sleep (manager);

	gpm_manager_update_ac_throttle (manager);

	/* simulate user input, but only when the lid is open */

	if (!lid_is_closed)

		gpm_screensaver_poke (manager->priv->screensaver);

	if (!on_battery)

		gpm_manager_play (manager, GPM_MANAGER_SOUND_POWER_PLUG, FALSE);

	else

		gpm_manager_play (manager, GPM_MANAGER_SOUND_POWER_UNPLUG, FALSE);

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

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

	event_when_closed = gconf_client_get_bool (manager->priv->conf, GPM_CONF_ACTIONS_SLEEP_WHEN_CLOSED, NULL);

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

		gpm_manager_perform_policy (manager, GPM_CONF_BUTTON_LID_BATT,

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

					    "removed (and gconf is okay).");

	}

}

/**

 * manager_critical_action_do:

 * @manager: This class instance

 *

 * This is the stub function when we have waited a few seconds for the user to

 * see the message, explaining what we are about to do.

 *

 * Return value: FALSE, as we don't want to repeat this action on resume.

 **/

static gboolean

manager_critical_action_do (GpmManager *manager)

{

	/* stop playing the alert as it's too late to do anything now */

	if (manager->priv->critical_alert_timeout_id)

		gpm_manager_play_loop_stop (manager);

	gpm_manager_perform_policy (manager, GPM_CONF_ACTIONS_CRITICAL_BATT, "Battery is critically low.");

	return FALSE;

}

/**

 * gpm_manager_class_init:

 * @klass: The GpmManagerClass

 **/

static void

gpm_manager_class_init (GpmManagerClass *klass)

{

	GObjectClass *object_class = G_OBJECT_CLASS (klass);

	object_class->finalize = gpm_manager_finalize;

	g_type_class_add_private (klass, sizeof (GpmManagerPrivate));

}

/**

 * gpm_conf_gconf_key_changed_cb:

 *

 * We might have to do things when the gconf keys change; do them here.

 **/

static void

gpm_conf_gconf_key_changed_cb (GConfClient *client, guint cnxn_id, GConfEntry *entry, GpmManager *manager)

{

	GConfValue *value;

	value = gconf_entry_get_value (entry);

	if (value == NULL)

		return;

	if (g_strcmp0 (entry->key, GPM_CONF_TIMEOUT_SLEEP_COMPUTER_BATT) == 0 ||

	    g_strcmp0 (entry->key, GPM_CONF_TIMEOUT_SLEEP_COMPUTER_AC) == 0 ||

	    g_strcmp0 (entry->key, GPM_CONF_TIMEOUT_SLEEP_DISPLAY_BATT) == 0 ||

	    g_strcmp0 (entry->key, GPM_CONF_TIMEOUT_SLEEP_DISPLAY_AC) == 0)

		gpm_manager_sync_policy_sleep (manager);

}

#if 0

/**

 * gpm_manager_screensaver_auth_request_cb:

 * @manager: This manager class instance

 * @auth: If we are trying to authenticate

 *

 * Called when the user is trying or has authenticated

 **/

static void

gpm_manager_screensaver_auth_request_cb (GpmScreensaver *screensaver, gboolean auth_begin, GpmManager *manager)

{

	GError *error = NULL;

	if (auth_begin) {

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

			error = NULL;

		}

	}

}

#endif

/**

 * gpm_manager_perhaps_recall_response_cb:

 */

static void

gpm_manager_perhaps_recall_response_cb (GtkDialog *dialog, gint response_id, GpmManager *manager)

{

	GdkScreen *screen;

	GtkWidget *dialog_error;

	GError *error = NULL;

	gboolean ret;

	const gchar *website;

	/* don't show this again */