← 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-manager.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-manager.c
30
30
#include <glib.h>
31
31
 
32
32
#include <libxfce4util/libxfce4util.h>
 
33
#include <libxfce4ui/libxfce4ui.h>
33
34
#include <xfconf/xfconf.h>
34
35
 
35
36
#include <dbus/dbus-glib.h>
37
38
 
38
39
#include <libnotify/notify.h>
39
40
 
40
 
#include "libxfpm/xfpm-string.h"
41
 
#include "libxfpm/xfpm-dbus.h"
42
 
#include "libxfpm/xfpm-popups.h"
43
 
 
 
41
#include "xfpm-power.h"
 
42
#include "xfpm-dbus.h"
 
43
#include "xfpm-disks.h"
 
44
#include "xfpm-dpms.h"
44
45
#include "xfpm-manager.h"
45
 
#include "xfpm-engine.h"
46
 
#include "xfpm-session.h"
 
46
#include "xfpm-console-kit.h"
 
47
#include "xfpm-button.h"
 
48
#include "xfpm-backlight.h"
 
49
#include "xfpm-inhibit.h"
 
50
#include "egg-idletime.h"
 
51
#include "xfpm-config.h"
 
52
#include "xfpm-debug.h"
 
53
#include "xfpm-xfconf.h"
 
54
#include "xfpm-errors.h"
 
55
#include "xfpm-common.h"
 
56
#include "xfpm-enum.h"
 
57
#include "xfpm-enum-glib.h"
 
58
#include "xfpm-enum-types.h"
47
59
#include "xfpm-dbus-monitor.h"
48
 
#include "xfpm-errors.h"
49
60
 
50
61
static void xfpm_manager_finalize   (GObject *object);
51
62
 
57
68
#define XFPM_MANAGER_GET_PRIVATE(o) \
58
69
(G_TYPE_INSTANCE_GET_PRIVATE((o), XFPM_TYPE_MANAGER, XfpmManagerPrivate))
59
70
 
 
71
#define SLEEP_KEY_TIMEOUT 6.0f
 
72
 
60
73
struct XfpmManagerPrivate
61
74
{
62
 
    XfpmSession     *session;
63
 
    XfpmEngine      *engine;
64
 
    
 
75
    DBusGConnection *session_bus;
 
76
    
 
77
    XfceSMClient    *client;
 
78
    
 
79
    XfpmPower       *power;
 
80
    XfpmButton      *button;
 
81
    XfpmXfconf      *conf;
 
82
    XfpmBacklight   *backlight;
 
83
    XfpmConsoleKit  *console;
65
84
    XfpmDBusMonitor *monitor;
 
85
    XfpmDisks       *disks;
 
86
    XfpmInhibit     *inhibit;
 
87
    EggIdletime     *idle;
 
88
#ifdef HAVE_DPMS
 
89
    XfpmDpms        *dpms;
 
90
#endif
 
91
 
 
92
    GTimer          *timer;
66
93
    
67
 
    DBusGConnection *session_bus;
 
94
    gboolean         inhibited;
 
95
    gboolean         session_managed;
68
96
};
69
97
 
70
 
G_DEFINE_TYPE(XfpmManager, xfpm_manager, G_TYPE_OBJECT)
71
 
 
72
 
static void
73
 
xfpm_manager_hal_connection_changed_cb (XfpmDBusMonitor *monitor, gboolean connected, XfpmManager *manager)
74
 
{
75
 
    TRACE("connected = %s", xfpm_bool_to_string (connected));
76
 
    
77
 
    if ( connected  == TRUE )
78
 
    {
79
 
        if ( manager->priv->engine == NULL)
80
 
        {
81
 
            manager->priv->engine = xfpm_engine_new ();
82
 
        }
83
 
        else
84
 
        {
85
 
            xfpm_engine_reload_hal_objects (manager->priv->engine);
86
 
        }
87
 
    }
88
 
}
89
 
 
90
 
static void
91
 
xfpm_manager_system_bus_connection_changed_cb (XfpmDBusMonitor *monitor, gboolean connected, XfpmManager *manager)
92
 
