« back to all changes in this revision
Viewing changes to src/xfpm-battery.c
- browse files at revision 2.3.5
- compare with another revision
- download diff
- download tarball
- view history from revision 2.3.5
- Committer: Bazaar Package Importer
- Author(s): Lionel Le Folgoc
- Date: 2010-12-09 18:28:34 UTC
- mto: This revision was merged to the branch mainline in revision 19.
- Revision ID: james.westby@ubuntu.com-20101209182834-tjz13qcewqlq19eu
Tags: upstream-1.0.1
Import upstream version 1.0.1
- files added:
- common
- data/icons/128x128
- data/icons/128x128/devices
- data/icons/22x22
- data/icons/22x22/actions
- data/icons/22x22/status
- libdbus
- libhal
- files removed:
- libxfpm
- files modified:
- Makefile.am
added
removed
src/xfpm-battery.c
1
1
/*
2
* * Copyright (C) 2008 Ali <aliov@xfce.org>
2
* * Copyright (C) 2009 Ali <aliov@xfce.org>
3
3
*
4
4
* Licensed under the GNU General Public License Version 2
5
5
*
26
26
#include <stdlib.h>
27
27
#include <string.h>
28
28
29
#include <glib.h>
30
29
#include <gtk/gtk.h>
31
30
32
#include <glib.h>
33
34
31
#include <libxfce4util/libxfce4util.h>
35
32
36
#include "libxfpm/xfpm-string.h"
37
#include "libxfpm/xfpm-notify.h"
38
#include "libxfpm/xfpm-icons.h"
39
40
33
#include "xfpm-battery.h"
41
#include "xfpm-tray-icon.h"
42
#include "xfpm-string.h"
43
#include "xfpm-marshal.h"
44
#include "xfpm-enum-types.h"
45
#include "xfpm-enum.h"
46
#include "xfpm-battery-info.h"
34
#include "xfpm-dbus.h"
35
#include "xfpm-icons.h"
47
36
#include "xfpm-xfconf.h"
37
#include "xfpm-notify.h"
48
38
#include "xfpm-config.h"
49
#include "xfpm-adapter.h"
39
#include "xfpm-enum-glib.h"
40
#include "xfpm-enum-types.h"
50
41
#include "xfpm-debug.h"
42
#include "xfpm-power-common.h"
43
#include "xfpm-common.h"
51
44
52
45
static void xfpm_battery_finalize (GObject *object);
53
46
54
47
#define XFPM_BATTERY_GET_PRIVATE(o) \
55
(G_TYPE_INSTANCE_GET_PRIVATE((o), XFPM_TYPE_BATTERY, XfpmBatteryPrivate))
48
(G_TYPE_INSTANCE_GET_PRIVATE ((o), XFPM_TYPE_BATTERY, XfpmBatteryPrivate))
56
49
57
50
struct XfpmBatteryPrivate
58
51
{
59
XfpmTrayIcon *icon;
60
XfpmAdapter *adapter;
61
HalBattery *device;
62
XfpmXfconf *conf;
63
XfpmNotify *notify;
64
65
HalDeviceType type;
66
gchar *icon_prefix;
67
68
gboolean adapter_present;
69
XfpmBatteryState state;
70
71
gulong sig_1;
72
gulong sig_2;
73
gulong sig_3;
74
};
75
76
enum
77
{
78
BATTERY_STATE_CHANGED,
52
XfpmXfconf *conf;
53
XfpmNotify *notify;
54
DBusGProxy *proxy;
55
DBusGProxy *proxy_prop;
56
57
gchar *icon_prefix;
58
59
XfpmBatteryCharge charge;
60
XfpmDeviceState state;
61
XfpmDeviceType type;
62
gboolean ac_online;
63
gboolean present;
64
guint percentage;
65
gint64 time_to_full;
66
gint64 time_to_empty;
67
68
const gchar *backend_iface_device; /*upower or devkit*/
69
70
gulong sig;
71
};
72
73
enum
74
{
75
PROP_0,
76
PROP_AC_ONLINE,
77
PROP_CHARGE_STATUS,
78
PROP_DEVICE_TYPE
79
};
80
81
enum
82
{
83
BATTERY_CHARGE_CHANGED,
79
84
LAST_SIGNAL
80
85
};
81
86
82
static guint signals[LAST_SIGNAL] = { 0 };
87
static guint signals [LAST_SIGNAL] = { 0 };
83
88
84
G_DEFINE_TYPE(XfpmBattery, xfpm_battery, G_TYPE_OBJECT)
89
G_DEFINE_TYPE (XfpmBattery, xfpm_battery, GTK_TYPE_STATUS_ICON)
85
90
86
91
static const gchar * G_GNUC_CONST
87
xfpm_battery_get_icon_index (HalDeviceType type, guint percent)
92
xfpm_battery_get_icon_index (XfpmDeviceType type, guint percent)
88
93
{
89
94
if (percent < 10) {
90
return "000";
95
return "000";
91
96
} else if (percent < 30) {
92
return (type == HAL_DEVICE_TYPE_PRIMARY || type == HAL_DEVICE_TYPE_UPS ? "020" : "030");
97
return ( (type == XFPM_DEVICE_TYPE_BATTERY || type == XFPM_DEVICE_TYPE_UPS) ? "020" : "030");
93
98
} else if (percent < 50) {
94
return (type == HAL_DEVICE_TYPE_PRIMARY || type == HAL_DEVICE_TYPE_UPS ? "040" : "030");
99
return ( (type == XFPM_DEVICE_TYPE_BATTERY || type == XFPM_DEVICE_TYPE_UPS ) ? "040" : "030");
95
100
} else if (percent < 70) {
96
return "060";
101
return "060";
97
102
} else if (percent < 90) {
98
return (type == HAL_DEVICE_TYPE_PRIMARY || type == HAL_DEVICE_TYPE_UPS ? "080" : "060");
103
return ((type == XFPM_DEVICE_TYPE_BATTERY || type == XFPM_DEVICE_TYPE_UPS) ? "080" : "060");
99
104
}
100
105
return "100";
101
106
}
102
107
103
static const gchar * G_GNUC_CONST
104
xfpm_battery_get_message_from_battery_state (XfpmBatteryState state, gboolean adapter_present)
105
{
106
switch (state)
107
{
108
case BATTERY_FULLY_CHARGED:
109
return _("Your battery is fully charged");
110
break;
111
case BATTERY_NOT_FULLY_CHARGED:
112
return _("Your battery is charging");
113
break;
114
case BATTERY_IS_CHARGING:
115
return _("Battery is charging");
116
break;
117
case BATTERY_IS_DISCHARGING:
118
return adapter_present ? _("Your battery is discharging"): _("System is running on battery power");
119
break;
120
case BATTERY_CHARGE_LOW:
121
return adapter_present ? _("Your battery charge is low") : _("System is running on low power");
122
break;
123
default:
124
return NULL;
125
}
126
}
127
128
108
static void
129
xfpm_battery_refresh_visible_icon (XfpmBattery *battery)
109
xfpm_battery_refresh_visible (XfpmBattery *battery)
130
110
{
131
111
XfpmShowIcon show_icon;
132
112
gboolean visible = TRUE;
141
121
visible = FALSE;
142
122
else if ( show_icon == SHOW_ICON_WHEN_BATTERY_PRESENT )
143
123
{
144
if ( battery->priv->state == BATTERY_NOT_PRESENT )
145
visible = FALSE;
146
else visible = TRUE;
124
if ( battery->priv->present )
125
visible = TRUE;
126
else visible = FALSE;
147
127
}
148
128
else if ( show_icon == SHOW_ICON_WHEN_BATTERY_CHARGING_DISCHARGING )
149
129
{
150
if ( battery->priv->state == BATTERY_FULLY_CHARGED )
130
if ( battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
151
131
visible = FALSE;
152
132
else visible = TRUE;
153
133
}
154
134
155
XFPM_DEBUG_ENUM ("Tray icon configuration: ", show_icon, XFPM_TYPE_SHOW_ICON);
156
XFPM_DEBUG_ENUM_FULL (battery->priv->state, XFPM_TYPE_BATTERY_STATE, " setting tray icon visible %s",
157
xfpm_bool_to_string (visible));
158
xfpm_tray_icon_set_visible (battery->priv->icon, visible);
159
}
160
135
XFPM_DEBUG_ENUM (show_icon, XFPM_TYPE_SHOW_ICON, "visible=%s", xfpm_bool_to_string (visible));
136
137
gtk_status_icon_set_visible (GTK_STATUS_ICON (battery), visible);
138
}
139
140
141
static const gchar * G_GNUC_CONST
142
xfpm_battery_get_message_from_battery_state (XfpmDeviceState state, gboolean ac_online)
143
{
144
switch (state)
145
{
146
case XFPM_DEVICE_STATE_FULLY_CHARGED:
147
return _("Your battery is fully charged");
148
break;
149
case XFPM_DEVICE_STATE_CHARGING:
150
return _("Your battery is charging");
151
break;
152
case XFPM_DEVICE_STATE_DISCHARGING:
153
return ac_online ? _("Your battery is discharging"): _("System is running on battery power");
154
break;
155
default:
156
return NULL;
157
}
158
}
159
161
160
static void
162
xfpm_battery_refresh_icon (XfpmBattery *battery,
163
XfpmBatteryState state,
164
guint percentage)
161
xfpm_battery_refresh_icon (XfpmBattery *battery)
165
162
{
166
gchar *icon;
167
168
if ( state == BATTERY_NOT_PRESENT )
169
{
170
xfpm_tray_icon_set_icon (battery->priv->icon,
171
battery->priv->type == HAL_DEVICE_TYPE_UPS ?
172
XFPM_UPS_ICON_PREFIX "missing" :
173
XFPM_PRIMARY_ICON_PREFIX "missing");
174
return;
175
}
176
177
/* Battery full */
178
if ( state == BATTERY_FULLY_CHARGED )
179
{
180
if ( battery->priv->type == HAL_DEVICE_TYPE_PRIMARY)
181
xfpm_tray_icon_set_icon (battery->priv->icon,
182
battery->priv->adapter_present ?
183
XFPM_PRIMARY_ICON_PREFIX "charged" :
184
XFPM_PRIMARY_ICON_PREFIX "100");
185
else
186
{
187
icon = g_strdup_printf("%s%s",
188
battery->priv->icon_prefix,
189
xfpm_battery_get_icon_index (battery->priv->type, percentage));
190
xfpm_tray_icon_set_icon (battery->priv->icon, icon);
191
g_free(icon);
192
}
193
}
194
else if ( state == BATTERY_NOT_FULLY_CHARGED )
195
{
196
if ( battery->priv->adapter_present )
197
{
198
icon = g_strdup_printf("%s%s-%s",
199
battery->priv->icon_prefix,
200
xfpm_battery_get_icon_index (battery->priv->type, percentage),
201
"charging");
202
}
203
else
204
{
205
icon = g_strdup_printf("%s%s",
206
battery->priv->icon_prefix,
207
xfpm_battery_get_icon_index (battery->priv->type, percentage));
208
}
209
xfpm_tray_icon_set_icon (battery->priv->icon, icon);
210
g_free(icon);
211
212
}
213
else if ( state == BATTERY_IS_CHARGING )
214
{
215
icon = g_strdup_printf("%s%s-%s",
216
battery->priv->icon_prefix,
217
xfpm_battery_get_icon_index (battery->priv->type, percentage),
218
"charging");
219
220
xfpm_tray_icon_set_icon (battery->priv->icon, icon);
221
g_free(icon);
222
}
223
else if ( state == BATTERY_IS_DISCHARGING || state == BATTERY_CHARGE_CRITICAL ||
224
state == BATTERY_CHARGE_LOW )
225
{
226
icon = g_strdup_printf("%s%s",
227
battery->priv->icon_prefix,
228
xfpm_battery_get_icon_index (battery->priv->type, percentage));
229
230
xfpm_tray_icon_set_icon (battery->priv->icon, icon);
231
g_free(icon);
232
233
}
163
gchar icon_name[128];
164
165
XFPM_DEBUG ("Battery state %d", battery->priv->state);
166
167
if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
168
battery->priv->type == XFPM_DEVICE_TYPE_UPS )
169
{
170
if (!battery->priv->present)
171
{
172
g_snprintf (icon_name, 128, "%s%s", battery->priv->icon_prefix, "missing");
173
}
174
else if (battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
175
{
176
g_snprintf (icon_name, 128, "%s%s", battery->priv->icon_prefix, battery->priv->ac_online ? "charged" : "100");
177
}
178
else if ( battery->priv->state == XFPM_DEVICE_STATE_CHARGING ||
179
battery->priv->state == XFPM_DEVICE_STATE_PENDING_CHARGING)
180
{
181
g_snprintf (icon_name, 128, "%s%s-%s",
182
battery->priv->icon_prefix,
183
xfpm_battery_get_icon_index (battery->priv->type, battery->priv->percentage),
184
"charging");
185
}
186
else if ( battery->priv->state == XFPM_DEVICE_STATE_DISCHARGING ||
187
battery->priv->state == XFPM_DEVICE_STATE_PENDING_DISCHARGING)
188
{
189
g_snprintf (icon_name, 128, "%s%s",
190
battery->priv->icon_prefix,
191
xfpm_battery_get_icon_index (battery->priv->type, battery->priv->percentage));
192
}
193
}
194
else
195
{
196
if ( !battery->priv->present )
197
{
198
g_snprintf (icon_name, 128, "%s-000", battery->priv->icon_prefix);
199
}
200
else if ( battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
201
{
202
g_snprintf (icon_name, 128, "%s-100", battery->priv->icon_prefix);
203
}
204
else if ( battery->priv->state == XFPM_DEVICE_STATE_DISCHARGING )
205
{
206
g_snprintf (icon_name, 128, "%s-%s",
207
battery->priv->icon_prefix,
208
xfpm_battery_get_icon_index (battery->priv->type, battery->priv->percentage));
209
}
210
}
211
212
gtk_status_icon_set_from_icon_name (GTK_STATUS_ICON (battery), icon_name);
234
213
}
235
214
236
215
static gboolean
241
220
242
221
battery = XFPM_BATTERY (data);
243
222
244
message = xfpm_battery_get_message_from_battery_state (battery->priv->state, battery->priv->adapter_present);
223
message = xfpm_battery_get_message_from_battery_state (battery->priv->state, battery->priv->ac_online);
224
245
225
if ( !message )
246
226
return FALSE;
247
227
248
228
xfpm_notify_show_notification (battery->priv->notify,
249
_("Xfce power manager"),
250
message,
251
xfpm_tray_icon_get_icon_name (battery->priv->icon),
252
8000,
253
battery->priv->type == HAL_DEVICE_TYPE_PRIMARY ? FALSE : TRUE,
254
XFPM_NOTIFY_NORMAL,
255
xfpm_tray_icon_get_tray_icon(battery->priv->icon));
256
229
_("Xfce power manager"),
230
message,
231
gtk_status_icon_get_icon_name (GTK_STATUS_ICON (battery)),
232
8000,
233
FALSE,
234
XFPM_NOTIFY_NORMAL,
235
GTK_STATUS_ICON (battery));
257
236
return FALSE;
258
237
}
259
238
260
239
static void
261
xfpm_battery_notify (XfpmBattery *battery)
240
xfpm_battery_notify_state (XfpmBattery *battery)
262
241
{
263
242
gboolean notify;
264
243
static gboolean starting_up = TRUE;
265
266
if ( starting_up )
267
{
268
starting_up = FALSE;
244
245
if ( !gtk_status_icon_get_visible (GTK_STATUS_ICON (battery)) )
269
246
return;
270
}
271
247
248
if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
249
battery->priv->type == XFPM_DEVICE_TYPE_UPS )
250
{
251
if ( starting_up )
252
{
253
starting_up = FALSE;
254
return;
255
}
256
257
g_object_get (G_OBJECT (battery->priv->conf),
258
GENERAL_NOTIFICATION_CFG, ¬ify,
259
NULL);
260
261
if ( notify )
262
{
263
g_idle_add ((GSourceFunc) xfpm_battery_notify_idle, battery);
264
}
265
}
266
}
267
268
/*
269
* Taken from gpm
270
*/
271
static gchar *
272
xfpm_battery_get_time_string (guint seconds)
273
{
274
char* timestring = NULL;
275
gint hours;
276
gint minutes;
277
278
/* Add 0.5 to do rounding */
279
minutes = (int) ( ( seconds / 60.0 ) + 0.5 );
280
281
if (minutes == 0)
282
{
283
timestring = g_strdup (_("Unknown time"));
284
return timestring;
285
}
286
287
if (minutes < 60)
288
{
289
timestring = g_strdup_printf (ngettext ("%i minute",
290
"%i minutes",
291
minutes), minutes);
292
return timestring;
293
}
294
295
hours = minutes / 60;
296
minutes = minutes % 60;
297
298
if (minutes == 0)
299
timestring = g_strdup_printf (ngettext (
300
"%i hour",
301
"%i hours",
302
hours), hours);
303
else
304
/* TRANSLATOR: "%i %s %i %s" are "%i hours %i minutes"
305
* Swap order with "%2$s %2$i %1$s %1$i if needed */
306
timestring = g_strdup_printf (_("%i %s %i %s"),
307
hours, ngettext ("hour", "hours", hours),
308
minutes, ngettext ("minute", "minutes", minutes));
309
return timestring;
310
}
311
312
/*
313
* Refresh tooltip function for UPS and battery device only.
314
*/
315
static void
316
xfpm_battery_set_tooltip_primary (XfpmBattery *battery, GtkTooltip *tooltip)
317
{
318
const gchar *battery_name;
319
gchar *tip = NULL;
320
gchar *est_time_str = NULL;
321
gchar *power_status = NULL;
322
323
power_status = g_strdup_printf (battery->priv->ac_online ? _("Adaptor is online") : _("System is running on battery power"));
324
325
battery_name = battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ? _("Battery") : _("UPS");
326
327
if ( battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
328
{
329
if ( battery->priv->time_to_empty > 0 )
330
{
331
est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_empty);
332
tip = g_strdup_printf (_("%s\nYour %s is fully charged (%i%%).\nProvides %s runtime"),
333
power_status,
334
battery_name,
335
battery->priv->percentage,
336
est_time_str);
337
g_free (est_time_str);
338
}
339
else
340
{
341
tip = g_strdup_printf (_("%s\nYour %s is fully charged (%i%%)."),
342
power_status,
343
battery_name,
344
battery->priv->percentage);
345
}
346
}
347
else if ( battery->priv->state == XFPM_DEVICE_STATE_CHARGING )
348
{
349
if ( battery->priv->time_to_full != 0 )
350
{
351
est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_full);
352
tip = g_strdup_printf (_("%s\nYour %s is charging (%i%%)\n%s until is fully charged."),
353
power_status,
354
battery_name,
355
battery->priv->percentage,
356
est_time_str);
357
g_free (est_time_str);
358
}
359
else
360
{
361
tip = g_strdup_printf (_("%s\nYour %s is charging (%i%%)."),
362
power_status,
363
battery_name,
364
battery->priv->percentage);
365
}
366
}
367
else if ( battery->priv->state == XFPM_DEVICE_STATE_DISCHARGING )
368
{
369
if ( battery->priv->time_to_empty != 0 )
370
{
371
est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_empty);
372
tip = g_strdup_printf (_("%s\nYour %s is discharging (%i%%)\nestimated time left is %s."),
373
power_status,
374
battery_name,
375
battery->priv->percentage,
376
est_time_str);
377
g_free (est_time_str);
378
}
379
else
380
{
381
tip = g_strdup_printf (_("%s\nYour %s is discharging (%i%%)."),
382
power_status,
383
battery_name,
384
battery->priv->percentage);
385
}
386
387
}
388
else if ( battery->priv->state == XFPM_DEVICE_STATE_PENDING_CHARGING )
389
{
390
tip = g_strdup_printf (_("%s\n%s waiting to discharge (%i%%)."), power_status, battery_name, battery->priv->percentage);
391
}
392
else if ( battery->priv->state == XFPM_DEVICE_STATE_PENDING_DISCHARGING )
393
{
394
tip = g_strdup_printf (_("%s\n%s waiting to charge (%i%%)."), power_status, battery_name, battery->priv->percentage);
395
}
396
else if ( battery->priv->state == XFPM_DEVICE_STATE_EMPTY )
397
{
398
tip = g_strdup_printf (_("%s\nYour %s is empty"), power_status, battery_name);
399
}
400
401
gtk_tooltip_set_text (tooltip, tip);
402
g_free (power_status);
403
g_free (tip);
404
}
405
406
static void
407
xfpm_battery_check_charge (XfpmBattery *battery)
408
{
409
XfpmBatteryCharge charge;
410
guint critical_level, low_level;
411
272
412
g_object_get (G_OBJECT (battery->priv->conf),
273
GENERAL_NOTIFICATION_CFG, ¬ify,
413
CRITICAL_POWER_LEVEL, &critical_level,
274
414
NULL);
275
415
276
if ( notify )
277
{
278
g_idle_add ((GSourceFunc) xfpm_battery_notify_idle, battery);
279
}
280
}
281
282
static const gchar * G_GNUC_CONST
283
_get_battery_name (HalDeviceType type)
284
{
285
if ( type == HAL_DEVICE_TYPE_UPS)
286
return _("Your UPS");
287
else if ( type == HAL_DEVICE_TYPE_MOUSE )
288
return _("Your Mouse battery");
289
else if ( type == HAL_DEVICE_TYPE_KEYBOARD )
290
return _("Your Keyboard battery");
291
else if ( type == HAL_DEVICE_TYPE_CAMERA )
292
return _("Your Camera battery");
293
else if ( type == HAL_DEVICE_TYPE_PDA)
294
return _("Your PDA battery");
416
low_level = critical_level + 10;
417
418
if ( battery->priv->percentage > low_level )
419
charge = XFPM_BATTERY_CHARGE_OK;
420
else if ( battery->priv->percentage <= low_level && battery->priv->percentage > critical_level )
421
charge = XFPM_BATTERY_CHARGE_LOW;
422
else if ( battery->priv->percentage <= critical_level )
423
charge = XFPM_BATTERY_CHARGE_CRITICAL;
295
424
296
return _("Your Battery");
297
}
298
299
static const gchar * G_GNUC_PURE
300
xfpm_battery_get_battery_state (XfpmBatteryState *state,
301
gboolean is_charging,
302
gboolean is_discharging,
303
guint32 last_full,
304
guint32 current_charge,
305
guint percentage,
306
guint8 critical_level)
307
{
308
if ( G_UNLIKELY (current_charge == 0 || percentage == 0) )
309
{
310
*state = BATTERY_CHARGE_CRITICAL;
311
return _("is empty");
312
}
313
314
if ( !is_charging && !is_discharging && current_charge >= last_full )
315
{
316
*state = BATTERY_FULLY_CHARGED;
317
return _("is fully charged");
318
}
319
else if ( !is_charging && !is_discharging && last_full != current_charge )
320
{
321
*state = BATTERY_NOT_FULLY_CHARGED;
322
return _("charge level");
323
}
324
else if ( is_charging && !is_discharging )
325
{
326
*state = BATTERY_IS_CHARGING;
327
return _("is charging");
328
}
329
else if ( !is_charging && is_discharging )
330
{
331
if ( percentage >= 30 )
332
{
333
*state = BATTERY_IS_DISCHARGING;
334
return _("is discharging");
335
}
336
else if ( percentage >= critical_level && percentage < 30)
337
{
338
*state = BATTERY_CHARGE_LOW;
339
return _("charge is low");
340
}
341
else if ( percentage < critical_level )
342
{
343
*state = BATTERY_CHARGE_CRITICAL;
344
return _("is almost empty");
345
}
346
}
347
348
g_warn_if_reached ();
349
350
return "";
425
if ( charge != battery->priv->charge)
426
{
427
battery->priv->charge = charge;
428
/*
429
* only emit signal when when battery charge changes from ok->low->critical
430
* and not the other way round.
431
*/
432
if ( battery->priv->charge != XFPM_BATTERY_CHARGE_CRITICAL || charge != XFPM_BATTERY_CHARGE_LOW )
433
g_signal_emit (G_OBJECT (battery), signals [BATTERY_CHARGE_CHANGED], 0);
434
}
351
435
}
352
436
353
437
static void
354
xfpm_battery_refresh_common (XfpmBattery *battery, guint percentage, XfpmBatteryState state)
438
xfpm_battery_refresh (XfpmBattery *battery, GHashTable *props)
355
439
{
356
XfpmShowIcon show_icon;
357
358
g_object_get (G_OBJECT (battery->priv->conf),
359
SHOW_TRAY_ICON_CFG, &show_icon,
360
NULL);
361
362
if ( show_icon != NEVER_SHOW_ICON )
363
xfpm_battery_refresh_icon (battery, state, percentage);
364
365
if ( battery->priv->state != state)
440
GValue *value;
441
guint state;
442
443
value = g_hash_table_lookup (props, "IsPresent");
444
445
if ( value == NULL )
446
{
447
g_warning ("No 'IsPresent' property found");
448
goto out;
449
}
450
451
battery->priv->present = g_value_get_boolean (value);
452
453
value = g_hash_table_lookup (props, "State");
454
455
if ( value == NULL )
456
{
457
g_warning ("No 'State' property found");
458
}
459
460
state = g_value_get_uint (value);
461
if ( state != battery->priv->state )
366
462
{
367
463
battery->priv->state = state;
368
XFPM_DEBUG_ENUM ("battery state change", battery->priv->state, XFPM_TYPE_BATTERY_STATE);
369
TRACE("Emitting signal battery state changed");
370
g_signal_emit (G_OBJECT(battery), signals[BATTERY_STATE_CHANGED], 0, state);
371
372
if ( battery->priv->state != BATTERY_NOT_FULLY_CHARGED && show_icon != NEVER_SHOW_ICON)
373
xfpm_battery_notify (battery);
374
else
375
xfpm_notify_close_normal (battery->priv->notify);
376
}
377
}
378
379
static void
380
xfpm_battery_refresh_misc (XfpmBattery *battery, gboolean is_present,
381
gboolean is_charging, gboolean is_discharging,
382
guint32 last_full, guint32 current_charge,
383
guint percentage, guint time_per)
384
{
385
gchar *tip;
386
XfpmBatteryState state;
387
const gchar *str;
388
guint critical_level;
389
390
g_object_get (G_OBJECT (battery->priv->conf),
391
CRITICAL_POWER_LEVEL, &critical_level,
392
NULL);
393
394
if ( !is_present )
395
{
396
tip = g_strdup_printf ("%s %s", _get_battery_name(battery->priv->type), _("is not present"));
397
xfpm_tray_icon_set_tooltip (battery->priv->icon, tip);
398
g_free(tip);
399
battery->priv->state = BATTERY_NOT_PRESENT;
400
return;
401
}
402
403
state = battery->priv->state;
404
str = xfpm_battery_get_battery_state (&state, is_charging, is_discharging,
405
last_full, current_charge, percentage,
406
critical_level);
407
tip = g_strdup_printf("%i%% %s %s", percentage, _get_battery_name(battery->priv->type), str);
408
//FIXME: Time for misc batteries
409
xfpm_tray_icon_set_tooltip (battery->priv->icon, tip);
410
g_free (tip);
411
412
xfpm_battery_refresh_common (battery, percentage, state);
413
}
414
415
static void
416
xfpm_battery_refresh_primary (XfpmBattery *battery, gboolean is_present,
417
gboolean is_charging, gboolean is_discharging,
418
guint32 last_full, guint32 current_charge,
419
guint percentage, guint time_per)
420
{
421
gchar *tip;
422
const gchar *str;
423
guint critical_level;
424
425
XfpmBatteryState state = battery->priv->state;
426
427
g_object_get (G_OBJECT (battery->priv->conf),
428
CRITICAL_POWER_LEVEL, &critical_level,
429
NULL);
430
431
TRACE ("Start");
432
433
if ( !is_present )
434
{
435
xfpm_tray_icon_set_tooltip(battery->priv->icon, _("Battery not present"));
436
battery->priv->state = BATTERY_NOT_PRESENT;
437
return;
438
}
439
440
str = xfpm_battery_get_battery_state (&state, is_charging, is_discharging,
441
last_full, current_charge, percentage, critical_level);
442
443
XFPM_DEBUG_ENUM ("battery state", state, XFPM_TYPE_BATTERY_STATE);
444
445
if ( time_per != 0 && time_per <= 28800 /* 8 hours */ &&
446
state != BATTERY_FULLY_CHARGED && state != BATTERY_NOT_FULLY_CHARGED )
447
{
448
gchar *time_str;
449
gchar *tip_no_time;
450
const gchar *est_time;
451
452
gint minutes, hours, minutes_left;
453
hours = time_per / 3600;
454
minutes = time_per / 60;
455
minutes_left = minutes % 60;
456
457
tip_no_time = g_strdup_printf ("%i%% %s %s\n%s",
458
percentage,
459
_("Battery"),
460
str,
461
battery->priv->adapter_present ?
462
_("System is running on AC power") :
463
_("System is running on battery power"));
464
465
if ( state == BATTERY_IS_DISCHARGING ||
466
state == BATTERY_CHARGE_LOW ||
467
state == BATTERY_CHARGE_CRITICAL )
468
{
469
est_time = _("Estimated time left");
470
}
471
else //* BATTERY_IS_CHARGING
472
{
473
est_time = _("Estimated time to be fully charged");
474
}
475
476
time_str = g_strdup_printf("%s: %d %s %d %s",est_time,
477
hours,hours > 1 ? _("hours") : _("hour") ,
478
minutes_left, minutes_left > 1 ? _("minutes") : _("minute"));
479
480
tip = (hours != 0 || minutes_left != 0 ) ?
481
g_strdup_printf ("%s\n%s", tip_no_time, time_str) :
482
g_strdup (tip_no_time);
483
484
g_free (tip_no_time);
485
g_free (time_str);
486
}
487
else
488
{
489
tip = g_strdup_printf ("%i%% %s %s\n%s",
490
percentage,
491
_("Battery"),
492
str,
493
battery->priv->adapter_present ?
494
_("System is running on AC power") :
495
_("System is running on battery power"));
496
}
497
498
xfpm_tray_icon_set_tooltip(battery->priv->icon, tip);
499
g_free(tip);
500
501
xfpm_battery_refresh_common (battery, percentage, state);
502
}
503
504
static void
505
xfpm_battery_refresh (XfpmBattery *battery)
506
{
507
gboolean is_present, is_charging, is_discharging = FALSE;
508
guint percentage = 0;
509
guint32 last_full, current_charge = 0;
510
guint time_per = 0;
511
512
g_object_get (G_OBJECT(battery->priv->device),
513
"is-present", &is_present,
514
"is-charging", &is_charging,
515
"is-discharging", &is_discharging,
516
"percentage", &percentage,
517
"last-full", &last_full,
518
"current-charge", ¤t_charge,
519
"time", &time_per,
520
NULL);
521
522
TRACE ("Battery status is_present %s is_charging %s is_discharging %s",
523
xfpm_bool_to_string (is_present),
524
xfpm_bool_to_string (is_charging),
525
xfpm_bool_to_string (is_discharging));
526
527
TRACE ("Battery info precentage %i last_full %i current_charge %i time_per %i",
528
percentage, last_full, current_charge, time_per);
529
530
battery->priv->type == HAL_DEVICE_TYPE_PRIMARY ?
531
xfpm_battery_refresh_primary (battery, is_present,
532
is_charging, is_discharging,
533
last_full, current_charge,
534
percentage, time_per)
535
:
536
xfpm_battery_refresh_misc (battery, is_present,
537
is_charging, is_discharging,
538
last_full, current_charge,
539
percentage, time_per);
540
541
xfpm_battery_refresh_visible_icon (battery);
542
}
543
544
static void
545
xfpm_battery_device_changed_cb (HalBattery *device, XfpmBattery *battery)
546
{
547
TRACE("start");
548
xfpm_battery_refresh (battery);
464
xfpm_battery_refresh_visible (battery);
465
xfpm_battery_notify_state (battery);
466
}
467
468
value = g_hash_table_lookup (props, "Percentage");
469
470
if ( value == NULL )
471
{
472
g_warning ("No 'Percentage' property found on battery device");
473
goto out;
474
}
475
476
battery->priv->percentage = (guint) g_value_get_double (value);
477
478
xfpm_battery_check_charge (battery);
479
480
xfpm_battery_refresh_icon (battery);
481
482
if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
483
battery->priv->type == XFPM_DEVICE_TYPE_UPS )
484
{
485
value = g_hash_table_lookup (props, "TimeToEmpty");
486
487
if ( value == NULL )
488
{
489
g_warning ("No 'TimeToEmpty' property found on battery device");
490
goto out;
491
}
492
493
battery->priv->time_to_empty = g_value_get_int64 (value);
494
495
value = g_hash_table_lookup (props, "TimeToFull");
496
497
if ( value == NULL )
498
{
499
g_warning ("No 'TimeToFull' property found on battery device");
500
goto out;
501
}
502
503
battery->priv->time_to_full = g_value_get_int64 (value);
504
}
505
506
out:
507
g_hash_table_destroy (props);
508
}
509
510
static void
511
xfpm_battery_changed_cb (DBusGProxy *proxy, XfpmBattery *battery)
512
{
513
GHashTable *props;
514
515
props = xfpm_power_get_interface_properties (battery->priv->proxy_prop,
516
battery->priv->backend_iface_device);
517
518
if ( props )
519
xfpm_battery_refresh (battery, props);
520
}
521
522
static gboolean
523
xfpm_battery_query_tooltip (GtkStatusIcon *icon,
524
gint x,
525
gint y,
526
gboolean keyboard_mode,
527
GtkTooltip *tooltip)
528
{
529
XfpmBattery *battery;
530
531
battery = XFPM_BATTERY (icon);
532
533
if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
534
battery->priv->type == XFPM_DEVICE_TYPE_UPS )
535
{
536
xfpm_battery_set_tooltip_primary (battery, tooltip);
537
return TRUE;
538
}
539
540
return FALSE;
541
}
542
543
static void
544
xfpm_battery_tray_icon_settings_changed (GObject *obj, GParamSpec *spec, XfpmBattery *battery)
545
{
546
xfpm_battery_refresh_visible (battery);
547
}
548
549
static void xfpm_battery_get_property (GObject *object,
550
guint prop_id,
551
GValue *value,
552
GParamSpec *pspec)
553
{
554
XfpmBattery *battery;
555
556
battery = XFPM_BATTERY (object);
557
558
switch (prop_id)
559
{
560
case PROP_AC_ONLINE:
561
g_value_set_boolean (value, battery->priv->ac_online);
562
break;
563
case PROP_DEVICE_TYPE:
564
g_value_set_enum (value, battery->priv->type);
565
break;
566
case PROP_CHARGE_STATUS:
567
g_value_set_enum (value, battery->priv->charge);
568
break;
569
default:
570
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
571
break;
572
}
573
}
574
575
static void xfpm_battery_set_property (GObject *object,
576
guint prop_id,
577
const GValue *value,
578
GParamSpec *pspec)
579
{
580
XfpmBattery *battery;
581
582
battery = XFPM_BATTERY (object);
583
584
switch (prop_id)
585
{
586
case PROP_AC_ONLINE:
587
battery->priv->ac_online = g_value_get_boolean (value);
588
xfpm_battery_refresh_icon (battery);
589
break;
590
default:
591
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
592
break;
593
}
594
}
595
596
597
static void
598
xfpm_battery_class_init (XfpmBatteryClass *klass)
599
{
600
GObjectClass *object_class = G_OBJECT_CLASS (klass);
601
GtkStatusIconClass *status_icon_class = GTK_STATUS_ICON_CLASS (klass);
602
603
object_class->finalize = xfpm_battery_finalize;
604
object_class->get_property = xfpm_battery_get_property;
605
object_class->set_property = xfpm_battery_set_property;
606
607
status_icon_class->query_tooltip = xfpm_battery_query_tooltip;
608
609
signals [BATTERY_CHARGE_CHANGED] =
610
g_signal_new ("battery-charge-changed",
611
XFPM_TYPE_BATTERY,
612
G_SIGNAL_RUN_LAST,
613
G_STRUCT_OFFSET(XfpmBatteryClass, battery_charge_changed),
614
NULL, NULL,
615
g_cclosure_marshal_VOID__VOID,
616
G_TYPE_NONE, 0, G_TYPE_NONE);
617
618
g_object_class_install_property (object_class,
619
PROP_AC_ONLINE,
620
g_param_spec_boolean("ac-online",
621
NULL, NULL,
622
FALSE,
623
G_PARAM_READWRITE));
624
625
g_object_class_install_property (object_class,
626
PROP_DEVICE_TYPE,
627
g_param_spec_enum ("device-type",
628
NULL, NULL,
629
XFPM_TYPE_DEVICE_TYPE,
630
XFPM_DEVICE_TYPE_UNKNOWN,
631
G_PARAM_READABLE));
632
633
g_object_class_install_property (object_class,
634
PROP_CHARGE_STATUS,
635
g_param_spec_enum ("charge-status",
636
NULL, NULL,
637
XFPM_TYPE_BATTERY_CHARGE,
638
XFPM_BATTERY_CHARGE_UNKNOWN,
639
G_PARAM_READABLE));
640
641
g_type_class_add_private (klass, sizeof (XfpmBatteryPrivate));
642
}
643
644
static void
645
xfpm_battery_init (XfpmBattery *battery)
646
{
647
battery->priv = XFPM_BATTERY_GET_PRIVATE (battery);
648
649
battery->priv->conf = xfpm_xfconf_new ();
650
battery->priv->notify = xfpm_notify_new ();
651
battery->priv->proxy_prop = NULL;
652
battery->priv->state = XFPM_DEVICE_STATE_UNKNOWN;
653
battery->priv->type = XFPM_DEVICE_TYPE_UNKNOWN;
654
battery->priv->charge = XFPM_BATTERY_CHARGE_UNKNOWN;
655
battery->priv->icon_prefix = NULL;
656
battery->priv->time_to_full = 0;
657
battery->priv->time_to_empty = 0;
658
battery->priv->ac_online = TRUE;
659
660
battery->priv->sig = g_signal_connect (G_OBJECT (battery->priv->conf), "notify::" SHOW_TRAY_ICON_CFG,
661
G_CALLBACK (xfpm_battery_tray_icon_settings_changed), battery);
662
}
663
664
static void
665
xfpm_battery_finalize (GObject *object)
666
{
667
XfpmBattery *battery;
668
669
battery = XFPM_BATTERY (object);
670
671
g_free (battery->priv->icon_prefix);
672
673
dbus_g_proxy_disconnect_signal (battery->priv->proxy, "Changed",
674
G_CALLBACK (xfpm_battery_changed_cb), battery);
675
676
if ( g_signal_handler_is_connected (battery->priv->conf, battery->priv->sig ) )
677
g_signal_handler_disconnect (G_OBJECT (battery->priv->conf), battery->priv->sig);
678
679
g_object_unref (battery->priv->proxy);
680
g_object_unref (battery->priv->proxy_prop);
681
g_object_unref (battery->priv->conf);
682
g_object_unref (battery->priv->notify);
683
684
G_OBJECT_CLASS (xfpm_battery_parent_class)->finalize (object);
549
685
}
550
686
551
687
static gchar *
552
_get_icon_prefix_from_enum_type (HalDeviceType type)
688
xfpm_battery_get_icon_prefix_device_enum_type (XfpmDeviceType type)
553
689
{
554
if ( type == HAL_DEVICE_TYPE_PRIMARY )
690
if ( type == XFPM_DEVICE_TYPE_BATTERY )
555
691
{
556
692
return g_strdup (XFPM_PRIMARY_ICON_PREFIX);
557
693
}
558
else if ( type == HAL_DEVICE_TYPE_UPS )
694
else if ( type == XFPM_DEVICE_TYPE_UPS )
559
695
{
560
696
return g_strdup (XFPM_UPS_ICON_PREFIX);
561
697
}
562
else if ( type == HAL_DEVICE_TYPE_MOUSE )
698
else if ( type == XFPM_DEVICE_TYPE_MOUSE )
563
699
{
564
700
return g_strdup (XFPM_MOUSE_ICON_PREFIX);
565
701
}
566
else if ( type == HAL_DEVICE_TYPE_KEYBOARD )
702
else if ( type == XFPM_DEVICE_TYPE_KBD )
567
703
{
568
704
return g_strdup (XFPM_KBD_ICON_PREFIX);
569
705
}
570
else if ( type == HAL_DEVICE_TYPE_CAMERA )
571
{
572
return g_strdup (XFPM_CAMERA_ICON_PREFIX);
573
}
574
else if ( type == HAL_DEVICE_TYPE_PDA )
575
{
576
return g_strdup (XFPM_PDA_ICON_PREFIX);
577
}
578
else if ( type == HAL_DEVICE_TYPE_KEYBOARD_MOUSE )
579
{
580
return g_strdup (XFPM_KBD_MOUSE_ICON_PREFIX);
706
else if ( type == XFPM_DEVICE_TYPE_PHONE )
707
{
708
return g_strdup (XFPM_PHONE_ICON_PREFIX);
581
709
}
582
710
583
711
return g_strdup (XFPM_PRIMARY_ICON_PREFIX);
584
712
}
585
713
586
static void
587
xfpm_battery_adapter_changed_cb (XfpmAdapter *adapter, gboolean present, XfpmBattery *battery)
588
{
589
battery->priv->adapter_present = present;
590
xfpm_battery_refresh (battery);
591
}
592
593
static void
594
xfpm_battery_tray_icon_settings_changed (GObject *obj, GParamSpec *spec, XfpmBattery *battery)
595
{
596
xfpm_battery_refresh_visible_icon (battery);
597
}
598
599
static void
600
xfpm_battery_show_info (XfpmTrayIcon *tray, XfpmBattery *battery)
601
{
602
gchar *icon = g_strdup_printf("%s%s",
603
battery->priv->icon_prefix,
604
xfpm_battery_get_icon_index(battery->priv->type, 100));
605
606
GtkWidget *info = xfpm_battery_info_new (battery->priv->device, icon);
607
608
g_free (icon);
609
610
gtk_widget_show_all (info);
611
}
612
613
static void
614
xfpm_battery_class_init(XfpmBatteryClass *klass)
615
{
616
GObjectClass *object_class = G_OBJECT_CLASS(klass);
617
618
signals[BATTERY_STATE_CHANGED] =
619
g_signal_new("battery-state-changed",
620
XFPM_TYPE_BATTERY,
621
G_SIGNAL_RUN_LAST,
622
G_STRUCT_OFFSET(XfpmBatteryClass, battery_state_changed),
623
NULL, NULL,
624
g_cclosure_marshal_VOID__ENUM,
625
G_TYPE_NONE, 1, XFPM_TYPE_BATTERY_STATE);
626
627
object_class->finalize = xfpm_battery_finalize;
628
629
g_type_class_add_private(klass,sizeof(XfpmBatteryPrivate));
630
}
631
632
static void
633
xfpm_battery_init(XfpmBattery *battery)
634
{
635
battery->priv = XFPM_BATTERY_GET_PRIVATE(battery);
636
637
battery->priv->icon = xfpm_tray_icon_new ();
638
battery->priv->adapter = xfpm_adapter_new ();
639
battery->priv->conf = xfpm_xfconf_new ();
640
battery->priv->notify = xfpm_notify_new ();
641
battery->priv->state = BATTERY_STATE_UNKNOWN;
642
battery->priv->icon_prefix = NULL;
643
644
battery->priv->adapter_present = xfpm_adapter_get_present (battery->priv->adapter);
645
646
battery->priv->sig_1 = g_signal_connect (battery->priv->adapter ,"adapter-changed",
647
G_CALLBACK (xfpm_battery_adapter_changed_cb), battery);
648
649
g_signal_connect (battery->priv->icon, "show-information",
650
G_CALLBACK (xfpm_battery_show_info), battery);
651
}
652
653
static void
654
xfpm_battery_finalize(GObject *object)
655
{
656
XfpmBattery *battery;
657
battery = XFPM_BATTERY(object);
658
659
if ( g_signal_handler_is_connected (battery->priv->adapter, battery->priv->sig_1 ) )
660
g_signal_handler_disconnect (G_OBJECT (battery->priv->adapter), battery->priv->sig_1);
661
662
if ( g_signal_handler_is_connected (battery->priv->conf, battery->priv->sig_2 ) )
663
g_signal_handler_disconnect (G_OBJECT (battery->priv->conf), battery->priv->sig_2);
664
665
if ( g_signal_handler_is_connected (battery->priv->device, battery->priv->sig_3 ) )
666
g_signal_handler_disconnect (G_OBJECT (battery->priv->device), battery->priv->sig_3);
667
668
g_object_unref (battery->priv->icon);
669
670
g_object_unref (battery->priv->device);
671
672
if ( battery->priv->icon_prefix )
673
g_free(battery->priv->icon_prefix);
674
675
g_object_unref (battery->priv->adapter);
676
677
g_object_unref (battery->priv->conf);
678
679
g_object_unref (battery->priv->notify);
680
681
G_OBJECT_CLASS(xfpm_battery_parent_class)->finalize(object);
682
}
683
684
XfpmBattery *
685
xfpm_battery_new(const HalBattery *device)
714
GtkStatusIcon *
715
xfpm_battery_new (void)
686
716
{
687
717
XfpmBattery *battery = NULL;
688
718
689
battery = g_object_new(XFPM_TYPE_BATTERY, NULL);
690
691
battery->priv->device = (HalBattery *)g_object_ref(G_OBJECT(device));
692
693
g_object_get(G_OBJECT(battery->priv->device), "type", &battery->priv->type, NULL);
694
695
battery->priv->icon_prefix = _get_icon_prefix_from_enum_type(battery->priv->type);
696
697
xfpm_battery_refresh (battery);
698
699
battery->priv->sig_3 = g_signal_connect (G_OBJECT(battery->priv->device), "battery-changed",
700
G_CALLBACK(xfpm_battery_device_changed_cb), battery);
701
702
battery->priv->sig_2 = g_signal_connect (G_OBJECT(battery->priv->conf), "notify::" SHOW_TRAY_ICON_CFG,
703
G_CALLBACK(xfpm_battery_tray_icon_settings_changed), battery);
704
705
return battery;
706
}
707
708
const HalBattery*
709
xfpm_battery_get_device (XfpmBattery *battery)
710
{
711
g_return_val_if_fail (XFPM_IS_BATTERY(battery), NULL);
712
713
return battery->priv->device;
714
}
715
716
XfpmBatteryState xfpm_battery_get_state (XfpmBattery *battery)
717
{
718
g_return_val_if_fail (XFPM_IS_BATTERY(battery), BATTERY_NOT_PRESENT);
719
720
return battery->priv->state;
721
}
722
723
GtkStatusIcon *xfpm_battery_get_status_icon (XfpmBattery *battery)
724
{
725
g_return_val_if_fail (XFPM_IS_BATTERY(battery), NULL);
726
727
return xfpm_tray_icon_get_tray_icon (battery->priv->icon);
728
729
}
730
731
const gchar *xfpm_battery_get_icon_name (XfpmBattery *battery)
732
{
733
g_return_val_if_fail (XFPM_IS_BATTERY (battery), NULL);
734
735
return xfpm_tray_icon_get_icon_name (battery->priv->icon);
719
battery = g_object_new (XFPM_TYPE_BATTERY, NULL);
720
721
return GTK_STATUS_ICON (battery);
722
}
723
724
void xfpm_battery_monitor_device (XfpmBattery *battery,
725
DBusGProxy *proxy,
726
DBusGProxy *proxy_prop,
727
const gchar *backend_iface_device,
728
XfpmDeviceType device_type)
729
{
730
battery->priv->type = device_type;
731
battery->priv->proxy_prop = proxy_prop;
732
battery->priv->proxy = proxy;
733
battery->priv->icon_prefix = xfpm_battery_get_icon_prefix_device_enum_type (device_type);
734
battery->priv->backend_iface_device = backend_iface_device;
735
736
dbus_g_proxy_add_signal (proxy, "Changed", G_TYPE_INVALID);
737
dbus_g_proxy_connect_signal (proxy, "Changed",
738
G_CALLBACK (xfpm_battery_changed_cb), battery, NULL);
739
740
g_object_set (G_OBJECT (battery),
741
"has-tooltip", TRUE,
742
NULL);
743
744
xfpm_battery_changed_cb (proxy, battery);
745
}
746
747
XfpmDeviceType xfpm_battery_get_device_type (XfpmBattery *battery)
748
{
749
g_return_val_if_fail (XFPM_IS_BATTERY (battery), XFPM_DEVICE_TYPE_UNKNOWN );
750
751
return battery->priv->type;
752
}
753
754
XfpmBatteryCharge xfpm_battery_get_charge (XfpmBattery *battery)
755
{
756
g_return_val_if_fail (XFPM_IS_BATTERY (battery), XFPM_BATTERY_CHARGE_UNKNOWN);
757
758
return battery->priv->charge;
736
759
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1