← Back to branch summary

~ubuntu-branches/ubuntu/utopic/xfce4-power-manager/utopic-proposed

« back to all changes in this revision

Viewing changes to .pc/10_inhibit_logind.patch/src/xfpm-manager.c

  • Committer: Package Import Robot
  • Author(s): Jackson Doak
  • Date: 2014-06-25 19:13:23 UTC
  • mfrom: (21.1.3 experimental)
  • Revision ID: package-import@ubuntu.com-20140625191323-w7xzyk3dkwkk15uh
Tags: 1.3.0-1ubuntu1
https://launchpad.net/bugs/1334185
* Merge from debian. (LP: #1334185) Remaining changes:
  - Switch to using logind for session tracking. Depend on systemd-services
    and add libsystemd-login-dev build dependency.
* Use upower << 0.99
* Drop all patches, fixed upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/10_inhibit_logind.patch/src/xfpm-manager.c
1
 
/*
2
 
 * * Copyright (C) 2008-2011 Ali <aliov@xfce.org>
3
 
 *
4
 
 * Licensed under the GNU General Public License Version 2
5
 
 *
6
 
 * This program is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU General Public License as published by
8
 
 * the Free Software Foundation; either version 2 of the License, or
9
 
 * (at your option) any later version.
10
 
 *
11
 
 * This program is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU General Public License
17
 
 * along with this program; if not, write to the Free Software
18
 
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
20
 
 
21
 
#ifdef HAVE_CONFIG_H
22
 
#include <config.h>
23
 
#endif
24
 
 
25
 
#include <stdio.h>
26
 
#include <stdlib.h>
27
 
#include <string.h>
28
 
 
29
 
#include <gtk/gtk.h>
30
 
#include <glib.h>
31
 
 
32
 
#include <libxfce4util/libxfce4util.h>
33
 
#include <libxfce4ui/libxfce4ui.h>
34
 
#include <xfconf/xfconf.h>
35
 
 
36
 
#include <dbus/dbus-glib.h>
37
 
#include <dbus/dbus-glib-lowlevel.h>
38
 
 
39
 
#include <libnotify/notify.h>
40
 
 
41
 
#include "xfpm-power.h"
42
 
#include "xfpm-dbus.h"
43
 
#include "xfpm-disks.h"
44
 
#include "xfpm-dpms.h"
45
 
#include "xfpm-manager.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"
59
 
#include "xfpm-dbus-monitor.h"
60
 
 
61
 
#ifdef HAVE_SYSTEMD
62
 
#include "xfpm-systemd.h"
63
 
#endif
64
 
 
65
 
static void xfpm_manager_finalize   (GObject *object);
66
 
 
67
 
static void xfpm_manager_dbus_class_init (XfpmManagerClass *klass);
68
 
static void xfpm_manager_dbus_init       (XfpmManager *manager);
69
 
 
70
 
static gboolean xfpm_manager_quit (XfpmManager *manager);
71
 
 
72
 
#define XFPM_MANAGER_GET_PRIVATE(o) \
73
 
(G_TYPE_INSTANCE_GET_PRIVATE((o), XFPM_TYPE_MANAGER, XfpmManagerPrivate))
74
 
 
75
 
#define SLEEP_KEY_TIMEOUT 6.0f
76
 
 
77
 
struct XfpmManagerPrivate
78
 
{
79
 
    DBusGConnection *session_bus;
80
 
    
81
 
    XfceSMClient    *client;
82
 
    
83
 
    XfpmPower       *power;
84
 
    XfpmButton      *button;
85
 
    XfpmXfconf      *conf;
86
 
    XfpmBacklight   *backlight;
87
 
#ifdef HAVE_SYSTEMD
88
 
    XfpmSystemd     *systemd;
89
 
#endif
90
 
    XfpmConsoleKit  *console;
91
 
    XfpmDBusMonitor *monitor;
92
 
    XfpmDisks       *disks;
93
 
    XfpmInhibit     *inhibit;
94
 
    EggIdletime     *idle;
95
 
#ifdef HAVE_DPMS
96
 
    XfpmDpms        *dpms;
97
 
#endif
98
 
 
99
 
    GTimer          *timer;
100
 
    
101
 
    gboolean         inhibited;
102
 
    gboolean         session_managed;
103
 
};
104
 
 
105
 
G_DEFINE_TYPE (XfpmManager, xfpm_manager, G_TYPE_OBJECT)
106
 
 
107
 
static void
108
 
xfpm_manager_class_init (XfpmManagerClass *klass)
109
 
{
110
 
    GObjectClass *object_class = G_OBJECT_CLASS(klass);
111
 
 
112
 
    object_class->finalize = xfpm_manager_finalize;
113
 
 
114
 
    g_type_class_add_private (klass, sizeof (XfpmManagerPrivate));
115
 
}
116
 
 
117
 
static void
118
 
xfpm_manager_init (XfpmManager *manager)
119
 
{
120
 
    manager->priv = XFPM_MANAGER_GET_PRIVATE (manager);
121
 
 
122
 
    manager->priv->timer = g_timer_new ();
123
 
    
124
 
    notify_init ("xfce4-power-manager");
125
 
}
126
 
 
127
 
static void
128
 
xfpm_manager_finalize (GObject *object)
129
 
{
130
 
    XfpmManager *manager;
131
 
 
132
 
    manager = XFPM_MANAGER(object);
133
 
 
134
 
    if ( manager->priv->session_bus )
135
 
        dbus_g_connection_unref (manager->priv->session_bus);
136
 
        
137
 
    g_object_unref (manager->priv->power);
138
 
    g_object_unref (manager->priv->button);
139
 
    g_object_unref (manager->priv->conf);
140
 
    g_object_unref (manager->priv->client);
141
 
#ifdef HAVE_SYSTEMD
142
 
    if ( manager->priv->systemd != NULL )
143
 
        g_object_unref (manager->priv->systemd);
144
 
#endif
145
 
    if ( manager->priv->console != NULL )
146
 
        g_object_unref (manager->priv->console);
147
 
    g_object_unref (manager->priv->monitor);
148
 
    g_object_unref (manager->priv->disks);
149
 
    g_object_unref (manager->priv->inhibit);
150
 
    g_object_unref (manager->priv->idle);
151
 
    
152
 
    g_timer_destroy (manager->priv->timer);
153
 
    
154
 
#ifdef HAVE_DPMS
155
 
    g_object_unref (manager->priv->dpms);
156
 
#endif
157
 
    
158
 
    g_object_unref (manager->priv->backlight);
159
 
        
160
 
    G_OBJECT_CLASS (xfpm_manager_parent_class)->finalize (object);
161
 
}
162
 
 
163
 
static void
164
 
xfpm_manager_release_names (XfpmManager *manager)
165
 
{
166
 
    xfpm_dbus_release_name (dbus_g_connection_get_connection(manager->priv->session_bus),
167
 
                           "org.xfce.PowerManager");
168
 
 
169
 
    xfpm_dbus_release_name (dbus_g_connection_get_connection(manager->priv->session_bus),
170
 
                            "org.freedesktop.PowerManagement");
171
 
}
172
 
 
173
 
static gboolean
174
 
xfpm_manager_quit (XfpmManager *manager)
175
 
{
176
 
    XFPM_DEBUG ("Exiting");
177
 
    
178
 
    xfpm_manager_release_names (manager);
179
 
    gtk_main_quit ();
180
 
    return TRUE;
181
 
}
182
 
 
183
 
static void
184
 
xfpm_manager_system_bus_connection_changed_cb (XfpmDBusMonitor *monitor, gboolean connected, XfpmManager *manager)
185
 
{
186
 
    if ( connected == TRUE )
187
 
    {
188
 
        XFPM_DEBUG ("System bus connection changed to TRUE, restarting the power manager");
189
 
        xfpm_manager_quit (manager);
190
 
        g_spawn_command_line_async ("xfce4-power-manager", NULL);
191
 
    }
192
 
}
193
 
 
194
 
static gboolean
195
 
xfpm_manager_reserve_names (XfpmManager *manager)
196
 
{
197
 
    if ( !xfpm_dbus_register_name (dbus_g_connection_get_connection (manager->priv->session_bus),
198
 
                                   "org.xfce.PowerManager") ||
199
 
         !xfpm_dbus_register_name (dbus_g_connection_get_connection (manager->priv->session_bus),
200
 
                                  "org.freedesktop.PowerManagement") )
201
 
    {
202
 
        g_warning ("Unable to reserve bus name: Maybe any already running instance?\n");
203
 
        
204
 
        g_object_unref (G_OBJECT (manager));
205
 
        gtk_main_quit ();
206
 
        
207
 
        return FALSE;
208
 
    }
209
 
    return TRUE;
210
 
}
211
 
 
212
 
static void
213
 
xfpm_manager_shutdown (XfpmManager *manager)
214
 
{
215
 
    GError *error = NULL;
216
 
#ifdef HAVE_SYSTEMD
217
 
    if ( LOGIND_RUNNING () )
218
 
        xfpm_systemd_shutdown (manager->priv->systemd, &error );
219
 
    else
220
 
#endif
221
 
    xfpm_console_kit_shutdown (manager->priv->console, &error );
222
 
    
223
 
    if ( error )
224
 
    {
225
 
        g_warning ("Failed to shutdown the system : %s", error->message);
226
 
        g_error_free (error);
227
 
        /* Try with the session then */
228
 
        if ( manager->priv->session_managed )
229
 
            xfce_sm_client_request_shutdown (manager->priv->client, XFCE_SM_CLIENT_SHUTDOWN_HINT_HALT);
230
 
    }