{
93
 
    if ( connected == TRUE )
94
 
    {
95
 
        TRACE ("System bus connection changed to TRUE, restarting the power manager");
96
 
        xfpm_manager_quit (manager);
97
 
        g_spawn_command_line_async ("xfce4-power-manager", NULL);
98
 
    }
99
 
}
100
 
 
101
 
static void
102
 
xfpm_manager_session_die_cb (XfpmSession *session, XfpmManager *manager)
103
 
{
104
 
    TRACE ("Session die signal, exiting");
105
 
    xfpm_manager_quit (manager);
106
 
}
 
98
G_DEFINE_TYPE (XfpmManager, xfpm_manager, G_TYPE_OBJECT)
107
99
 
108
100
static void
109
101
xfpm_manager_class_init (XfpmManagerClass *klass)
112
104
 
113
105
    object_class->finalize = xfpm_manager_finalize;
114
106
 
115
 
    g_type_class_add_private(klass,sizeof(XfpmManagerPrivate));
 
107
    g_type_class_add_private (klass, sizeof (XfpmManagerPrivate));
116
108
}
117
109
 
118
110
static void
119
 
xfpm_manager_init(XfpmManager *manager)
 
111
xfpm_manager_init (XfpmManager *manager)
120
112
{
121
 
    manager->priv = XFPM_MANAGER_GET_PRIVATE(manager);
122
 
 
123
 
    manager->priv->engine        = NULL;
124
 
    
125
 
    manager->priv->session = xfpm_session_new ();
126
 
    manager->priv->monitor = xfpm_dbus_monitor_new ();
127
 
    
128
 
    g_signal_connect (manager->priv->monitor, "hal-connection-changed",
129
 
                      G_CALLBACK(xfpm_manager_hal_connection_changed_cb), manager);
130
 
                      
131
 
    g_signal_connect (G_OBJECT (manager->priv->monitor), "system_bus_connection_changed",
132
 
                      G_CALLBACK (xfpm_manager_system_bus_connection_changed_cb), manager);
133
 
 
134
 
    g_signal_connect (manager->priv->session, "session-die",
135
 
                      G_CALLBACK (xfpm_manager_session_die_cb), manager);
136
 
                      
 
113
    manager->priv = XFPM_MANAGER_GET_PRIVATE (manager);
 
114
 
 
115
    manager->priv->timer = g_timer_new ();
 
116
    
137
117
    notify_init ("xfce4-power-manager");
138
118
}
139
119
 
140
120
static void
141
 
xfpm_manager_finalize(GObject *object)
 
121
xfpm_manager_finalize (GObject *object)
142
122
{
143
123
    XfpmManager *manager;
144
124
 
147
127
    if ( manager->priv->session_bus )
148
128
        dbus_g_connection_unref (manager->priv->session_bus);
149
129
        
150
 
    if ( manager->priv->engine )
151
 
        g_object_unref (manager->priv->engine);
152
 
        
153
 
    g_object_unref (manager->priv->session);
154
 
 
 
130
    g_object_unref (manager->priv->power);
 
131
    g_object_unref (manager->priv->button);
 
132
    g_object_unref (manager->priv->conf);
 
133
    g_object_unref (manager->priv->client);
 
134
    g_object_unref (manager->priv->console);
155
135
    g_object_unref (manager->priv->monitor);
156
 
    
 
136
    g_object_unref (manager->priv->disks);
 
137
    g_object_unref (manager->priv->inhibit);
 
138
    g_object_unref (manager->priv->idle);
 
139
    
 
140
    g_timer_destroy (manager->priv->timer);
 
141
    
 
142
#ifdef HAVE_DPMS
 
143
    g_object_unref (manager->priv->dpms);
 
144
#endif
 
145
    
 
146
    g_object_unref (manager->priv->backlight);
 
147
        
157
148
    G_OBJECT_CLASS (xfpm_manager_parent_class)->finalize (object);
158
149
}
159
150
 
