← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/xfpm-battery.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:
src/xfpm-battery.c
23
23
#endif
24
24
 
25
25
#include <stdio.h>
 
26
#ifdef HAVE_STDLIB_H
26
27
#include <stdlib.h>
 
28
#endif
 
29
#ifdef HAVE_STRING_H
27
30
#include <string.h>
 
31
#endif
28
32
 
29
33
#include <gtk/gtk.h>
 
34
#include <upower.h>
30
35
 
31
36
#include <libxfce4util/libxfce4util.h>
32
37
 
53
58
    XfpmXfconf             *conf;
54
59
    XfpmNotify             *notify;
55
60
    XfpmButton             *button;
56
 
    DBusGProxy             *proxy;
57
 
    DBusGProxy             *proxy_prop;
58
 
    
 
61
    UpDevice               *device;
 
62
    UpClient               *client;
 
63
 
59
64
    gchar                  *icon_prefix;
60
 
    
 
65
 
61
66
    XfpmBatteryCharge       charge;
62
 
    XfpmDeviceState         state;
63
 
    XfpmDeviceType          type;
 
67
    UpDeviceState           state;
 
68
    UpDeviceKind            type;
64
69
    gboolean                ac_online;
65
70
    gboolean                present;
66
71
    guint                   percentage;
68
73
    gint64                  time_to_empty;
69
74
 
70
75
    const gchar            *battery_name;
71
 
    
 
76
 
72
77
    gulong                  sig;
73
78
    gulong                  sig_bt;
74
 
    
 
79
    gulong                  sig_up;
 
80
 
75
81
    guint                   notify_idle;
76
82
};
77
83
 
82
88
    PROP_CHARGE_STATUS,
83
89
    PROP_DEVICE_TYPE
84
90
};
85
 
    
 
91
 
