← Back to branch summary

~noskcaj/ubuntu/saucy/xfce4-power-manager/1.2.0-2ubuntu1

« back to all changes in this revision

Viewing changes to src/xfpm-backlight.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc
  • Date: 2010-12-09 18:28:34 UTC
  • mfrom: (2.3.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20101209182834-efb7dinmf9ssp3es
Tags: 1.0.1-0ubuntu1
Upload to natty (pkg-xfce svn r4665), no Ubuntu changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/xfpm-backlight.c
26
26
#include <stdlib.h>
27
27
#include <string.h>
28
28
 
 
29
#include <math.h>
 
30
 
 
31
#include <gtk/gtk.h>
29
32
#include <libxfce4util/libxfce4util.h>
30
33
 
31
34
#include "xfpm-backlight.h"
32
 
#include "xfpm-brightness-hal.h"
33
 
#include "xfpm-brightness-widget.h"
34
 
 
35
 
static void xfpm_backlight_finalize   (GObject *object);
36
 
 
37
 
static void xfpm_backlight_dbus_class_init (XfpmBacklightClass *klass);
38
 
static void xfpm_backlight_dbus_init       (XfpmBacklight *bk);
 
35
#include "egg-idletime.h"
 
36
#include "xfpm-notify.h"
 
37
#include "xfpm-xfconf.h"
 
38
#include "xfpm-power.h"
 
39
#include "xfpm-config.h"
 
40
#include "xfpm-button.h"
 
41
#include "xfpm-brightness.h"
 
42
#include "xfpm-debug.h"
 
43
#include "xfpm-icons.h"
 
44
 
 
45
#include "gsd-media-keys-window.h"
 
46
 
 
47
static void xfpm_backlight_finalize     (GObject *object);
 
48
 
 
49
static void xfpm_backlight_create_popup (XfpmBacklight *backlight);
 
50
 
 
51
#define ALARM_DISABLED 9
 
52
#define BRIGHTNESS_POPUP_SIZE   180
39
53
 
40
54
#define XFPM_BACKLIGHT_GET_PRIVATE(o) \
41
 
(G_TYPE_INSTANCE_GET_PRIVATE((o), XFPM_TYPE_BACKLIGHT, XfpmBacklightPrivate))
 
55
(G_TYPE_INSTANCE_GET_PRIVATE ((o), XFPM_TYPE_BACKLIGHT, XfpmBacklightPrivate))
42
56
 
43
57
struct XfpmBacklightPrivate
44
58
{
45
 
    XfpmBrightnessHal    *br;
46
 
    XfpmBrightnessWidget *widget;
47
 
    
48
 
    gboolean has_hw;
 
59
    XfpmBrightness *brightness;
 
60
    XfpmPower      *power;
 
61
    EggIdletime    *idle;
 
62
    XfpmXfconf     *conf;
 
63
    XfpmButton     *button;
 
64
    XfpmNotify     *notify;
 
65
    
 
66
    GtkWidget      *osd;
 
67
    NotifyNotification *n;
 
68
    
 
69
    
 
70
    gulong          destroy_id;
 
71
    
 
72
    gboolean        has_hw;
 
73
    gboolean        on_battery;
 
74
    
 
75
    gint            last_level;
 
76
    gint            max_level;
 
77
    
 
78
    gboolean        dimmed;
 
79
    gboolean        block;
 
80
#ifdef WITH_HAL
 
81
    gboolean        brightness_in_hw;
 
82
#endif
49
83
};
50
84
 
51
 
G_DEFINE_TYPE(XfpmBacklight, xfpm_backlight, G_TYPE_OBJECT)
52
 
 
53
 
static void
54
 
xfpm_backlight_brightness_up (XfpmBrightnessHal *brg, guint level, XfpmBacklight *bk)
55
 
{
56
 
    xfpm_brightness_widget_set_level (bk->priv->widget, level);
57
 
}
58
 
 
59
 
static void
60
 
xfpm_backlight_brightness_down (XfpmBrightnessHal *brg, guint level, XfpmBacklight *bk)
61
 
{
62
 
    xfpm_brightness_widget_set_level (bk->priv->widget, level);
63
 
}
64
 
 
65
 
static void
66
 
xfpm_backlight_get_device (XfpmBacklight *bk)
67
 
{
68
 
    guint max_level;
69
 
    bk->priv->br     = xfpm_brightness_hal_new ();
70
 
    bk->priv->has_hw = xfpm_brightness_hal_has_hw (bk->priv->br);
71
 
    
72
 
    if ( bk->priv->has_hw == FALSE )
73
 
        g_object_unref (bk->priv->br);
74
 
    else
75
 
    {
76
 
        bk->priv->widget = xfpm_brightness_widget_new ();
77
 
        g_signal_connect (G_OBJECT(bk->priv->br), "brigthness-up",
78
 
                          G_CALLBACK (xfpm_backlight_brightness_up), bk);
79
 
                          
80
 
        g_signal_connect (G_OBJECT(bk->priv->br), "brigthness-down",
81
 
                          G_CALLBACK (xfpm_backlight_brightness_down), bk);
 
85
G_DEFINE_TYPE (XfpmBacklight, xfpm_backlight, G_TYPE_OBJECT)
 
86
 
 
87
static void
 
88
xfpm_backlight_dim_brightness (XfpmBacklight *backlight)
 
89
{
 
90
    gboolean ret;
 
91
    
 
92
    ret = xfpm_brightness_get_level (backlight->priv->brightness, &backlight->priv->last_level);
 
93
    
 
94
    if ( !ret )
 
95
    {
 
96
        g_warning ("Unable to get current brightness level");
 
97
        return;
 
98
    }
 
99
    XFPM_DEBUG ("Current brightness level before dimming : %u", backlight->priv->last_level);
 
100
    
 
101
    backlight->priv->dimmed = xfpm_brightness_dim_down (backlight->priv->brightness);
 
102
}
 
103
 
 
104
static gboolean
 
105
xfpm_backlight_destroy_popup (gpointer data)
 
106
{
 
107
    XfpmBacklight *backlight;
 
108
    
 
109
    backlight = XFPM_BACKLIGHT (data);
 
110
    
 
111
    if ( backlight->priv->osd )
 
112
    {
 
113
        gtk_widget_destroy (backlight->priv->osd);
 
114
        backlight->priv->osd = NULL;
 
115
    }
 
116
    
 
117
    if ( backlight->priv->n )
 
118
    {
 
119
        g_object_unref (backlight->priv->n);
 
120
        backlight->priv->n = NULL;
 
121
    }
 
122
    
 
123
    return FALSE;
 
124
}
 
125
 
 
126
static void
 
127
xfpm_backlight_composited_changed_cb (XfpmBacklight *backlight)
 
128
{
 
129
    xfpm_backlight_destroy_popup (backlight);
 
130
    xfpm_backlight_create_popup (backlight);
 
131
}
 
132
 
 
133
static void
 
134
xfpm_backlight_show_notification (XfpmBacklight *backlight, gfloat value)
 
135
{
 
136
    gint i;
 
137
    
 
138
    static const char *display_icon_name[] = 
 
139
    {
 
140
        "notification-display-brightness-off",
 
141
        "notification-display-brightness-low",
 
142
        "notification-display-brightness-medium",
 
143
        "notification-display-brightness-high",
 
144
        "notification-display-brightness-full",
 
145
        NULL
 
146
    };
 
147
    
 
148
    if ( backlight->priv->n == NULL )
 
149
    {
 
150
        backlight->priv->n = xfpm_notify_new_notification (backlight->priv->notify, 
 
151
                                                           " ", 
 
152
                                                           "", 
 
153
                                                           NULL, 
 
154
                                                           0, 
 
155
                                                           XFPM_NOTIFY_NORMAL,
 
156
                                                           NULL);
 
157
    }
 
158
    
 
159
    i = (gint)value / 25;
 
160
    
 
161
    if ( i > 4 || i < 0 )
 
162
        return;
 
163
    
 
164
    notify_notification_set_hint_int32  (backlight->priv->n,
 
165
                                         "value",
 
166
                                         value);
 
167
    
 
168
    notify_notification_set_hint_string (backlight->priv->n,
 
169
                                         "x-canonical-private-synchronous",
 
170
                                         "brightness");
 
171
    
 
172
    notify_notification_update (backlight->priv->n,
 
173
                                " ",
 
174
                                "",
 
175
                                display_icon_name[i]);
 
176
                                
 
177
    notify_notification_show (backlight->priv->n, NULL);
 
178
}
 
179
 
 
180
static void
 
181
xfpm_backlight_create_popup (XfpmBacklight *backlight)
 
182
{
 
183
    if ( backlight->priv->osd != NULL )
 
184
        return;
82
185
        
83
 
        max_level = xfpm_brightness_hal_get_max_level (bk->priv->br);
84
 
        xfpm_brightness_widget_set_max_level (bk->priv->widget,
85
 
                                              max_level);
86
 
    }
87
 
    
88
 
}
89
 
 
90
 
static void
91
 
xfpm_backlight_class_init(XfpmBacklightClass *klass)
92
 
{
93
 
    GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
186
    backlight->priv->osd = gsd_media_keys_window_new ();
 
187
    gsd_media_keys_window_set_action_custom (GSD_MEDIA_KEYS_WINDOW (backlight->priv->osd),
 
188
                                             XFPM_DISPLAY_BRIGHTNESS_ICON,
 
189
                                             TRUE);
 
190
    gtk_window_set_position (GTK_WINDOW (backlight->priv->osd), GTK_WIN_POS_CENTER);
 
191
    
 
192
    g_signal_connect_swapped (backlight->priv->osd, "composited-changed",
 
193
                              G_CALLBACK (xfpm_backlight_composited_changed_cb), backlight);
 
194
                              
 
195
}
 
196
 
 
197
static void
 
198
xfpm_backlight_show (XfpmBacklight *backlight, gint level)
 
199
{
 
200
    gfloat value;
 
201
    gboolean sync;
 
202
    gboolean show_popup;
 
203
    
 
204
    XFPM_DEBUG ("Level %u", level);
 
205
    
 
206
    g_object_get (G_OBJECT (backlight->priv->conf),
 
207
                  SHOW_BRIGHTNESS_POPUP, &show_popup,
 
208
                  NULL);
 
209
                  
 
210
    if ( !show_popup )
 
211
        goto out;
 
212
    
 
213
    g_object_get (G_OBJECT (backlight->priv->notify),
 
214
                  "sync", &sync,
 
215
                  NULL);
 
216
    
 
217
    value = (gfloat) 100 * level / backlight->priv->max_level;
 
218
    
 
219
    if ( !sync ) /*Notification server doesn't support sync notifications*/
 
220
    {
 
221
        xfpm_backlight_create_popup (backlight);
 
222
        gsd_media_keys_window_set_volume_level (GSD_MEDIA_KEYS_WINDOW (backlight->priv->osd),
 
223
                                                round (value));
 
224
        if ( !GTK_WIDGET_VISIBLE (backlight->priv->osd))
 
225
            gtk_window_present (GTK_WINDOW (backlight->priv->osd));
 
226
    }
 
227
    else
 
228
    {
 
229
        xfpm_backlight_show_notification (backlight, value);
 
230
    }
 
231
    
 
232
    if ( backlight->priv->destroy_id != 0 )
 
233
    {
 
234
        g_source_remove (backlight->priv->destroy_id);
 
235
        backlight->priv->destroy_id = 0;
 
236
    }
 
237
    
 
238
out:
 
239
    /* Release the memory after 60 seconds */
 
240
    backlight->priv->destroy_id = g_timeout_add_seconds (60, (GSourceFunc) xfpm_backlight_destroy_popup, backlight);
 
241
}
 
242
 
 
243
 
 
244
static void
 
245
xfpm_backlight_alarm_timeout_cb (EggIdletime *idle, guint id, XfpmBacklight *backlight)
 
246
{
 
247
    backlight->priv->block = FALSE;
 
248
    
 
249
    if ( id == TIMEOUT_BRIGHTNESS_ON_AC && !backlight->priv->on_battery)
 
250
        xfpm_backlight_dim_brightness (backlight);
 
251
    else if ( id == TIMEOUT_BRIGHTNESS_ON_BATTERY && backlight->priv->on_battery)
 
252
        xfpm_backlight_dim_brightness (backlight);
 
253
}
 
254
 
 
255
static void
 
256
xfpm_backlight_reset_cb (EggIdletime *idle, XfpmBacklight *backlight)
 
257
{
 
258
    if ( backlight->priv->dimmed)
 
259
    {
 
260
        if ( !backlight->priv->block)
 
261
        {
 
262
            XFPM_DEBUG ("Alarm reset, setting level to %i", backlight->priv->last_level);
 
263
            xfpm_brightness_set_level (backlight->priv->brightness, backlight->priv->last_level);
 
264
        }
 
265
        backlight->priv->dimmed = FALSE;
 
266
    }
 
267
}
 
268
 
 
269
static void
 
270
xfpm_backlight_button_pressed_cb (XfpmButton *button, XfpmButtonKey type, XfpmBacklight *backlight)
 
271
{
 
272
    gint level;
 
273
    gboolean ret = TRUE;
 
274
    
 
275
    gboolean enable_brightness, show_popup;
 
276
    
 
277
    g_object_get (G_OBJECT (backlight->priv->conf),
 
278
                  ENABLE_BRIGHTNESS_CONTROL, &enable_brightness,
 
279
                  SHOW_BRIGHTNESS_POPUP, &show_popup,
 
280
                  NULL);
 
281
    
 
282
    if ( type == BUTTON_MON_BRIGHTNESS_UP )
 
283
    {
 
284
        backlight->priv->block = TRUE;
 
285
#ifdef WITH_HAL
 
286
        if ( !backlight->priv->brightness_in_hw && enable_brightness)
 
287
            ret = xfpm_brightness_up (backlight->priv->brightness, &level);
 
288
#else
 
289
        if ( enable_brightness )
 
290
            ret = xfpm_brightness_up (backlight->priv->brightness, &level);
 
291
#endif
 
292
        if ( ret && show_popup)
 
293
            xfpm_backlight_show (backlight, level);
 
294
    }
 
295
    else if ( type == BUTTON_MON_BRIGHTNESS_DOWN )
 
296
    {
 
297
        backlight->priv->block = TRUE;
 
298
#ifdef WITH_HAL
 
299
        if ( !backlight->priv->brightness_in_hw && enable_brightness )
 
300
            ret = xfpm_brightness_down (backlight->priv->brightness, &level);
 
301
#else
 
302
        if ( enable_brightness )
 
303
            ret = xfpm_brightness_down (backlight->priv->brightness, &level);
 
304
#endif
 
305
        if ( ret && show_popup)
 
306
            xfpm_backlight_show (backlight, level);
 
307
    }
 
308
}
 
309
 
 
310
static void
 
311
xfpm_backlight_brightness_on_ac_settings_changed (XfpmBacklight *backlight)
 
312
{
 
313
    guint timeout_on_ac;
 
314
    
 
315
    g_object_get (G_OBJECT (backlight->priv->conf),
 
316
                  BRIGHTNESS_ON_AC, &timeout_on_ac,
 
317
                  NULL);
 
318
                  
 
319
    XFPM_DEBUG ("Alarm on ac timeout changed %u", timeout_on_ac);
 
320
    
 
321
    if ( timeout_on_ac == ALARM_DISABLED )
 
322
    {
 
323
        egg_idletime_alarm_remove (backlight->priv->idle, TIMEOUT_BRIGHTNESS_ON_AC );
 
324
    }
 
325
    else
 
326
    {
 
327
        egg_idletime_alarm_set (backlight->priv->idle, TIMEOUT_BRIGHTNESS_ON_AC, timeout_on_ac * 1000);
 
328
    }
 
329
}
 
330
 
 
331
static void
 
332
xfpm_backlight_brightness_on_battery_settings_changed (XfpmBacklight *backlight)
 
333
{
 
334
    guint timeout_on_battery ;
 
335
    
 
336
    g_object_get (G_OBJECT (backlight->priv->conf),
 
337
                  BRIGHTNESS_ON_BATTERY, &timeout_on_battery,
 
338
                  NULL);
 
339
    
 
340
    XFPM_DEBUG ("Alarm on battery timeout changed %u", timeout_on_battery);
 
341
    
 
342
    if ( timeout_on_battery == ALARM_DISABLED )
 
343
    {
 
344
        egg_idletime_alarm_remove (backlight->priv->idle, TIMEOUT_BRIGHTNESS_ON_BATTERY );
 
345
    }
 
346
    else
 
347
    {
 
348
        egg_idletime_alarm_set (backlight->priv->idle, TIMEOUT_BRIGHTNESS_ON_BATTERY, timeout_on_battery * 1000);
 
349
    } 
 
350
}
 
351
 
 
352
 
 
353
static void
 
354
xfpm_backlight_set_timeouts (XfpmBacklight *backlight)
 
355
{
 
356
    xfpm_backlight_brightness_on_ac_settings_changed (backlight);
 
357
    xfpm_backlight_brightness_on_battery_settings_changed (backlight);
 
358
}
 
359
 
 
360
static void
 
361
xfpm_backlight_on_battery_changed_cb (XfpmPower *power, gboolean on_battery, XfpmBacklight *backlight)
 
362
{
 
363
    backlight->priv->on_battery = on_battery;
 
364
}
 
365
 
 
366
static void
 
367
xfpm_backlight_class_init (XfpmBacklightClass *klass)
 
368
{
 
369
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
94
370
 
95
371
    object_class->finalize = xfpm_backlight_finalize;
96
372
 
97
 
    g_type_class_add_private(klass,sizeof(XfpmBacklightPrivate));
98
 
    
99
 
    xfpm_backlight_dbus_class_init (klass);
100
 
}
101
 
 
102
 
static void
103
 
xfpm_backlight_init(XfpmBacklight *bk)
104
 
{
105
 
    bk->priv = XFPM_BACKLIGHT_GET_PRIVATE(bk);
106
 
    
107
 
    xfpm_backlight_get_device (bk);
108
 
    
109
 
    xfpm_backlight_dbus_init (bk);
110
 
}
111
 
 
112
 
static void
113
 
xfpm_backlight_finalize(GObject *object)
114
 
{
115
 
    XfpmBacklight *bk;
116
 
 
117
 
    bk = XFPM_BACKLIGHT(object);
118
 
    
119
 
    if ( bk->priv->has_hw == TRUE )
120
 
    {
121
 
        g_object_unref (bk->priv->br);
122
 
        g_object_unref (bk->priv->widget);
123
 
    }
124
 
    
125
 
    G_OBJECT_CLASS(xfpm_backlight_parent_class)->finalize(object);
 
373
    g_type_class_add_private (klass, sizeof (XfpmBacklightPrivate));
 
374
}
 
375
 
 
376
static void
 
377
xfpm_backlight_init (XfpmBacklight *backlight)
 
378
{
 
379
    backlight->priv = XFPM_BACKLIGHT_GET_PRIVATE (backlight);
 
380
    
 
381
    backlight->priv->brightness = xfpm_brightness_new ();
 
382
    backlight->priv->has_hw     = xfpm_brightness_setup (backlight->priv->brightness);
 
383
    
 
384
    backlight->priv->osd    = NULL;
 
385
    backlight->priv->notify = NULL;
 
386
    backlight->priv->idle   = NULL;
 
387
    backlight->priv->conf   = NULL;
 
388
    backlight->priv->button = NULL;
 
389
    backlight->priv->power    = NULL;
 
390
    backlight->priv->dimmed = FALSE;
 
391
    backlight->priv->block = FALSE;
 
392
    backlight->priv->destroy_id = 0;
 
393
    
 
394
    if ( !backlight->priv->has_hw )
 
395
    {
 
396
        g_object_unref (backlight->priv->brightness);
 
397
        backlight->priv->brightness = NULL;
 
398
    }
 
399
    else
 
400
    {
 
401
        backlight->priv->idle   = egg_idletime_new ();
 
402
        backlight->priv->conf   = xfpm_xfconf_new ();
 
403
        backlight->priv->button = xfpm_button_new ();
 
404
        backlight->priv->power    = xfpm_power_get ();
 
405
        backlight->priv->notify = xfpm_notify_new ();
 
406
        backlight->priv->max_level = xfpm_brightness_get_max_level (backlight->priv->brightness);
 
407
#ifdef WITH_HAL
 
408
        if ( xfpm_brightness_get_control (backlight->priv->brightness) == XFPM_BRIGHTNESS_CONTROL_HAL )
 
409
            backlight->priv->brightness_in_hw = xfpm_brightness_in_hw (backlight->priv->brightness);
 
410
#endif
 
411
        g_signal_connect (backlight->priv->idle, "alarm-expired",
 
412
                          G_CALLBACK (xfpm_backlight_alarm_timeout_cb), backlight);
 
413
        
 
414
        g_signal_connect (backlight->priv->idle, "reset",
 
415
                          G_CALLBACK(xfpm_backlight_reset_cb), backlight);
 
416
                          
 
417
        g_signal_connect (backlight->priv->button, "button-pressed",
 
418
                          G_CALLBACK (xfpm_backlight_button_pressed_cb), backlight);
 
419
                          
 
420
        g_signal_connect_swapped (backlight->priv->conf, "notify::" BRIGHTNESS_ON_AC,
 
421
                                  G_CALLBACK (xfpm_backlight_brightness_on_ac_settings_changed), backlight);
 
422
        
 
423
        g_signal_connect_swapped (backlight->priv->conf, "notify::" BRIGHTNESS_ON_BATTERY,
 
424
                                  G_CALLBACK (xfpm_backlight_brightness_on_battery_settings_changed), backlight);
 
425
                                
 
426
        g_signal_connect (backlight->priv->power, "on-battery-changed",
 
427
                          G_CALLBACK (xfpm_backlight_on_battery_changed_cb), backlight);
 
428
        g_object_get (G_OBJECT (backlight->priv->power),
 
429
                      "on-battery", &backlight->priv->on_battery,
 
430
                      NULL);
 
431
        xfpm_brightness_get_level (backlight->priv->brightness, &backlight->priv->last_level);
 
432
        xfpm_backlight_set_timeouts (backlight);
 
433
    }
 
434
}
 
435
 
 
436
static void
 
437
xfpm_backlight_finalize (GObject *object)
 
438
{
 
439
    XfpmBacklight *backlight;
 
440
 
 
441
    backlight = XFPM_BACKLIGHT (object);
 
442
 
 
443
    xfpm_backlight_destroy_popup (backlight);
 
444
 
 
445
    if ( backlight->priv->brightness )
 
446
        g_object_unref (backlight->priv->brightness);
 
447
 
 
448
    if ( backlight->priv->idle )
 
449
        g_object_unref (backlight->priv->idle);
 
450
 
 
451
    if ( backlight->priv->conf )
 
452
        g_object_unref (backlight->priv->conf);
 
453
 
 
454
    if ( backlight->priv->button )
 
455
        g_object_unref (backlight->priv->button);
 
456
 
 
457
    if ( backlight->priv->power )
 
458
        g_object_unref (backlight->priv->power);
 
459
 
 
460
    if ( backlight->priv->notify)
 
461
        g_object_unref (backlight->priv->notify);
 
462
 
 
463
    G_OBJECT_CLASS (xfpm_backlight_parent_class)->finalize (object);
126
464
}
127
465
 
128
466
XfpmBacklight *
129
 
xfpm_backlight_new(void)
130
 
{
131
 
    XfpmBacklight *bk = NULL;
132
 
    bk = g_object_new (XFPM_TYPE_BACKLIGHT, NULL);
133
 
    return bk;
134
 
}
135
 
 
136
 
/*
137
 
 * 
138
 
 * DBus server implementation for org.freedesktop.PowerManagement.Backlight (Not standard) 
139
 
 *
140
 
 */
141
 
 
142
 
static gboolean xfpm_backlight_dbus_update_brightness (XfpmBacklight *bk,
143
 
                                                       guint IN_level,
144
 
                                                       GError **error);
145
 
 
146
 
#include "org.freedesktop.PowerManagement.Backlight.h"
147
 
 
148
 
static void xfpm_backlight_dbus_class_init  (XfpmBacklightClass *klass)
149
 
{
150
 
    dbus_g_object_type_install_info (G_TYPE_FROM_CLASS(klass),
151
 
                                     &dbus_glib_xfpm_backlight_object_info);
152
 
}
153
 
 
154
 
static void xfpm_backlight_dbus_init      (XfpmBacklight *bk)
155
 
{
156
 
    DBusGConnection *bus = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
157
 
    
158
 
    dbus_g_connection_register_g_object (bus,
159
 
                                         "/org/freedesktop/PowerManagement/Backlight",
160
 
                                         G_OBJECT(bk));
161
 
}
162
 
 
163
 
 
164
 
static gboolean xfpm_backlight_dbus_update_brightness (XfpmBacklight *bk,
165
 
                                                       guint IN_level,
166
 
                                                       GError **error)
167
 
{
168
 
    TRACE("Update backlight message received");
169
 
    if ( bk->priv->has_hw )
170
 
        xfpm_brightness_hal_update_level (bk->priv->br, IN_level);
171
 
    
172
 
    return TRUE;
173
 
}
174
 
 
175
 
gboolean xfpm_backlight_has_hw (XfpmBacklight *bk)
176
 
{
177
 
    g_return_val_if_fail (XFPM_IS_BACKLIGHT (bk), FALSE);
178
 
    
179
 
    return bk->priv->has_hw;
180
 
}
181
 
 
182
 
void xfpm_backlight_reload (XfpmBacklight *bk)
183
 
{
184
 
    g_return_if_fail (XFPM_IS_BACKLIGHT (bk));
185
 
    
186
 
    if ( bk->priv->has_hw == TRUE )
187
 
    {
188
 
        g_object_unref (bk->priv->br);
189
 
        g_object_unref (bk->priv->widget);
190
 
    }
191
 
    
192
 
    xfpm_backlight_get_device (bk);
 
467
xfpm_backlight_new (void)
 
468
{
 
469
    XfpmBacklight *backlight = NULL;
 
470
    backlight = g_object_new (XFPM_TYPE_BACKLIGHT, NULL);
 
471
    return backlight;
 
472
}
 
473
 
 
474
gboolean xfpm_backlight_has_hw (XfpmBacklight *backlight)
 
475
{
 
476
    return backlight->priv->has_hw;
193
477
}