170
161
static gboolean
171
162
xfpm_manager_quit (XfpmManager *manager)
172
163
{
173
 
    TRACE ("Exiting");
 
164
    XFPM_DEBUG ("Exiting");
174
165
    
175
166
    xfpm_manager_release_names (manager);
176
 
    xfpm_session_quit (manager->priv->session);
177
 
    
178
 
    g_object_unref (G_OBJECT (manager));
179
 
    
180
167
    gtk_main_quit ();
181
168
    return TRUE;
182
169
}
183
170
 
 
171
static void
 
172
xfpm_manager_system_bus_connection_changed_cb (XfpmDBusMonitor *monitor, gboolean connected, XfpmManager *manager)
 
173
{
 
174
    if ( connected == TRUE )
 
175
    {
 
176
        XFPM_DEBUG ("System bus connection changed to TRUE, restarting the power manager");
 
177
        xfpm_manager_quit (manager);
 
178
        g_spawn_command_line_async ("xfce4-power-manager", NULL);
 
179
    }
 
180
}
 
181
 
184
182
static gboolean
185
183
xfpm_manager_reserve_names (XfpmManager *manager)
186
184
{
190
188
                                  "org.freedesktop.PowerManagement") )
191
189
    {
192
190
        g_warning ("Unable to reserve bus name: Maybe any already running instance?\n");
193
 
        xfpm_session_quit (manager->priv->session);
 
191
        
194
192
        g_object_unref (G_OBJECT (manager));
195
193
        gtk_main_quit ();
 
194
        
196
195
        return FALSE;
197
196
    }
198
197
    return TRUE;
199
198
}
200
199
 
 
200
static void
 
201
xfpm_manager_shutdown (XfpmManager *manager)
 
202
{
 
203
    GError *error = NULL;
 
204
    xfpm_console_kit_shutdown (manager->priv->console, &error );
 
205
    
 
206
    if ( error )
 
207
    {
 
208
        g_warning ("Failed to shutdown the system : %s", error->message);
 
209
        g_error_free (error);
 
210
        /* Try with the session then */
 
211
        if ( manager->priv->session_managed )
 
212
            xfce_sm_client_request_shutdown (manager->priv->client, XFCE_SM_CLIENT_SHUTDOWN_HINT_HALT);
 
213
    }
 
214
}
 
215
 
 
216
static void
 
217
xfpm_manager_ask_shutdown (XfpmManager *manager)
 
218
{
 
219
    if ( manager->priv->session_managed )
 
220
        xfce_sm_client_request_shutdown (manager->priv->client, XFCE_SM_CLIENT_SHUTDOWN_HINT_ASK);
 
221
}
 
222
 
 
223
static void
 
224
xfpm_manager_sleep_request (XfpmManager *manager, XfpmShutdownRequest req, gboolean force)
 
225
{
 
226
    switch (req)
 
227
    {
 
228
        case XFPM_DO_NOTHING:
 
229
            break;
 
230
        case XFPM_DO_SUSPEND:
 
231
            xfpm_power_suspend (manager->priv->power, force);
 
232
            break;
 
233
        case XFPM_DO_HIBERNATE:
 
234
            xfpm_power_hibernate (manager->priv->power, force);
 
235
            break;
 
236
        case XFPM_DO_SHUTDOWN:
 
237
            xfpm_manager_shutdown (manager);
 
238
            break;
 
239
        case XFPM_ASK:
 
240
            xfpm_manager_ask_shutdown (manager);
 
241
            break;
 
242
        default:
 
243
            g_warn_if_reached ();
 
244
            break;
 
245
    }
 
246
}
 
247
 
 
248
static void
 
249
xfpm_manager_reset_sleep_timer (XfpmManager *manager)
 
250
{
 
251
    g_timer_reset (manager->priv->timer);
 
252
}
 
253
 
 
254
static void
 
255
xfpm_manager_button_pressed_cb (XfpmButton *bt, XfpmButtonKey type, XfpmManager *manager)
 