231
 
}
232
 
 
233
 
static void
234
 
xfpm_manager_ask_shutdown (XfpmManager *manager)
235
 
{
236
 
    if ( manager->priv->session_managed )
237
 
        xfce_sm_client_request_shutdown (manager->priv->client, XFCE_SM_CLIENT_SHUTDOWN_HINT_ASK);
238
 
}
239
 
 
240
 
static void
241
 
xfpm_manager_sleep_request (XfpmManager *manager, XfpmShutdownRequest req, gboolean force)
242
 
{
243
 
    switch (req)
244
 
    {
245
 
        case XFPM_DO_NOTHING:
246
 
            break;
247
 
        case XFPM_DO_SUSPEND:
248
 
            xfpm_power_suspend (manager->priv->power, force);
249
 
            break;
250
 
        case XFPM_DO_HIBERNATE:
251
 
            xfpm_power_hibernate (manager->priv->power, force);
252
 
            break;
253
 
        case XFPM_DO_SHUTDOWN:
254
 
            xfpm_manager_shutdown (manager);
255
 
            break;
256
 
        case XFPM_ASK:
257
 
            xfpm_manager_ask_shutdown (manager);
258
 
            break;
259
 
        default:
260
 
            g_warn_if_reached ();
261
 
            break;
262
 
    }
263
 
}
264
 
 
265
 