86
92
enum
87
93
{
88
94
    BATTERY_CHARGE_CHANGED,
93
99
 
94
100
G_DEFINE_TYPE (XfpmBattery, xfpm_battery, GTK_TYPE_STATUS_ICON)
95
101
 
96
 
static const gchar * G_GNUC_CONST
97
 
xfpm_battery_get_icon_index (XfpmDeviceType type, guint percent)
98
 
{
99
 
    if (percent < 10) 
100
 
    {
101
 
        return "000";
102
 
    } 
103
 
    else if (percent < 30) 
104
 
    {
105
 
        return ( (type == XFPM_DEVICE_TYPE_BATTERY || type == XFPM_DEVICE_TYPE_UPS) ? "020" : "030");
106
 
    } 
107
 
    else if (percent < 50) 
108
 
    {
109
 
        return ( (type == XFPM_DEVICE_TYPE_BATTERY || type == XFPM_DEVICE_TYPE_UPS ) ? "040" : "030");
110
 
    } 
111
 
    else if (percent < 70) 
112
 
    {
113
 
        return "060";
114
 
    } 
115
 
    else if (percent < 90) 
116
 
    {
117
 
        return ((type == XFPM_DEVICE_TYPE_BATTERY || type == XFPM_DEVICE_TYPE_UPS) ? "080" : "060");
118
 
    }
119
 
    
120
 
    return "100";
121
 
}
122
 
 
123
 
static void
124
 
xfpm_battery_refresh_visible (XfpmBattery *battery)
125
 
{
126
 
    XfpmShowIcon show_icon;
127
 
    gboolean visible = TRUE;
128
 
    
129
 
    g_object_get (G_OBJECT (battery->priv->conf),
130
 
                  SHOW_TRAY_ICON_CFG, &show_icon,
131
 
                  NULL);
132
 
                  
133
 
    if ( show_icon == SHOW_ICON_ALWAYS )
134
 
        visible = TRUE;
135
 
    else if ( show_icon == NEVER_SHOW_ICON )
136
 
        visible = FALSE;
137
 
    else if ( show_icon == SHOW_ICON_WHEN_BATTERY_PRESENT )
138
 
    {
139
 
        if ( battery->priv->present )
140
 
            visible = TRUE;
141
 
        else visible = FALSE;
142
 
    }
143
 
    else if ( show_icon == SHOW_ICON_WHEN_BATTERY_CHARGING_DISCHARGING )
144
 
    {
145
 
        if ( battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
146
 
            visible = FALSE;
147
 
        else visible = TRUE;
148
 
    }
149
 
 
150
 
    XFPM_DEBUG_ENUM (show_icon, XFPM_TYPE_SHOW_ICON, "visible=%s", xfpm_bool_to_string (visible));
151
 
                          
152
 
    gtk_status_icon_set_visible (GTK_STATUS_ICON (battery), visible);
153
 
}
154
 
 
155
 
 
156
 
/*
157
 
 * Taken from gpm
158
 
 */
159
 
static gchar *
160
 
xfpm_battery_get_time_string (guint seconds)
161
 
{
162
 
    char* timestring = NULL;
163
 
    gint  hours;
164
 
    gint  minutes;
165
 
 
166
 
    /* Add 0.5 to do rounding */
167
 
    minutes = (int) ( ( seconds / 60.0 ) + 0.5 );
168
 
 
169
 
    if (minutes == 0) 
170
 
    {
171
 
        timestring = g_strdup (_("Unknown time"));
172
 
        return timestring;
173
 
    }
174
 
 
175
 
    if (minutes < 60) 
176
 
    {
177
 
        timestring = g_strdup_printf (ngettext ("%i minute",
178
 
                                      "%i minutes",
179
 
                                      minutes), minutes);
180
 
        return timestring;
181
 
    }
182
 
 
183
 
    hours = minutes / 60;
184
 
    minutes = minutes % 60;
185
 
 
186
 
    if (minutes == 0)
187
 
        timestring = g_strdup_printf (ngettext (
188
 
                            "%i hour",
189
 
                            "%i hours",
190
 
                            hours), hours);
191
 
    else
192
 
        /* TRANSLATOR: "%i %s %i %s" are "%i hours %i minutes"
193
 
         * Swap order with "%2$s %2$i %1$s %1$i if needed */
194
 
        timestring = g_strdup_printf (_("%i %s %i %s"),
195
 
                            hours, ngettext ("hour", "hours", hours),
196
 
                            minutes, ngettext ("minute", "minutes", minutes));
197
 
    return timestring;
198
 
}
199
102
 
200
103
static gchar *
201
104
xfpm_battery_get_message_from_battery_state (XfpmBattery *battery)
202
105
{
203
106
    gchar *msg  = NULL;
204
 
    
205
 
    
206
 
    if (battery->priv->type == XFPM_DEVICE_TYPE_BATTERY || battery->priv->type == XFPM_DEVICE_TYPE_UPS)
 
107
 
 
108
 
 
109
    if (battery->priv->type == UP_DEVICE_KIND_BATTERY || battery->priv->type == UP_DEVICE_KIND_UPS)
207
110
    {
208
111
        switch (battery->priv->state)
209
112
        {
210
 
            case XFPM_DEVICE_STATE_FULLY_CHARGED:
 
113
            case UP_DEVICE_STATE_FULLY_CHARGED:
211
114
                msg = g_strdup_printf (_("Your %s is fully charged"), battery->priv->battery_name);
212
115
                break;
213
 
            case XFPM_DEVICE_STATE_CHARGING:
 
116
            case UP_DEVICE_STATE_CHARGING:
214
117
                msg = g_strdup_printf (_("Your %s is charging"), battery->priv->battery_name);
215
 
                
 
118
 
216
119
                if ( battery->priv->time_to_full != 0 )
217
120
                {
218
121
                    gchar *tmp, *est_time_str;
219
122
                    tmp = g_strdup (msg);
220
123
                    g_free (msg);
221
 
                    
 
124
 
222
125
                    est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_full);
223
 
                    
224
 
                    msg = g_strdup_printf (_("%s (%i%%)\n%s until is fully charged."), tmp, battery->priv->percentage, est_time_str);
 
126
 
 
127
                    msg = g_strdup_printf (_("%s (%i%%)\n%s until it is fully charged."), tmp, battery->priv->percentage, est_time_str);
225
128
                    g_free (est_time_str);
226
129
                    g_free (tmp);
227
130
                }
228
131
 
229
132
                break;
230
 
            case XFPM_DEVICE_STATE_DISCHARGING:
 
133
            case UP_DEVICE_STATE_DISCHARGING:
231
134
                if (battery->priv->ac_online)
232
135
                    msg =  g_strdup_printf (_("Your %s is discharging"), battery->priv->battery_name);
233
136
                else
234
137
                    msg =  g_strdup_printf (_("System is running on %s power"), battery->priv->battery_name);
235
 
                    
 
138
 
236
139
                    if ( battery->priv->time_to_empty != 0 )
237
140
                    {
238
141
                        gchar *tmp, *est_time_str;
239
142
                        tmp = g_strdup (msg);
240
143
                        g_free (msg);
241
 
                        
 
144
 
242
145
                        est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_empty);
243
 
                        
 
146
 
244
147
                        msg = g_strdup_printf (_("%s (%i%%)\nEstimated time left is %s."), tmp, battery->priv->percentage, est_time_str);
245
148
                        g_free (tmp);
246
149
                        g_free (est_time_str);
247
150
                    }
248
151
                break;
249
 
            case XFPM_DEVICE_STATE_EMPTY:
 
152
            case UP_DEVICE_STATE_EMPTY:
250
153
                msg = g_strdup_printf (_("Your %s is empty"), battery->priv->battery_name);
251
154
                break;
252
155
            default:
253
156
                break;
254
157
        }
255
 
        
 
158
 
256
159
    }
257
 
    else if (battery->priv->type >= XFPM_DEVICE_TYPE_MONITOR)
 
160
    else if (battery->priv->type >= UP_DEVICE_KIND_MONITOR)
258
161
    {
259
162
        switch (battery->priv->state)
260
163
        {
261
 
            case XFPM_DEVICE_STATE_FULLY_CHARGED:
 
164
            case UP_DEVICE_STATE_FULLY_CHARGED:
262
165
                msg = g_strdup_printf (_("Your %s is fully charged"), battery->priv->battery_name);
263
166
                break;
264
 
            case XFPM_DEVICE_STATE_CHARGING:
 
167
            case UP_DEVICE_STATE_CHARGING:
265
168
                msg = g_strdup_printf (_("Your %s is charging"), battery->priv->battery_name);
266
169
                break;
267
 
            case XFPM_DEVICE_STATE_DISCHARGING:
 
170
            case UP_DEVICE_STATE_DISCHARGING:
268
171
                msg =  g_strdup_printf (_("Your %s is discharging"), battery->priv->battery_name);
269
172
                break;
270
 
            case XFPM_DEVICE_STATE_EMPTY:
 
173
            case UP_DEVICE_STATE_EMPTY:
271
174
                msg = g_strdup_printf (_("Your %s is empty"), battery->priv->battery_name);
272
175
                break;
273
176
            default:
274
177
                break;
275
178
        }
276
179
    }
277
 
    
 
180
 
278
181
    return msg;
279
182
}
280
183
 