256
{
 
257
    XfpmShutdownRequest req = XFPM_DO_NOTHING;
 
258
    
 
259
    XFPM_DEBUG_ENUM (type, XFPM_TYPE_BUTTON_KEY, "Received button press event");
 
260
  
 
261
    if ( type == BUTTON_MON_BRIGHTNESS_DOWN || type == BUTTON_MON_BRIGHTNESS_UP )
 
262
        return;
 
263
        
 
264
    if ( type == BUTTON_POWER_OFF )
 
265
    {
 
266
        g_object_get (G_OBJECT (manager->priv->conf),
 
267
                      POWER_SWITCH_CFG, &req,
 
268
                      NULL);
 
269
    }
 
270
    else if ( type == BUTTON_SLEEP )
 
271
    {
 
272
        g_object_get (G_OBJECT (manager->priv->conf),
 
273
                      SLEEP_SWITCH_CFG, &req,
 
274
                      NULL);
 
275
    }
 
276
    else if ( type == BUTTON_HIBERNATE )
 
277
    {
 
278
        g_object_get (G_OBJECT (manager->priv->conf),
 
279
                      HIBERNATE_SWITCH_CFG, &req,
 
280
                      NULL);
 
281
    }
 
282
    else
 
283
    {
 
284
        g_return_if_reached ();
 
285
    }
 
286
 
 
287
    XFPM_DEBUG_ENUM (req, XFPM_TYPE_SHUTDOWN_REQUEST, "Shutdown request : ");
 
288
        
 
289
    if ( req == XFPM_ASK )
 
290
        xfpm_manager_ask_shutdown (manager);
 
291
    else
 
292
    {
 
293
        if ( g_timer_elapsed (manager->priv->timer, NULL) > SLEEP_KEY_TIMEOUT )
 
294
        {
 
295
            g_timer_reset (manager->priv->timer);
 
296
            xfpm_manager_sleep_request (manager, req, FALSE);
 
297
        }
 
298
    }
 
299
}
 
300
 
 
301
static void
 
302
xfpm_manager_lid_changed_cb (XfpmPower *power, gboolean lid_is_closed, XfpmManager *manager)
 
303
{
 
304
    XfpmLidTriggerAction action;
 
305
    gboolean on_battery;
 
306
    
 
307
    g_object_get (G_OBJECT (power),
 
308
                  "on-battery", &on_battery,
 
309
                  NULL);
 
310
    
 
311
    g_object_get (G_OBJECT (manager->priv->conf),
 
312
                  on_battery ? LID_SWITCH_ON_BATTERY_CFG : LID_SWITCH_ON_AC_CFG, &action,
 
313
                  NULL);
 
314
 
 
315
    if ( lid_is_closed )
 
316
    {
 
317
        XFPM_DEBUG_ENUM (action, XFPM_TYPE_LID_TRIGGER_ACTION, "LID close event");
 
318
        
 
319
        if ( action == LID_TRIGGER_NOTHING )
 
320
        {
 
321
            if ( !xfpm_is_multihead_connected () )
 
322
                xfpm_dpms_force_level (manager->priv->dpms, DPMSModeOff);
 
323
        }
 
324
        else if ( action == LID_TRIGGER_LOCK_SCREEN )
 
325
        {
 
326
            if ( !xfpm_is_multihead_connected () )
 
327
                xfpm_lock_screen ();
 
328
        }
 
329
        else 
 
330
        {
 
331
            /*
 
332
             * Force sleep here as lid is closed and no point of asking the
 
333
             * user for confirmation in case of an application is inhibiting
 
334
             * the power manager. 
 
335
             */
 
336
            xfpm_manager_sleep_request (manager, action, TRUE);
 
337
        }
 
338
        
 
339
    }
 
340
    else
 
341
    {
 
342
        XFPM_DEBUG_ENUM (action, XFPM_TYPE_LID_TRIGGER_ACTION, "LID opened");
 
343
        xfpm_dpms_force_level (manager->priv->dpms, DPMSModeOn);
 
344
    }
 
345
}
 
346
 
 
347
static void
 
348
xfpm_manager_inhibit_changed_cb (XfpmInhibit *inhibit, gboolean inhibited, XfpmManager *manager)
 
349
{
 
350
    manager->priv->inhibited = inhibited;
 
351
}
 
352
 
 
353
static void
 
354
xfpm_manager_alarm_timeout_cb (EggIdletime *idle, guint id, XfpmManager *manager)
 