static void
266
 
xfpm_manager_reset_sleep_timer (XfpmManager *manager)
267
 
{
268
 
    g_timer_reset (manager->priv->timer);
269
 
}
270
 
 
271
 
static void
272
 
xfpm_manager_button_pressed_cb (XfpmButton *bt, XfpmButtonKey type, XfpmManager *manager)
273
 
{
274
 
    XfpmShutdownRequest req = XFPM_DO_NOTHING;
275
 
    
276
 
    XFPM_DEBUG_ENUM (type, XFPM_TYPE_BUTTON_KEY, "Received button press event");
277
 
  
278
 
    if ( type == BUTTON_MON_BRIGHTNESS_DOWN || type == BUTTON_MON_BRIGHTNESS_UP )
279
 
        return;
280
 
        
281
 
    if ( type == BUTTON_POWER_OFF )
282
 
    {
283
 
        g_object_get (G_OBJECT (manager->priv->conf),
284
 
                      POWER_SWITCH_CFG, &req,
285
 
                      NULL);
286
 
    }
287
 
    else if ( type == BUTTON_SLEEP )
288
 
    {
289
 
        g_object_get (G_OBJECT (manager->priv->conf),
290
 
                      SLEEP_SWITCH_CFG, &req,
291
 
                      NULL);
292
 
    }
293
 
    else if ( type == BUTTON_HIBERNATE )
294
 
    {
295
 
        g_object_get (G_OBJECT (manager->priv->conf),
296
 
                      HIBERNATE_SWITCH_CFG, &req,
297
 
                      NULL);
298
 
    }
299
 
    else
300
 
    {
301
 
        g_return_if_reached ();
302
 
    }
303
 
 
304
 
    XFPM_DEBUG_ENUM (req, XFPM_TYPE_SHUTDOWN_REQUEST, "Shutdown request : ");
305
 
        
306
 
    if ( req == XFPM_ASK )
307
 
        xfpm_manager_ask_shutdown (manager);
308
 
    else
309
 
    {
310
 
        if ( g_timer_elapsed (manager->priv->timer, NULL) > SLEEP_KEY_TIMEOUT )
311
 
        {
312
 
            g_timer_reset (manager->priv->timer);
313
 
            xfpm_manager_sleep_request (manager, req, FALSE);
314
 
        }
315
 
    }
316
 
}
317
 
 
318
 