282
185
xfpm_battery_refresh_icon (XfpmBattery *battery)
283
186
{
284
187
    gchar icon_name[128];
285
 
    
 
188
 
286
189
    XFPM_DEBUG ("Battery state %d", battery->priv->state);
287
 
    
288
 
    if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY || 
289
 
         battery->priv->type == XFPM_DEVICE_TYPE_UPS )
 
190
 
 
191
    if ( battery->priv->type == UP_DEVICE_KIND_BATTERY ||
 
192
         battery->priv->type == UP_DEVICE_KIND_UPS )
290
193
    {
291
194
        if (!battery->priv->present)
292
195
        {
293
196
            g_snprintf (icon_name, 128, "%s%s", battery->priv->icon_prefix, "missing");
294
197
        }
295
 
        else if (battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
 
198
        else if (battery->priv->state == UP_DEVICE_STATE_FULLY_CHARGED )
296
199
        {
297
200
            g_snprintf (icon_name, 128, "%s%s", battery->priv->icon_prefix, battery->priv->ac_online ? "charged" : "100");
298
201
        }
299
 
        else if ( battery->priv->state == XFPM_DEVICE_STATE_CHARGING || 
300
 
                  battery->priv->state == XFPM_DEVICE_STATE_PENDING_CHARGING)
 
202
        else if ( battery->priv->state == UP_DEVICE_STATE_CHARGING ||
 
203
                  battery->priv->state == UP_DEVICE_STATE_PENDING_CHARGE)
301
204
        {
302
 
            g_snprintf (icon_name, 128, "%s%s-%s", 
303
 
                        battery->priv->icon_prefix, 
 
205
            g_snprintf (icon_name, 128, "%s%s-%s",
 
206
                        battery->priv->icon_prefix,
304
207
                        xfpm_battery_get_icon_index (battery->priv->type, battery->priv->percentage),
305
208
                        "charging");
306
209
        }
307
 
        else if ( battery->priv->state == XFPM_DEVICE_STATE_DISCHARGING ||
308
 
                  battery->priv->state == XFPM_DEVICE_STATE_PENDING_DISCHARGING)
 
210
        else if ( battery->priv->state == UP_DEVICE_STATE_DISCHARGING ||
 
211
                  battery->priv->state == UP_DEVICE_STATE_PENDING_DISCHARGE)
309
212
        {
310
 
            g_snprintf (icon_name, 128, "%s%s", 
311
 
                        battery->priv->icon_prefix, 
 
213
            g_snprintf (icon_name, 128, "%s%s",
 
214
                        battery->priv->icon_prefix,
312
215
                        xfpm_battery_get_icon_index (battery->priv->type, battery->priv->percentage));
313
216
        }
314
 
        else if ( battery->priv->state == XFPM_DEVICE_STATE_EMPTY)
 
217
        else if ( battery->priv->state == UP_DEVICE_STATE_EMPTY)
315
218
        {
316
219
            g_snprintf (icon_name, 128, "%s%s", battery->priv->icon_prefix, battery->priv->ac_online ? "000-charging" : "000");
317
220
        }
318
221
    }
319
222
    else
320
223
    {
321
 
        if ( !battery->priv->present || battery->priv->state == XFPM_DEVICE_STATE_EMPTY )
 
224
        if ( !battery->priv->present || battery->priv->state == UP_DEVICE_STATE_EMPTY )
322
225
        {
323
226
            g_snprintf (icon_name, 128, "%s000", battery->priv->icon_prefix);
324
227
        }
325
 
        else if ( battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
 
228
        else if ( battery->priv->state == UP_DEVICE_STATE_FULLY_CHARGED )
326
229
        {
327
230
            g_snprintf (icon_name, 128, "%s100", battery->priv->icon_prefix);
328
231
        }
329
 
        else if ( battery->priv->state == XFPM_DEVICE_STATE_DISCHARGING )
 
232
        else if ( battery->priv->state == UP_DEVICE_STATE_DISCHARGING || battery->priv->state == UP_DEVICE_STATE_CHARGING )
330
233
        {
331
 
            g_snprintf (icon_name, 128, "%s%s", 
332
 
                        battery->priv->icon_prefix, 
 
234
            g_snprintf (icon_name, 128, "%s%s",
 
235
                        battery->priv->icon_prefix,
333
236
                        xfpm_battery_get_icon_index (battery->priv->type, battery->priv->percentage));
334
237
        }
335
238
    }
336
 
    
 
239
 
 
240
    XFPM_DEBUG ("Battery icon %s", icon_name);
 
241
 
337
242
    gtk_status_icon_set_from_icon_name (GTK_STATUS_ICON (battery), icon_name);
338
243
}
339
244
 
341
246
xfpm_battery_notify (XfpmBattery *battery)
342
247
{
343
248
    gchar *message = NULL;
344
 
    
 
249
 
345
250
    message = xfpm_battery_get_message_from_battery_state (battery);
346
 
    
 
251
 
347
252
    if ( !message )
348
253
        return;
349
 
        
350
 
    xfpm_notify_show_notification (battery->priv->notify, 
351
 
                                   _("Power Manager"), 
352
 
                                   message, 
 
254
 
 
255
    xfpm_notify_show_notification (battery->priv->notify,
 
256
                                   _("Power Manager"),
 
257
                                   message,
353
258
                                   gtk_status_icon_get_icon_name (GTK_STATUS_ICON (battery)),
354
259
                                   8000,
355
260
                                   FALSE,
356
261
                                   XFPM_NOTIFY_NORMAL,
357
262
                                   GTK_STATUS_ICON (battery));
358
 
    
 
263
 
359
264
    g_free (message);
360
265
}
361
266
 
363
268
xfpm_battery_notify_idle (gpointer data)
364
269
{
365
270
    XfpmBattery *battery = XFPM_BATTERY (data);
366
 
    
 
271
 
367
272
    xfpm_battery_notify (battery);
368
273
    battery->priv->notify_idle = 0;
369
 
    
 
274
 
370
275
    return FALSE;
371
276
}
372
277
 
375
280
{
376
281
    gboolean notify;
377
282
    static gboolean starting_up = TRUE;
378
 
    
379
 
    if ( !gtk_status_icon_get_visible (GTK_STATUS_ICON (battery)) )
380
 
        return;
381
 
    
382
 
    if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
383
 
         battery->priv->type == XFPM_DEVICE_TYPE_UPS )
 
283
 
 
284
    if ( battery->priv->type == UP_DEVICE_KIND_BATTERY ||
 
285
         battery->priv->type == UP_DEVICE_KIND_UPS )
384
286
    {
385
287
        if ( starting_up )
386
288
        {
387
289
            starting_up = FALSE;
388
290
            return;
389
291
        }
390
 
    
 
292
 
391
293
        g_object_get (G_OBJECT (battery->priv->conf),
392
294
                      GENERAL_NOTIFICATION_CFG, &notify,
393
295
                      NULL);
394
 
                      
 
296
 
395
297
        if ( notify )
396
298
        {
397
299
            if (battery->priv->notify_idle == 0)
400
302
    }
401
303
}
402
304
 
403
 
/*
404
 
 * Refresh tooltip function for UPS and battery device only.
405
 
 */
406
 
static void
407
 
xfpm_battery_set_tooltip_primary (XfpmBattery *battery, GtkTooltip *tooltip)
408
 
{
409
 
    gchar *tip;
410
 
    gchar *est_time_str = NULL;
411
 
    gchar *power_status = NULL;
412
 
    
413
 
    power_status = g_strdup_printf (battery->priv->ac_online ? _("Adaptor is online") : _("System is running on battery power"));
414
 
    
415
 
    if ( battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
416
 
    {
417
 
        if ( battery->priv->time_to_empty > 0 )
418
 
        {
419
 
            est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_empty);
420
 
            tip = g_strdup_printf (_("%s\nYour %s is fully charged (%i%%).\nProvides %s runtime"), 
421
 
                                   power_status,
422
 
                                   battery->priv->battery_name, 
423
 
                                   battery->priv->percentage,
424
 
                                   est_time_str);
425
 
            g_free (est_time_str);
426
 
        }
427
 
        else
428
 
        {
429
 
            tip = g_strdup_printf (_("%s\nYour %s is fully charged (%i%%)."), 
430
 
                                   power_status,
431
 
                                   battery->priv->battery_name,
432
 
                                   battery->priv->percentage);
433
 
        }
434
 
    }
435
 
    else if ( battery->priv->state == XFPM_DEVICE_STATE_CHARGING )
436
 
    {
437
 
        if ( battery->priv->time_to_full != 0 )
438
 
        {
439
 
            est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_full);
440
 
            tip = g_strdup_printf (_("%s\nYour %s is charging (%i%%)\n%s until is fully charged."), 
441
 
                                   power_status,
442
 
                                   battery->priv->battery_name, 
443
 
                                   battery->priv->percentage, 
444
 
                                   est_time_str);
445
 
            g_free (est_time_str);
446
 
        }
447
 
        else
448
 
        {
449
 
            tip = g_strdup_printf (_("%s\nYour %s is charging (%i%%)."),
450
 
                                   power_status,
451
 
                                   battery->priv->battery_name,
452
 
                                   battery->priv->percentage);
453
 
        }
454
 
    }
455
 
    else if ( battery->priv->state == XFPM_DEVICE_STATE_DISCHARGING )
456
 
    {
457
 
        if ( battery->priv->time_to_empty != 0 )
458
 
        {
459
 
            est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_empty);
460
 
            tip = g_strdup_printf (_("%s\nYour %s is discharging (%i%%)\nEstimated time left is %s."), 
461
 
                                   power_status,
462
 
                                   battery->priv->battery_name, 
463
 
                                   battery->priv->percentage, 
464
 
                                   est_time_str);
465
 
            g_free (est_time_str);
466
 
        }
467
 
        else
468
 
        {
469
 
            tip = g_strdup_printf (_("%s\nYour %s is discharging (%i%%)."),
470
 
                                   power_status,
471
 
                                   battery->priv->battery_name,
472
 
                                   battery->priv->percentage);
473
 
        }
474
 
        
475
 
    }
476
 
    else if ( battery->priv->state == XFPM_DEVICE_STATE_PENDING_CHARGING )
477
 
    {
478
 
        tip = g_strdup_printf (_("%s\n%s waiting to discharge (%i%%)."), power_status, battery->priv->battery_name, battery->priv->percentage);
479
 
    }
480
 
    else if ( battery->priv->state == XFPM_DEVICE_STATE_PENDING_DISCHARGING )
481
 
    {
482
 
        tip = g_strdup_printf (_("%s\n%s waiting to charge (%i%%)."), power_status, battery->priv->battery_name, battery->priv->percentage);
483
 
    }
484
 
    else if ( battery->priv->state == XFPM_DEVICE_STATE_EMPTY )
485
 
    {
486
 
        tip = g_strdup_printf (_("%s\nYour %s is empty"), power_status, battery->priv->battery_name);
487
 
    }
488
 
    
489
 
    gtk_tooltip_set_text (tooltip, tip);
490
 
    g_free (power_status);
491
 
    g_free (tip);
492
 
}
493
 
 
494
305
static void
495
306
xfpm_battery_check_charge (XfpmBattery *battery)
496
307
{
497
308
    XfpmBatteryCharge charge;
498
309
    guint critical_level, low_level;
499
 
    
 
310
 
500
311
    g_object_get (G_OBJECT (battery->priv->conf),
501
312
                  CRITICAL_POWER_LEVEL, &critical_level,
502
313
                  NULL);
503
 
                  
 
314
 
504
315
    low_level = critical_level + 10;
505
 
    
 
316
 
506
317
    if ( battery->priv->percentage > low_level )
507
318
        charge = XFPM_BATTERY_CHARGE_OK;
508
319
    else if ( battery->priv->percentage <= low_level && battery->priv->percentage > critical_level )
509
320
        charge = XFPM_BATTERY_CHARGE_LOW;
510
321
    else if ( battery->priv->percentage <= critical_level )
511
322
        charge = XFPM_BATTERY_CHARGE_CRITICAL;
512
 
        
 
323
    else
 
324
        charge = XFPM_BATTERY_CHARGE_UNKNOWN;
 
325
 
513
326
    if ( charge != battery->priv->charge)
514
327
    {
515
328
        battery->priv->charge = charge;
523
336
}
524
337
 
525
338
static void
526
 
xfpm_battery_refresh (XfpmBattery *battery, GHashTable *props)
 
339
xfpm_battery_refresh (XfpmBattery *battery, UpDevice *device)
527
340
{
528
 
    GValue *value;
 
341
    gboolean present;
529
342
    guint state;
530
 
    
531
 
    value = g_hash_table_lookup (props, "IsPresent");
532
 
    
533
 
    if ( value == NULL )
534
 
    {
535
 
        g_warning ("No 'IsPresent' property found");
536
 
        goto out;
537
 
    }
538
 
    
539
 
    battery->priv->present = g_value_get_boolean (value);
540
 
    
541
 
    value = g_hash_table_lookup (props, "State");
542
 
    
543
 
    if ( value == NULL )
544
 
    {
545
 
        g_warning ("No 'State' property found");
546
 
    }
547
 
    
548
 
    state = g_value_get_uint (value);
 
343
    gdouble percentage;
 
344
    guint64 to_empty, to_full;
 
345
    g_object_get(device,
 
346
                 "is-present", &present,
 
347
                 "percentage", &percentage,
 
348
                 "state", &state,
 
349
                 "time-to-empty", &to_empty,
 
350
                 "time-to-full", &to_full,
 
351
                 NULL);
 
352
 
 
353
    battery->priv->present = present;
549
354
    if ( state != battery->priv->state )
550
355
    {
551
356
        battery->priv->state = state;
552
 
        xfpm_battery_refresh_visible (battery);
553
357
        xfpm_battery_notify_state (battery);
554
358
    }
555
 
    
556
 
    value = g_hash_table_lookup (props, "Percentage");
557
 
    
558
 
    if ( value == NULL )
559
 
    {
560
 
        g_warning ("No 'Percentage' property found on battery device");
561
 
        goto out;
562
 
    }
563
 
    
564
 
    battery->priv->percentage = (guint) g_value_get_double (value);
565
 
    
 
359
    battery->priv->percentage = (guint) percentage;
 
360
 
566
361
    xfpm_battery_check_charge (battery);
567
 
    
 
362
 
568
363
    xfpm_battery_refresh_icon (battery);
569
 
    
570
 
    if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
571
 
         battery->priv->type == XFPM_DEVICE_TYPE_UPS )
572
 
    {
573
 
        value = g_hash_table_lookup (props, "TimeToEmpty");
574
 
        
575
 
        if ( value == NULL )
576
 
        {
577
 
            g_warning ("No 'TimeToEmpty' property found on battery device");
578
 
            goto out;
579
 
        }
580
 
        
581
 
        battery->priv->time_to_empty = g_value_get_int64 (value);
582
 
        
583
 
        value = g_hash_table_lookup (props, "TimeToFull");
584
 
        
585
 
        if ( value == NULL )
586
 
        {
587
 
            g_warning ("No 'TimeToFull' property found on battery device");
588
 
            goto out;
589
 
        }
590
 
        
591
 
        battery->priv->time_to_full = g_value_get_int64 (value);
592
 
    }
593
 
    
594
 
    out:
595
 
        g_hash_table_destroy (props);
596
 
}
597
 
 
598
 
static void
599
 
xfpm_battery_button_pressed_cb (XfpmButton *button, XfpmButtonKey type, XfpmBattery *battery)
600
 
{
601
 
    if (type == BUTTON_BATTERY)
602
 
        xfpm_battery_notify (battery);
603
 
}
604
 
 
605
 
static void
606
 
xfpm_battery_changed_cb (DBusGProxy *proxy, XfpmBattery *battery)
607
 
{
608
 
    GHashTable *props;
609
 
    
610
 
    props = xfpm_power_get_interface_properties (battery->priv->proxy_prop, 
611
 
                                                 UPOWER_IFACE_DEVICE);
612
 
    
613
 
    if ( props )
614
 
        xfpm_battery_refresh (battery, props);
615
 
}
616
 
 
617
 
static gboolean
618
 
xfpm_battery_query_tooltip (GtkStatusIcon *icon, 
619
 
                            gint x,
620
 
                            gint y,
621
 
                            gboolean keyboard_mode,
622
 
                            GtkTooltip *tooltip)
623
 
{
624
 
    XfpmBattery *battery;
625
 
    
626
 
    battery = XFPM_BATTERY (icon);
627
 
 
628
 
    if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
629
 
         battery->priv->type == XFPM_DEVICE_TYPE_UPS )
630
 
    {
631
 
        xfpm_battery_set_tooltip_primary (battery, tooltip);
632
 
        return TRUE;
633
 
    }
634
 
    
635
 
    return FALSE;
636
 
}
637
 
 
638
 
static void
639
 
xfpm_battery_tray_icon_settings_changed (GObject *obj, GParamSpec *spec, XfpmBattery *battery)
640
 
{
641
 
    xfpm_battery_refresh_visible (battery);
 
364
 
 
365
    if ( battery->priv->type == UP_DEVICE_KIND_BATTERY ||
 
366
         battery->priv->type == UP_DEVICE_KIND_UPS )
 
367
    {
 
368
        battery->priv->time_to_empty = to_empty;
 
369
        battery->priv->time_to_full  = to_empty;
 
370
    }
 
371
}
 
372
 
 
373
static void
 
374
xfpm_battery_changed_cb (UpDevice *device,
 
375
#if UP_CHECK_VERSION(0, 99, 0)
 
376
                         GParamSpec *pspec,
 
377
#endif
 
378
                         XfpmBattery *battery)
 
379
{
 
380
    xfpm_battery_refresh (battery, device);
642
381
}
643
382
 
644
383
static void xfpm_battery_get_property (GObject *object,
647
386
                                       GParamSpec *pspec)
648
387
{
649
388
    XfpmBattery *battery;
650
 
    
 
389
 
651
390
    battery = XFPM_BATTERY (object);
652
 
    
 
391
 
653
392
    switch (prop_id)
654
393
    {
655
394
        case PROP_AC_ONLINE:
673
412
                                       GParamSpec *pspec)
674
413
{
675
414
    XfpmBattery *battery;
676
 
    
 
415
 
677
416
    battery = XFPM_BATTERY (object);
678
 
    
 
417
 
679
418
    switch (prop_id)
680
419
    {
681
420
        case PROP_AC_ONLINE:
693
432
xfpm_battery_class_init (XfpmBatteryClass *klass)
694
433
{
695
434
    GObjectClass *object_class = G_OBJECT_CLASS (klass);
696
 
    GtkStatusIconClass *status_icon_class = GTK_STATUS_ICON_CLASS (klass);
697
435
 
698
436
    object_class->finalize = xfpm_battery_finalize;
699
437
    object_class->get_property = xfpm_battery_get_property;
700
438
    object_class->set_property = xfpm_battery_set_property;
701
439
 
702
 
    status_icon_class->query_tooltip = xfpm_battery_query_tooltip;
703
 
    
704
 
    signals [BATTERY_CHARGE_CHANGED] = 
 
440
    signals [BATTERY_CHARGE_CHANGED] =
705
441
        g_signal_new ("battery-charge-changed",
706
442
                      XFPM_TYPE_BATTERY,
707
443
                      G_SIGNAL_RUN_LAST,
709
445
                      NULL, NULL,
710
446
                      g_cclosure_marshal_VOID__VOID,
711
447
                      G_TYPE_NONE, 0, G_TYPE_NONE);
712
 
    
 
448
 
713
449
    g_object_class_install_property (object_class,
714
450
                                     PROP_AC_ONLINE,
715
451
                                     g_param_spec_boolean("ac-online",
719
455
 
720
456
    g_object_class_install_property (object_class,
721
457
                                     PROP_DEVICE_TYPE,
722
 
                                     g_param_spec_enum ("device-type",
 
458
                                     g_param_spec_uint ("device-type",
723
459
                                                        NULL, NULL,
724
 
                                                        XFPM_TYPE_DEVICE_TYPE,
725
 
                                                        XFPM_DEVICE_TYPE_UNKNOWN,
 
460
                                                        UP_DEVICE_KIND_UNKNOWN,
 
461
                                                        UP_DEVICE_KIND_LAST,
 
462
                                                        UP_DEVICE_KIND_UNKNOWN,
726
463
                                                        G_PARAM_READABLE));
727
464
 
728
465
    g_object_class_install_property (object_class,
740
477
xfpm_battery_init (XfpmBattery *battery)
741
478
{
742
479
    battery->priv = XFPM_BATTERY_GET_PRIVATE (battery);
743
 
    
 
480
 
744
481
    battery->priv->conf          = xfpm_xfconf_new ();
745
482
    battery->priv->notify        = xfpm_notify_new ();
746
 
    battery->priv->proxy_prop    = NULL;
747
 
    battery->priv->state         = XFPM_DEVICE_STATE_UNKNOWN;
748
 
    battery->priv->type          = XFPM_DEVICE_TYPE_UNKNOWN;
 
483
    battery->priv->device        = NULL;
 
484
    battery->priv->client        = NULL;
 
485
    battery->priv->state         = UP_DEVICE_STATE_UNKNOWN;
 
486
    battery->priv->type          = UP_DEVICE_KIND_UNKNOWN;
749
487
    battery->priv->charge        = XFPM_BATTERY_CHARGE_UNKNOWN;
750
488
    battery->priv->icon_prefix   = NULL;
751
489
    battery->priv->time_to_full  = 0;
752
490
    battery->priv->time_to_empty = 0;
753
491
    battery->priv->button        = xfpm_button_new ();
754
492
    battery->priv->ac_online     = TRUE;
755
 
    
756
 
    battery->priv->sig = g_signal_connect (G_OBJECT (battery->priv->conf), "notify::" SHOW_TRAY_ICON_CFG,
757
 
                                           G_CALLBACK (xfpm_battery_tray_icon_settings_changed), battery);
758
 
                                           
759
 
    
760
 
    battery->priv->sig_bt = g_signal_connect (G_OBJECT (battery->priv->button), "button-pressed",
761
 
                                           G_CALLBACK (xfpm_battery_button_pressed_cb), battery);
762
493
}
763
494
 
764
495
static void
767
498
    XfpmBattery *battery;
768
499
 
769
500
    battery = XFPM_BATTERY (object);
770
 
    
 
501
 
771
502
    g_free (battery->priv->icon_prefix);
772
503
 
773
504
    if (battery->priv->notify_idle != 0)
774
505
        g_source_remove (battery->priv->notify_idle);
775
506
 
776
 
    dbus_g_proxy_disconnect_signal (battery->priv->proxy, "Changed",
777
 
                                    G_CALLBACK (xfpm_battery_changed_cb), battery);
778
 
                                    
 
507
    if ( g_signal_handler_is_connected (battery->priv->device, battery->priv->sig_up ) )
 
508
        g_signal_handler_disconnect (G_OBJECT (battery->priv->device), battery->priv->sig_up);
 
509
 
779
510
    if ( g_signal_handler_is_connected (battery->priv->conf, battery->priv->sig ) )
780
511
        g_signal_handler_disconnect (G_OBJECT (battery->priv->conf), battery->priv->sig);
781
 
        
 
512
 
782
513
     if ( g_signal_handler_is_connected (battery->priv->button, battery->priv->sig_bt ) )
783
514
        g_signal_handler_disconnect (G_OBJECT (battery->priv->button), battery->priv->sig_bt);
784
 
                                    
785
 
    g_object_unref (battery->priv->proxy);
786
 
    g_object_unref (battery->priv->proxy_prop);
 
515
 
 
516
    g_object_unref (battery->priv->device);
787
517
    g_object_unref (battery->priv->conf);
788
518
    g_object_unref (battery->priv->notify);
789
519
    g_object_unref (battery->priv->button);
793
523
    G_OBJECT_CLASS (xfpm_battery_parent_class)->finalize (object);
794
524
}
795
525
 
796
 
static gchar *
797
 
xfpm_battery_get_icon_prefix_device_enum_type (XfpmDeviceType type)
798
 
{
799
 
    if ( type == XFPM_DEVICE_TYPE_BATTERY )
800
 
    {
801
 
        return g_strdup (XFPM_PRIMARY_ICON_PREFIX);
802
 
    }
803
 
    else if ( type == XFPM_DEVICE_TYPE_UPS ) 
804
 
    {
805
 
        return g_strdup (XFPM_UPS_ICON_PREFIX);
806
 
    }
807
 
    else if ( type == XFPM_DEVICE_TYPE_MOUSE ) 
808
 
    {
809
 
        return g_strdup (XFPM_MOUSE_ICON_PREFIX);
810
 
    }
811
 
    else if ( type == XFPM_DEVICE_TYPE_KBD ) 
812
 
    {
813
 
        return g_strdup (XFPM_KBD_ICON_PREFIX);
814
 
    }
815
 
    else if ( type == XFPM_DEVICE_TYPE_PHONE ) 
816
 
    {
817
 
        return g_strdup (XFPM_PHONE_ICON_PREFIX);
818
 
    }
819
 
    
820
 
    return g_strdup (XFPM_PRIMARY_ICON_PREFIX);
821
 
}
822
 
 
823
526
static const gchar *
824
 
xfpm_battery_get_name (XfpmDeviceType type)
 
527
xfpm_battery_get_name (UpDeviceKind type)
825
528
{
826
529
    const gchar *name = NULL;
827
 
    
 
530
 
828
531
    switch (type)
829
532
    {
830
 
        case XFPM_DEVICE_TYPE_BATTERY:
 
533
        case UP_DEVICE_KIND_BATTERY:
831
534
            name = _("battery");
832
535
            break;
833
 
        case XFPM_DEVICE_TYPE_UPS:
 
536
        case UP_DEVICE_KIND_UPS:
834
537
            name = _("UPS");
835
538
            break;
836
 
        case XFPM_DEVICE_TYPE_MONITOR:
 
539
        case UP_DEVICE_KIND_MONITOR:
837
540
            name = _("monitor battery");
838
541
            break;
839
 
        case XFPM_DEVICE_TYPE_MOUSE:
 
542
        case UP_DEVICE_KIND_MOUSE:
840
543
            name = _("mouse battery");
841
544
            break;
842
 
        case XFPM_DEVICE_TYPE_KBD:
 
545
        case UP_DEVICE_KIND_KEYBOARD:
843
546
            name = _("keyboard battery");
844
547
            break;
845
 
        case XFPM_DEVICE_TYPE_PDA:
 
548
        case UP_DEVICE_KIND_PDA:
846
549
            name = _("PDA battery");
847
550
            break;
848
 
        case XFPM_DEVICE_TYPE_PHONE:
 
551
        case UP_DEVICE_KIND_PHONE:
849
552
            name = _("Phone battery");
850
553
            break;
851
554
        default:
852
555
            name = _("Unknown");
853
556
            break;
854
557
    }
855
 
    
 
558
 
856
559
    return name;
857
560
}
858
561
 
860
563
xfpm_battery_new (void)
861
564
{
862
565
    XfpmBattery *battery = NULL;
863
 
    
 
566
 
864
567
    battery = g_object_new (XFPM_TYPE_BATTERY, NULL);
865
 
    
 
568
 
866
569
    return GTK_STATUS_ICON (battery);
867
570
}
868
571
 
869
572
void xfpm_battery_monitor_device (XfpmBattery *battery,
870
 
                                  DBusGProxy *proxy,
871
 
                                  DBusGProxy *proxy_prop,
872
 
                                  XfpmDeviceType device_type)
 
573
                                  const char *object_path,
 
574
                                  UpDeviceKind device_type)
873
575
{
 
576
    UpDevice *device;
874
577
    battery->priv->type = device_type;
875
 
    battery->priv->proxy_prop = proxy_prop;
876
 
    battery->priv->proxy = proxy;
 
578
    battery->priv->client = up_client_new();
877
579
    battery->priv->icon_prefix = xfpm_battery_get_icon_prefix_device_enum_type (device_type);
878
580
    battery->priv->battery_name = xfpm_battery_get_name (device_type);
879
 
    
880
 
    
881
 
    dbus_g_proxy_add_signal (proxy, "Changed", G_TYPE_INVALID);
882
 
    dbus_g_proxy_connect_signal (proxy, "Changed",
883
 
                                 G_CALLBACK (xfpm_battery_changed_cb), battery, NULL);
884
581
 
 
582
    device = up_device_new();
 
583
    up_device_set_object_path_sync (device, object_path, NULL, NULL);
 
584
    battery->priv->device = device;
 
585
#if UP_CHECK_VERSION(0, 99, 0)
 
586
    battery->priv->sig_up = g_signal_connect (battery->priv->device, "notify", G_CALLBACK (xfpm_battery_changed_cb), battery);
 
587
#else
 
588
    battery->priv->sig_up = g_signal_connect (battery->priv->device, "changed", G_CALLBACK (xfpm_battery_changed_cb), battery);
 
589
#endif
885
590
    g_object_set (G_OBJECT (battery),
886
591
                  "has-tooltip", TRUE,
887
592
                  NULL);
888
593
 
889
 
    xfpm_battery_changed_cb (proxy, battery);
 
594
    xfpm_battery_refresh (battery, device);
890
595
}
891
596
 
892
 
XfpmDeviceType xfpm_battery_get_device_type (XfpmBattery *battery)
 
597
UpDeviceKind xfpm_battery_get_device_type (XfpmBattery *battery)
893
598
{
894
 
    g_return_val_if_fail (XFPM_IS_BATTERY (battery), XFPM_DEVICE_TYPE_UNKNOWN );
895
 
    
 
599
    g_return_val_if_fail (XFPM_IS_BATTERY (battery), UP_DEVICE_KIND_UNKNOWN );
 
600
 
896
601
    return battery->priv->type;
897
602
}
898
603
 
899
604
XfpmBatteryCharge xfpm_battery_get_charge (XfpmBattery *battery)
900
605
{
901
606
    g_return_val_if_fail (XFPM_IS_BATTERY (battery), XFPM_BATTERY_CHARGE_UNKNOWN);
902
 
    
 
607
 
903
608
    return battery->priv->charge;
904
609
}
905
610
 
906
611
const gchar *xfpm_battery_get_battery_name (XfpmBattery *battery)
907
612
{
908
613
    g_return_val_if_fail (XFPM_IS_BATTERY (battery), NULL);
909
 
    
 
614
 
910
615
    return battery->priv->battery_name;
911
616
}
912
617
 
913
618
gchar *xfpm_battery_get_time_left (XfpmBattery *battery)
914
619
{
915
620
    g_return_val_if_fail (XFPM_IS_BATTERY (battery), NULL);
916
 
    
 
621
 
917
622
    return xfpm_battery_get_time_string (battery->priv->time_to_empty);
918
623
}