355
{
 
356
    XFPM_DEBUG ("Alarm inactivity timeout id %d", id);
 
357
    
 
358
    if ( id == TIMEOUT_INACTIVITY_ON_AC || id == TIMEOUT_INACTIVITY_ON_BATTERY )
 
359
    {
 
360
        XfpmShutdownRequest req = XFPM_DO_NOTHING;
 
361
        gchar *sleep_mode;
 
362
        gboolean on_battery;
 
363
        
 
364
        if ( manager->priv->inhibited )
 
365
        {
 
366
            XFPM_DEBUG ("Idle sleep alarm timeout, but power manager is currently inhibited, action ignored");
 
367
            return;
 
368
        }
 
369
    
 
370
        g_object_get (G_OBJECT (manager->priv->conf),
 
371
                      INACTIVITY_SLEEP_MODE, &sleep_mode,
 
372
                      NULL);
 
373
        
 
374
        g_object_get (G_OBJECT (manager->priv->power),
 
375
                      "on-battery", &on_battery,
 
376
                      NULL);
 
377
                  
 
378
        if ( !g_strcmp0 (sleep_mode, "Suspend") )
 
379
            req = XFPM_DO_SUSPEND;
 
380
        else
 
381
            req = XFPM_DO_HIBERNATE;
 
382
        
 
383
        g_free (sleep_mode);
 
384
 
 
385
        if ( id == TIMEOUT_INACTIVITY_ON_AC && on_battery == FALSE )
 
386
            xfpm_manager_sleep_request (manager, req, FALSE);
 
387
        else if ( id ==  TIMEOUT_INACTIVITY_ON_BATTERY && on_battery  )
 
388
            xfpm_manager_sleep_request (manager, req, FALSE);
 
389
    }
 
390
}
 
391
 
 
392
static void
 
393
xfpm_manager_set_idle_alarm_on_ac (XfpmManager *manager)
 
394
{
 
395
    guint on_ac;
 
396
    
 
397
    g_object_get (G_OBJECT (manager->priv->conf),
 
398
                  ON_AC_INACTIVITY_TIMEOUT, &on_ac,
 
399
                  NULL);
 
400
    
 
401
#ifdef DEBUG
 
402
    if ( on_ac == 14 )
 
403
        TRACE ("setting inactivity sleep timeout on ac to never");
 
404
    else
 
405
        TRACE ("setting inactivity sleep timeout on ac to %d", on_ac);
 
406
#endif
 
407
    
 
408
    if ( on_ac == 14 )
 
409
    {
 
410
        egg_idletime_alarm_remove (manager->priv->idle, TIMEOUT_INACTIVITY_ON_AC );
 
411
    }
 
412
    else
 
413
    {
 
414
        egg_idletime_alarm_set (manager->priv->idle, TIMEOUT_INACTIVITY_ON_AC, on_ac * 1000 * 60);
 
415
    }
 
416
}
 
417
 
 
418
static void
 
419
xfpm_manager_set_idle_alarm_on_battery (XfpmManager *manager)
 
420
{
 
421
    guint on_battery;
 
422
    
 
423
    g_object_get (G_OBJECT (manager->priv->conf),
 
424
                  ON_BATTERY_INACTIVITY_TIMEOUT, &on_battery,
 
425
                  NULL);
 
426
    
 
427
#ifdef DEBUG
 
428
    if ( on_battery == 14 )
 
429
        TRACE ("setting inactivity sleep timeout on battery to never");
 
430
    else
 
431
        TRACE ("setting inactivity sleep timeout on battery to %d", on_battery);
 
432
#endif
 
433
    
 
434
    if ( on_battery == 14 )
 
435
    {
 
436
        egg_idletime_alarm_remove (manager->priv->idle, TIMEOUT_INACTIVITY_ON_BATTERY );
 
437
    }
 
438
    else
 
439
    {
 
440
        egg_idletime_alarm_set (manager->priv->idle, TIMEOUT_INACTIVITY_ON_BATTERY, on_battery * 1000 * 60);
 
441
    }
 
442
}
 
443
 
 
444
static void
 
445
xfpm_manager_on_battery_changed_cb (XfpmPower *power, gboolean on_battery, XfpmManager *manager)
 
446
{
 
447
    egg_idletime_alarm_reset_all (manager->priv->idle);
 
448
}
 