static void
319
 
xfpm_manager_lid_changed_cb (XfpmPower *power, gboolean lid_is_closed, XfpmManager *manager)
320
 
{
321
 
    XfpmLidTriggerAction action;
322
 
    gboolean on_battery;
323
 
    
324
 
    g_object_get (G_OBJECT (power),
325
 
                  "on-battery", &on_battery,
326
 
                  NULL);
327
 
    
328
 
    g_object_get (G_OBJECT (manager->priv->conf),
329
 
                  on_battery ? LID_SWITCH_ON_BATTERY_CFG : LID_SWITCH_ON_AC_CFG, &action,
330
 
                  NULL);
331
 
 
332
 
    if ( lid_is_closed )
333
 
    {
334
 
        XFPM_DEBUG_ENUM (action, XFPM_TYPE_LID_TRIGGER_ACTION, "LID close event");
335
 
        
336
 
        if ( action == LID_TRIGGER_NOTHING )
337
 
        {
338
 
#ifdef HAVE_DPMS
339
 
            if ( !xfpm_is_multihead_connected () )
340
 
                xfpm_dpms_force_level (manager->priv->dpms, DPMSModeOff);
341
 
#endif
342
 
        }
343
 
        else if ( action == LID_TRIGGER_LOCK_SCREEN )
344
 
        {
345
 
            if ( !xfpm_is_multihead_connected () )
346
 
                xfpm_lock_screen ();
347
 
        }
348
 
        else 
349
 
        {
350
 
            /*
351
 
             * Force sleep here as lid is closed and no point of asking the
352
 
             * user for confirmation in case of an application is inhibiting
353
 
             * the power manager. 
354
 
             */
355
 
            xfpm_manager_sleep_request (manager, action, TRUE);
356
 
        }
357
 
        
358
 
    }
359
 
    else
360
 
    {
361
 
        XFPM_DEBUG_ENUM (action, XFPM_TYPE_LID_TRIGGER_ACTION, "LID opened");
362
 
#ifdef HAVE_DPMS
363
 
        xfpm_dpms_force_level (manager->priv->dpms, DPMSModeOn);
364
 
#endif
365
 
    }
366
 
}
367
 
 
368
 
static void
369
 
xfpm_manager_inhibit_changed_cb (XfpmInhibit *inhibit, gboolean inhibited, XfpmManager *manager)
370
 
{
371
 
    manager->priv->inhibited = inhibited;
372
 
}
373
 
 
374
 
static void
375
 
xfpm_manager_alarm_timeout_cb (EggIdletime *idle, guint id, XfpmManager *manager)
376
 
{
377
 
    if (xfpm_power_get_mode (manager->priv->power) == XFPM_POWER_MODE_PRESENTATION)
378
 
        return;
379
 
    
380
 
    XFPM_DEBUG ("Alarm inactivity timeout id %d", id);
381
 
    
382
 
    if ( id == TIMEOUT_INACTIVITY_ON_AC || id == TIMEOUT_INACTIVITY_ON_BATTERY )
383
 
    {
384
 
        XfpmShutdownRequest req = XFPM_DO_NOTHING;
385
 
        gchar *sleep_mode;
386
 
        gboolean on_battery;
387
 
        
388
 
        if ( manager->priv->inhibited )
389
 
        {
390
 
            XFPM_DEBUG ("Idle sleep alarm timeout, but power manager is currently inhibited, action ignored");
391
 
            return;
392
 
        }
393
 
    
394
 
        g_object_get (G_OBJECT (manager->priv->conf),
395
 
                      INACTIVITY_SLEEP_MODE, &sleep_mode,
396
 
                      NULL);
397
 
        
398
 
        g_object_get (G_OBJECT (manager->priv->power),
399
 
                      "on-battery", &on_battery,
400
 
                      NULL);
401
 
                  
402
 
        if ( !g_strcmp0 (sleep_mode, "Suspend") )
403
 
            req = XFPM_DO_SUSPEND;
404
 
        else
405
 
            req = XFPM_DO_HIBERNATE;
406
 
        
407
 
        g_free (sleep_mode);
408
 
 
409
 
        if ( id == TIMEOUT_INACTIVITY_ON_AC && on_battery == FALSE )
410
 
            xfpm_manager_sleep_request (manager, req, FALSE);
411
 
        else if ( id ==  TIMEOUT_INACTIVITY_ON_BATTERY && on_battery  )
412
 
            xfpm_manager_sleep_request (manager, req, FALSE);
413
 
    }
414
 
}
415
 
 
416
 
