diff options
Diffstat (limited to 'src/gpm-backlight.c')
| -rw-r--r-- | src/gpm-backlight.c | 821 |
1 files changed, 821 insertions, 0 deletions
diff --git a/src/gpm-backlight.c b/src/gpm-backlight.c new file mode 100644 index 0000000..c0479fd --- /dev/null +++ b/src/gpm-backlight.c @@ -0,0 +1,821 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- + * + * Copyright (C) 2005-2009 Richard Hughes <[email protected]> + * Copyright (C) 2005 William Jon McCann <[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. + */ + +#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 <mateconf/mateconf-client.h> +#include <libupower-glib/upower.h> + +#include "gpm-button.h" +#include "gpm-backlight.h" +#include "gpm-brightness.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_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GPM_TYPE_BACKLIGHT, GpmBacklightPrivate)) + +struct GpmBacklightPrivate +{ + UpClient *client; + GpmBrightness *brightness; + GpmButton *button; + MateConfClient *conf; + GtkWidget *popup; + GpmControl *control; + GpmDpms *dpms; + GpmIdle *idle; + EggConsoleKit *consolekit; + gboolean can_dim; + gboolean system_is_idle; + GTimer *idle_timer; + guint idle_dim_timeout; + guint master_percentage; +}; + +enum { + BRIGHTNESS_CHANGED, + LAST_SIGNAL +}; + +static guint signals [LAST_SIGNAL] = { 0 }; + +G_DEFINE_TYPE (GpmBacklight, gpm_backlight, G_TYPE_OBJECT) + +/** + * gpm_backlight_error_quark: + * Return value: Our personal error quark. + **/ +GQuark +gpm_backlight_error_quark (void) +{ + static GQuark quark = 0; + if (!quark) + quark = g_quark_from_static_string ("gpm_backlight_error"); + return quark; +} + +/** + * gpm_backlight_get_brightness: + **/ +gboolean +gpm_backlight_get_brightness (GpmBacklight *backlight, guint *brightness, GError **error) +{ + guint level; + gboolean ret; + g_return_val_if_fail (backlight != NULL, FALSE); + g_return_val_if_fail (GPM_IS_BACKLIGHT (backlight), FALSE); + g_return_val_if_fail (brightness != NULL, FALSE); + + /* check if we have the hw */ + if (backlight->priv->can_dim == FALSE) { + g_set_error_literal (error, gpm_backlight_error_quark (), + GPM_BACKLIGHT_ERROR_HARDWARE_NOT_PRESENT, + "Dim capable hardware not present"); + return FALSE; + } + + /* gets the current brightness */ + ret = gpm_brightness_get (backlight->priv->brightness, &level); + if (ret) { + *brightness = level; + } else { + g_set_error_literal (error, gpm_backlight_error_quark (), + GPM_BACKLIGHT_ERROR_DATA_NOT_AVAILABLE, + "Data not available"); + } + return ret; +} + +/** + * gpm_backlight_set_brightness: + **/ +gboolean +gpm_backlight_set_brightness (GpmBacklight *backlight, guint percentage, GError **error) +{ + gboolean ret; + gboolean hw_changed; + + g_return_val_if_fail (backlight != NULL, FALSE); + g_return_val_if_fail (GPM_IS_BACKLIGHT (backlight), FALSE); + + /* check if we have the hw */ + if (backlight->priv->can_dim == FALSE) { + g_set_error_literal (error, gpm_backlight_error_quark (), + GPM_BACKLIGHT_ERROR_HARDWARE_NOT_PRESENT, + "Dim capable hardware not present"); + return FALSE; + } + + /* just set the master percentage for now, don't try to be clever */ + backlight->priv->master_percentage = percentage; + + /* sets the current policy brightness */ + ret = gpm_brightness_set (backlight->priv->brightness, percentage, &hw_changed); + if (!ret) { + g_set_error_literal (error, gpm_backlight_error_quark (), + GPM_BACKLIGHT_ERROR_GENERAL, + "Cannot set policy brightness"); + } + /* we emit a signal for the brightness applet */ + if (ret && hw_changed) { + egg_debug ("emitting brightness-changed : %i", percentage); + g_signal_emit (backlight, signals [BRIGHTNESS_CHANGED], 0, percentage); + } + return ret; +} + +/** + * gpm_backlight_dialog_init: + * + * Initialises the popup, and makes sure that it matches the compositing of the screen. + **/ +static void +gpm_backlight_dialog_init (GpmBacklight *backlight) +{ + if (backlight->priv->popup != NULL + && !gsd_media_keys_window_is_valid (GSD_MEDIA_KEYS_WINDOW (backlight->priv->popup))) { + gtk_widget_destroy (backlight->priv->popup); + backlight->priv->popup = NULL; + } + + if (backlight->priv->popup == NULL) { + backlight->priv->popup= gsd_media_keys_window_new (); + gsd_media_keys_window_set_action_custom (GSD_MEDIA_KEYS_WINDOW (backlight->priv->popup), + "gpm-brightness-lcd", + TRUE); + gtk_window_set_position (GTK_WINDOW (backlight->priv->popup), GTK_WIN_POS_NONE); + } +} + +/** + * gpm_backlight_dialog_show: + * + * Show the brightness popup, and place it nicely on the screen. + **/ +static void +gpm_backlight_dialog_show (GpmBacklight *backlight) +{ + 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->priv->popup), &orig_w, &orig_h); + gtk_widget_size_request (backlight->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->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->priv->popup), x, y); + + gtk_widget_show (backlight->priv->popup); + + gdk_display_sync (gtk_widget_get_display (backlight->priv->popup)); +} + +/** + * gpm_common_sum_scale: + * + * Finds the average between value1 and value2 set on a scale factor + **/ +inline static gfloat +gpm_common_sum_scale (gfloat value1, gfloat value2, gfloat factor) +{ + gfloat diff; + diff = value1 - value2; + return value2 + (diff * factor); +} + +/** + * gpm_backlight_brightness_evaluate_and_set: + **/ +static gboolean +gpm_backlight_brightness_evaluate_and_set (GpmBacklight *backlight, gboolean interactive) +{ + gfloat brightness; + gfloat scale; + gboolean ret; + gboolean on_battery; + gboolean do_laptop_lcd; + gboolean enable_action; + gboolean battery_reduce; + gboolean hw_changed; + guint value; + guint old_value; + + if (backlight->priv->can_dim == FALSE) { + egg_warning ("no dimming hardware"); + return FALSE; + } + + do_laptop_lcd = mateconf_client_get_bool (backlight->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->priv->master_percentage / 100.0f; + egg_debug ("1. main brightness %f", brightness); + + /* get battery status */ + g_object_get (backlight->priv->client, + "on-battery", &on_battery, + NULL); + + /* reduce if on battery power if we should */ + battery_reduce = mateconf_client_get_bool (backlight->priv->conf, GPM_CONF_BACKLIGHT_BATTERY_REDUCE, NULL); + if (on_battery && battery_reduce) { + value = mateconf_client_get_int (backlight->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 = mateconf_client_get_bool (backlight->priv->conf, GPM_CONF_BACKLIGHT_IDLE_DIM_AC, NULL); + else + enable_action = mateconf_client_get_bool (backlight->priv->conf, GPM_CONF_BACKLIGHT_IDLE_DIM_BATT, NULL); + if (enable_action && backlight->priv->system_is_idle) { + value = mateconf_client_get_int (backlight->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 = (guint) ((brightness * 100.0f) + 0.5); + + /* only do stuff if the brightness is different */ + gpm_brightness_get (backlight->priv->brightness, &old_value); + if (old_value == value) { + egg_debug ("values are the same, no action"); + return FALSE; + } + + /* only show dialog if interactive */ + if (interactive) { + gpm_backlight_dialog_init (backlight); + gsd_media_keys_window_set_volume_level (GSD_MEDIA_KEYS_WINDOW (backlight->priv->popup), + round (brightness)); + gpm_backlight_dialog_show (backlight); + } + + ret = gpm_brightness_set (backlight->priv->brightness, value, &hw_changed); + /* we emit a signal for the brightness applet */ + if (ret && hw_changed) { + egg_debug ("emitting brightness-changed : %i", value); + g_signal_emit (backlight, signals [BRIGHTNESS_CHANGED], 0, value); + } + return TRUE; +} + +/** + * gpm_conf_mateconf_key_changed_cb: + * + * We might have to do things when the mateconf keys change; do them here. + **/ +static void +gpm_conf_mateconf_key_changed_cb (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, GpmBacklight *backlight) +{ + MateConfValue *value; + gboolean on_battery; + + value = mateconf_entry_get_value (entry); + if (value == NULL) + return; + + /* get battery status */ + g_object_get (backlight->priv->client, + "on-battery", &on_battery, + NULL); + + if (!on_battery && strcmp (entry->key, GPM_CONF_BACKLIGHT_BRIGHTNESS_AC) == 0) { + backlight->priv->master_percentage = mateconf_value_get_int (value); + gpm_backlight_brightness_evaluate_and_set (backlight, FALSE); + + } else if (on_battery && strcmp (entry->key, GPM_CONF_BACKLIGHT_BRIGHTNESS_DIM_BATT) == 0) { + gpm_backlight_brightness_evaluate_and_set (backlight, 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_brightness_evaluate_and_set (backlight, FALSE); + + } else if (strcmp (entry->key, GPM_CONF_BACKLIGHT_IDLE_DIM_TIME) == 0) { + backlight->priv->idle_dim_timeout = mateconf_value_get_int (value); + gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->priv->idle_dim_timeout); + } else { + egg_debug ("unknown key %s", entry->key); + } +} + +/** + * gpm_backlight_client_changed_cb: + * @client: The up_client class instance + * @backlight: This class instance + * + * Does the actions when the ac power source is inserted/removed. + **/ +static void +gpm_backlight_client_changed_cb (UpClient *client, GpmBacklight *backlight) +{ + gpm_backlight_brightness_evaluate_and_set (backlight, FALSE); +} + +/** + * gpm_backlight_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_button_pressed_cb (GpmButton *button, const gchar *type, GpmBacklight *backlight) +{ + gboolean ret; + GError *error = NULL; + guint percentage; + gboolean hw_changed; + egg_debug ("Button press event type=%s", type); + + if (strcmp (type, GPM_BUTTON_BRIGHT_UP) == 0) { + /* go up one step */ + ret = gpm_brightness_up (backlight->priv->brightness, &hw_changed); + + /* show the new value */ + if (ret) { + gpm_brightness_get (backlight->priv->brightness, &percentage); + gpm_backlight_dialog_init (backlight); + gsd_media_keys_window_set_volume_level (GSD_MEDIA_KEYS_WINDOW (backlight->priv->popup), + percentage); + gpm_backlight_dialog_show (backlight); + /* save the new percentage */ + backlight->priv->master_percentage = percentage; + } + /* we emit a signal for the brightness applet */ + if (ret && hw_changed) { + egg_debug ("emitting brightness-changed : %i", percentage); + g_signal_emit (backlight, signals [BRIGHTNESS_CHANGED], 0, percentage); + } + } else if (strcmp (type, GPM_BUTTON_BRIGHT_DOWN) == 0) { + /* go up down step */ + ret = gpm_brightness_down (backlight->priv->brightness, &hw_changed); + + /* show the new value */ + if (ret) { + gpm_brightness_get (backlight->priv->brightness, &percentage); + gpm_backlight_dialog_init (backlight); + gsd_media_keys_window_set_volume_level (GSD_MEDIA_KEYS_WINDOW (backlight->priv->popup), + percentage); + gpm_backlight_dialog_show (backlight); + /* save the new percentage */ + backlight->priv->master_percentage = percentage; + } + /* we emit a signal for the brightness applet */ + if (ret && hw_changed) { + egg_debug ("emitting brightness-changed : %i", percentage); + g_signal_emit (backlight, signals [BRIGHTNESS_CHANGED], 0, percentage); + } + } 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); + + /* 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); + } + } +} + +/** + * gpm_backlight_notify_system_idle_changed: + **/ +static gboolean +gpm_backlight_notify_system_idle_changed (GpmBacklight *backlight, gboolean is_idle) +{ + gdouble elapsed; + + /* no point continuing */ + if (backlight->priv->system_is_idle == is_idle) { + egg_debug ("state not changed"); + return FALSE; + } + + /* get elapsed time and reset timer */ + elapsed = g_timer_elapsed (backlight->priv->idle_timer, NULL); + g_timer_reset (backlight->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->priv->idle_dim_timeout *= 2.0; + egg_debug ("increasing idle dim time to %is", backlight->priv->idle_dim_timeout); + gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->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->priv->idle_dim_timeout = + mateconf_client_get_int (backlight->priv->conf, + GPM_CONF_BACKLIGHT_IDLE_DIM_TIME, NULL); + egg_debug ("resetting idle dim time to %is", backlight->priv->idle_dim_timeout); + gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->priv->idle_dim_timeout); + } + } else { + egg_debug ("we were active for %lfs", elapsed); + } + + egg_debug ("changing powersave idle status to %i", is_idle); + backlight->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 mate-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, GpmBacklight *backlight) +{ + gboolean ret; + GError *error = NULL; + gboolean on_battery; + 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; + + /* don't dim or undim the screen unless we are on the active console */ + if (!egg_console_kit_is_active (backlight->priv->consolekit)) { + egg_debug ("ignoring as not on active console"); + return; + } + + if (mode == GPM_IDLE_MODE_NORMAL) { + /* sync lcd brightness */ + gpm_backlight_notify_system_idle_changed (backlight, FALSE); + gpm_backlight_brightness_evaluate_and_set (backlight, FALSE); + + /* 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, TRUE); + gpm_backlight_brightness_evaluate_and_set (backlight, FALSE); + + /* 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_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 */ + g_object_get (backlight->priv->client, + "on-battery", &on_battery, + NULL); + if (!on_battery) + dpms_method = mateconf_client_get_string (backlight->priv->conf, GPM_CONF_BACKLIGHT_DPMS_METHOD_AC, NULL); + else + dpms_method = mateconf_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); + } +} + +/** + * brightness_changed_cb: + * @brightness: The GpmBrightness class instance + * @percentage: The new percentage brightness + * @brightness: This class instance + * + * This callback is called when the brightness value changes. + **/ +static void +brightness_changed_cb (GpmBrightness *brightness, guint percentage, GpmBacklight *backlight) +{ + /* save the new percentage */ + backlight->priv->master_percentage = percentage; + + /* we emit a signal for the brightness applet */ + egg_debug ("emitting brightness-changed : %i", percentage); + g_signal_emit (backlight, signals [BRIGHTNESS_CHANGED], 0, percentage); +} + +/** + * control_resume_cb: + * @control: The control class instance + * @power: This power class instance + * + * We have to update the caches on resume + **/ +static void +control_resume_cb (GpmControl *control, GpmControlAction action, GpmBacklight *backlight) +{ + gboolean ret; + GError *error = NULL; + + /* 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); + } +} + +/** + * gpm_backlight_finalize: + **/ +static void +gpm_backlight_finalize (GObject *object) +{ + GpmBacklight *backlight; + g_return_if_fail (object != NULL); + g_return_if_fail (GPM_IS_BACKLIGHT (object)); + backlight = GPM_BACKLIGHT (object); + + g_timer_destroy (backlight->priv->idle_timer); + gtk_widget_destroy (backlight->priv->popup); + + g_object_unref (backlight->priv->dpms); + g_object_unref (backlight->priv->control); + g_object_unref (backlight->priv->conf); + g_object_unref (backlight->priv->client); + g_object_unref (backlight->priv->button); + g_object_unref (backlight->priv->idle); + g_object_unref (backlight->priv->brightness); + g_object_unref (backlight->priv->consolekit); + + g_return_if_fail (backlight->priv != NULL); + G_OBJECT_CLASS (gpm_backlight_parent_class)->finalize (object); +} + +/** + * gpm_backlight_class_init: + **/ +static void +gpm_backlight_class_init (GpmBacklightClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + object_class->finalize = gpm_backlight_finalize; + + signals [BRIGHTNESS_CHANGED] = + g_signal_new ("brightness-changed", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GpmBacklightClass, brightness_changed), + NULL, NULL, + g_cclosure_marshal_VOID__UINT, + G_TYPE_NONE, 1, G_TYPE_UINT); + + g_type_class_add_private (klass, sizeof (GpmBacklightPrivate)); +} + +/** + * gpm_backlight_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_init (GpmBacklight *backlight) +{ + gboolean lid_is_present = TRUE; + GpmPrefsServer *prefs_server; + + backlight->priv = GPM_BACKLIGHT_GET_PRIVATE (backlight); + + /* record our idle time */ + backlight->priv->idle_timer = g_timer_new (); + + /* watch for manual brightness changes (for the popup widget) */ + backlight->priv->brightness = gpm_brightness_new (); + g_signal_connect (backlight->priv->brightness, "brightness-changed", + G_CALLBACK (brightness_changed_cb), backlight); + + /* we use up_client for the ac-adapter-changed signal */ + backlight->priv->client = up_client_new (); + g_signal_connect (backlight->priv->client, "changed", + G_CALLBACK (gpm_backlight_client_changed_cb), backlight); + + /* gets caps */ + backlight->priv->can_dim = gpm_brightness_has_hw (backlight->priv->brightness); + + /* we use UPower to see if we should show the lid UI */ + g_object_get (backlight->priv->client, + "lid-is-present", &lid_is_present, + NULL); + + /* expose ui in prefs program */ + prefs_server = gpm_prefs_server_new (); + if (lid_is_present) + gpm_prefs_server_set_capability (prefs_server, GPM_PREFS_SERVER_LID); + if (backlight->priv->can_dim) + gpm_prefs_server_set_capability (prefs_server, GPM_PREFS_SERVER_BACKLIGHT); + g_object_unref (prefs_server); + + /* watch for dim value changes */ + backlight->priv->conf = mateconf_client_get_default (); + + /* watch mate-power-manager keys */ + mateconf_client_add_dir (backlight->priv->conf, GPM_CONF_DIR, MATECONF_CLIENT_PRELOAD_RECURSIVE, NULL); + mateconf_client_notify_add (backlight->priv->conf, GPM_CONF_DIR, + (MateConfClientNotifyFunc) gpm_conf_mateconf_key_changed_cb, + backlight, 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->priv->master_percentage = mateconf_client_get_int (backlight->priv->conf, GPM_CONF_BACKLIGHT_BRIGHTNESS_AC, NULL); + + /* watch for brightness up and down buttons and also check lid state */ + backlight->priv->button = gpm_button_new (); + g_signal_connect (backlight->priv->button, "button-pressed", + G_CALLBACK (gpm_backlight_button_pressed_cb), backlight); + + /* watch for idle mode changes */ + backlight->priv->idle = gpm_idle_new (); + g_signal_connect (backlight->priv->idle, "idle-changed", + G_CALLBACK (idle_changed_cb), backlight); + + /* assumption */ + backlight->priv->system_is_idle = FALSE; + backlight->priv->idle_dim_timeout = mateconf_client_get_int (backlight->priv->conf, GPM_CONF_BACKLIGHT_IDLE_DIM_TIME, NULL); + gpm_idle_set_timeout_dim (backlight->priv->idle, backlight->priv->idle_dim_timeout); + + /* use a visual widget */ + backlight->priv->popup = gsd_media_keys_window_new (); + gsd_media_keys_window_set_action_custom (GSD_MEDIA_KEYS_WINDOW (backlight->priv->popup), + "gpm-brightness-lcd", + TRUE); + gtk_window_set_position (GTK_WINDOW (backlight->priv->popup), GTK_WIN_POS_NONE); + + /* DPMS mode poll class */ + backlight->priv->dpms = gpm_dpms_new (); + + /* we refresh DPMS on resume */ + backlight->priv->control = gpm_control_new (); + g_signal_connect (backlight->priv->control, "resume", + G_CALLBACK (control_resume_cb), backlight); + + /* Don't do dimming on inactive console */ + backlight->priv->consolekit = egg_console_kit_new (); + + /* sync at startup */ + gpm_backlight_brightness_evaluate_and_set (backlight, FALSE); +} + +/** + * gpm_backlight_new: + * Return value: A new brightness class instance. + **/ +GpmBacklight * +gpm_backlight_new (void) +{ + GpmBacklight *backlight = g_object_new (GPM_TYPE_BACKLIGHT, NULL); + return backlight; +} + |