449
 
 
450
static void
 
451
xfpm_manager_set_idle_alarm (XfpmManager *manager)
 
452
{
 
453
    xfpm_manager_set_idle_alarm_on_ac (manager);
 
454
    xfpm_manager_set_idle_alarm_on_battery (manager);
 
455
    
 
456
}
 
457
 
201
458
XfpmManager *
202
 
xfpm_manager_new (DBusGConnection *bus)
 
459
xfpm_manager_new (DBusGConnection *bus, const gchar *client_id)
203
460
{
204
461
    XfpmManager *manager = NULL;
205
 
    manager = g_object_new(XFPM_TYPE_MANAGER,NULL);
 
462
    GError *error = NULL;
 
463
    gchar *current_dir;
 
464
    
 
465
    const gchar *restart_command[] =
 
466
    {
 
467
        "xfce4-power-manager",
 
468
        "--restart",
 
469
        NULL
 
470
    };
 
471
        
 
472
    manager = g_object_new (XFPM_TYPE_MANAGER, NULL);
206
473
 
207
474
    manager->priv->session_bus = bus;
208
475
    
209
 
    xfpm_manager_dbus_class_init (XFPM_MANAGER_GET_CLASS(manager));
 
476
    current_dir = g_get_current_dir ();
 
477
    manager->priv->client = xfce_sm_client_get_full (XFCE_SM_CLIENT_RESTART_NORMAL,
 
478
                                                     XFCE_SM_CLIENT_PRIORITY_DEFAULT,
 
479
                                                     client_id,
 
480
                                                     current_dir,
 
481
                                                     restart_command,
 
482
                                                     SYSCONFDIR "/xdg/autostart/" PACKAGE_NAME ".desktop");
 
483
    
 
484
    g_free (current_dir);
 
485
    
 
486
    manager->priv->session_managed = xfce_sm_client_connect (manager->priv->client, &error);
 
487
    
 
488
    if ( error )
 
489
    {
 
490
        g_warning ("Unable to connect to session managet : %s", error->message);
 
491
        g_error_free (error);
 
492
    }
 
493
    else
 
494
    {
 
495
        g_signal_connect_swapped (manager->priv->client, "quit",
 
496
                                  G_CALLBACK (xfpm_manager_quit), manager);
 
497
    }
 
498
    
 
499
    xfpm_manager_dbus_class_init (XFPM_MANAGER_GET_CLASS (manager));
210
500
    xfpm_manager_dbus_init (manager);
211
501
    
212
502
    return manager;
214
504
 
215
505
void xfpm_manager_start (XfpmManager *manager)
216
506
{
217
 
    gboolean hal_running;
218
 
    
219
507
    if ( !xfpm_manager_reserve_names (manager) )
220
508
        goto out;
221
509
        
223
511
                                  NULL,
224
512
                                  XFPM_TYPE_ERROR);
225
513
    
226
 
    hal_running = xfpm_dbus_monitor_hal_connected (manager->priv->monitor);
227
 
    
228
 
    if (!hal_running )
229
 
    {
230
 
        xfpm_error (_("Xfce power manager"), _("HAL daemon is not running"));
231
 
        goto out;
232
 
    }
233
 
    manager->priv->engine = xfpm_engine_new ();
234
 
    
 
514
    manager->priv->power = xfpm_power_get ();
 
515
    manager->priv->button = xfpm_button_new ();
 
516
    manager->priv->conf = xfpm_xfconf_new ();
 
517
    manager->priv->console = xfpm_console_kit_new ();
 
518
    manager->priv->monitor = xfpm_dbus_monitor_new ();
 
519
    manager->priv->disks = xfpm_disks_new ();
 
520
    manager->priv->inhibit = xfpm_inhibit_new ();
 
521
    manager->priv->idle = egg_idletime_new ();
 
522
    
 
523
    g_signal_connect (manager->priv->idle, "alarm-expired",
 
524
                      G_CALLBACK (xfpm_manager_alarm_timeout_cb), manager);
 
525
    
 
526
    g_signal_connect (manager->priv->conf, "notify::" ON_AC_INACTIVITY_TIMEOUT,
 
527
                      G_CALLBACK (xfpm_manager_set_idle_alarm_on_ac), manager);
 
528
                      
 
529
    g_signal_connect (manager->priv->conf, "notify::" ON_BATTERY_INACTIVITY_TIMEOUT,
 
530
                      G_CALLBACK (xfpm_manager_set_idle_alarm_on_battery), manager);
 
531
    
 
532
    xfpm_manager_set_idle_alarm (manager);
 
533
    
 
534
    g_signal_connect (manager->priv->inhibit, "has-inhibit-changed",
 
535
                      G_CALLBACK (xfpm_manager_inhibit_changed_cb), manager);
 
536
    
 
537
    g_signal_connect (manager->priv->monitor, "system-bus-connection-changed",
 
538
                      G_CALLBACK (xfpm_manager_system_bus_connection_changed_cb), manager);
 
539
   
 
540
    manager->priv->backlight = xfpm_backlight_new ();
 
541
    
 
542
#ifdef HAVE_DPMS
 
543
    manager->priv->dpms = xfpm_dpms_new ();
 
544
#endif
 
545
    
 
546
    g_signal_connect (manager->priv->button, "button_pressed",
 
547
                      G_CALLBACK (xfpm_manager_button_pressed_cb), manager);
 
548
    
 
549
    g_signal_connect (manager->priv->power, "lid-changed",
 
550
                      G_CALLBACK (xfpm_manager_lid_changed_cb), manager);
 
551
    
 
552
    g_signal_connect (manager->priv->power, "on-battery-changed",
 
553
                      G_CALLBACK (xfpm_manager_on_battery_changed_cb), manager);
 
554
    
 
555
    g_signal_connect_swapped (manager->priv->power, "waking-up",
 
556
                              G_CALLBACK (xfpm_manager_reset_sleep_timer), manager);
 
557
    
 
558
    g_signal_connect_swapped (manager->priv->power, "sleeping",
 
559
                              G_CALLBACK (xfpm_manager_reset_sleep_timer), manager);
 
560
                              
 
561
    g_signal_connect_swapped (manager->priv->power, "ask-shutdown",
 
562
                              G_CALLBACK (xfpm_manager_ask_shutdown), manager);
 
563
    
 
564
    g_signal_connect_swapped (manager->priv->power, "shutdown",
 
565
                              G_CALLBACK (xfpm_manager_shutdown), manager);
 
566
                              
235
567
out:
236
568
        ;
237
569
}
238
570
 