static void
417
 
xfpm_manager_set_idle_alarm_on_ac (XfpmManager *manager)
418
 
{
419
 
    guint on_ac;
420
 
    
421
 
    g_object_get (G_OBJECT (manager->priv->conf),
422
 
                  ON_AC_INACTIVITY_TIMEOUT, &on_ac,
423
 
                  NULL);
424
 
    
425
 
#ifdef DEBUG
426
 
    if ( on_ac == 14 )
427
 
        TRACE ("setting inactivity sleep timeout on ac to never");
428
 
    else
429
 
        TRACE ("setting inactivity sleep timeout on ac to %d", on_ac);
430
 
#endif
431
 
    
432
 
    if ( on_ac == 14 )
433
 
    {
434
 
        egg_idletime_alarm_remove (manager->priv->idle, TIMEOUT_INACTIVITY_ON_AC );
435
 
    }
436
 
    else
437
 
    {
438
 
        egg_idletime_alarm_set (manager->priv->idle, TIMEOUT_INACTIVITY_ON_AC, on_ac * 1000 * 60);
439
 
    }
440
 
}
441
 
 
442
 
static void
443
 
xfpm_manager_set_idle_alarm_on_battery (XfpmManager *manager)
444
 
{
445
 
    guint on_battery;
446
 
    
447
 
    g_object_get (G_OBJECT (manager->priv->conf),
448
 
                  ON_BATTERY_INACTIVITY_TIMEOUT, &on_battery,
449
 
                  NULL);
450
 
    
451
 
#ifdef DEBUG
452
 
    if ( on_battery == 14 )
453
 
        TRACE ("setting inactivity sleep timeout on battery to never");
454
 
    else
455
 
        TRACE ("setting inactivity sleep timeout on battery to %d", on_battery);
456
 
#endif
457
 
    
458
 
    if ( on_battery == 14 )
459
 
    {
460
 
        egg_idletime_alarm_remove (manager->priv->idle, TIMEOUT_INACTIVITY_ON_BATTERY );
461
 
    }
462
 
    else
463
 
    {
464
 
        egg_idletime_alarm_set (manager->priv->idle, TIMEOUT_INACTIVITY_ON_BATTERY, on_battery * 1000 * 60);
465
 
    }
466
 
}
467
 
 
468
 
static void
469
 
xfpm_manager_on_battery_changed_cb (XfpmPower *power, gboolean on_battery, XfpmManager *manager)
470
 
{
471
 
    egg_idletime_alarm_reset_all (manager->priv->idle);
472
 
}
473
 
 
474
 
static void
475
 
xfpm_manager_set_idle_alarm (XfpmManager *manager)
476
 
{
477
 
    xfpm_manager_set_idle_alarm_on_ac (manager);
478
 
    xfpm_manager_set_idle_alarm_on_battery (manager);
479
 
    
480
 
}
481
 
 
482
 
XfpmManager *
483
 
xfpm_manager_new (DBusGConnection *bus, const gchar *client_id)
484
 
{
485
 
    XfpmManager *manager = NULL;
486
 
    GError *error = NULL;
487
 
    gchar *current_dir;
488
 
    
489
 
    const gchar *restart_command[] =
490
 
    {
491
 
        "xfce4-power-manager",
492
 
        "--restart",
493
 
        NULL
494
 
    };
495
 
        
496
 
    manager = g_object_new (XFPM_TYPE_MANAGER, NULL);
497
 
 
498
 
    manager->priv->session_bus = bus;
499
 
    
500
 
    current_dir = g_get_current_dir ();
501
 
    manager->priv->client = xfce_sm_client_get_full (XFCE_SM_CLIENT_RESTART_NORMAL,
502
 
                                                     XFCE_SM_CLIENT_PRIORITY_DEFAULT,
503
 
                                                     client_id,
504
 
                                                     current_dir,
505
 
                                                     restart_command,
506
 
                                                     SYSCONFDIR "/xdg/autostart/" PACKAGE_NAME ".desktop");
507
 
    
508
 
    g_free (current_dir);
509
 
    
510
 
    manager->priv->session_managed = xfce_sm_client_connect (manager->priv->client, &error);
511
 
    
512
 
    if ( error )
513
 
    {
514
 
        g_warning ("Unable to connect to session managet : %s", error->message);
515
 
        g_error_free (error);
516
 
    }
517
 
    else
518
 
    {
519
 
        g_signal_connect_swapped (manager->priv->client, "quit",
520
 
                                  G_CALLBACK (xfpm_manager_quit), manager);
521
 
    }
522
 
    
523
 
    xfpm_manager_dbus_class_init (XFPM_MANAGER_GET_CLASS (manager));
524
 
    xfpm_manager_dbus_init (manager);
525
 
    
526
 
    return manager;
527
 
}
528
 
 
529
 
void xfpm_manager_start (XfpmManager *manager)
530
 
{
531
 
    if ( !xfpm_manager_reserve_names (manager) )
532
 
        goto out;
533
 
        
534
 
    dbus_g_error_domain_register (XFPM_ERROR,
535
 
                                  NULL,
536
 
                                  XFPM_TYPE_ERROR);
537
 
 
538
 
    manager->priv->power = xfpm_power_get ();
539
 
    manager->priv->button = xfpm_button_new ();
540
 
    manager->priv->conf = xfpm_xfconf_new ();
541
 
#ifdef HAVE_SYSTEMD
542
 
    manager->priv->console = NULL;
543
 
    manager->priv->systemd = NULL;
544
 
    if ( LOGIND_RUNNING () )
545
 
        manager->priv->systemd = xfpm_systemd_new ();
546
 
    else
547
 
#endif
548
 
    manager->priv->console = xfpm_console_kit_new ();
549
 
    manager->priv->monitor = xfpm_dbus_monitor_new ();
550
 
    manager->priv->disks = xfpm_disks_new ();
551
 
    manager->priv->inhibit = xfpm_inhibit_new ();
552
 
    manager->priv->idle = egg_idletime_new ();
553
 
    
554
 
    g_signal_connect (manager->priv->idle, "alarm-expired",
555
 
                      G_CALLBACK (xfpm_manager_alarm_timeout_cb), manager);
556
 
    
557
 
    g_signal_connect_swapped (manager->priv->conf, "notify::" ON_AC_INACTIVITY_TIMEOUT,
558
 
                              G_CALLBACK (xfpm_manager_set_idle_alarm_on_ac), manager);
559
 
                      
560
 
    g_signal_connect_swapped (manager->priv->conf, "notify::" ON_BATTERY_INACTIVITY_TIMEOUT,
561
 
                              G_CALLBACK (xfpm_manager_set_idle_alarm_on_battery), manager);
562
 
    
563
 
    xfpm_manager_set_idle_alarm (manager);
564
 
    
565
 
    g_signal_connect (manager->priv->inhibit, "has-inhibit-changed",
566
 
                      G_CALLBACK (xfpm_manager_inhibit_changed_cb), manager);
567
 
    
568
 
    g_signal_connect (manager->priv->monitor, "system-bus-connection-changed",
569
 
                      G_CALLBACK (xfpm_manager_system_bus_connection_changed_cb), manager);
570
 
   
571
 
    manager->priv->backlight = xfpm_backlight_new ();
572
 
    
573
 
#ifdef HAVE_DPMS
574
 
    manager->priv->dpms = xfpm_dpms_new ();
575
 
#endif
576
 
    
577
 
    g_signal_connect (manager->priv->button, "button_pressed",
578
 
                      G_CALLBACK (xfpm_manager_button_pressed_cb), manager);
579
 
    
580
 
    g_signal_connect (manager->priv->power, "lid-changed",
581
 
                      G_CALLBACK (xfpm_manager_lid_changed_cb), manager);
582
 
    
583
 
    g_signal_connect (manager->priv->power, "on-battery-changed",
584
 
                      G_CALLBACK (xfpm_manager_on_battery_changed_cb), manager);
585
 
    
586
 
    g_signal_connect_swapped (manager->priv->power, "waking-up",
587
 
                              G_CALLBACK (xfpm_manager_reset_sleep_timer), manager);
588
 
    
589
 
    g_signal_connect_swapped (manager->priv->power, "sleeping",
590
 
                              G_CALLBACK (xfpm_manager_reset_sleep_timer), manager);
591
 
                              
592
 
    g_signal_connect_swapped (manager->priv->power, "ask-shutdown",
593
 
                              G_CALLBACK (xfpm_manager_ask_shutdown), manager);
594
 
    
595
 
    g_signal_connect_swapped (manager->priv->power, "shutdown",
596
 
                              G_CALLBACK (xfpm_manager_shutdown), manager);
597
 
                              
598
 
out:
599
 
        ;
600
 
}
601
 
 
602
 