239
571
void xfpm_manager_stop (XfpmManager *manager)
240
572
{
241
 
    TRACE ("Stopping");
 
573
    XFPM_DEBUG ("Stopping");
242
574
    g_return_if_fail (XFPM_IS_MANAGER (manager));
243
575
    xfpm_manager_quit (manager);
244
576
}
245
577
 
 
578
GHashTable *xfpm_manager_get_config (XfpmManager *manager)
 
579
{
 
580
    GHashTable *hash;
 
581
    
 
582
    guint8 mapped_buttons;
 
583
    gboolean auth_hibernate = FALSE;
 
584
    gboolean auth_suspend = FALSE;
 
585
    gboolean can_suspend = FALSE;
 
586
    gboolean can_hibernate = FALSE;
 
587
    gboolean has_sleep_button = FALSE;
 
588
    gboolean has_hibernate_button = FALSE;
 
589
    gboolean has_power_button = FALSE;
 
590
    gboolean has_battery = TRUE;
 
591
    gboolean has_lcd_brightness = TRUE;
 
592
    gboolean can_shutdown = TRUE;
 
593
    gboolean has_lid = FALSE;
 
594
    gboolean can_spin = FALSE;
 
595
    gboolean devkit_disk = FALSE;
 
596
    
 
597
    hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
 
598
    
 
599
    g_object_get (G_OBJECT (manager->priv->console),
 
600
                  "can-shutdown", &can_shutdown,
 
601
                  NULL);
 
602
 
 
603
    g_object_get (G_OBJECT (manager->priv->power),
 
604
                  "auth-suspend", &auth_suspend,
 
605
                  "auth-hibernate", &auth_hibernate,
 
606
                  "can-suspend", &can_suspend,
 
607
                  "can-hibernate", &can_hibernate, 
 
608
                  "has-lid", &has_lid,
 
609
                  NULL);
 
610
 
 
611
    can_spin = xfpm_disks_get_can_spin (manager->priv->disks);
 
612
    devkit_disk = xfpm_disks_kit_is_running (manager->priv->disks);
 
613
    
 
614
    has_battery = xfpm_power_has_battery (manager->priv->power);
 
615
    has_lcd_brightness = xfpm_backlight_has_hw (manager->priv->backlight);
 
616
    
 
617
    mapped_buttons = xfpm_button_get_mapped (manager->priv->button);
 
618
    
 
619
    if ( mapped_buttons & SLEEP_KEY )
 
620
        has_sleep_button = TRUE;
 
621
    if ( mapped_buttons & HIBERNATE_KEY )
 
622
        has_hibernate_button = TRUE;
 
623
    if ( mapped_buttons & POWER_KEY )
 
624
        has_power_button = TRUE;
 
625
        
 
626
    g_hash_table_insert (hash, g_strdup ("sleep-button"), g_strdup (xfpm_bool_to_string (has_sleep_button)));
 
627
    g_hash_table_insert (hash, g_strdup ("power-button"), g_strdup (xfpm_bool_to_string (has_power_button)));
 
628
    g_hash_table_insert (hash, g_strdup ("hibernate-button"), g_strdup (xfpm_bool_to_string (has_hibernate_button)));
 
629
    g_hash_table_insert (hash, g_strdup ("auth-suspend"), g_strdup (xfpm_bool_to_string (auth_suspend)));
 
630
    g_hash_table_insert (hash, g_strdup ("auth-hibernate"), g_strdup (xfpm_bool_to_string (auth_hibernate)));
 
631
    g_hash_table_insert (hash, g_strdup ("can-suspend"), g_strdup (xfpm_bool_to_string (can_suspend)));
 
632
    g_hash_table_insert (hash, g_strdup ("can-hibernate"), g_strdup (xfpm_bool_to_string (can_hibernate)));
 
633
    g_hash_table_insert (hash, g_strdup ("can-shutdown"), g_strdup (xfpm_bool_to_string (can_shutdown)));
 
634
    
 
635
    g_hash_table_insert (hash, g_strdup ("has-battery"), g_strdup (xfpm_bool_to_string (has_battery)));
 
636
    g_hash_table_insert (hash, g_strdup ("has-lid"), g_strdup (xfpm_bool_to_string (has_lid)));
 
637
    g_hash_table_insert (hash, g_strdup ("can-spin"), g_strdup (xfpm_bool_to_string (can_spin)));
 
638
    g_hash_table_insert (hash, g_strdup ("devkit-disk"), g_strdup (xfpm_bool_to_string (devkit_disk)));
 
639
    
 
640
    g_hash_table_insert (hash, g_strdup ("has-brightness"), g_strdup (xfpm_bool_to_string (has_lcd_brightness)));
 
641
    
 
642
    return hash;
 
643
}
 
644
 
246
645
/*
247
646
 * 
248
647
 * DBus server implementation
284
683
static gboolean
285
684
xfpm_manager_dbus_quit (XfpmManager *manager, GError **error)
286
685
{
287
 
    TRACE("Quit message received\n");
 
686
    XFPM_DEBUG("Quit message received\n");
288
687
    
289
688
    xfpm_manager_quit (manager);
290
689
    
294
693
static gboolean xfpm_manager_dbus_restart     (XfpmManager *manager,
295
694
                                               GError **error)
296
695
{
297
 
    TRACE("Restart message received");
 
696
    XFPM_DEBUG("Restart message received");
298
697
    
299
698
    xfpm_manager_quit (manager);
300
699
    
308
707
                                              GError **error)
309
708
{
310
709
    
311
 
    *OUT_config = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
312
 
    
313
 
    xfpm_engine_get_info (manager->priv->engine, *OUT_config);
314
 
    
 
710
    *OUT_config = xfpm_manager_get_config (manager);
315
711
    return TRUE;
316
712
}
317
713