void xfpm_manager_stop (XfpmManager *manager)
603
 
{
604
 
    XFPM_DEBUG ("Stopping");
605
 
    g_return_if_fail (XFPM_IS_MANAGER (manager));
606
 
    xfpm_manager_quit (manager);
607
 
}
608
 
 
609
 
GHashTable *xfpm_manager_get_config (XfpmManager *manager)
610
 
{
611
 
    GHashTable *hash;
612
 
    
613
 
    guint8 mapped_buttons;
614
 
    gboolean auth_hibernate = FALSE;
615
 
    gboolean auth_suspend = FALSE;
616
 
    gboolean can_suspend = FALSE;
617
 
    gboolean can_hibernate = FALSE;
618
 
    gboolean has_sleep_button = FALSE;
619
 
    gboolean has_hibernate_button = FALSE;
620
 
    gboolean has_power_button = FALSE;
621
 
    gboolean has_battery = TRUE;
622
 
    gboolean has_lcd_brightness = TRUE;
623
 
    gboolean can_shutdown = TRUE;
624
 
    gboolean has_lid = FALSE;
625
 
    gboolean can_spin = FALSE;
626
 
    gboolean devkit_disk = FALSE;
627
 
    
628
 
    hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
629
 
    
630
 
#ifdef HAVE_SYSTEMD
631
 
    if ( LOGIND_RUNNING () )
632
 
        g_object_get (G_OBJECT (manager->priv->systemd),
633
 
                      "can-shutdown", &can_shutdown,
634
 
                      NULL);
635
 
    else
636
 
#endif
637
 
    g_object_get (G_OBJECT (manager->priv->console),
638
 
                  "can-shutdown", &can_shutdown,
639
 
                  NULL);
640
 
 
641
 
    g_object_get (G_OBJECT (manager->priv->power),
642
 
                  "auth-suspend", &auth_suspend,
643
 
                  "auth-hibernate", &auth_hibernate,
644
 
                  "can-suspend", &can_suspend,
645
 
                  "can-hibernate", &can_hibernate, 
646
 
                  "has-lid", &has_lid,
647
 
                  NULL);
648
 
 
649
 
    can_spin = xfpm_disks_get_can_spin (manager->priv->disks);
650
 
    devkit_disk = xfpm_disks_kit_is_running (manager->priv->disks);
651
 
    
652
 
    has_battery = xfpm_power_has_battery (manager->priv->power);
653
 
    has_lcd_brightness = xfpm_backlight_has_hw (manager->priv->backlight);
654
 
    
655
 
    mapped_buttons = xfpm_button_get_mapped (manager->priv->button);
656
 
    
657
 
    if ( mapped_buttons & SLEEP_KEY )
658
 
        has_sleep_button = TRUE;
659
 
    if ( mapped_buttons & HIBERNATE_KEY )
660
 
        has_hibernate_button = TRUE;
661
 
    if ( mapped_buttons & POWER_KEY )
662
 
        has_power_button = TRUE;
663
 
        
664
 
    g_hash_table_insert (hash, g_strdup ("sleep-button"), g_strdup (xfpm_bool_to_string (has_sleep_button)));
665
 
    g_hash_table_insert (hash, g_strdup ("power-button"), g_strdup (xfpm_bool_to_string (has_power_button)));
666
 
    g_hash_table_insert (hash, g_strdup ("hibernate-button"), g_strdup (xfpm_bool_to_string (has_hibernate_button)));
667
 
    g_hash_table_insert (hash, g_strdup ("auth-suspend"), g_strdup (xfpm_bool_to_string (auth_suspend)));
668
 
    g_hash_table_insert (hash, g_strdup ("auth-hibernate"), g_strdup (xfpm_bool_to_string (auth_hibernate)));
669
 
    g_hash_table_insert (hash, g_strdup ("can-suspend"), g_strdup (xfpm_bool_to_string (can_suspend)));
670
 
    g_hash_table_insert (hash, g_strdup ("can-hibernate"), g_strdup (xfpm_bool_to_string (can_hibernate)));
671
 
    g_hash_table_insert (hash, g_strdup ("can-shutdown"), g_strdup (xfpm_bool_to_string (can_shutdown)));
672
 
    
673
 
    g_hash_table_insert (hash, g_strdup ("has-battery"), g_strdup (xfpm_bool_to_string (has_battery)));
674
 
    g_hash_table_insert (hash, g_strdup ("has-lid"), g_strdup (xfpm_bool_to_string (has_lid)));
675
 
    g_hash_table_insert (hash, g_strdup ("can-spin"), g_strdup (xfpm_bool_to_string (can_spin)));
676
 
    g_hash_table_insert (hash, g_strdup ("devkit-disk"), g_strdup (xfpm_bool_to_string (devkit_disk)));
677
 
    
678
 
    g_hash_table_insert (hash, g_strdup ("has-brightness"), g_strdup (xfpm_bool_to_string (has_lcd_brightness)));
679
 
    
680
 
    return hash;
681
 
}
682
 
 
683
 
/*
684
 
 * 
685
 
 * DBus server implementation
686
 
 * 
687
 
 */
688
 
static gboolean xfpm_manager_dbus_quit       (XfpmManager *manager,
689
 
                                              GError **error);
690
 
                                              
691
 
static gboolean xfpm_manager_dbus_restart     (XfpmManager *manager,
692
 
                                               GError **error);
693
 
                                              
694
 
static gboolean xfpm_manager_dbus_get_config (XfpmManager *manager,
695
 
                                              GHashTable **OUT_config,
696
 
                                              GError **error);
697
 
                                                                                      
698
 
static gboolean xfpm_manager_dbus_get_info   (XfpmManager *manager,
699
 
                                              gchar **OUT_name,
700
 
                                              gchar **OUT_version,
701
 
                                              gchar **OUT_vendor,
702
 
                                              GError **error);
703
 
 
704
 
#include "xfce-power-manager-dbus-server.h"
705
 
 
706
 
static void
707
 
xfpm_manager_dbus_class_init (XfpmManagerClass *klass)
708
 
{
709
 
     dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (klass),
710
 
                                     &dbus_glib_xfpm_manager_object_info);
711
 
}
712
 
 
713
 
static void
714
 
xfpm_manager_dbus_init (XfpmManager *manager)
715
 
{
716
 
    dbus_g_connection_register_g_object (manager->priv->session_bus,
717
 
                                        "/org/xfce/PowerManager",
718
 
                                        G_OBJECT (manager));
719
 
}
720
 
 
721
 
static gboolean
722
 
xfpm_manager_dbus_quit (XfpmManager *manager, GError **error)
723
 
{
724
 
    XFPM_DEBUG("Quit message received\n");
725
 
    
726
 
    xfpm_manager_quit (manager);
727
 
    
728
 
    return TRUE;
729
 
}
730
 
 
731
 
static gboolean xfpm_manager_dbus_restart     (XfpmManager *manager,
732
 
                                               GError **error)
733
 
{
734
 
    XFPM_DEBUG("Restart message received");
735
 
    
736
 
    xfpm_manager_quit (manager);
737
 
    
738
 
    g_spawn_command_line_async ("xfce4-power-manager", NULL);
739
 
    
740
 
    return TRUE;
741
 
}
742
 
 
743
 
static gboolean xfpm_manager_dbus_get_config (XfpmManager *manager,
744
 
                                              GHashTable **OUT_config,
745
 
                                              GError **error)
746
 
{
747
 
    
748
 
    *OUT_config = xfpm_manager_get_config (manager);
749
 
    return TRUE;
750
 
}
751
 
                                              
752
 
static gboolean 
753
 
xfpm_manager_dbus_get_info (XfpmManager *manager,
754
 
                            gchar **OUT_name,
755
 
                            gchar **OUT_version,
756
 
                            gchar **OUT_vendor,
757
 
                            GError **error)
758
 
{
759
 
    
760
 
    *OUT_name    = g_strdup(PACKAGE);
761
 
    *OUT_version = g_strdup(VERSION);
762
 
    *OUT_vendor  = g_strdup("Xfce-goodies");
763
 
    
764
 
    return TRUE;
765
 
}