« back to all changes in this revision
Viewing changes to settings/xfpm-settings.c
- browse files at revision 2579
- compare with another revision
- download diff
- download tarball
- view history from revision 2579
- Committer: Simon Steinbeiss
- Date: 2019-11-15 23:50:05 UTC
- Revision ID: git-v1:90dc136450cc2878619a19aaca0357bee016dd1f
Fix indentation
- files modified:
- common/xfpm-brightness.c
added
removed
settings/xfpm-settings.c
50
50
#include "xfpm-enum-glib.h"
51
51
#include "xfpm-enum.h"
52
52
53
#define BRIGHTNESS_DISABLED 9
54
55
static GtkApplication *app = NULL;
56
static GtkBuilder *xml = NULL;
57
static GtkWidget *nt = NULL;
58
59
static GtkWidget *on_battery_display_blank = NULL;
60
static GtkWidget *on_battery_dpms_sleep = NULL;
61
static GtkWidget *on_battery_dpms_off = NULL;
62
static GtkWidget *on_ac_display_blank = NULL;
63
static GtkWidget *on_ac_dpms_sleep = NULL;
64
static GtkWidget *on_ac_dpms_off = NULL;
53
#define BRIGHTNESS_DISABLED 9
54
55
static GtkApplication *app = NULL;
56
static GtkBuilder *xml = NULL;
57
static GtkWidget *nt = NULL;
58
59
static GtkWidget *on_battery_display_blank = NULL;
60
static GtkWidget *on_battery_dpms_sleep = NULL;
61
static GtkWidget *on_battery_dpms_off = NULL;
62
static GtkWidget *on_ac_display_blank = NULL;
63
static GtkWidget *on_ac_dpms_sleep = NULL;
64
static GtkWidget *on_ac_dpms_off = NULL;
65
65
static GtkWidget *sideview = NULL; /* Sidebar tree view - all devices are in the sideview */
66
66
static GtkWidget *device_details_notebook = NULL; /* Displays the details of a deivce */
67
67
96
96
97
97
enum
98
98
{
99
COL_SIDEBAR_ICON,
100
COL_SIDEBAR_NAME,
101
COL_SIDEBAR_INT,
102
COL_SIDEBAR_BATTERY_DEVICE, /* Pointer to the UpDevice */
103
COL_SIDEBAR_OBJECT_PATH, /* UpDevice object path */
104
COL_SIDEBAR_SIGNAL_ID, /* device changed callback id */
105
COL_SIDEBAR_VIEW, /* Pointer to GtkTreeView of the devcie details */
106
NCOLS_SIDEBAR
99
COL_SIDEBAR_ICON,
100
COL_SIDEBAR_NAME,
101
COL_SIDEBAR_INT,
102
COL_SIDEBAR_BATTERY_DEVICE, /* Pointer to the UpDevice */
103
COL_SIDEBAR_OBJECT_PATH, /* UpDevice object path */
104
COL_SIDEBAR_SIGNAL_ID, /* device changed callback id */
105
COL_SIDEBAR_VIEW, /* Pointer to GtkTreeView of the devcie details */
106
NCOLS_SIDEBAR
107
107
};
108
108
109
109
enum
110
110
{
111
XFPM_DEVICE_INFO_NAME,
112
XFPM_DEVICE_INFO_VALUE,
113
XFPM_DEVICE_INFO_LAST
111
XFPM_DEVICE_INFO_NAME,
112
XFPM_DEVICE_INFO_VALUE,
113
XFPM_DEVICE_INFO_LAST
114
114
};
115
115
116
116
/*
117
117
* GtkBuilder callbacks
118
118
*/
119
void brightness_level_on_ac (GtkWidget *w,
120
XfconfChannel *channel);
121
122
void brightness_level_on_battery (GtkWidget *w,
123
XfconfChannel *channel);
124
125
void battery_critical_changed_cb (GtkWidget *w,
126
XfconfChannel *channel);
127
128
void inactivity_on_ac_value_changed_cb (GtkWidget *widget,
129
XfconfChannel *channel);
130
131
void inactivity_on_battery_value_changed_cb (GtkWidget *widget,
132
XfconfChannel *channel);
133
134
void button_sleep_changed_cb (GtkWidget *w,
135
XfconfChannel *channel);
136
137
void button_power_changed_cb (GtkWidget *w,
138
XfconfChannel *channel);
139
140
void button_hibernate_changed_cb (GtkWidget *w,
141
XfconfChannel *channel);
142
143
void button_battery_changed_cb (GtkWidget *w,
144
XfconfChannel *channel);
145
146
void on_sleep_mode_changed_cb (GtkWidget *w,
147
XfconfChannel *channel);
148
149
void dpms_toggled_cb (GtkWidget *w,
150
gboolean is_active,
151
XfconfChannel *channel);
152
153
void sleep_on_battery_value_changed_cb (GtkWidget *w,
154
XfconfChannel *channel);
155
156
void display_blank_on_battery_value_changed_cb (GtkWidget *w,
157
XfconfChannel *channel);
158
159
void off_on_battery_value_changed_cb (GtkWidget *w,
160
XfconfChannel *channel);
161
162
void display_blank_on_ac_value_changed_cb (GtkWidget *w,
163
XfconfChannel *channel);
164
165
void sleep_on_ac_value_changed_cb (GtkWidget *w,
166
XfconfChannel *channel);
167
168
void off_on_ac_value_changed_cb (GtkWidget *w,
169
XfconfChannel *channel);
170
171
gchar *format_dpms_value_cb (gint value);
172
173
gchar *format_inactivity_value_cb (gint value);
174
175
gchar *format_brightness_value_cb (gint value);
176
177
gchar *format_brightness_percentage_cb (gint value);
178
179
void brightness_on_battery_value_changed_cb (GtkWidget *w,
180
XfconfChannel *channel);
181
182
void brightness_on_ac_value_changed_cb (GtkWidget *w,
183
XfconfChannel *channel);
184
185
void on_battery_lid_changed_cb (GtkWidget *w,
186
XfconfChannel *channel);
187
188
void on_ac_lid_changed_cb (GtkWidget *w,
189
XfconfChannel *channel);
190
191
void critical_level_value_changed_cb (GtkSpinButton *w,
192
XfconfChannel *channel);
193
194
void lock_screen_toggled_cb (GtkWidget *w,
195
XfconfChannel *channel);
196
197
static void view_cursor_changed_cb (GtkTreeView *view,
198
gpointer *user_data);
199
void on_ac_sleep_mode_changed_cb (GtkWidget *w,
200
XfconfChannel *channel);
201
void on_battery_sleep_mode_changed_cb (GtkWidget *w,
202
XfconfChannel *channel);
203
119
void brightness_level_on_ac (GtkWidget *w,
120
XfconfChannel *channel);
121
void brightness_level_on_battery (GtkWidget *w,
122
XfconfChannel *channel);
123
void battery_critical_changed_cb (GtkWidget *w,
124
XfconfChannel *channel);
125
void inactivity_on_ac_value_changed_cb (GtkWidget *widget,
126
XfconfChannel *channel);
127
void inactivity_on_battery_value_changed_cb (GtkWidget *widget,
128
XfconfChannel *channel);
129
void button_sleep_changed_cb (GtkWidget *w,
130
XfconfChannel *channel);
131
void button_power_changed_cb (GtkWidget *w,
132
XfconfChannel *channel);
133
void button_hibernate_changed_cb (GtkWidget *w,
134
XfconfChannel *channel);
135
void button_battery_changed_cb (GtkWidget *w,
136
XfconfChannel *channel);
137
void on_sleep_mode_changed_cb (GtkWidget *w,
138
XfconfChannel *channel);
139
void dpms_toggled_cb (GtkWidget *w,
140
gboolean is_active,
141
XfconfChannel *channel);
142
void sleep_on_battery_value_changed_cb (GtkWidget *w,
143
XfconfChannel *channel);
144
void display_blank_on_battery_value_changed_cb (GtkWidget *w,
145
XfconfChannel *channel);
146
void off_on_battery_value_changed_cb (GtkWidget *w,
147
XfconfChannel *channel);
148
void display_blank_on_ac_value_changed_cb (GtkWidget *w,
149
XfconfChannel *channel);
150
void sleep_on_ac_value_changed_cb (GtkWidget *w,
151
XfconfChannel *channel);
152
void off_on_ac_value_changed_cb (GtkWidget *w,
153
XfconfChannel *channel);
154
gchar *format_dpms_value_cb (gint value);
155
gchar *format_inactivity_value_cb (gint value);
156
gchar *format_brightness_value_cb (gint value);
157
gchar *format_brightness_percentage_cb (gint value);
158
void brightness_on_battery_value_changed_cb (GtkWidget *w,
159
XfconfChannel *channel);
160
void brightness_on_ac_value_changed_cb (GtkWidget *w,
161
XfconfChannel *channel);
162
void on_battery_lid_changed_cb (GtkWidget *w,
163
XfconfChannel *channel);
164
void on_ac_lid_changed_cb (GtkWidget *w,
165
XfconfChannel *channel);
166
void critical_level_value_changed_cb (GtkSpinButton *w,
167
XfconfChannel *channel);
168
void lock_screen_toggled_cb (GtkWidget *w,
169
XfconfChannel *channel);
170
static void view_cursor_changed_cb (GtkTreeView *view,
171
gpointer *user_data);
172
void on_ac_sleep_mode_changed_cb (GtkWidget *w,
173
XfconfChannel *channel);
174
void on_battery_sleep_mode_changed_cb (GtkWidget *w,
175
XfconfChannel *channel);
204
176
/* Light Locker Integration */
205
gchar *format_light_locker_value_cb (gint value);
206
177
gchar *format_light_locker_value_cb (gint value);
207
178
void light_locker_late_locking_value_changed_cb (GtkWidget *w,
208
179
XfconfChannel *channel);
209
210
void light_locker_automatic_locking_changed_cb (GtkWidget *w,
211
XfconfChannel *channel);
212
213
void xfpm_update_logind_handle_lid_switch (XfconfChannel *channel);
180
void light_locker_automatic_locking_changed_cb (GtkWidget *w,
181
XfconfChannel *channel);
182
void xfpm_update_logind_handle_lid_switch (XfconfChannel *channel);
214
183
/* END Light Locker Integration */
215
184
216
185
static void
217
186
update_label (GtkWidget *label, GtkWidget *scale, gchar* (*format)(gint))
218
187
{
219
gint value = (gint) gtk_range_get_value (GTK_RANGE (scale));
188
gint value = (gint) gtk_range_get_value (GTK_RANGE (scale));
220
189
221
gchar *formatted_value = format (value);
222
gtk_label_set_text (GTK_LABEL (label), formatted_value);
223
g_free (formatted_value);
190
gchar *formatted_value = format (value);
191
gtk_label_set_text (GTK_LABEL (label), formatted_value);
192
g_free (formatted_value);
224
193
}
225
194
226
195
void brightness_level_on_ac (GtkWidget *w, XfconfChannel *channel)
227
196
{
228
guint val = (guint) gtk_range_get_value (GTK_RANGE (w));
229
230
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_AC, val) )
231
{
232
g_critical ("Unable to set value %u for property %s\n", val, BRIGHTNESS_LEVEL_ON_AC);
233
}
234
235
update_label (label_brightness_level_on_ac, w, format_brightness_percentage_cb);
197
guint val = (guint) gtk_range_get_value (GTK_RANGE (w));
198
199
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_AC, val) )
200
{
201
g_critical ("Unable to set value %u for property %s\n", val, BRIGHTNESS_LEVEL_ON_AC);
202
}
203
204
update_label (label_brightness_level_on_ac, w, format_brightness_percentage_cb);
236
205
}
237
206
238
207
void brightness_level_on_battery (GtkWidget *w, XfconfChannel *channel)
239
208
{
240
guint val = (guint) gtk_range_get_value (GTK_RANGE (w));
241
242
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_BATTERY, val) )
243
{
244
g_critical ("Unable to set value %u for property %s\n", val, BRIGHTNESS_LEVEL_ON_BATTERY);
245
}
246
247
update_label (label_brightness_level_on_battery, w, format_brightness_percentage_cb);
209
guint val = (guint) gtk_range_get_value (GTK_RANGE (w));
210
211
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_BATTERY, val) )
212
{
213
g_critical ("Unable to set value %u for property %s\n", val, BRIGHTNESS_LEVEL_ON_BATTERY);
214
}
215
216
update_label (label_brightness_level_on_battery, w, format_brightness_percentage_cb);
248
217
}
249
218
250
219
void
251
220
battery_critical_changed_cb (GtkWidget *w, XfconfChannel *channel)
252
221
{
253
GtkTreeModel *model;
254
GtkTreeIter selected_row;
255
gint value = 0;
256
257
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
258
return;
259
260
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
261
262
gtk_tree_model_get(model,
263
&selected_row,
264
1,
265
&value,
266
-1);
267
268
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_BATT_ACTION_CFG, value) )
269
{
270
g_critical ("Cannot set value for property %s\n", CRITICAL_BATT_ACTION_CFG);
271
}
222
GtkTreeModel *model;
223
GtkTreeIter selected_row;
224
gint value = 0;
225
226
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
227
return;
228
229
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
230
231
gtk_tree_model_get(model,
232
&selected_row,
233
1,
234
&value,
235
-1);
236
237
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_BATT_ACTION_CFG, value) )
238
{
239
g_critical ("Cannot set value for property %s\n", CRITICAL_BATT_ACTION_CFG);
240
}
272
241
}
273
242
274
243
void
275
244
inactivity_on_ac_value_changed_cb (GtkWidget *widget, XfconfChannel *channel)
276
245
{
277
gint value = (gint)gtk_range_get_value (GTK_RANGE (widget));
278
279
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_INACTIVITY_TIMEOUT, value))
280
{
281
g_critical ("Cannot set value for property %s\n", ON_AC_INACTIVITY_TIMEOUT);
282
}
283
284
update_label (label_inactivity_on_ac, widget, format_inactivity_value_cb);
246
gint value = (gint)gtk_range_get_value (GTK_RANGE (widget));
247
248
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_INACTIVITY_TIMEOUT, value))
249
{
250
g_critical ("Cannot set value for property %s\n", ON_AC_INACTIVITY_TIMEOUT);
251
}
252
253
update_label (label_inactivity_on_ac, widget, format_inactivity_value_cb);
285
254
}
286
255
287
256
void
288
257
inactivity_on_battery_value_changed_cb (GtkWidget *widget, XfconfChannel *channel)
289
258
{
290
gint value = (gint)gtk_range_get_value (GTK_RANGE (widget));
291
292
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_INACTIVITY_TIMEOUT, value))
293
{
294
g_critical ("Cannot set value for property %s\n", ON_BATTERY_INACTIVITY_TIMEOUT);
295
}
296
297
update_label (label_inactivity_on_battery, widget, format_inactivity_value_cb);
259
gint value = (gint)gtk_range_get_value (GTK_RANGE (widget));
260
261
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_INACTIVITY_TIMEOUT, value))
262
{
263
g_critical ("Cannot set value for property %s\n", ON_BATTERY_INACTIVITY_TIMEOUT);
264
}
265
266
update_label (label_inactivity_on_battery, widget, format_inactivity_value_cb);
298
267
}
299
268
300
269
void
301
270
button_sleep_changed_cb (GtkWidget *w, XfconfChannel *channel)
302
271
{
303
GtkTreeModel *model;
304
GtkTreeIter selected_row;
305
gint value = 0;
306
307
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
308
return;
309
310
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
311
312
gtk_tree_model_get(model,
313
&selected_row,
314
1,
315
&value,
316
-1);
317
318
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX SLEEP_SWITCH_CFG, value ) )
319
{
320
g_critical ("Cannot set value for property %s\n", SLEEP_SWITCH_CFG);
321
}
272
GtkTreeModel *model;
273
GtkTreeIter selected_row;
274
gint value = 0;
275
276
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
277
return;
278
279
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
280
281
gtk_tree_model_get(model,
282
&selected_row,
283
1,
284
&value,
285
-1);
286
287
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX SLEEP_SWITCH_CFG, value ) )
288
{
289
g_critical ("Cannot set value for property %s\n", SLEEP_SWITCH_CFG);
290
}
322
291
}
323
292
324
293
void
325
294
button_power_changed_cb (GtkWidget *w, XfconfChannel *channel)
326
295
{
327
GtkTreeModel *model;
328
GtkTreeIter selected_row;
329
gint value = 0;
330
331
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
332
return;
333
334
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
335
336
gtk_tree_model_get(model,
337
&selected_row,
338
1,
339
&value,
340
-1);
341
342
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX POWER_SWITCH_CFG, value) )
343
{
344
g_critical ("Cannot set value for property %s\n", POWER_SWITCH_CFG);
345
}
296
GtkTreeModel *model;
297
GtkTreeIter selected_row;
298
gint value = 0;
299
300
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
301
return;
302
303
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
304
305
gtk_tree_model_get(model,
306
&selected_row,
307
1,
308
&value,
309
-1);
310
311
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX POWER_SWITCH_CFG, value) )
312
{
313
g_critical ("Cannot set value for property %s\n", POWER_SWITCH_CFG);
314
}
346
315
}
347
316
348
317
void
349
318
button_hibernate_changed_cb (GtkWidget *w, XfconfChannel *channel)
350
319
{
351
GtkTreeModel *model;
352
GtkTreeIter selected_row;
353
gint value = 0;
354
355
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
356
return;
357
358
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
359
360
gtk_tree_model_get(model,
361
&selected_row,
362
1,
363
&value,
364
-1);
365
366
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX HIBERNATE_SWITCH_CFG, value ) )
367
{
368
g_critical ("Cannot set value for property %s\n", HIBERNATE_SWITCH_CFG);
369
}
320
GtkTreeModel *model;
321
GtkTreeIter selected_row;
322
gint value = 0;
323
324
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
325
return;
326
327
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
328
329
gtk_tree_model_get (model,
330
&selected_row,
331
1,
332
&value,
333
-1);
334
335
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX HIBERNATE_SWITCH_CFG, value ) )
336
{
337
g_critical ("Cannot set value for property %s\n", HIBERNATE_SWITCH_CFG);
338
}
370
339
}
371
340
372
341
void
373
342
button_battery_changed_cb (GtkWidget *w, XfconfChannel *channel)
374
343
{
375
GtkTreeModel *model;
376
GtkTreeIter selected_row;
377
gint value = 0;
378
379
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
380
return;
381
382
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
383
384
gtk_tree_model_get(model,
385
&selected_row,
386
1,
387
&value,
388
-1);
389
390
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BATTERY_SWITCH_CFG, value ) )
391
{
392
g_critical ("Cannot set value for property %s\n", BATTERY_SWITCH_CFG);
393
}
344
GtkTreeModel *model;
345
GtkTreeIter selected_row;
346
gint value = 0;
347
348
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
349
return;
350
351
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
352
353
gtk_tree_model_get (model,
354
&selected_row,
355
1,
356
&value,
357
-1);
358
359
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BATTERY_SWITCH_CFG, value ) )
360
{
361
g_critical ("Cannot set value for property %s\n", BATTERY_SWITCH_CFG);
362
}
394
363
}
395
364
396
365
void
397
366
on_ac_sleep_mode_changed_cb (GtkWidget *w, XfconfChannel *channel)
398
367
{
399
GtkTreeModel *model;
400
GtkTreeIter selected_row;
401
guint value = 0;
402
403
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
404
return;
405
406
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
407
408
gtk_tree_model_get(model,
409
&selected_row,
410
1,
411
&value,
412
-1);
413
414
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_AC, value) )
415
{
416
g_critical ("Cannot set value for property %s\n", INACTIVITY_SLEEP_MODE_ON_AC);
417
}
368
GtkTreeModel *model;
369
GtkTreeIter selected_row;
370
guint value = 0;
371
372
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
373
return;
374
375
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
376
377
gtk_tree_model_get(model,
378
&selected_row,
379
1,
380
&value,
381
-1);
382
383
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_AC, value) )
384
{
385
g_critical ("Cannot set value for property %s\n", INACTIVITY_SLEEP_MODE_ON_AC);
386
}
418
387
}
419
388
420
389
void
421
390
on_battery_sleep_mode_changed_cb (GtkWidget *w, XfconfChannel *channel)
422
391
{
423
GtkTreeModel *model;
424
GtkTreeIter selected_row;
425
guint value = 0;
426
427
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
428
return;
429
430
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
431
432
gtk_tree_model_get(model,
433
&selected_row,
434
1,
435
&value,
436
-1);
437
438
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_BATTERY, value) )
439
{
440
g_critical ("Cannot set value for property %s\n", INACTIVITY_SLEEP_MODE_ON_BATTERY);
441
}
392
GtkTreeModel *model;
393
GtkTreeIter selected_row;
394
guint value = 0;
395
396
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
397
return;
398
399
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
400
401
gtk_tree_model_get(model,
402
&selected_row,
403
1,
404
&value,
405
-1);
406
407
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_BATTERY, value) )
408
{
409
g_critical ("Cannot set value for property %s\n", INACTIVITY_SLEEP_MODE_ON_BATTERY);
410
}
442
411
}
443
412
444
413
void
445
414
dpms_toggled_cb (GtkWidget *w, gboolean is_active, XfconfChannel *channel)
446
415
{
447
xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, is_active);
448
449
gtk_widget_set_sensitive (on_ac_dpms_off, is_active);
450
gtk_widget_set_sensitive (on_ac_dpms_sleep, is_active);
451
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-label")), is_active);
452
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-label")), is_active);
453
454
if ( GTK_IS_WIDGET (on_battery_dpms_off ) )
455
{
456
gtk_widget_set_sensitive (on_battery_dpms_off, is_active);
457
gtk_widget_set_sensitive (on_battery_dpms_sleep, is_active);
458
}
416
xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, is_active);
417
418
gtk_widget_set_sensitive (on_ac_dpms_off, is_active);
419
gtk_widget_set_sensitive (on_ac_dpms_sleep, is_active);
420
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-label")), is_active);
421
gtk_widget_set_sensitive (GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-label")), is_active);
422
423
if ( GTK_IS_WIDGET (on_battery_dpms_off ) )
424
{
425
gtk_widget_set_sensitive (on_battery_dpms_off, is_active);
426
gtk_widget_set_sensitive (on_battery_dpms_sleep, is_active);
427
}
459
428
}
460
429
461
430
void
462
431
display_blank_on_battery_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
463
432
{
464
GtkWidget *brg;
465
gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_display_blank));
466
gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_sleep));
467
gint brightness_value;
468
469
if ( sleep_value != 0 )
470
{
471
if ( blank_value >= sleep_value )
472
{
473
gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), blank_value + 1 );
474
}
475
}
476
477
if ( lcd_brightness )
478
{
479
brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery"));
480
brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
481
482
if ( blank_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
483
{
484
gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
485
}
486
}
487
488
update_label (label_display_blank_on_battery, w, format_dpms_value_cb);
433
GtkWidget *brg;
434
gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_display_blank));
435
gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_sleep));
436
gint brightness_value;
437
438
if ( sleep_value != 0 )
439
{
440
if ( blank_value >= sleep_value )
441
{
442
gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), blank_value + 1 );
443
}
444
}
445
446
if ( lcd_brightness )
447
{
448
brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery"));
449
brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
450
451
if ( blank_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
452
{
453
gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
454
}
455
}
456
457
update_label (label_display_blank_on_battery, w, format_dpms_value_cb);
489
458
}
490
459
491
460
void
492
461
sleep_on_battery_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
493
462
{
494
GtkWidget *brg;
495
gint off_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_off));
496
gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (w));
497
gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_display_blank));
498
gint brightness_value;
499
500
if ( off_value != 0 )
501
{
502
if ( sleep_value >= off_value )
503
{
504
gtk_range_set_value (GTK_RANGE(on_battery_dpms_off), sleep_value + 1 );
505
}
506
}
507
508
if ( blank_value != 0 )
509
{
510
if ( blank_value >= sleep_value )
511
{
512
gtk_range_set_value (GTK_RANGE(on_battery_display_blank), sleep_value - 1 );
513
}
514
}
515
516
if ( lcd_brightness )
517
{
518
brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery"));
519
brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
520
521
if ( sleep_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
522
{
523
gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
524
}
525
}
526
527
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_SLEEP, sleep_value))
528
{
529
g_critical ("Cannot set value for property %s\n", ON_BATT_DPMS_SLEEP);
530
}
531
532
update_label (label_dpms_sleep_on_battery, w, format_dpms_value_cb);
463
GtkWidget *brg;
464
gint off_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_off));
465
gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (w));
466
gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_battery_display_blank));
467
gint brightness_value;
468
469
if ( off_value != 0 )
470
{
471
if ( sleep_value >= off_value )
472
{
473
gtk_range_set_value (GTK_RANGE(on_battery_dpms_off), sleep_value + 1 );
474
}
475
}
476
477
if ( blank_value != 0 )
478
{
479
if ( blank_value >= sleep_value )
480
{
481
gtk_range_set_value (GTK_RANGE(on_battery_display_blank), sleep_value - 1 );
482
}
483
}
484
485
if ( lcd_brightness )
486
{
487
brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery"));
488
brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
489
490
if ( sleep_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
491
{
492
gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
493
}
494
}
495
496
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_SLEEP, sleep_value))
497
{
498
g_critical ("Cannot set value for property %s\n", ON_BATT_DPMS_SLEEP);
499
}
500
501
update_label (label_dpms_sleep_on_battery, w, format_dpms_value_cb);
533
502
}
534
503
535
504
void
536
505
off_on_battery_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
537
506
{
538
gint off_value = (gint)gtk_range_get_value (GTK_RANGE(w));
539
gint sleep_value = (gint)gtk_range_get_value (GTK_RANGE(on_battery_dpms_sleep));
540
541
if ( sleep_value != 0 )
542
{
543
if ( off_value <= sleep_value )
544
{
545
gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), off_value -1 );
546
}
547
}
548
549
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_OFF, off_value))
550
{
551
g_critical ("Cannot set value for property %s\n", ON_BATT_DPMS_OFF);
552
}
553
554
update_label (label_dpms_off_on_battery, w, format_dpms_value_cb);
507
gint off_value = (gint)gtk_range_get_value (GTK_RANGE(w));
508
gint sleep_value = (gint)gtk_range_get_value (GTK_RANGE(on_battery_dpms_sleep));
509
510
if ( sleep_value != 0 )
511
{
512
if ( off_value <= sleep_value )
513
{
514
gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), off_value -1 );
515
}
516
}
517
518
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_OFF, off_value))
519
{
520
g_critical ("Cannot set value for property %s\n", ON_BATT_DPMS_OFF);
521
}
522
523
update_label (label_dpms_off_on_battery, w, format_dpms_value_cb);
555
524
}
556
525
557
526
void
558
527
display_blank_on_ac_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
559
528
{
560
GtkWidget *brg;
561
gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_ac_display_blank));
562
gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (on_ac_dpms_sleep));
563
gint brightness_value;
564
565
if ( sleep_value != 0 )
566
{
567
if ( blank_value >= sleep_value )
568
{
569
gtk_range_set_value (GTK_RANGE(on_ac_dpms_sleep), blank_value + 1 );
570
}
571
}
572
573
if ( lcd_brightness )
574
{
575
brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac"));
576
brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
577
578
if ( blank_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
579
{
580
gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
581
}
582
}
583
584
update_label (label_display_blank_on_ac, w, format_dpms_value_cb);
529
GtkWidget *brg;
530
gint blank_value = (gint) gtk_range_get_value (GTK_RANGE (on_ac_display_blank));
531
gint sleep_value = (gint) gtk_range_get_value (GTK_RANGE (on_ac_dpms_sleep));
532
gint brightness_value;
533
534
if ( sleep_value != 0 )
535
{
536
if ( blank_value >= sleep_value )
537
{
538
gtk_range_set_value (GTK_RANGE(on_ac_dpms_sleep), blank_value + 1 );
539
}
540
}
541
542
if ( lcd_brightness )
543
{
544
brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac"));
545
brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
546
547
if ( blank_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
548
{
549
gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
550
}
551
}
552
553
update_label (label_display_blank_on_ac, w, format_dpms_value_cb);
585
554
}
586
555
587
556
void
588
557
sleep_on_ac_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
589
558
{
590
GtkWidget *brg;
591
592
gint brightness_value;
593
gint off_value = (gint)gtk_range_get_value (GTK_RANGE (on_ac_dpms_off));
594
gint sleep_value = (gint)gtk_range_get_value (GTK_RANGE (w));
595
gint blank_value = (gint)gtk_range_get_value (GTK_RANGE (on_ac_display_blank));
596
597
if ( off_value > 60 || sleep_value > 60 )
598
return;
599
600
if ( off_value != 0 )
601
{
602
if ( sleep_value >= off_value )
603
{
604
gtk_range_set_value (GTK_RANGE(on_ac_dpms_off), sleep_value + 1 );
605
}
606
}
607
608
if ( blank_value != 0 )
609
{
610
if ( blank_value >= sleep_value )
611
{
612
gtk_range_set_value (GTK_RANGE(on_ac_display_blank), sleep_value - 1 );
613
}
614
}
615
616
if ( lcd_brightness )
617
{
618
brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac"));
619
620
brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
621
622
if ( sleep_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
623
{
624
gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
625
}
626
}
627
628
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_SLEEP, sleep_value))
629
{
630
g_critical ("Cannot set value for property %s\n", ON_AC_DPMS_SLEEP);
631
}
632
633
update_label (label_dpms_sleep_on_ac, w, format_dpms_value_cb);
559
GtkWidget *brg;
560
561
gint brightness_value;
562
gint off_value = (gint)gtk_range_get_value (GTK_RANGE (on_ac_dpms_off));
563
gint sleep_value = (gint)gtk_range_get_value (GTK_RANGE (w));
564
gint blank_value = (gint)gtk_range_get_value (GTK_RANGE (on_ac_display_blank));
565
566
if ( off_value > 60 || sleep_value > 60 )
567
return;
568
569
if ( off_value != 0 )
570
{
571
if ( sleep_value >= off_value )
572
{
573
gtk_range_set_value (GTK_RANGE(on_ac_dpms_off), sleep_value + 1 );
574
}
575
}
576
577
if ( blank_value != 0 )
578
{
579
if ( blank_value >= sleep_value )
580
{
581
gtk_range_set_value (GTK_RANGE(on_ac_display_blank), sleep_value - 1 );
582
}
583
}
584
585
if ( lcd_brightness )
586
{
587
brg = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac"));
588
589
brightness_value = (gint) gtk_range_get_value (GTK_RANGE (brg));
590
591
if ( sleep_value * 60 <= brightness_value && brightness_value != BRIGHTNESS_DISABLED)
592
{
593
gtk_range_set_value (GTK_RANGE (brg), BRIGHTNESS_DISABLED);
594
}
595
}
596
597
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_SLEEP, sleep_value))
598
{
599
g_critical ("Cannot set value for property %s\n", ON_AC_DPMS_SLEEP);
600
}
601
602
update_label (label_dpms_sleep_on_ac, w, format_dpms_value_cb);
634
603
}
635
604
636
605
void
637
606
off_on_ac_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
638
607
{
639
gint off_value = (gint)gtk_range_get_value (GTK_RANGE(w));
640
gint sleep_value = (gint)gtk_range_get_value (GTK_RANGE(on_ac_dpms_sleep));
641
642
if ( off_value > 60 || sleep_value > 60 )
643
return;
644
645
if ( sleep_value != 0 )
646
{
647
if ( off_value <= sleep_value )
648
{
649
gtk_range_set_value (GTK_RANGE(on_ac_dpms_sleep), off_value -1 );
650
}
651
}
652
653
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_OFF, off_value))
654
{
655
g_critical ("Cannot set value for property %s\n", ON_AC_DPMS_OFF);
656
}
657
658
update_label (label_dpms_off_on_ac, w, format_dpms_value_cb);
608
gint off_value = (gint)gtk_range_get_value (GTK_RANGE(w));
609
gint sleep_value = (gint)gtk_range_get_value (GTK_RANGE(on_ac_dpms_sleep));
610
611
if ( off_value > 60 || sleep_value > 60 )
612
return;
613
614
if ( sleep_value != 0 )
615
{
616
if ( off_value <= sleep_value )
617
{
618
gtk_range_set_value (GTK_RANGE(on_ac_dpms_sleep), off_value -1 );
619
}
620
}
621
622
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_OFF, off_value))
623
{
624
g_critical ("Cannot set value for property %s\n", ON_AC_DPMS_OFF);
625
}
626
627
update_label (label_dpms_off_on_ac, w, format_dpms_value_cb);
659
628
}
660
629
661
630
/*
664
633
gchar *
665
634
format_dpms_value_cb (gint value)
666
635
{
667
if ( value == 0 )
668
return g_strdup (_("Never"));
669
670
if ( value == 1 )
671
return g_strdup (_("One minute"));
672
636
if ( value == 0 )
637
return g_strdup (_("Never"));
638
639
if ( value == 1 )
640
return g_strdup (_("One minute"));
641
642
return g_strdup_printf ("%d %s", value, _("minutes"));
643
}
644
645
646
gchar *
647
format_inactivity_value_cb (gint value)
648
{
649
gint h, min;
650
651
if ( value <= 14 )
652
return g_strdup (_("Never"));
653
else if ( value < 60 )
673
654
return g_strdup_printf ("%d %s", value, _("minutes"));
674
}
675
676
677
gchar *
678
format_inactivity_value_cb (gint value)
679
{
680
gint h, min;
681
682
if ( value <= 14 )
683
return g_strdup (_("Never"));
684
else if ( value < 60 )
685
return g_strdup_printf ("%d %s", value, _("minutes"));
686
else if ( value == 60 )
687
return g_strdup (_("One hour"));
688
689
/* value > 60 */
690
h = value/60;
691
min = value%60;
692
693
if ( h <= 1 )
694
if ( min == 0 ) return g_strdup_printf ("%s", _("One hour"));
695
else if ( min == 1 ) return g_strdup_printf ("%s %s", _("One hour"), _("one minute"));
696
else return g_strdup_printf ("%s %d %s", _("One hour"), min, _("minutes"));
697
else
698
if ( min == 0 ) return g_strdup_printf ("%d %s", h, _("hours"));
699
else if ( min == 1 ) return g_strdup_printf ("%d %s %s", h, _("hours"), _("one minute"));
700
else return g_strdup_printf ("%d %s %d %s", h, _("hours"), min, _("minutes"));
655
else if ( value == 60 )
656
return g_strdup (_("One hour"));
657
658
/* value > 60 */
659
h = value/60;
660
min = value%60;
661
662
if ( h <= 1 )
663
if ( min == 0 ) return g_strdup_printf ("%s", _("One hour"));
664
else if ( min == 1 ) return g_strdup_printf ("%s %s", _("One hour"), _("one minute"));
665
else return g_strdup_printf ("%s %d %s", _("One hour"), min, _("minutes"));
666
else
667
if ( min == 0 ) return g_strdup_printf ("%d %s", h, _("hours"));
668
else if ( min == 1 ) return g_strdup_printf ("%d %s %s", h, _("hours"), _("one minute"));
669
else return g_strdup_printf ("%d %s %d %s", h, _("hours"), min, _("minutes"));
701
670
}
702
671
703
672
/*
706
675
gchar *
707
676
format_brightness_value_cb (gint value)
708
677
{
709
if ( value <= 9 )
710
return g_strdup (_("Never"));
678
if ( value <= 9 )
679
return g_strdup (_("Never"));
711
680
712
return g_strdup_printf ("%d %s", value, _("seconds"));
681
return g_strdup_printf ("%d %s", value, _("seconds"));
713
682
}
714
683
715
684
gchar *
716
685
format_brightness_percentage_cb (gint value)
717
686
{
718
return g_strdup_printf ("%d %s", value, _("%"));
687
return g_strdup_printf ("%d %s", value, _("%"));
719
688
}
720
689
721
690
void
722
691
brightness_on_battery_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
723
692
{
724
gint value = (gint)gtk_range_get_value (GTK_RANGE (w));
725
gint dpms_sleep = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_sleep) );
726
727
if ( value != BRIGHTNESS_DISABLED )
728
{
729
if ( dpms_sleep != 0 && dpms_sleep * 60 <= value)
730
{
731
gtk_range_set_value (GTK_RANGE (on_battery_dpms_sleep), (value / 60) + 1);
732
}
733
}
734
735
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_BATTERY, value))
736
{
737
g_critical ("Cannot set value for property %s\n", BRIGHTNESS_ON_BATTERY);
738
}
739
740
update_label (label_brightness_inactivity_on_battery, w, format_brightness_value_cb);
693
gint value = (gint)gtk_range_get_value (GTK_RANGE (w));
694
gint dpms_sleep = (gint) gtk_range_get_value (GTK_RANGE (on_battery_dpms_sleep) );
695
696
if ( value != BRIGHTNESS_DISABLED )
697
{
698
if ( dpms_sleep != 0 && dpms_sleep * 60 <= value)
699
{
700
gtk_range_set_value (GTK_RANGE (on_battery_dpms_sleep), (value / 60) + 1);
701
}
702
}
703
704
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_BATTERY, value))
705
{
706
g_critical ("Cannot set value for property %s\n", BRIGHTNESS_ON_BATTERY);
707
}
708
709
update_label (label_brightness_inactivity_on_battery, w, format_brightness_value_cb);
741
710
}
742
711
743
712
void
744
713
brightness_on_ac_value_changed_cb (GtkWidget *w, XfconfChannel *channel)
745
714
{
746
gint value = (gint)gtk_range_get_value (GTK_RANGE (w));
747
gint dpms_sleep = (gint) gtk_range_get_value (GTK_RANGE (on_ac_dpms_sleep) );
748
749
if ( value != BRIGHTNESS_DISABLED )
750
{
751
if ( dpms_sleep != 0 && dpms_sleep * 60 <= value)
752
{
753
gtk_range_set_value (GTK_RANGE (on_ac_dpms_sleep), (value / 60) + 1);
754
}
755
}
756
757
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_AC, value))
758
{
759
g_critical ("Cannot set value for property %s\n", BRIGHTNESS_ON_AC);
760
}
761
762
update_label (label_brightness_inactivity_on_ac, w, format_brightness_value_cb);
715
gint value = (gint)gtk_range_get_value (GTK_RANGE (w));
716
gint dpms_sleep = (gint) gtk_range_get_value (GTK_RANGE (on_ac_dpms_sleep) );
717
718
if ( value != BRIGHTNESS_DISABLED )
719
{
720
if ( dpms_sleep != 0 && dpms_sleep * 60 <= value)
721
{
722
gtk_range_set_value (GTK_RANGE (on_ac_dpms_sleep), (value / 60) + 1);
723
}
724
}
725
726
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_AC, value))
727
{
728
g_critical ("Cannot set value for property %s\n", BRIGHTNESS_ON_AC);
729
}
730
731
update_label (label_brightness_inactivity_on_ac, w, format_brightness_value_cb);
763
732
}
764
733
765
734
void
766
735
on_battery_lid_changed_cb (GtkWidget *w, XfconfChannel *channel)
767
736
{
768
GtkTreeModel *model;
769
GtkTreeIter selected_row;
770
gint value = 0;
771
772
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
773
return;
774
775
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
776
777
gtk_tree_model_get(model,
778
&selected_row,
779
1,
780
&value,
781
-1);
782
783
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, value) )
784
{
785
g_critical ("Cannot set value for property %s\n", LID_SWITCH_ON_BATTERY_CFG);
786
}
787
xfpm_update_logind_handle_lid_switch (channel);
737
GtkTreeModel *model;
738
GtkTreeIter selected_row;
739
gint value = 0;
740
741
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
742
return;
743
744
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
745
746
gtk_tree_model_get (model,
747
&selected_row,
748
1,
749
&value,
750
-1);
751
752
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, value) )
753
{
754
g_critical ("Cannot set value for property %s\n", LID_SWITCH_ON_BATTERY_CFG);
755
}
756
xfpm_update_logind_handle_lid_switch (channel);
788
757
}
789
758
790
759
void
791
760
on_ac_lid_changed_cb (GtkWidget *w, XfconfChannel *channel)
792
761
{
793
GtkTreeModel *model;
794
GtkTreeIter selected_row;
795
gint value = 0;
796
797
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
798
return;
799
800
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
801
802
gtk_tree_model_get(model,
803
&selected_row,
804
1,
805
&value,
806
-1);
807
808
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, value) )
809
{
810
g_critical ("Cannot set value for property %s\n", LID_SWITCH_ON_AC_CFG);
811
}
812
xfpm_update_logind_handle_lid_switch (channel);
762
GtkTreeModel *model;
763
GtkTreeIter selected_row;
764
gint value = 0;
765
766
if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (w), &selected_row))
767
return;
768
769
model = gtk_combo_box_get_model (GTK_COMBO_BOX(w));
770
771
gtk_tree_model_get (model,
772
&selected_row,
773
1,
774
&value,
775
-1);
776
777
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, value) )
778
{
779
g_critical ("Cannot set value for property %s\n", LID_SWITCH_ON_AC_CFG);
780
}
781
xfpm_update_logind_handle_lid_switch (channel);
813
782
}
814
783
815
784
void
816
785
critical_level_value_changed_cb (GtkSpinButton *w, XfconfChannel *channel)
817
786
{
818
guint val = (guint) gtk_spin_button_get_value (w);
787
guint val = (guint) gtk_spin_button_get_value (w);
819
788
820
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_POWER_LEVEL, val) )
821
{
822
g_critical ("Unable to set value %d for property %s\n", val, CRITICAL_POWER_LEVEL);
823
}
789
if (!xfconf_channel_set_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_POWER_LEVEL, val) )
790
{
791
g_critical ("Unable to set value %d for property %s\n", val, CRITICAL_POWER_LEVEL);
792
}
824
793
}
825
794
826
795
void
827
796
lock_screen_toggled_cb (GtkWidget *w, XfconfChannel *channel)
828
797
{
829
XfconfChannel *session_channel = xfconf_channel_get ("xfce4-session");
830
gboolean val = (gint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(w));
831
832
if ( !xfconf_channel_set_bool (session_channel, "/shutdown/LockScreen", val) )
833
{
834
g_critical ("Unable to set value for property %s\n", LOCK_SCREEN_ON_SLEEP);
835
}
836
837
if ( !xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, val) )
838
{
839
g_critical ("Unable to set value for property %s\n", LOCK_SCREEN_ON_SLEEP);
840
}
841
842
/* Light Locker Integration */
843
if ( light_locker_settings )
844
{
845
GVariant *variant;
846
variant = g_variant_new_boolean (val);
847
if (!g_settings_set_value (light_locker_settings, "lock-on-suspend", variant))
848
g_critical ("Cannot set value for property lock-on-suspend\n");
849
850
xfpm_update_logind_handle_lid_switch (channel);
851
}
852
/* END Light Locker Integration */
798
XfconfChannel *session_channel = xfconf_channel_get ("xfce4-session");
799
gboolean val = (gint) gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(w));
800
801
if ( !xfconf_channel_set_bool (session_channel, "/shutdown/LockScreen", val) )
802
{
803
g_critical ("Unable to set value for property %s\n", LOCK_SCREEN_ON_SLEEP);
804
}
805
806
if ( !xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, val) )
807
{
808
g_critical ("Unable to set value for property %s\n", LOCK_SCREEN_ON_SLEEP);
809
}
810
811
/* Light Locker Integration */
812
if ( light_locker_settings )
813
{
814
GVariant *variant;
815
variant = g_variant_new_boolean (val);
816
if (!g_settings_set_value (light_locker_settings, "lock-on-suspend", variant))
817
g_critical ("Cannot set value for property lock-on-suspend\n");
818
819
xfpm_update_logind_handle_lid_switch (channel);
820
}
821
/* END Light Locker Integration */
853
822
}
854
823
855
824
/* Light Locker Integration */
856
825
void
857
826
xfpm_update_logind_handle_lid_switch (XfconfChannel *channel)
858
827
{
859
gboolean lock_on_suspend = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
860
guint lid_switch_on_ac = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, LID_TRIGGER_LOCK_SCREEN);
861
guint lid_switch_on_battery = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, LID_TRIGGER_LOCK_SCREEN);
828
gboolean lock_on_suspend = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
829
guint lid_switch_on_ac = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, LID_TRIGGER_LOCK_SCREEN);
830
guint lid_switch_on_battery = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, LID_TRIGGER_LOCK_SCREEN);
862
831
863
// logind-handle-lid-switch = true when: lock_on_suspend == true and (lid_switch_on_ac == suspend or lid_switch_on_battery == suspend)
864
xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX LOGIND_HANDLE_LID_SWITCH, lock_on_suspend && (lid_switch_on_ac == 1 || lid_switch_on_battery == 1));
832
// logind-handle-lid-switch = true when: lock_on_suspend == true and (lid_switch_on_ac == suspend or lid_switch_on_battery == suspend)
833
xfconf_channel_set_bool (channel, XFPM_PROPERTIES_PREFIX LOGIND_HANDLE_LID_SWITCH, lock_on_suspend && (lid_switch_on_ac == 1 || lid_switch_on_battery == 1));
865
834
}
866
835
/* END Light Locker Integration */
867
836
871
840
gboolean can_hibernate, gboolean can_shutdown,
872
841
gboolean has_lcd_brightness, gboolean has_lid)
873
842
{
874
gboolean valid, handle_dpms;
875
gint list_value;
876
gint val;
877
GtkListStore *list_store;
878
GtkTreeIter iter;
879
GtkWidget *inact_timeout, *inact_action;
880
GtkWidget *battery_critical;
881
GtkWidget *lid;
882
GtkWidget *brg;
883
GtkWidget *brg_level;
884
885
/*
886
* Inactivity sleep mode on battery
887
*/
888
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
889
inact_action = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-mode-on-battery"));
890
gtk_combo_box_set_model (GTK_COMBO_BOX(inact_action), GTK_TREE_MODEL(list_store));
891
892
if ( can_suspend )
893
{
843
gboolean valid, handle_dpms;
844
gint list_value;
845
gint val;
846
GtkListStore *list_store;
847
GtkTreeIter iter;
848
GtkWidget *inact_timeout, *inact_action;
849
GtkWidget *battery_critical;
850
GtkWidget *lid;
851
GtkWidget *brg;
852
GtkWidget *brg_level;
853
854
/*
855
* Inactivity sleep mode on battery
856
*/
857
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
858
inact_action = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-mode-on-battery"));
859
gtk_combo_box_set_model (GTK_COMBO_BOX(inact_action), GTK_TREE_MODEL(list_store));
860
861
if ( can_suspend )
862
{
894
863
gtk_list_store_append (list_store, &iter);
895
864
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
896
}
897
else if ( !auth_suspend )
898
{
865
}
866
else if ( !auth_suspend )
867
{
899
868
gtk_widget_set_tooltip_text (inact_action, _("Suspend operation not permitted"));
900
}
901
else
902
{
869
}
870
else
871
{
903
872
gtk_widget_set_tooltip_text (inact_action, _("Suspend operation not supported"));
904
}
873
}
905
874
906
if ( can_hibernate )
907
{
875
if ( can_hibernate )
876
{
908
877
gtk_list_store_append (list_store, &iter);
909
878
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
910
}
911
else if ( !auth_hibernate )
912
{
879
}
880
else if ( !auth_hibernate )
881
{
913
882
gtk_widget_set_tooltip_text (inact_action, _("Hibernate operation not permitted"));
914
}
915
else
916
{
883
}
884
else
885
{
917
886
gtk_widget_set_tooltip_text (inact_action, _("Hibernate operation not supported"));
918
}
919
920
gtk_combo_box_set_active (GTK_COMBO_BOX (inact_action), 0);
921
922
val = xfconf_channel_get_uint (channel,
923
XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_BATTERY,
924
XFPM_DO_HIBERNATE);
925
926
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
927
valid;
928
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
929
{
930
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
931
1, &list_value, -1);
932
if ( val == list_value )
933
{
934
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (inact_action), &iter);
935
break;
936
}
937
}
938
939
/*
940
* Inactivity timeout on battery
941
*/
942
inact_timeout = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-battery"));
943
944
if ( !can_suspend && !can_hibernate )
945
{
887
}
888
889
gtk_combo_box_set_active (GTK_COMBO_BOX (inact_action), 0);
890
891
val = xfconf_channel_get_uint (channel,
892
XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_BATTERY,
893
XFPM_DO_HIBERNATE);
894
895
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
896
valid;
897
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
898
{
899
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
900
1, &list_value, -1);
901
if ( val == list_value )
902
{
903
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (inact_action), &iter);
904
break;
905
}
906
}
907
908
/*
909
* Inactivity timeout on battery
910
*/
911
inact_timeout = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-battery"));
912
913
if ( !can_suspend && !can_hibernate )
914
{
946
915
gtk_widget_set_sensitive (inact_timeout, FALSE);
947
916
gtk_widget_set_tooltip_text (inact_timeout, _("Hibernate and suspend operations not supported"));
948
}
949
else if ( !auth_suspend && !auth_hibernate )
950
{
917
}
918
else if ( !auth_suspend && !auth_hibernate )
919
{
951
920
gtk_widget_set_sensitive (inact_timeout, FALSE);
952
921
gtk_widget_set_tooltip_text (inact_timeout, _("Hibernate and suspend operations not permitted"));
922
}
923
924
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_INACTIVITY_TIMEOUT, 14);
925
gtk_range_set_value (GTK_RANGE (inact_timeout), val);
926
927
928
/*
929
* Battery critical
930
*/
931
battery_critical = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-action-combo"));
932
933
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
934
935
gtk_combo_box_set_model (GTK_COMBO_BOX(battery_critical), GTK_TREE_MODEL(list_store));
936
937
gtk_list_store_append(list_store, &iter);
938
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
939
940
if ( can_suspend && auth_suspend )
941
{
942
gtk_list_store_append(list_store, &iter);
943
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
944
}
945
946
if ( can_hibernate && auth_hibernate )
947
{
948
gtk_list_store_append(list_store, &iter);
949
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
950
}
951
952
if ( can_shutdown )
953
{
954
gtk_list_store_append(list_store, &iter);
955
gtk_list_store_set (list_store, &iter, 0, _("Shutdown"), 1, XFPM_DO_SHUTDOWN, -1);
956
}
957
958
gtk_list_store_append(list_store, &iter);
959
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
960
961
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_BATT_ACTION_CFG, XFPM_DO_NOTHING);
962
963
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
964
valid;
965
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
966
{
967
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
968
1, &list_value, -1);
969
if ( val == list_value )
970
{
971
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (battery_critical), &iter);
972
break;
953
973
}
954
955
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_INACTIVITY_TIMEOUT, 14);
956
gtk_range_set_value (GTK_RANGE (inact_timeout), val);
957
958
959
/*
960
* Battery critical
961
*/
962
battery_critical = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-action-combo"));
963
974
}
975
976
/*
977
* DPMS settings when running on battery power
978
*/
979
handle_dpms = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
980
981
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_SLEEP, 5);
982
gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), val);
983
gtk_widget_set_sensitive (on_battery_dpms_sleep, handle_dpms);
984
985
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_OFF, 10);
986
gtk_range_set_value (GTK_RANGE(on_battery_dpms_off), val);
987
gtk_widget_set_sensitive (on_battery_dpms_off, handle_dpms);
988
989
/*
990
* Lid switch settings on battery
991
*/
992
lid = GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-battery-combo"));
993
if ( has_lid )
994
{
964
995
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
965
996
966
gtk_combo_box_set_model (GTK_COMBO_BOX(battery_critical), GTK_TREE_MODEL(list_store));
997
gtk_combo_box_set_model (GTK_COMBO_BOX(lid), GTK_TREE_MODEL(list_store));
967
998
968
gtk_list_store_append(list_store, &iter);
969
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
999
gtk_list_store_append (list_store, &iter);
1000
gtk_list_store_set (list_store, &iter, 0, _("Switch off display"), 1, LID_TRIGGER_NOTHING, -1);
970
1001
971
1002
if ( can_suspend && auth_suspend )
972
1003
{
973
gtk_list_store_append(list_store, &iter);
974
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
975
}
976
977
if ( can_hibernate && auth_hibernate )
978
{
979
gtk_list_store_append(list_store, &iter);
980
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
981
}
982
983
if ( can_shutdown )
984
{
985
gtk_list_store_append(list_store, &iter);
986
gtk_list_store_set (list_store, &iter, 0, _("Shutdown"), 1, XFPM_DO_SHUTDOWN, -1);
1004
gtk_list_store_append(list_store, &iter);
1005
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, LID_TRIGGER_SUSPEND, -1);
1006
}
1007
1008
if ( can_hibernate && auth_hibernate)
1009
{
1010
gtk_list_store_append(list_store, &iter);
1011
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, LID_TRIGGER_HIBERNATE, -1);
987
1012
}
988
1013
989
1014
gtk_list_store_append(list_store, &iter);
990
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
991
992
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_BATT_ACTION_CFG, XFPM_DO_NOTHING);
1015
gtk_list_store_set (list_store, &iter, 0, _("Lock screen"), 1, LID_TRIGGER_LOCK_SCREEN, -1);
1016
1017
gtk_combo_box_set_active (GTK_COMBO_BOX (lid), 0);
1018
1019
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, LID_TRIGGER_LOCK_SCREEN);
993
1020
994
1021
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
995
valid;
996
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
997
{
998
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
999
1, &list_value, -1);
1000
if ( val == list_value )
1001
{
1002
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (battery_critical), &iter);
1003
break;
1004
}
1005
}
1006
1007
/*
1008
* DPMS settings when running on battery power
1009
*/
1010
handle_dpms = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
1011
1012
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_SLEEP, 5);
1013
gtk_range_set_value (GTK_RANGE(on_battery_dpms_sleep), val);
1014
gtk_widget_set_sensitive (on_battery_dpms_sleep, handle_dpms);
1015
1016
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATT_DPMS_OFF, 10);
1017
gtk_range_set_value (GTK_RANGE(on_battery_dpms_off), val);
1018
gtk_widget_set_sensitive (on_battery_dpms_off, handle_dpms);
1019
1020
/*
1021
* Lid switch settings on battery
1022
*/
1023
lid = GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-battery-combo"));
1024
if ( has_lid )
1025
{
1026
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1027
1028
gtk_combo_box_set_model (GTK_COMBO_BOX(lid), GTK_TREE_MODEL(list_store));
1029
1030
gtk_list_store_append(list_store, &iter);
1031
gtk_list_store_set (list_store, &iter, 0, _("Switch off display"), 1, LID_TRIGGER_NOTHING, -1);
1032
1033
if ( can_suspend && auth_suspend )
1034
{
1035
gtk_list_store_append(list_store, &iter);
1036
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, LID_TRIGGER_SUSPEND, -1);
1037
}
1038
1039
if ( can_hibernate && auth_hibernate)
1040
{
1041
gtk_list_store_append(list_store, &iter);
1042
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, LID_TRIGGER_HIBERNATE, -1);
1043
}
1044
1045
gtk_list_store_append(list_store, &iter);
1046
gtk_list_store_set (list_store, &iter, 0, _("Lock screen"), 1, LID_TRIGGER_LOCK_SCREEN, -1);
1047
1048
gtk_combo_box_set_active (GTK_COMBO_BOX (lid), 0);
1049
1050
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_BATTERY_CFG, LID_TRIGGER_LOCK_SCREEN);
1051
1052
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1053
valid;
1054
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1055
{
1056
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1057
1, &list_value, -1);
1058
if ( val == list_value )
1059
{
1060
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (lid), &iter);
1061
break;
1062
}
1063
}
1064
}
1065
else
1066
{
1067
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-action-label")));
1068
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-battery-header")));
1069
gtk_widget_hide (lid);
1070
}
1071
1072
/*
1073
* Brightness on battery
1074
*/
1075
brg = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-inactivity-on-battery"));
1076
brg_level = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-level-on-battery"));
1077
if ( has_lcd_brightness )
1078
{
1022
valid;
1023
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1024
{
1025
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1026
1, &list_value, -1);
1027
if ( val == list_value )
1028
{
1029
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (lid), &iter);
1030
break;
1031
}
1032
}
1033
}
1034
else
1035
{
1036
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-action-label")));
1037
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-battery-header")));
1038
gtk_widget_hide (lid);
1039
}
1040
1041
/*
1042
* Brightness on battery
1043
*/
1044
brg = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-inactivity-on-battery"));
1045
brg_level = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-level-on-battery"));
1046
if ( has_lcd_brightness )
1047
{
1079
1048
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_BATTERY, 120);
1080
1049
gtk_range_set_value (GTK_RANGE(brg), val);
1081
1050
1082
1051
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_BATTERY, 20);
1083
1052
gtk_range_set_value (GTK_RANGE (brg_level), val);
1084
}
1085
else
1086
{
1053
}
1054
else
1055
{
1087
1056
gtk_widget_hide (brg);
1088
1057
gtk_widget_hide (brg_level);
1089
}
1090
1091
label_inactivity_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-battery-label"));
1092
label_display_blank_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-battery-label"));
1093
label_dpms_sleep_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-battery-label"));
1094
label_dpms_off_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-battery-label"));
1095
label_brightness_level_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-level-on-battery-label"));
1096
label_brightness_inactivity_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery-label"));
1097
1098
update_label (label_inactivity_on_battery, inact_timeout, format_inactivity_value_cb);
1099
update_label (label_display_blank_on_battery, on_battery_display_blank, format_dpms_value_cb);
1100
update_label (label_dpms_sleep_on_battery, on_battery_dpms_sleep, format_dpms_value_cb);
1101
update_label (label_dpms_off_on_battery, on_battery_dpms_off, format_dpms_value_cb);
1102
update_label (label_brightness_level_on_battery, brg_level, format_brightness_percentage_cb);
1103
update_label (label_brightness_inactivity_on_battery, brg, format_brightness_value_cb);
1058
}
1059
1060
label_inactivity_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-battery-label"));
1061
label_display_blank_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-battery-label"));
1062
label_dpms_sleep_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-battery-label"));
1063
label_dpms_off_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-battery-label"));
1064
label_brightness_level_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-level-on-battery-label"));
1065
label_brightness_inactivity_on_battery = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-battery-label"));
1066
1067
update_label (label_inactivity_on_battery, inact_timeout, format_inactivity_value_cb);
1068
update_label (label_display_blank_on_battery, on_battery_display_blank, format_dpms_value_cb);
1069
update_label (label_dpms_sleep_on_battery, on_battery_dpms_sleep, format_dpms_value_cb);
1070
update_label (label_dpms_off_on_battery, on_battery_dpms_off, format_dpms_value_cb);
1071
update_label (label_brightness_level_on_battery, brg_level, format_brightness_percentage_cb);
1072
update_label (label_brightness_inactivity_on_battery, brg, format_brightness_value_cb);
1104
1073
}
1105
1074
1106
1075
static void
1109
1078
gboolean can_hibernate, gboolean has_lcd_brightness,
1110
1079
gboolean has_lid)
1111
1080
{
1112
gboolean valid, handle_dpms;
1113
GtkWidget *inact_timeout, *inact_action;
1114
GtkWidget *lid;
1115
GtkWidget *brg;
1116
GtkWidget *brg_level;
1117
GtkListStore *list_store;
1118
GtkTreeIter iter;
1119
guint val;
1120
guint list_value;
1121
1122
/*
1123
* Inactivity sleep mode on AC
1124
*/
1125
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1126
inact_action = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-mode-on-ac"));
1127
gtk_combo_box_set_model (GTK_COMBO_BOX(inact_action), GTK_TREE_MODEL(list_store));
1128
1129
if ( can_suspend )
1130
{
1081
gboolean valid, handle_dpms;
1082
GtkWidget *inact_timeout, *inact_action;
1083
GtkWidget *lid;
1084
GtkWidget *brg;
1085
GtkWidget *brg_level;
1086
GtkListStore *list_store;
1087
GtkTreeIter iter;
1088
guint val;
1089
guint list_value;
1090
1091
/*
1092
* Inactivity sleep mode on AC
1093
*/
1094
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1095
inact_action = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-mode-on-ac"));
1096
gtk_combo_box_set_model (GTK_COMBO_BOX(inact_action), GTK_TREE_MODEL(list_store));
1097
1098
if ( can_suspend )
1099
{
1131
1100
gtk_list_store_append (list_store, &iter);
1132
1101
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
1133
}
1134
else if ( !auth_suspend )
1135
{
1102
}
1103
else if ( !auth_suspend )
1104
{
1136
1105
gtk_widget_set_tooltip_text (inact_action, _("Suspend operation not permitted"));
1137
}
1138
else
1139
{
1106
}
1107
else
1108
{
1140
1109
gtk_widget_set_tooltip_text (inact_action, _("Suspend operation not supported"));
1141
}
1110
}
1142
1111
1143
if ( can_hibernate )
1144
{
1112
if ( can_hibernate )
1113
{
1145
1114
gtk_list_store_append (list_store, &iter);
1146
1115
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
1147
}
1148
else if ( !auth_hibernate )
1149
{
1116
}
1117
else if ( !auth_hibernate )
1118
{
1150
1119
gtk_widget_set_tooltip_text (inact_action, _("Hibernate operation not permitted"));
1151
}
1152
else
1153
{
1120
}
1121
else
1122
{
1154
1123
gtk_widget_set_tooltip_text (inact_action, _("Hibernate operation not supported"));
1155
}
1156
1157
gtk_combo_box_set_active (GTK_COMBO_BOX (inact_action), 0);
1158
1159
val = xfconf_channel_get_uint (channel,
1160
XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_AC,
1161
XFPM_DO_SUSPEND);
1162
1163
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1164
valid;
1165
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1166
{
1167
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1168
1, &list_value, -1);
1169
if ( val == list_value )
1170
{
1171
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (inact_action), &iter);
1172
break;
1173
}
1174
}
1175
1176
/*
1177
* Inactivity timeout on AC
1178
*/
1179
inact_timeout = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-ac"));
1180
1181
if ( !can_suspend && !can_hibernate )
1182
{
1124
}
1125
1126
gtk_combo_box_set_active (GTK_COMBO_BOX (inact_action), 0);
1127
1128
val = xfconf_channel_get_uint (channel,
1129
XFPM_PROPERTIES_PREFIX INACTIVITY_SLEEP_MODE_ON_AC,
1130
XFPM_DO_SUSPEND);
1131
1132
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1133
valid;
1134
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1135
{
1136
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1137
1, &list_value, -1);
1138
if ( val == list_value )
1139
{
1140
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (inact_action), &iter);
1141
break;
1142
}
1143
}
1144
1145
/*
1146
* Inactivity timeout on AC
1147
*/
1148
inact_timeout = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-ac"));
1149
1150
if ( !can_suspend && !can_hibernate )
1151
{
1183
1152
gtk_widget_set_sensitive (inact_timeout, FALSE);
1184
1153
gtk_widget_set_tooltip_text (inact_timeout, _("Hibernate and suspend operations not supported"));
1185
}
1186
else if ( !auth_suspend && !auth_hibernate )
1187
{
1154
}
1155
else if ( !auth_suspend && !auth_hibernate )
1156
{
1188
1157
gtk_widget_set_sensitive (inact_timeout, FALSE);
1189
1158
gtk_widget_set_tooltip_text (inact_timeout, _("Hibernate and suspend operations not permitted"));
1190
}
1191
1192
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_INACTIVITY_TIMEOUT, 14);
1193
gtk_range_set_value (GTK_RANGE (inact_timeout), val);
1194
1195
/*
1196
* DPMS settings when running on AC power
1197
*/
1198
handle_dpms = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
1199
1200
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_SLEEP, 10);
1201
gtk_range_set_value (GTK_RANGE (on_ac_dpms_sleep), val);
1202
gtk_widget_set_sensitive (on_ac_dpms_sleep, handle_dpms);
1203
1204
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_OFF, 15);
1205
gtk_range_set_value (GTK_RANGE(on_ac_dpms_off), val);
1206
gtk_widget_set_sensitive (on_ac_dpms_off, handle_dpms);
1207
1208
/*
1209
* Lid switch settings on AC power
1210
*/
1211
lid = GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-ac-combo"));
1212
if ( has_lid )
1213
{
1214
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1215
1216
gtk_combo_box_set_model (GTK_COMBO_BOX(lid), GTK_TREE_MODEL(list_store));
1217
1218
gtk_list_store_append(list_store, &iter);
1219
gtk_list_store_set (list_store, &iter, 0, _("Switch off display"), 1, LID_TRIGGER_NOTHING, -1);
1220
1221
if ( can_suspend && auth_suspend )
1222
{
1223
gtk_list_store_append(list_store, &iter);
1224
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, LID_TRIGGER_SUSPEND, -1);
1225
}
1226
1227
if ( can_hibernate && auth_hibernate )
1228
{
1229
gtk_list_store_append(list_store, &iter);
1230
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, LID_TRIGGER_HIBERNATE, -1);
1231
}
1232
1233
gtk_list_store_append(list_store, &iter);
1234
gtk_list_store_set (list_store, &iter, 0, _("Lock screen"), 1, LID_TRIGGER_LOCK_SCREEN, -1);
1235
1236
gtk_combo_box_set_active (GTK_COMBO_BOX (lid), 0);
1237
1238
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, LID_TRIGGER_LOCK_SCREEN);
1239
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1240
valid;
1241
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1242
{
1243
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1244
1, &list_value, -1);
1245
if ( val == list_value )
1246
{
1247
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (lid), &iter);
1248
break;
1249
}
1250
}
1251
}
1252
else
1253
{
1254
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-action-label1")));
1255
gtk_widget_hide (lid);
1256
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-plugged-in-header")));
1257
}
1258
1259
/*
1260
* Brightness on AC power
1261
*/
1262
brg = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-inactivity-on-ac"));
1263
brg_level = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-level-on-ac"));
1264
if ( has_lcd_brightness )
1265
{
1266
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_AC, 9);
1267
gtk_range_set_value (GTK_RANGE(brg), val);
1268
1269
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_AC, 80);
1270
gtk_range_set_value (GTK_RANGE (brg_level), val);
1271
1272
}
1273
else
1274
{
1275
gtk_widget_hide (brg);
1276
gtk_widget_hide (brg_level);
1277
}
1278
1279
label_inactivity_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-ac-label"));
1280
label_display_blank_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-ac-label"));
1281
label_dpms_sleep_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-ac-label"));
1282
label_dpms_off_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-ac-label"));
1283
label_brightness_level_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-level-on-ac-label"));
1284
label_brightness_inactivity_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac-label"));
1285
1286
update_label (label_inactivity_on_ac, inact_timeout, format_inactivity_value_cb);
1287
update_label (label_display_blank_on_ac, on_ac_display_blank, format_dpms_value_cb);
1288
update_label (label_dpms_sleep_on_ac, on_ac_dpms_sleep, format_dpms_value_cb);
1289
update_label (label_dpms_off_on_ac, on_ac_dpms_off, format_dpms_value_cb);
1290
update_label (label_brightness_level_on_ac, brg_level, format_brightness_percentage_cb);
1291
update_label (label_brightness_inactivity_on_ac, brg, format_brightness_value_cb);
1159
}
1160
1161
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_INACTIVITY_TIMEOUT, 14);
1162
gtk_range_set_value (GTK_RANGE (inact_timeout), val);
1163
1164
/*
1165
* DPMS settings when running on AC power
1166
*/
1167
handle_dpms = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
1168
1169
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_SLEEP, 10);
1170
gtk_range_set_value (GTK_RANGE (on_ac_dpms_sleep), val);
1171
gtk_widget_set_sensitive (on_ac_dpms_sleep, handle_dpms);
1172
1173
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_AC_DPMS_OFF, 15);
1174
gtk_range_set_value (GTK_RANGE(on_ac_dpms_off), val);
1175
gtk_widget_set_sensitive (on_ac_dpms_off, handle_dpms);
1176
1177
/*
1178
* Lid switch settings on AC power
1179
*/
1180
lid = GTK_WIDGET (gtk_builder_get_object (xml, "lid-on-ac-combo"));
1181
if ( has_lid )
1182
{
1183
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1184
1185
gtk_combo_box_set_model (GTK_COMBO_BOX(lid), GTK_TREE_MODEL(list_store));
1186
1187
gtk_list_store_append (list_store, &iter);
1188
gtk_list_store_set (list_store, &iter, 0, _("Switch off display"), 1, LID_TRIGGER_NOTHING, -1);
1189
1190
if ( can_suspend && auth_suspend )
1191
{
1192
gtk_list_store_append(list_store, &iter);
1193
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, LID_TRIGGER_SUSPEND, -1);
1194
}
1195
1196
if ( can_hibernate && auth_hibernate )
1197
{
1198
gtk_list_store_append(list_store, &iter);
1199
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, LID_TRIGGER_HIBERNATE, -1);
1200
}
1201
1202
gtk_list_store_append(list_store, &iter);
1203
gtk_list_store_set (list_store, &iter, 0, _("Lock screen"), 1, LID_TRIGGER_LOCK_SCREEN, -1);
1204
1205
gtk_combo_box_set_active (GTK_COMBO_BOX (lid), 0);
1206
1207
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX LID_SWITCH_ON_AC_CFG, LID_TRIGGER_LOCK_SCREEN);
1208
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1209
valid;
1210
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1211
{
1212
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1213
1, &list_value, -1);
1214
if ( val == list_value )
1215
{
1216
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (lid), &iter);
1217
break;
1218
}
1219
}
1220
}
1221
else
1222
{
1223
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-action-label1")));
1224
gtk_widget_hide (lid);
1225
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml, "lid-plugged-in-header")));
1226
}
1227
1228
/*
1229
* Brightness on AC power
1230
*/
1231
brg = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-inactivity-on-ac"));
1232
brg_level = GTK_WIDGET (gtk_builder_get_object (xml ,"brightness-level-on-ac"));
1233
if ( has_lcd_brightness )
1234
{
1235
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_ON_AC, 9);
1236
gtk_range_set_value (GTK_RANGE(brg), val);
1237
1238
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BRIGHTNESS_LEVEL_ON_AC, 80);
1239
gtk_range_set_value (GTK_RANGE (brg_level), val);
1240
}
1241
else
1242
{
1243
gtk_widget_hide (brg);
1244
gtk_widget_hide (brg_level);
1245
}
1246
1247
label_inactivity_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "system-sleep-inactivity-on-ac-label"));
1248
label_display_blank_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-ac-label"));
1249
label_dpms_sleep_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-ac-label"));
1250
label_dpms_off_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-ac-label"));
1251
label_brightness_level_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-level-on-ac-label"));
1252
label_brightness_inactivity_on_ac = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-inactivity-on-ac-label"));
1253
1254
update_label (label_inactivity_on_ac, inact_timeout, format_inactivity_value_cb);
1255
update_label (label_display_blank_on_ac, on_ac_display_blank, format_dpms_value_cb);
1256
update_label (label_dpms_sleep_on_ac, on_ac_dpms_sleep, format_dpms_value_cb);
1257
update_label (label_dpms_off_on_ac, on_ac_dpms_off, format_dpms_value_cb);
1258
update_label (label_brightness_level_on_ac, brg_level, format_brightness_percentage_cb);
1259
update_label (label_brightness_inactivity_on_ac, brg, format_brightness_value_cb);
1292
1260
}
1293
1261
1294
1262
static void
1298
1266
gboolean has_sleep_button, gboolean has_hibernate_button,
1299
1267
gboolean has_power_button, gboolean has_battery_button)
1300
1268
{
1301
GtkWidget *power;
1302
GtkWidget *power_label;
1303
GtkWidget *hibernate;
1304
GtkWidget *hibernate_label;
1305
GtkWidget *sleep_w;
1306
GtkWidget *sleep_label;
1307
GtkWidget *battery_w;
1308
GtkWidget *battery_label;
1309
GtkWidget *dpms;
1310
1311
guint value;
1312
guint list_value;
1313
gboolean valid;
1314
gboolean val;
1315
1316
GtkListStore *list_store;
1317
GtkTreeIter iter;
1318
1319
dpms = GTK_WIDGET (gtk_builder_get_object (xml, "handle-dpms"));
1320
1321
/*
1322
* Global dpms settings (enable/disable)
1323
*/
1324
val = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
1325
gtk_switch_set_state (GTK_SWITCH (dpms), val);
1326
1327
/*
1328
* Power button
1329
*/
1330
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1331
power = GTK_WIDGET (gtk_builder_get_object (xml, "button-power-combo"));
1332
power_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-power-label"));
1333
1334
if ( has_power_button )
1335
{
1336
gtk_combo_box_set_model (GTK_COMBO_BOX(power), GTK_TREE_MODEL(list_store));
1337
1338
gtk_list_store_append (list_store, &iter);
1339
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
1340
1341
if ( can_suspend && auth_suspend)
1342
{
1343
gtk_list_store_append (list_store, &iter);
1344
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
1345
}
1346
1347
if ( can_hibernate && auth_hibernate )
1348
{
1349
gtk_list_store_append (list_store, &iter);
1350
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
1351
}
1352
1353
if ( can_shutdown )
1354
{
1355
gtk_list_store_append (list_store, &iter);
1356
gtk_list_store_set (list_store, &iter, 0, _("Shutdown"), 1, XFPM_DO_SHUTDOWN, -1);
1357
}
1358
1359
gtk_list_store_append (list_store, &iter);
1360
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
1361
1362
gtk_combo_box_set_active (GTK_COMBO_BOX (power), 0);
1363
1364
value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX POWER_SWITCH_CFG, XFPM_DO_NOTHING);
1365
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1366
valid;
1367
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1368
{
1369
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1370
1, &list_value, -1);
1371
if ( value == list_value )
1372
{
1373
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (power), &iter);
1374
break;
1375
}
1376
}
1377
}
1378
else
1379
{
1380
gtk_widget_hide (power);
1381
gtk_widget_hide (power_label);
1382
}
1383
1384
/*
1385
* Hibernate button
1386
*/
1387
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1388
hibernate = GTK_WIDGET (gtk_builder_get_object (xml, "button-hibernate-combo"));
1389
hibernate_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-hibernate-label"));
1390
1391
if (has_hibernate_button )
1392
{
1393
gtk_combo_box_set_model (GTK_COMBO_BOX(hibernate), GTK_TREE_MODEL(list_store));
1394
1395
gtk_list_store_append (list_store, &iter);
1396
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
1397
1398
if ( can_suspend && auth_suspend)
1399
{
1400
gtk_list_store_append (list_store, &iter);
1401
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
1402
}
1403
1404
if ( can_hibernate && auth_hibernate )
1405
{
1406
gtk_list_store_append (list_store, &iter);
1407
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
1408
}
1409
1410
gtk_list_store_append (list_store, &iter);
1411
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
1412
1413
value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX HIBERNATE_SWITCH_CFG, XFPM_DO_NOTHING);
1414
1415
gtk_combo_box_set_active (GTK_COMBO_BOX (hibernate), 0);
1416
1417
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1418
valid;
1419
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1420
{
1421
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1422
1, &list_value, -1);
1423
if ( value == list_value )
1424
{
1425
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (hibernate), &iter);
1426
break;
1427
}
1428
}
1429
}
1430
else
1431
{
1432
gtk_widget_hide (hibernate);
1433
gtk_widget_hide (hibernate_label);
1434
}
1435
1436
/*
1437
* Sleep button
1438
*/
1439
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1440
sleep_w = GTK_WIDGET (gtk_builder_get_object (xml, "button-sleep-combo"));
1441
sleep_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-sleep-label"));
1442
1443
if ( has_sleep_button )
1444
{
1445
gtk_combo_box_set_model (GTK_COMBO_BOX(sleep_w), GTK_TREE_MODEL(list_store));
1446
1447
gtk_list_store_append (list_store, &iter);
1448
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
1449
1450
if ( can_suspend && auth_suspend )
1451
{
1452
gtk_list_store_append (list_store, &iter);
1453
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
1454
}
1455
1456
if ( can_hibernate && auth_hibernate)
1457
{
1458
gtk_list_store_append (list_store, &iter);
1459
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
1460
}
1461
1462
gtk_list_store_append (list_store, &iter);
1463
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
1464
1465
gtk_combo_box_set_active (GTK_COMBO_BOX (sleep_w), 0);
1466
1467
value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX SLEEP_SWITCH_CFG, XFPM_DO_NOTHING);
1468
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1469
valid;
1470
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1471
{
1472
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1473
1, &list_value, -1);
1474
if ( value == list_value )
1475
{
1476
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (sleep_w), &iter);
1477
break;
1478
}
1479
}
1480
}
1481
else
1482
{
1483
gtk_widget_hide (sleep_w);
1484
gtk_widget_hide (sleep_label);
1485
}
1486
1487
/*
1488
* Battery button
1489
*/
1490
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1491
battery_w = GTK_WIDGET (gtk_builder_get_object (xml, "button-battery-combo"));
1492
battery_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-battery-label"));
1493
1494
if ( has_battery_button )
1495
{
1496
gtk_combo_box_set_model (GTK_COMBO_BOX(battery_w), GTK_TREE_MODEL(list_store));
1497
1498
gtk_list_store_append (list_store, &iter);
1499
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
1500
1501
if ( can_suspend && auth_suspend )
1502
{
1503
gtk_list_store_append (list_store, &iter);
1504
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
1505
}
1506
1507
if ( can_hibernate && auth_hibernate)
1508
{
1509
gtk_list_store_append (list_store, &iter);
1510
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
1511
}
1512
1513
gtk_list_store_append (list_store, &iter);
1514
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
1515
1516
gtk_combo_box_set_active (GTK_COMBO_BOX (battery_w), 0);
1517
1518
value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BATTERY_SWITCH_CFG, XFPM_DO_NOTHING);
1519
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1520
valid;
1521
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1522
{
1523
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1524
1, &list_value, -1);
1525
if ( value == list_value )
1526
{
1527
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (battery_w), &iter);
1528
break;
1529
}
1530
}
1531
}
1532
else
1533
{
1534
gtk_widget_hide (battery_w);
1535
gtk_widget_hide (battery_label);
1536
}
1269
GtkWidget *power;
1270
GtkWidget *power_label;
1271
GtkWidget *hibernate;
1272
GtkWidget *hibernate_label;
1273
GtkWidget *sleep_w;
1274
GtkWidget *sleep_label;
1275
GtkWidget *battery_w;
1276
GtkWidget *battery_label;
1277
GtkWidget *dpms;
1278
1279
guint value;
1280
guint list_value;
1281
gboolean valid;
1282
gboolean val;
1283
1284
GtkListStore *list_store;
1285
GtkTreeIter iter;
1286
1287
dpms = GTK_WIDGET (gtk_builder_get_object (xml, "handle-dpms"));
1288
1289
/*
1290
* Global dpms settings (enable/disable)
1291
*/
1292
val = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX DPMS_ENABLED_CFG, TRUE);
1293
gtk_switch_set_state (GTK_SWITCH (dpms), val);
1294
1295
/*
1296
* Power button
1297
*/
1298
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1299
power = GTK_WIDGET (gtk_builder_get_object (xml, "button-power-combo"));
1300
power_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-power-label"));
1301
1302
if ( has_power_button )
1303
{
1304
gtk_combo_box_set_model (GTK_COMBO_BOX(power), GTK_TREE_MODEL(list_store));
1305
1306
gtk_list_store_append (list_store, &iter);
1307
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
1308
1309
if ( can_suspend && auth_suspend)
1310
{
1311
gtk_list_store_append (list_store, &iter);
1312
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
1313
}
1314
1315
if ( can_hibernate && auth_hibernate )
1316
{
1317
gtk_list_store_append (list_store, &iter);
1318
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
1319
}
1320
1321
if ( can_shutdown )
1322
{
1323
gtk_list_store_append (list_store, &iter);
1324
gtk_list_store_set (list_store, &iter, 0, _("Shutdown"), 1, XFPM_DO_SHUTDOWN, -1);
1325
}
1326
1327
gtk_list_store_append (list_store, &iter);
1328
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
1329
1330
gtk_combo_box_set_active (GTK_COMBO_BOX (power), 0);
1331
1332
value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX POWER_SWITCH_CFG, XFPM_DO_NOTHING);
1333
1334
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1335
valid;
1336
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1337
{
1338
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1339
1, &list_value, -1);
1340
if ( value == list_value )
1341
{
1342
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (power), &iter);
1343
break;
1344
}
1345
}
1346
}
1347
else
1348
{
1349
gtk_widget_hide (power);
1350
gtk_widget_hide (power_label);
1351
}
1352
1353
/*
1354
* Hibernate button
1355
*/
1356
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1357
hibernate = GTK_WIDGET (gtk_builder_get_object (xml, "button-hibernate-combo"));
1358
hibernate_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-hibernate-label"));
1359
1360
if (has_hibernate_button )
1361
{
1362
gtk_combo_box_set_model (GTK_COMBO_BOX(hibernate), GTK_TREE_MODEL(list_store));
1363
1364
gtk_list_store_append (list_store, &iter);
1365
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
1366
1367
if ( can_suspend && auth_suspend)
1368
{
1369
gtk_list_store_append (list_store, &iter);
1370
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
1371
}
1372
1373
if ( can_hibernate && auth_hibernate )
1374
{
1375
gtk_list_store_append (list_store, &iter);
1376
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
1377
}
1378
1379
gtk_list_store_append (list_store, &iter);
1380
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
1381
1382
value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX HIBERNATE_SWITCH_CFG, XFPM_DO_NOTHING);
1383
1384
gtk_combo_box_set_active (GTK_COMBO_BOX (hibernate), 0);
1385
1386
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1387
valid;
1388
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1389
{
1390
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1391
1, &list_value, -1);
1392
if ( value == list_value )
1393
{
1394
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (hibernate), &iter);
1395
break;
1396
}
1397
}
1398
}
1399
else
1400
{
1401
gtk_widget_hide (hibernate);
1402
gtk_widget_hide (hibernate_label);
1403
}
1404
1405
/*
1406
* Sleep button
1407
*/
1408
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1409
sleep_w = GTK_WIDGET (gtk_builder_get_object (xml, "button-sleep-combo"));
1410
sleep_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-sleep-label"));
1411
1412
if ( has_sleep_button )
1413
{
1414
gtk_combo_box_set_model (GTK_COMBO_BOX(sleep_w), GTK_TREE_MODEL(list_store));
1415
1416
gtk_list_store_append (list_store, &iter);
1417
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
1418
1419
if ( can_suspend && auth_suspend )
1420
{
1421
gtk_list_store_append (list_store, &iter);
1422
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
1423
}
1424
1425
if ( can_hibernate && auth_hibernate)
1426
{
1427
gtk_list_store_append (list_store, &iter);
1428
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
1429
}
1430
1431
gtk_list_store_append (list_store, &iter);
1432
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
1433
1434
gtk_combo_box_set_active (GTK_COMBO_BOX (sleep_w), 0);
1435
1436
value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX SLEEP_SWITCH_CFG, XFPM_DO_NOTHING);
1437
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1438
valid;
1439
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1440
{
1441
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1442
1, &list_value, -1);
1443
if ( value == list_value )
1444
{
1445
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (sleep_w), &iter);
1446
break;
1447
}
1448
}
1449
}
1450
else
1451
{
1452
gtk_widget_hide (sleep_w);
1453
gtk_widget_hide (sleep_label);
1454
}
1455
1456
/*
1457
* Battery button
1458
*/
1459
list_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
1460
battery_w = GTK_WIDGET (gtk_builder_get_object (xml, "button-battery-combo"));
1461
battery_label = GTK_WIDGET (gtk_builder_get_object (xml, "button-battery-label"));
1462
1463
if ( has_battery_button )
1464
{
1465
gtk_combo_box_set_model (GTK_COMBO_BOX(battery_w), GTK_TREE_MODEL(list_store));
1466
1467
gtk_list_store_append (list_store, &iter);
1468
gtk_list_store_set (list_store, &iter, 0, _("Do nothing"), 1, XFPM_DO_NOTHING, -1);
1469
1470
if ( can_suspend && auth_suspend )
1471
{
1472
gtk_list_store_append (list_store, &iter);
1473
gtk_list_store_set (list_store, &iter, 0, _("Suspend"), 1, XFPM_DO_SUSPEND, -1);
1474
}
1475
1476
if ( can_hibernate && auth_hibernate)
1477
{
1478
gtk_list_store_append (list_store, &iter);
1479
gtk_list_store_set (list_store, &iter, 0, _("Hibernate"), 1, XFPM_DO_HIBERNATE, -1);
1480
}
1481
1482
gtk_list_store_append (list_store, &iter);
1483
gtk_list_store_set (list_store, &iter, 0, _("Ask"), 1, XFPM_ASK, -1);
1484
1485
gtk_combo_box_set_active (GTK_COMBO_BOX (battery_w), 0);
1486
1487
value = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX BATTERY_SWITCH_CFG, XFPM_DO_NOTHING);
1488
for ( valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (list_store), &iter);
1489
valid;
1490
valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (list_store), &iter) )
1491
{
1492
gtk_tree_model_get (GTK_TREE_MODEL (list_store), &iter,
1493
1, &list_value, -1);
1494
if ( value == list_value )
1495
{
1496
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (battery_w), &iter);
1497
break;
1498
}
1499
}
1500
}
1501
else
1502
{
1503
gtk_widget_hide (battery_w);
1504
gtk_widget_hide (battery_label);
1505
}
1537
1506
}
1538
1507
1539
1508
static void
1541
1510
gboolean auth_hibernate, gboolean can_suspend,
1542
1511
gboolean can_hibernate, gboolean has_battery)
1543
1512
{
1544
guint val;
1545
GtkWidget *critical_level;
1546
GtkWidget *lock;
1547
GtkWidget *label;
1548
1549
/*
1550
* Critical battery level
1551
*/
1552
critical_level = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-level-spin"));
1553
if ( has_battery )
1513
guint val;
1514
GtkWidget *critical_level;
1515
GtkWidget *lock;
1516
GtkWidget *label;
1517
1518
/*
1519
* Critical battery level
1520
*/
1521
critical_level = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-level-spin"));
1522
if ( has_battery )
1523
{
1524
gtk_widget_set_tooltip_text (critical_level,
1525
_("When all the power sources of the computer reach this charge level"));
1526
1527
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_POWER_LEVEL, 10);
1528
1529
if ( val > 20 || val < 1)
1554
1530
{
1555
gtk_widget_set_tooltip_text (critical_level,
1556
_("When all the power sources of the computer reach this charge level"));
1557
1558
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX CRITICAL_POWER_LEVEL, 10);
1559
1560
if ( val > 20 || val < 1)
1561
{
1562
g_critical ("Value %d if out of range for property %s\n", val, CRITICAL_POWER_LEVEL);
1563
gtk_spin_button_set_value (GTK_SPIN_BUTTON(critical_level), 10);
1564
}
1565
else
1566
gtk_spin_button_set_value (GTK_SPIN_BUTTON(critical_level), val);
1531
g_critical ("Value %d if out of range for property %s\n", val, CRITICAL_POWER_LEVEL);
1532
gtk_spin_button_set_value (GTK_SPIN_BUTTON(critical_level), 10);
1567
1533
}
1568
1534
else
1569
{
1570
label = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-level-label" ));
1571
gtk_widget_hide (critical_level);
1572
gtk_widget_hide (label);
1573
}
1574
1575
/*
1576
* Lock screen for suspend/hibernate
1577
*/
1578
lock = GTK_WIDGET (gtk_builder_get_object (xml, "lock-screen"));
1579
1580
if ( !can_suspend && !can_hibernate )
1581
{
1582
gtk_widget_set_sensitive (lock, FALSE);
1583
gtk_widget_set_tooltip_text (lock, _("Hibernate and suspend operations not supported"));
1584
}
1585
else if ( !auth_hibernate && !auth_suspend)
1586
{
1587
gtk_widget_set_sensitive (lock, FALSE);
1588
gtk_widget_set_tooltip_text (lock, _("Hibernate and suspend operations not permitted"));
1589
}
1590
1591
val = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
1592
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(lock), val);
1535
gtk_spin_button_set_value (GTK_SPIN_BUTTON(critical_level), val);
1536
}
1537
else
1538
{
1539
label = GTK_WIDGET (gtk_builder_get_object (xml, "critical-power-level-label" ));
1540
gtk_widget_hide (critical_level);
1541
gtk_widget_hide (label);
1542
}
1543
1544
/*
1545
* Lock screen for suspend/hibernate
1546
*/
1547
lock = GTK_WIDGET (gtk_builder_get_object (xml, "lock-screen"));
1548
1549
if ( !can_suspend && !can_hibernate )
1550
{
1551
gtk_widget_set_sensitive (lock, FALSE);
1552
gtk_widget_set_tooltip_text (lock, _("Hibernate and suspend operations not supported"));
1553
}
1554
else if ( !auth_hibernate && !auth_suspend)
1555
{
1556
gtk_widget_set_sensitive (lock, FALSE);
1557
gtk_widget_set_tooltip_text (lock, _("Hibernate and suspend operations not permitted"));
1558
}
1559
1560
val = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
1561
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(lock), val);
1593
1562
}
1594
1563
1595
1564
/* Light Locker Integration */
1596
1565
static gchar*
1597
1566
get_light_locker_path (void)
1598
1567
{
1599
gchar** paths = NULL;
1600
gchar* path = NULL;
1601
unsigned int i = 0;
1568
gchar** paths = NULL;
1569
gchar* path = NULL;
1570
unsigned int i = 0;
1602
1571
1603
/* Check if executable in path */
1604
paths = g_strsplit(g_getenv("PATH"), ":", 0);
1605
for (i = 0; i < g_strv_length(paths); i++) {
1606
path = g_strdup(g_build_filename(paths[i], "light-locker", NULL));
1607
if (g_file_test(path, G_FILE_TEST_EXISTS))
1608
{
1609
break;
1610
}
1611
g_free(path);
1612
path = NULL;
1572
/* Check if executable is in path */
1573
paths = g_strsplit (g_getenv ("PATH"), ":", 0);
1574
for (i = 0; i < g_strv_length (paths); i++) {
1575
path = g_strdup (g_build_filename (paths[i], "light-locker", NULL));
1576
if (g_file_test (path, G_FILE_TEST_EXISTS))
1577
{
1578
break;
1613
1579
}
1614
g_strfreev(paths);
1580
g_free (path);
1581
path = NULL;
1582
}
1583
g_strfreev (paths);
1615
1584
1616
return path;
1585
return path;
1617
1586
}
1618
1587
1619
1588
gchar *
1620
1589
format_light_locker_value_cb (gint value)
1621
1590
{
1622
gint min;
1591
gint min;
1623
1592
1624
if ( value <= 0 )
1625
return g_strdup (_("Never"));
1626
else if ( value < 60 )
1627
return g_strdup_printf ("%d %s", value, _("seconds"));
1593
if ( value <= 0 )
1594
return g_strdup (_("Never"));
1595
else if ( value < 60 )
1596
return g_strdup_printf ("%d %s", value, _("seconds"));
1597
else
1598
{
1599
min = value - 60;
1600
if (min == 0)
1601
return g_strdup_printf ("%d %s", min + 1, _("minute"));
1628
1602
else
1629
{
1630
min = value - 60;
1631
if (min == 0)
1632
return g_strdup_printf ("%d %s", min + 1, _("minute"));
1633
else
1634
return g_strdup_printf ("%d %s", min + 1, _("minutes"));
1635
}
1603
return g_strdup_printf ("%d %s", min + 1, _("minutes"));
1604
}
1636
1605
}
1637
1606
1638
1607
void
1639
1608
light_locker_late_locking_value_changed_cb (GtkWidget *widget, XfconfChannel *channel)
1640
1609
{
1641
GVariant *variant;
1642
gint value = (gint)gtk_range_get_value (GTK_RANGE (widget));
1643
1644
if (value > 60) {
1645
value = ((value - 60) + 1) * 60;
1646
}
1647
1648
variant = g_variant_new_uint32 (value);
1649
1650
if (!g_settings_set_value (light_locker_settings, "lock-after-screensaver", variant))
1651
{
1652
g_critical ("Cannot set value for property lock-after-screensaver\n");
1653
}
1654
1655
update_label (label_light_locker_late_locking_scale, widget, format_light_locker_value_cb);
1610
GVariant *variant;
1611
gint value = (gint)gtk_range_get_value (GTK_RANGE (widget));
1612
1613
if (value > 60) {
1614
value = ((value - 60) + 1) * 60;
1615
}
1616
1617
variant = g_variant_new_uint32 (value);
1618
1619
if (!g_settings_set_value (light_locker_settings, "lock-after-screensaver", variant))
1620
{
1621
g_critical ("Cannot set value for property lock-after-screensaver\n");
1622
}
1623
1624
update_label (label_light_locker_late_locking_scale, widget, format_light_locker_value_cb);
1656
1625
}
1657
1626
1658
1627
void
1659
1628
light_locker_automatic_locking_changed_cb (GtkWidget *widget, XfconfChannel *channel)
1660
1629
{
1661
GVariant *variant;
1662
gint value;
1663
gint lock_after_screensaver;
1664
gboolean late_locking = FALSE;
1665
1666
value = gtk_combo_box_get_active (GTK_COMBO_BOX(widget));
1667
gtk_widget_set_sensitive (light_locker_delay, value != 0);
1668
1669
if (value == 0)
1670
lock_after_screensaver = 0;
1671
else {
1672
lock_after_screensaver = (gint)gtk_range_get_value (GTK_RANGE (light_locker_delay));
1673
if (lock_after_screensaver > 60) {
1674
lock_after_screensaver = (lock_after_screensaver - 60) * 60;
1675
}
1630
GVariant *variant;
1631
gint value;
1632
gint lock_after_screensaver;
1633
gboolean late_locking = FALSE;
1634
1635
value = gtk_combo_box_get_active (GTK_COMBO_BOX(widget));
1636
gtk_widget_set_sensitive (light_locker_delay, value != 0);
1637
1638
if (value == 0)
1639
lock_after_screensaver = 0;
1640
else {
1641
lock_after_screensaver = (gint)gtk_range_get_value (GTK_RANGE (light_locker_delay));
1642
if (lock_after_screensaver > 60) {
1643
lock_after_screensaver = (lock_after_screensaver - 60) * 60;
1676
1644
}
1677
1678
if (value == 2)
1679
late_locking = TRUE;
1680
1681
variant = g_variant_new_uint32 (lock_after_screensaver);
1682
if (!g_settings_set_value (light_locker_settings, "lock-after-screensaver", variant))
1683
g_critical ("Cannot set value for property lock-after-screensaver\n");
1684
1685
variant = g_variant_new_boolean (late_locking);
1686
if (!g_settings_set_value (light_locker_settings, "late-locking", variant))
1687
g_critical ("Cannot set value for property late-locking\n");
1645
}
1646
1647
if (value == 2)
1648
late_locking = TRUE;
1649
1650
variant = g_variant_new_uint32 (lock_after_screensaver);
1651
if (!g_settings_set_value (light_locker_settings, "lock-after-screensaver", variant))
1652
g_critical ("Cannot set value for property lock-after-screensaver\n");
1653
1654
variant = g_variant_new_boolean (late_locking);
1655
if (!g_settings_set_value (light_locker_settings, "late-locking", variant))
1656
g_critical ("Cannot set value for property late-locking\n");
1688
1657
}
1689
1658
1690
1659
static void xfpm_settings_light_locker (XfconfChannel *channel,
1691
1660
gboolean auth_suspend, gboolean auth_hibernate,
1692
1661
gboolean can_suspend, gboolean can_hibernate)
1693
1662
{
1694
GSettingsSchemaSource *schema_source;
1695
GSettingsSchema *schema;
1696
GVariant *variant;
1697
gboolean late_locking, lock_on_suspend, xfpm_lock_on_suspend;
1698
guint32 lock_after_screensaver;
1699
GtkWidget *security_frame;
1700
1701
/* Collect the Light Locker widgets */
1702
light_locker_tab = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-vbox1"));
1703
light_locker_autolock = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-automatic-locking-combo"));
1704
light_locker_delay = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-late-locking-scale"));
1705
light_locker_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-suspend"));
1706
1707
if ( !can_suspend && !can_hibernate )
1708
{
1709
gtk_widget_set_sensitive (light_locker_sleep, FALSE);
1710
gtk_widget_set_tooltip_text (light_locker_sleep, _("Hibernate and suspend operations not supported"));
1711
}
1712
else if ( !auth_hibernate && !auth_suspend)
1713
{
1714
gtk_widget_set_sensitive (light_locker_sleep, FALSE);
1715
gtk_widget_set_tooltip_text (light_locker_sleep, _("Hibernate and suspend operations not permitted"));
1716
}
1717
1718
schema_source = g_settings_schema_source_get_default();
1719
schema = g_settings_schema_source_lookup (schema_source, "apps.light-locker", TRUE);
1720
1721
if (schema != NULL && get_light_locker_path() != NULL) {
1722
security_frame = GTK_WIDGET (gtk_builder_get_object (xml, "security-frame"));
1723
gtk_widget_hide(security_frame);
1724
/* Load the settings (Light Locker compiled with GSettings backend required) */
1725
light_locker_settings = g_settings_new ("apps.light-locker");
1726
1727
variant = g_settings_get_value (light_locker_settings, "late-locking");
1728
late_locking = g_variant_get_boolean (variant);
1729
1730
variant = g_settings_get_value (light_locker_settings, "lock-on-suspend");
1731
lock_on_suspend = g_variant_get_boolean (variant);
1732
xfpm_lock_on_suspend = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
1733
if (lock_on_suspend != xfpm_lock_on_suspend) {
1734
variant = g_variant_new_boolean (xfpm_lock_on_suspend);
1735
if (!g_settings_set_value (light_locker_settings, "lock-on-suspend", variant)) {
1736
g_critical ("Cannot set value for property lock-on-suspend\n");
1737
}
1738
lock_on_suspend = xfpm_lock_on_suspend;
1739
}
1740
1741
variant = g_settings_get_value (light_locker_settings, "lock-after-screensaver");
1742
lock_after_screensaver = g_variant_get_uint32 (variant);
1743
1744
gtk_widget_set_sensitive (light_locker_delay, lock_after_screensaver != 0);
1745
1746
if (lock_after_screensaver > 60) {
1747
lock_after_screensaver = (lock_after_screensaver / 60) + 60;
1748
}
1749
1750
/* Apply the settings */
1751
if (lock_after_screensaver == 0) {
1752
gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 0);
1753
} else {
1754
if (!late_locking) {
1755
gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 1);
1756
} else {
1757
gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 2);
1758
}
1759
gtk_range_set_value (GTK_RANGE(light_locker_delay), lock_after_screensaver);
1760
}
1761
1762
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(light_locker_sleep), lock_on_suspend);
1763
1764
g_settings_schema_unref (schema);
1765
} else {
1766
XFPM_DEBUG ("Schema \"apps.light-locker\" not found. Not configuring Light Locker.");
1767
gtk_widget_hide (light_locker_tab);
1768
}
1769
1770
label_light_locker_late_locking_scale = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-late-locking-scale-label"));
1771
update_label (label_light_locker_late_locking_scale, light_locker_delay, format_light_locker_value_cb);
1663
GSettingsSchemaSource *schema_source;
1664
GSettingsSchema *schema;
1665
GVariant *variant;
1666
gboolean late_locking, lock_on_suspend, xfpm_lock_on_suspend;
1667
guint32 lock_after_screensaver;
1668
GtkWidget *security_frame;
1669
1670
/* Collect the Light Locker widgets */
1671
light_locker_tab = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-vbox1"));
1672
light_locker_autolock = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-automatic-locking-combo"));
1673
light_locker_delay = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-late-locking-scale"));
1674
light_locker_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-suspend"));
1675
1676
if ( !can_suspend && !can_hibernate )
1677
{
1678
gtk_widget_set_sensitive (light_locker_sleep, FALSE);
1679
gtk_widget_set_tooltip_text (light_locker_sleep, _("Hibernate and suspend operations not supported"));
1680
}
1681
else if ( !auth_hibernate && !auth_suspend)
1682
{
1683
gtk_widget_set_sensitive (light_locker_sleep, FALSE);
1684
gtk_widget_set_tooltip_text (light_locker_sleep, _("Hibernate and suspend operations not permitted"));
1685
}
1686
1687
schema_source = g_settings_schema_source_get_default();
1688
schema = g_settings_schema_source_lookup (schema_source, "apps.light-locker", TRUE);
1689
1690
if (schema != NULL && get_light_locker_path() != NULL)
1691
{
1692
security_frame = GTK_WIDGET (gtk_builder_get_object (xml, "security-frame"));
1693
gtk_widget_hide (security_frame);
1694
/* Load the settings (Light Locker compiled with GSettings backend required) */
1695
light_locker_settings = g_settings_new ("apps.light-locker");
1696
1697
variant = g_settings_get_value (light_locker_settings, "late-locking");
1698
late_locking = g_variant_get_boolean (variant);
1699
1700
variant = g_settings_get_value (light_locker_settings, "lock-on-suspend");
1701
lock_on_suspend = g_variant_get_boolean (variant);
1702
xfpm_lock_on_suspend = xfconf_channel_get_bool (channel, XFPM_PROPERTIES_PREFIX LOCK_SCREEN_ON_SLEEP, TRUE);
1703
if (lock_on_suspend != xfpm_lock_on_suspend)
1704
{
1705
variant = g_variant_new_boolean (xfpm_lock_on_suspend);
1706
if (!g_settings_set_value (light_locker_settings, "lock-on-suspend", variant))
1707
{
1708
g_critical ("Cannot set value for property lock-on-suspend\n");
1709
}
1710
lock_on_suspend = xfpm_lock_on_suspend;
1711
}
1712
1713
variant = g_settings_get_value (light_locker_settings, "lock-after-screensaver");
1714
lock_after_screensaver = g_variant_get_uint32 (variant);
1715
1716
gtk_widget_set_sensitive (light_locker_delay, lock_after_screensaver != 0);
1717
1718
if (lock_after_screensaver > 60)
1719
{
1720
lock_after_screensaver = (lock_after_screensaver / 60) + 60;
1721
}
1722
1723
/* Apply the settings */
1724
if (lock_after_screensaver == 0)
1725
{
1726
gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 0);
1727
}
1728
else
1729
{
1730
if (!late_locking)
1731
{
1732
gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 1);
1733
}
1734
else
1735
{
1736
gtk_combo_box_set_active (GTK_COMBO_BOX(light_locker_autolock), 2);
1737
}
1738
gtk_range_set_value (GTK_RANGE(light_locker_delay), lock_after_screensaver);
1739
}
1740
1741
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(light_locker_sleep), lock_on_suspend);
1742
1743
g_settings_schema_unref (schema);
1744
}
1745
else
1746
{
1747
XFPM_DEBUG ("Schema \"apps.light-locker\" not found. Not configuring Light Locker.");
1748
gtk_widget_hide (light_locker_tab);
1749
}
1750
1751
label_light_locker_late_locking_scale = GTK_WIDGET (gtk_builder_get_object (xml, "light-locker-late-locking-scale-label"));
1752
update_label (label_light_locker_late_locking_scale, light_locker_delay, format_light_locker_value_cb);
1772
1753
}
1773
1754
/* END Light Locker Integration */
1774
1755
1776
1757
static GtkTreeIter*
1777
1758
find_device_in_tree (const gchar *object_path)
1778
1759
{
1779
GtkTreeModel *model;
1780
GtkTreeIter iter;
1781
1782
if ( !sideview )
1783
return NULL;
1784
1785
model = gtk_tree_view_get_model(GTK_TREE_VIEW(sideview));
1786
1787
if (!model)
1788
return NULL;
1789
1790
if(gtk_tree_model_get_iter_first(model, &iter)) {
1791
do {
1792
gchar *path = NULL;
1793
gtk_tree_model_get(model, &iter, COL_SIDEBAR_OBJECT_PATH, &path, -1);
1794
1795
if(g_strcmp0(path, object_path) == 0) {
1796
g_free(path);
1797
return gtk_tree_iter_copy(&iter);
1798
}
1799
1800
g_free(path);
1801
} while(gtk_tree_model_iter_next(model, &iter));
1802
}
1803
1804
return NULL;
1760
GtkTreeModel *model;
1761
GtkTreeIter iter;
1762
1763
if ( !sideview )
1764
return NULL;
1765
1766
model = gtk_tree_view_get_model(GTK_TREE_VIEW(sideview));
1767
1768
if (!model)
1769
return NULL;
1770
1771
if(gtk_tree_model_get_iter_first(model, &iter))
1772
{
1773
do {
1774
gchar *path = NULL;
1775
gtk_tree_model_get(model, &iter, COL_SIDEBAR_OBJECT_PATH, &path, -1);
1776
1777
if(g_strcmp0(path, object_path) == 0)
1778
{
1779
g_free(path);
1780
return gtk_tree_iter_copy(&iter);
1781
}
1782
1783
g_free (path);
1784
} while (gtk_tree_model_iter_next(model, &iter));
1785
}
1786
1787
return NULL;
1805
1788
}
1806
1789
1807
1790
/* Call gtk_tree_iter_free when done with the tree iter */
1808
1791
static GtkTreeIter*
1809
1792
find_device_info_name_in_tree (GtkTreeView *view, const gchar *device_info_name)
1810
1793
{
1811
GtkTreeModel *model;
1812
GtkTreeIter iter;
1813
1814
if ( !view )
1815
return NULL;
1816
1817
model = gtk_tree_view_get_model(view);
1818
1819
if (!model)
1820
return NULL;
1821
1822
if(gtk_tree_model_get_iter_first(model, &iter)) {
1823
do {
1824
gchar *name = NULL;
1825
gtk_tree_model_get(model, &iter, XFPM_DEVICE_INFO_NAME, &name, -1);
1826
1827
if(g_strcmp0(name, device_info_name) == 0) {
1828
g_free(name);
1829
return gtk_tree_iter_copy(&iter);
1830
}
1831
1832
g_free(name);
1833
} while(gtk_tree_model_iter_next(model, &iter));
1834
}
1835
1836
return NULL;
1794
GtkTreeModel *model;
1795
GtkTreeIter iter;
1796
1797
if ( !view )
1798
return NULL;
1799
1800
model = gtk_tree_view_get_model (view);
1801
1802
if (!model)
1803
return NULL;
1804
1805
if (gtk_tree_model_get_iter_first (model, &iter)) {
1806
do {
1807
gchar *name = NULL;
1808
gtk_tree_model_get (model, &iter, XFPM_DEVICE_INFO_NAME, &name, -1);
1809
1810
if(g_strcmp0 (name, device_info_name) == 0) {
1811
g_free (name);
1812
return gtk_tree_iter_copy (&iter);
1813
}
1814
1815
g_free (name);
1816
} while(gtk_tree_model_iter_next(model, &iter));
1817
}
1818
1819
return NULL;
1837
1820
}
1838
1821
1839
1822
static gchar *
1840
1823
xfpm_info_get_energy_property (gdouble energy, const gchar *unit)
1841
1824
{
1842
gchar *val = NULL;
1843
1844
val = g_strdup_printf ("%.1f %s", energy, unit);
1845
1846
return val;
1825
gchar *val = NULL;
1826
1827
val = g_strdup_printf ("%.1f %s", energy, unit);
1828
1829
return val;
1847
1830
}
1848
1831
1849
1832
static void
1852
1835
const gchar *name,
1853
1836
const gchar *value)
1854
1837
{
1855
GtkTreeIter *iter;
1856
1857
g_return_if_fail (GTK_IS_TREE_VIEW(view));
1858
g_return_if_fail (GTK_IS_LIST_STORE(list_store));
1859
g_return_if_fail (name != NULL);
1860
/* Value can be NULL */
1861
1862
DBG ("updating name %s with value %s", name, value);
1863
1864
iter = find_device_info_name_in_tree (view, name);
1865
if (iter == NULL)
1866
{
1867
/* The row doesn't exist yet, add it */
1868
GtkTreeIter new_iter;
1869
gtk_list_store_append (list_store, &new_iter);
1870
iter = gtk_tree_iter_copy (&new_iter);
1871
}
1872
1873
if (value != NULL)
1874
{
1875
gtk_list_store_set (list_store, iter,
1876
XFPM_DEVICE_INFO_NAME, name,
1877
XFPM_DEVICE_INFO_VALUE, value,
1878
-1);
1879
}
1880
else
1881
{
1882
/* The value no longer applies, remove the row */
1883
gtk_list_store_remove (list_store, iter);
1884
}
1885
1886
gtk_tree_iter_free (iter);
1838
GtkTreeIter *iter;
1839
1840
g_return_if_fail (GTK_IS_TREE_VIEW(view));
1841
g_return_if_fail (GTK_IS_LIST_STORE(list_store));
1842
g_return_if_fail (name != NULL);
1843
/* Value can be NULL */
1844
1845
DBG ("updating name %s with value %s", name, value);
1846
1847
iter = find_device_info_name_in_tree (view, name);
1848
if (iter == NULL)
1849
{
1850
/* The row doesn't exist yet, add it */
1851
GtkTreeIter new_iter;
1852
gtk_list_store_append (list_store, &new_iter);
1853
iter = gtk_tree_iter_copy (&new_iter);
1854
}
1855
1856
if (value != NULL)
1857
{
1858
gtk_list_store_set (list_store, iter,
1859
XFPM_DEVICE_INFO_NAME, name,
1860
XFPM_DEVICE_INFO_VALUE, value,
1861
-1);
1862
}
1863
else
1864
{
1865
/* The value no longer applies, remove the row */
1866
gtk_list_store_remove (list_store, iter);
1867
}
1868
1869
gtk_tree_iter_free (iter);
1887
1870
}
1888
1871
1889
1872
static void
1890
1873
update_sideview_icon (UpDevice *device)
1891
1874
{
1892
GtkListStore *list_store;
1893
GtkTreeIter *iter;
1894
GdkPixbuf *pix;
1895
guint type = 0;
1896
gchar *name = NULL, *icon_name = NULL, *model = NULL, *vendor = NULL;
1897
const gchar *object_path = up_device_get_object_path(device);
1898
1899
list_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (sideview)));
1900
1901
TRACE("entering for %s", object_path);
1902
1903
iter = find_device_in_tree (object_path);
1904
1905
/* quit if device doesn't exist in the sidebar */
1906
if (!iter)
1907
return;
1908
1909
/* hack, this depends on XFPM_DEVICE_TYPE_* being in sync with UP_DEVICE_KIND_* */
1910
g_object_get (device,
1911
"kind", &type,
1912
"vendor", &vendor,
1913
"model", &model,
1914
NULL);
1915
1916
1917
name = get_device_description (upower, device);
1918
icon_name = get_device_icon_name (upower, device);
1919
1920
pix = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
1921
icon_name,
1922
48,
1923
GTK_ICON_LOOKUP_USE_BUILTIN,
1924
NULL);
1925
1926
gtk_list_store_set (list_store, iter,
1927
COL_SIDEBAR_ICON, pix,
1928
COL_SIDEBAR_NAME, name,
1929
-1);
1930
1931
if ( pix )
1932
g_object_unref (pix);
1933
1934
g_free (name);
1935
g_free (icon_name);
1936
1937
gtk_tree_iter_free (iter);
1875
GtkListStore *list_store;
1876
GtkTreeIter *iter;
1877
GdkPixbuf *pix;
1878
guint type = 0;
1879
gchar *name = NULL, *icon_name = NULL, *model = NULL, *vendor = NULL;
1880
const gchar *object_path = up_device_get_object_path(device);
1881
1882
list_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (sideview)));
1883
1884
TRACE("entering for %s", object_path);
1885
1886
iter = find_device_in_tree (object_path);
1887
1888
/* quit if device doesn't exist in the sidebar */
1889
if (!iter)
1890
return;
1891
1892
/* hack, this depends on XFPM_DEVICE_TYPE_* being in sync with UP_DEVICE_KIND_* */
1893
g_object_get (device,
1894
"kind", &type,
1895
"vendor", &vendor,
1896
"model", &model,
1897
NULL);
1898
1899
1900
name = get_device_description (upower, device);
1901
icon_name = get_device_icon_name (upower, device);
1902
1903
pix = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
1904
icon_name,
1905
48,
1906
GTK_ICON_LOOKUP_USE_BUILTIN,
1907
NULL);
1908
1909
gtk_list_store_set (list_store, iter,
1910
COL_SIDEBAR_ICON, pix,
1911
COL_SIDEBAR_NAME, name,
1912
-1);
1913
1914
if ( pix )
1915
g_object_unref (pix);
1916
1917
g_free (name);
1918
g_free (icon_name);
1919
1920
gtk_tree_iter_free (iter);
1938
1921
}
1939
1922
1940
1923
static void
1941
1924
update_device_details (UpDevice *device)
1942
1925
{
1943
GtkTreeView *view;
1944
GtkListStore *list_store;
1945
GtkTreeIter *sideview_iter;
1946
gchar *str;
1947
guint type = 0, tech = 0;
1948
gdouble energy_full_design = -1.0, energy_full = -1.0, energy_empty = -1.0, voltage = -1.0, percent = -1.0;
1949
gboolean p_supply = FALSE;
1950
gchar *model = NULL, *vendor = NULL, *serial = NULL;
1951
const gchar *battery_type = NULL;
1952
const gchar *object_path = up_device_get_object_path(device);
1953
1954
TRACE("entering for %s", object_path);
1955
1956
sideview_iter = find_device_in_tree (object_path);
1957
1958
/* quit if device doesn't exist in the sidebar */
1959
if (sideview_iter == NULL)
1960
return;
1961
1962
gtk_tree_model_get (gtk_tree_view_get_model(GTK_TREE_VIEW(sideview)), sideview_iter,
1963
COL_SIDEBAR_VIEW, &view,
1964
-1);
1965
1966
list_store = GTK_LIST_STORE (gtk_tree_view_get_model (view));
1967
1968
/**
1969
* Add/Update Device information:
1970
**/
1971
/*Device*/
1972
update_device_info_value_for_name (view,
1973
list_store,
1974
_("Device"),
1975
g_str_has_prefix (object_path, UPOWER_PATH_DEVICE) ? object_path + strlen (UPOWER_PATH_DEVICE) : object_path);
1976
1977
/*Type*/
1978
/* hack, this depends on XFPM_DEVICE_TYPE_* being in sync with UP_DEVICE_KIND_* */
1979
g_object_get (device,
1980
"kind", &type,
1981
"power-supply", &p_supply,
1982
"model", &model,
1983
"vendor", &vendor,
1984
"serial", &serial,
1985
"technology", &tech,
1986
"energy-full-design", &energy_full_design,
1987
"energy-full", &energy_full,
1988
"energy-empty", &energy_empty,
1989
"voltage", &voltage,
1990
"percentage", &percent,
1991
NULL);
1992
1993
if (type != UP_DEVICE_KIND_UNKNOWN)
1994
{
1995
battery_type = xfpm_power_translate_device_type (type);
1996
update_device_info_value_for_name (view, list_store, _("Type"), battery_type);
1997
}
1998
1999
update_device_info_value_for_name (view,
2000
list_store,
2001
_("PowerSupply"),
2002
p_supply == TRUE ? _("True") : _("False"));
2003
2004
if ( type != UP_DEVICE_KIND_LINE_POWER )
2005
{
2006
/*Model*/
2007
if (model && strlen (model) > 0)
2008
{
2009
update_device_info_value_for_name (view, list_store, _("Model"), model);
2010
}
2011
2012
update_device_info_value_for_name (view, list_store, _("Technology"), xfpm_power_translate_technology (tech));
2013
2014
/*Percentage*/
2015
if (percent >= 0)
2016
{
2017
str = g_strdup_printf("%d%%", (guint) percent);
2018
2019
update_device_info_value_for_name (view, list_store, _("Current charge"), str);
2020
2021
g_free(str);
2022
}
2023
2024
if (energy_full_design > 0)
2025
{
2026
/* TRANSLATORS: Unit here is Watt hour*/
2027
str = xfpm_info_get_energy_property (energy_full_design, _("Wh"));
2028
2029
update_device_info_value_for_name (view, list_store, _("Fully charged (design)"), str);
2030
2031
g_free (str);
2032
}
2033
2034
if (energy_full > 0)
2035
{
2036
gchar *str2;
2037
2038
/* TRANSLATORS: Unit here is Watt hour*/
2039
str = xfpm_info_get_energy_property (energy_full, _("Wh"));
2040
str2 = g_strdup_printf ("%s (%d%%)", str, (guint) (energy_full / energy_full_design *100));
2041
2042
update_device_info_value_for_name (view, list_store, _("Fully charged"), str2);
2043
2044
g_free (str);
2045
g_free (str2);
2046
}
2047
2048
if (energy_empty > 0)
2049
{
2050
/* TRANSLATORS: Unit here is Watt hour*/
2051
str = xfpm_info_get_energy_property (energy_empty, _("Wh"));
2052
2053
update_device_info_value_for_name (view, list_store, _("Energy empty"), str);
2054
2055
g_free (str);
2056
}
2057
2058
if (voltage > 0)
2059
{
2060
/* TRANSLATORS: Unit here is Volt*/
2061
str = xfpm_info_get_energy_property (voltage, _("V"));
2062
2063
update_device_info_value_for_name (view, list_store, _("Voltage"), str);
2064
2065
g_free (str);
2066
}
2067
2068
if (vendor && strlen (vendor) > 0)
2069
{
2070
update_device_info_value_for_name (view, list_store, _("Vendor"), vendor);
2071
}
2072
2073
if (serial && strlen (serial) > 0)
2074
{
2075
update_device_info_value_for_name (view, list_store, _("Serial"), serial);
2076
}
2077
}
2078
2079
update_sideview_icon (device);
2080
gtk_widget_show_all (GTK_WIDGET(view));
1926
GtkTreeView *view;
1927
GtkListStore *list_store;
1928
GtkTreeIter *sideview_iter;
1929
gchar *str;
1930
guint type = 0, tech = 0;
1931
gdouble energy_full_design = -1.0, energy_full = -1.0, energy_empty = -1.0, voltage = -1.0, percent = -1.0;
1932
gboolean p_supply = FALSE;
1933
gchar *model = NULL, *vendor = NULL, *serial = NULL;
1934
const gchar *battery_type = NULL;
1935
const gchar *object_path = up_device_get_object_path(device);
1936
1937
TRACE("entering for %s", object_path);
1938
1939
sideview_iter = find_device_in_tree (object_path);
1940
1941
/* quit if device doesn't exist in the sidebar */
1942
if (sideview_iter == NULL)
1943
return;
1944
1945
gtk_tree_model_get (gtk_tree_view_get_model (GTK_TREE_VIEW(sideview)), sideview_iter,
1946
COL_SIDEBAR_VIEW, &view,
1947
-1);
1948
1949
list_store = GTK_LIST_STORE (gtk_tree_view_get_model (view));
1950
1951
/**
1952
* Add/Update Device information:
1953
**/
1954
/*Device*/
1955
update_device_info_value_for_name (view,
1956
list_store,
1957
_("Device"),
1958
g_str_has_prefix (object_path, UPOWER_PATH_DEVICE) ? object_path + strlen (UPOWER_PATH_DEVICE) : object_path);
1959
1960
/*Type*/
1961
/* hack, this depends on XFPM_DEVICE_TYPE_* being in sync with UP_DEVICE_KIND_* */
1962
g_object_get (device,
1963
"kind", &type,
1964
"power-supply", &p_supply,
1965
"model", &model,
1966
"vendor", &vendor,
1967
"serial", &serial,
1968
"technology", &tech,
1969
"energy-full-design", &energy_full_design,
1970
"energy-full", &energy_full,
1971
"energy-empty", &energy_empty,
1972
"voltage", &voltage,
1973
"percentage", &percent,
1974
NULL);
1975
1976
if (type != UP_DEVICE_KIND_UNKNOWN)
1977
{
1978
battery_type = xfpm_power_translate_device_type (type);
1979
update_device_info_value_for_name (view, list_store, _("Type"), battery_type);
1980
}
1981
1982
update_device_info_value_for_name (view,
1983
list_store,
1984
_("PowerSupply"),
1985
p_supply == TRUE ? _("True") : _("False"));
1986
1987
if ( type != UP_DEVICE_KIND_LINE_POWER )
1988
{
1989
/*Model*/
1990
if (model && strlen (model) > 0)
1991
{
1992
update_device_info_value_for_name (view, list_store, _("Model"), model);
1993
}
1994
1995
update_device_info_value_for_name (view, list_store, _("Technology"), xfpm_power_translate_technology (tech));
1996
1997
/*Percentage*/
1998
if (percent >= 0)
1999
{
2000
str = g_strdup_printf("%d%%", (guint) percent);
2001
2002
update_device_info_value_for_name (view, list_store, _("Current charge"), str);
2003
2004
g_free(str);
2005
}
2006
2007
if (energy_full_design > 0)
2008
{
2009
/* TRANSLATORS: Unit here is Watt hour*/
2010
str = xfpm_info_get_energy_property (energy_full_design, _("Wh"));
2011
2012
update_device_info_value_for_name (view, list_store, _("Fully charged (design)"), str);
2013
2014
g_free (str);
2015
}
2016
2017
if (energy_full > 0)
2018
{
2019
gchar *str2;
2020
2021
/* TRANSLATORS: Unit here is Watt hour*/
2022
str = xfpm_info_get_energy_property (energy_full, _("Wh"));
2023
str2 = g_strdup_printf ("%s (%d%%)", str, (guint) (energy_full / energy_full_design *100));
2024
2025
update_device_info_value_for_name (view, list_store, _("Fully charged"), str2);
2026
2027
g_free (str);
2028
g_free (str2);
2029
}
2030
2031
if (energy_empty > 0)
2032
{
2033
/* TRANSLATORS: Unit here is Watt hour*/
2034
str = xfpm_info_get_energy_property (energy_empty, _("Wh"));
2035
2036
update_device_info_value_for_name (view, list_store, _("Energy empty"), str);
2037
2038
g_free (str);
2039
}
2040
2041
if (voltage > 0)
2042
{
2043
/* TRANSLATORS: Unit here is Volt*/
2044
str = xfpm_info_get_energy_property (voltage, _("V"));
2045
2046
update_device_info_value_for_name (view, list_store, _("Voltage"), str);
2047
2048
g_free (str);
2049
}
2050
2051
if (vendor && strlen (vendor) > 0)
2052
{
2053
update_device_info_value_for_name (view, list_store, _("Vendor"), vendor);
2054
}
2055
2056
if (serial && strlen (serial) > 0)
2057
{
2058
update_device_info_value_for_name (view, list_store, _("Serial"), serial);
2059
}
2060
}
2061
2062
update_sideview_icon (device);
2063
gtk_widget_show_all (GTK_WIDGET(view));
2081
2064
}
2082
2065
2083
2066
static void
2089
2072
static void
2090
2073
add_device (UpDevice *device)
2091
2074
{
2092
GtkTreeIter iter, *device_iter;
2093
GtkListStore *sideview_store, *devices_store;
2094
GtkTreeViewColumn *col;
2095
GtkCellRenderer *renderer;
2096
GtkWidget *frame, *view;
2097
const gchar *object_path = up_device_get_object_path(device);
2098
gulong signal_id;
2099
guint index;
2100
static gboolean first_run = TRUE;
2101
2102
TRACE("entering for %s", object_path);
2103
2104
/* don't add the same device twice */
2105
device_iter = find_device_in_tree (object_path);
2106
if (device_iter)
2107
{
2108
gtk_tree_iter_free (device_iter);
2109
return;
2110
}
2111
2112
/* Make sure the devices tab is shown */
2113
gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2114
2115
signal_id = g_signal_connect (device, "notify", G_CALLBACK (device_changed_cb), NULL);
2116
2117
sideview_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (sideview)));
2118
2119
index = gtk_notebook_get_n_pages (GTK_NOTEBOOK (device_details_notebook));
2120
2121
/* Create the page that the update_device_details will update/replace */
2122
frame = gtk_frame_new (NULL);
2123
view = gtk_tree_view_new ();
2124
gtk_container_add (GTK_CONTAINER (frame), view);
2125
gtk_widget_show_all (frame);
2126
gtk_notebook_append_page (GTK_NOTEBOOK (device_details_notebook), frame, NULL);
2127
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
2128
2129
/* Create the list store that the devices view will display */
2130
devices_store = gtk_list_store_new (XFPM_DEVICE_INFO_LAST, G_TYPE_STRING, G_TYPE_STRING);
2131
gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (devices_store));
2132
2133
/* Create the headers for this item in the device details tab */
2134
renderer = gtk_cell_renderer_text_new ();
2135
2136
/*Device Attribute*/
2137
col = gtk_tree_view_column_new();
2138
gtk_tree_view_column_pack_start (col, renderer, FALSE);
2139
gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_NAME, NULL);
2140
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
2141
2142
/*Device Attribute Value*/
2143
col = gtk_tree_view_column_new();
2144
gtk_tree_view_column_pack_start (col, renderer, FALSE);
2145
gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_VALUE, NULL);
2146
2147
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
2148
2149
/* Add the new device to the sidebar */
2150
gtk_list_store_append (sideview_store, &iter);
2151
gtk_list_store_set (sideview_store, &iter,
2152
COL_SIDEBAR_INT, index,
2153
COL_SIDEBAR_BATTERY_DEVICE, device,
2154
COL_SIDEBAR_OBJECT_PATH, object_path,
2155
COL_SIDEBAR_SIGNAL_ID, signal_id,
2156
COL_SIDEBAR_VIEW, view,
2157
-1);
2158
2159
/* Add the icon and description for the device */
2160
update_device_details (device);
2161
2162
/* See if we're to select this device, for it to be selected,
2163
* the starting_device_id must be unset and the this is the first
2164
* time add_device is called (i.e. select the first device) or
2165
* our current device matches starting_device_id. */
2166
if ((starting_device_id == NULL && first_run == TRUE) ||
2167
(g_strcmp0 (object_path, starting_device_id) == 0))
2168
{
2169
GtkTreeSelection *selection;
2170
2171
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sideview));
2172
2173
gtk_tree_selection_select_iter (selection, &iter);
2174
view_cursor_changed_cb (GTK_TREE_VIEW (sideview), NULL);
2175
}
2176
2177
first_run = FALSE;
2075
GtkTreeIter iter, *device_iter;
2076
GtkListStore *sideview_store, *devices_store;
2077
GtkTreeViewColumn *col;
2078
GtkCellRenderer *renderer;
2079
GtkWidget *frame, *view;
2080
const gchar *object_path = up_device_get_object_path(device);
2081
gulong signal_id;
2082
guint index;
2083
static gboolean first_run = TRUE;
2084
2085
TRACE("entering for %s", object_path);
2086
2087
/* don't add the same device twice */
2088
device_iter = find_device_in_tree (object_path);
2089
if (device_iter)
2090
{
2091
gtk_tree_iter_free (device_iter);
2092
return;
2093
}
2094
2095
/* Make sure the devices tab is shown */
2096
gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2097
2098
signal_id = g_signal_connect (device, "notify", G_CALLBACK (device_changed_cb), NULL);
2099
2100
sideview_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (sideview)));
2101
2102
index = gtk_notebook_get_n_pages (GTK_NOTEBOOK (device_details_notebook));
2103
2104
/* Create the page that the update_device_details will update/replace */
2105
frame = gtk_frame_new (NULL);
2106
view = gtk_tree_view_new ();
2107
gtk_container_add (GTK_CONTAINER (frame), view);
2108
gtk_widget_show_all (frame);
2109
gtk_notebook_append_page (GTK_NOTEBOOK (device_details_notebook), frame, NULL);
2110
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
2111
2112
/* Create the list store that the devices view will display */
2113
devices_store = gtk_list_store_new (XFPM_DEVICE_INFO_LAST, G_TYPE_STRING, G_TYPE_STRING);
2114
gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (devices_store));
2115
2116
/* Create the headers for this item in the device details tab */
2117
renderer = gtk_cell_renderer_text_new ();
2118
2119
/*Device Attribute*/
2120
col = gtk_tree_view_column_new();
2121
gtk_tree_view_column_pack_start (col, renderer, FALSE);
2122
gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_NAME, NULL);
2123
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
2124
2125
/*Device Attribute Value*/
2126
col = gtk_tree_view_column_new();
2127
gtk_tree_view_column_pack_start (col, renderer, FALSE);
2128
gtk_tree_view_column_set_attributes (col, renderer, "text", XFPM_DEVICE_INFO_VALUE, NULL);
2129
2130
gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
2131
2132
/* Add the new device to the sidebar */
2133
gtk_list_store_append (sideview_store, &iter);
2134
gtk_list_store_set (sideview_store, &iter,
2135
COL_SIDEBAR_INT, index,
2136
COL_SIDEBAR_BATTERY_DEVICE, device,
2137
COL_SIDEBAR_OBJECT_PATH, object_path,
2138
COL_SIDEBAR_SIGNAL_ID, signal_id,
2139
COL_SIDEBAR_VIEW, view,
2140
-1);
2141
2142
/* Add the icon and description for the device */
2143
update_device_details (device);
2144
2145
/* See if we're to select this device, for it to be selected,
2146
* the starting_device_id must be unset and the this is the first
2147
* time add_device is called (i.e. select the first device) or
2148
* our current device matches starting_device_id. */
2149
if ((starting_device_id == NULL && first_run == TRUE) ||
2150
(g_strcmp0 (object_path, starting_device_id) == 0))
2151
{
2152
GtkTreeSelection *selection;
2153
2154
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sideview));
2155
2156
gtk_tree_selection_select_iter (selection, &iter);
2157
view_cursor_changed_cb (GTK_TREE_VIEW (sideview), NULL);
2158
}
2159
2160
first_run = FALSE;
2178
2161
}
2179
2162
2180
2163
static void
2181
2164
remove_device (const gchar *object_path)
2182
2165
{
2183
GtkTreeIter *iter;
2184
GtkListStore *list_store;
2185
gulong signal_id;
2186
UpDevice *device;
2187
2188
TRACE("entering for %s", object_path);
2189
2190
iter = find_device_in_tree (object_path);
2191
2192
if (iter == NULL)
2193
return;
2194
2195
list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(sideview)));
2196
2197
gtk_tree_model_get (GTK_TREE_MODEL(list_store), iter,
2198
COL_SIDEBAR_SIGNAL_ID, &signal_id,
2199
COL_SIDEBAR_BATTERY_DEVICE, &device,
2200
-1);
2201
2202
gtk_list_store_remove (list_store, iter);
2203
2204
if (device)
2205
g_signal_handler_disconnect (device, signal_id);
2206
2207
/* If there are no devices left, hide the devices tab */
2208
if(!gtk_tree_model_get_iter_first (GTK_TREE_MODEL(list_store), iter))
2209
gtk_widget_hide (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2166
GtkTreeIter *iter;
2167
GtkListStore *list_store;
2168
gulong signal_id;
2169
UpDevice *device;
2170
2171
TRACE("entering for %s", object_path);
2172
2173
iter = find_device_in_tree (object_path);
2174
2175
if (iter == NULL)
2176
return;
2177
2178
list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(sideview)));
2179
2180
gtk_tree_model_get (GTK_TREE_MODEL(list_store), iter,
2181
COL_SIDEBAR_SIGNAL_ID, &signal_id,
2182
COL_SIDEBAR_BATTERY_DEVICE, &device,
2183
-1);
2184
2185
gtk_list_store_remove (list_store, iter);
2186
2187
if (device)
2188
g_signal_handler_disconnect (device, signal_id);
2189
2190
/* If there are no devices left, hide the devices tab */
2191
if(!gtk_tree_model_get_iter_first (GTK_TREE_MODEL(list_store), iter))
2192
gtk_widget_hide (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2210
2193
}
2211
2194
2212
2195
static void
2213
2196
device_added_cb (UpClient *upclient, UpDevice *device, gpointer user_data)
2214
2197
{
2215
add_device (device);
2198
add_device (device);
2216
2199
}
2217
2200
2218
2201
static void
2219
2202
device_removed_cb (UpClient *upclient, const gchar *object_path, gpointer user_data)
2220
2203
{
2221
remove_device (object_path);
2204
remove_device (object_path);
2222
2205
}
2223
2206
2224
2207
static void
2225
2208
add_all_devices (void)
2226
2209
{
2227
GPtrArray *array = NULL;
2228
guint i;
2210
GPtrArray *array = NULL;
2211
guint i;
2229
2212
2230
2213
#if UP_CHECK_VERSION(0, 99, 8)
2231
array = up_client_get_devices2 (upower);
2214
array = up_client_get_devices2 (upower);
2232
2215
#else
2233
array = up_client_get_devices (upower);
2216
array = up_client_get_devices (upower);
2234
2217
#endif
2235
2218
2236
if ( array )
2219
if ( array )
2220
{
2221
for ( i = 0; i < array->len; i++)
2237
2222
{
2238
for ( i = 0; i < array->len; i++)
2239
{
2240
UpDevice *device = g_ptr_array_index (array, i);
2223
UpDevice *device = g_ptr_array_index (array, i);
2241
2224
2242
add_device (device);
2243
}
2244
g_ptr_array_free (array, TRUE);
2225
add_device (device);
2245
2226
}
2227
g_ptr_array_free (array, TRUE);
2228
}
2246
2229
}
2247
2230
2248
2231
static void
2249
2232
settings_create_devices_list (void)
2250
2233
{
2251
upower = up_client_new ();
2252
2253
g_signal_connect (upower, "device-added", G_CALLBACK (device_added_cb), NULL);
2254
g_signal_connect (upower, "device-removed", G_CALLBACK (device_removed_cb), NULL);
2255
2256
add_all_devices ();
2234
upower = up_client_new ();
2235
2236
g_signal_connect (upower, "device-added", G_CALLBACK (device_added_cb), NULL);
2237
g_signal_connect (upower, "device-removed", G_CALLBACK (device_removed_cb), NULL);
2238
2239
add_all_devices ();
2257
2240
}
2258
2241
2259
2242
static void
2260
2243
view_cursor_changed_cb (GtkTreeView *view, gpointer *user_data)
2261
2244
{
2262
GtkTreeSelection *sel;
2263
GtkTreeModel *model;
2264
GtkTreeIter selected_row;
2265
gint int_data = 0;
2266
2267
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
2268
2269
if ( !gtk_tree_selection_get_selected (sel, &model, &selected_row))
2270
return;
2271
2272
gtk_tree_model_get(model,
2273
&selected_row,
2274
COL_SIDEBAR_INT,
2275
&int_data,
2276
-1);
2277
2278
gtk_notebook_set_current_page (GTK_NOTEBOOK (device_details_notebook), int_data);
2245
GtkTreeSelection *sel;
2246
GtkTreeModel *model;
2247
GtkTreeIter selected_row;
2248
gint int_data = 0;
2249
2250
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
2251
2252
if ( !gtk_tree_selection_get_selected (sel, &model, &selected_row))
2253
return;
2254
2255
gtk_tree_model_get (model,
2256
&selected_row,
2257
COL_SIDEBAR_INT,
2258
&int_data,
2259
-1);
2260
2261
gtk_notebook_set_current_page (GTK_NOTEBOOK (device_details_notebook), int_data);
2279
2262
}
2280
2263
2281
2264
static void
2282
2265
settings_quit (GtkWidget *widget, XfconfChannel *channel)
2283
2266
{
2284
g_object_unref (channel);
2285
xfconf_shutdown();
2286
gtk_widget_destroy (widget);
2287
/* initiate the quit action on the application so it terminates */
2288
g_action_group_activate_action(G_ACTION_GROUP(app), "quit", NULL);
2267
g_object_unref (channel);
2268
xfconf_shutdown ();
2269
gtk_widget_destroy (widget);
2270
/* initiate the quit action on the application so it terminates */
2271
g_action_group_activate_action (G_ACTION_GROUP(app), "quit", NULL);
2289
2272
}
2290
2273
2291
2274
static void dialog_response_cb (GtkDialog *dialog, gint response, XfconfChannel *channel)
2292
2275
{
2293
switch(response)
2294
{
2295
case GTK_RESPONSE_HELP:
2296
xfce_dialog_show_help_with_version (NULL, "xfce4-power-manager", "start", NULL, XFPM_VERSION_SHORT);
2297
break;
2298
default:
2299
settings_quit (GTK_WIDGET (dialog), channel);
2300
break;
2301
}
2276
switch(response)
2277
{
2278
case GTK_RESPONSE_HELP:
2279
xfce_dialog_show_help_with_version (NULL, "xfce4-power-manager", "start", NULL, XFPM_VERSION_SHORT);
2280
break;
2281
default:
2282
settings_quit (GTK_WIDGET (dialog), channel);
2283
break;
2284
}
2302
2285
}
2303
2286
2304
2287
static void
2305
2288
delete_event_cb (GtkWidget *plug, GdkEvent *ev, XfconfChannel *channel)
2306
2289
{
2307
settings_quit (plug, channel);
2290
settings_quit (plug, channel);
2308
2291
}
2309
2292
2310
2293
GtkWidget *
2317
2300
gboolean has_battery_button, Window id, gchar *device_id,
2318
2301
GtkApplication *gtk_app)
2319
2302
{
2320
GtkWidget *plug;
2321
GtkWidget *parent;
2322
GtkWidget *dialog;
2323
GtkWidget *plugged_box;
2324
GtkWidget *viewport;
2325
GtkWidget *hbox;
2326
GtkWidget *frame;
2327
GtkWidget *switch_widget;
2328
GtkWidget *stack;
2329
GtkStyleContext *context;
2330
GtkListStore *list_store;
2331
GtkTreeViewColumn *col;
2332
GtkCellRenderer *renderer;
2333
GError *error = NULL;
2334
guint val;
2335
GtkCssProvider *css_provider;
2336
2337
XFPM_DEBUG ("auth_hibernate=%s auth_suspend=%s can_shutdown=%s can_suspend=%s can_hibernate=%s " \
2338
"has_battery=%s has_lcd_brightness=%s has_lid=%s has_sleep_button=%s " \
2339
"has_hibernate_button=%s has_power_button=%s has_battery_button=%s",
2340
xfpm_bool_to_string (has_battery), xfpm_bool_to_string (auth_hibernate),
2341
xfpm_bool_to_string (can_shutdown), xfpm_bool_to_string (auth_suspend),
2342
xfpm_bool_to_string (can_suspend), xfpm_bool_to_string (can_hibernate),
2343
xfpm_bool_to_string (has_lcd_brightness), xfpm_bool_to_string (has_lid),
2344
xfpm_bool_to_string (has_sleep_button), xfpm_bool_to_string (has_hibernate_button),
2345
xfpm_bool_to_string (has_power_button), xfpm_bool_to_string (has_battery_button));
2346
2347
xml = xfpm_builder_new_from_string (xfpm_settings_ui, &error);
2348
2349
if ( G_UNLIKELY (error) )
2350
{
2351
xfce_dialog_show_error (NULL, error, "%s", _("Check your power manager installation"));
2352
g_error ("%s", error->message);
2353
}
2354
2355
lcd_brightness = has_lcd_brightness;
2356
starting_device_id = device_id;
2357
2358
on_battery_dpms_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-battery"));
2359
on_battery_dpms_off = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-battery"));
2360
on_ac_dpms_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-ac"));
2361
on_ac_dpms_off = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-ac"));
2362
2363
on_battery_display_blank = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-battery"));
2364
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_BLANK, 1);
2365
gtk_range_set_value (GTK_RANGE (on_battery_display_blank), val);
2366
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_BLANK,
2367
G_TYPE_INT, gtk_range_get_adjustment (GTK_RANGE (on_battery_display_blank)),
2368
"value");
2369
2370
on_ac_display_blank = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-ac"));
2371
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX ON_AC_BLANK,
2372
G_TYPE_INT, gtk_range_get_adjustment (GTK_RANGE (on_ac_display_blank)),
2373
"value");
2374
2375
switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "handle-brightness-keys"));
2376
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX HANDLE_BRIGHTNESS_KEYS,
2377
G_TYPE_BOOLEAN, switch_widget, "active");
2378
2379
switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "show-notifications"));
2380
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX GENERAL_NOTIFICATION_CFG,
2381
G_TYPE_BOOLEAN, switch_widget, "active");
2382
2383
switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "show-systray"));
2384
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX SHOW_TRAY_ICON_CFG,
2385
G_TYPE_BOOLEAN, switch_widget, "active");
2386
2387
dialog = GTK_WIDGET (gtk_builder_get_object (xml, "xfpm-settings-dialog"));
2388
nt = GTK_WIDGET (gtk_builder_get_object (xml, "main-notebook"));
2389
2390
/* Set Gtk style */
2391
css_provider = gtk_css_provider_new ();
2392
gtk_css_provider_load_from_data (css_provider,
2393
".xfce4-scale-label { padding-bottom: 0; }",
2394
-1, NULL);
2395
gtk_style_context_add_provider_for_screen (gdk_screen_get_default(),
2396
GTK_STYLE_PROVIDER(css_provider),
2397
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
2398
g_object_unref (css_provider);
2399
2400
/* Devices listview */
2401
sideview = gtk_tree_view_new ();
2402
list_store = gtk_list_store_new (NCOLS_SIDEBAR,
2403
GDK_TYPE_PIXBUF, /* COL_SIDEBAR_ICON */
2404
G_TYPE_STRING, /* COL_SIDEBAR_NAME */
2405
G_TYPE_INT, /* COL_SIDEBAR_INT */
2406
G_TYPE_POINTER, /* COL_SIDEBAR_BATTERY_DEVICE */
2407
G_TYPE_STRING, /* COL_SIDEBAR_OBJECT_PATH */
2408
G_TYPE_ULONG, /* COL_SIDEBAR_SIGNAL_ID */
2409
G_TYPE_POINTER /* COL_SIDEBAR_VIEW */
2410
);
2411
2412
gtk_tree_view_set_model (GTK_TREE_VIEW (sideview), GTK_TREE_MODEL (list_store));
2413
2414
col = gtk_tree_view_column_new ();
2415
2416
renderer = gtk_cell_renderer_pixbuf_new ();
2417
2418
gtk_tree_view_column_pack_start (col, renderer, FALSE);
2419
gtk_tree_view_column_set_attributes (col, renderer, "pixbuf", 0, NULL);
2420
2421
/* The device label */
2422
renderer = gtk_cell_renderer_text_new ();
2423
gtk_tree_view_column_pack_start (col, renderer, FALSE);
2424
gtk_tree_view_column_set_attributes (col, renderer, "markup", 1, NULL);
2425
2426
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (sideview), FALSE);
2427
gtk_tree_view_append_column (GTK_TREE_VIEW (sideview), col);
2428
2429
g_signal_connect (sideview, "cursor-changed", G_CALLBACK (view_cursor_changed_cb), NULL);
2430
2431
/* Pack the content of the devices tab */
2432
device_details_notebook = gtk_notebook_new ();
2433
2434
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (device_details_notebook), FALSE);
2435
context = gtk_widget_get_style_context (GTK_WIDGET (device_details_notebook));
2436
gtk_style_context_add_class (context, "frame");
2437
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
2438
2439
viewport = gtk_viewport_new (NULL, NULL);
2440
gtk_container_add (GTK_CONTAINER (viewport), sideview);
2441
gtk_box_pack_start (GTK_BOX (hbox), viewport, FALSE, FALSE, 0);
2442
gtk_box_pack_start (GTK_BOX (hbox), device_details_notebook, TRUE, TRUE, 0);
2443
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
2444
devices_page_num = gtk_notebook_append_page (GTK_NOTEBOOK (nt), hbox, gtk_label_new (_("Devices")) );
2445
2446
gtk_widget_show_all (sideview);
2447
gtk_widget_show_all (viewport);
2448
gtk_widget_show_all (hbox);
2449
gtk_widget_hide (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2450
2451
settings_create_devices_list ();
2452
2453
xfpm_settings_on_ac (channel,
2454
auth_suspend,
2455
auth_hibernate,
2456
can_suspend,
2457
can_hibernate,
2458
has_lcd_brightness,
2459
has_lid);
2460
2461
if ( has_battery )
2462
xfpm_settings_on_battery (channel,
2463
auth_suspend,
2464
auth_hibernate,
2465
can_suspend,
2466
can_hibernate,
2467
can_shutdown,
2468
has_lcd_brightness,
2469
has_lid);
2470
else
2471
{
2472
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"critical-power-frame")));
2473
stack = GTK_WIDGET (gtk_builder_get_object (xml ,"system-stack"));
2474
gtk_widget_hide (gtk_stack_get_child_by_name (GTK_STACK (stack), "page0"));
2475
stack = GTK_WIDGET (gtk_builder_get_object (xml ,"display-stack"));
2476
gtk_widget_hide (gtk_stack_get_child_by_name (GTK_STACK (stack), "page0"));
2477
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"system-stack-switcher")));
2478
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"display-stack-switcher")));
2479
}
2480
2481
xfpm_settings_general (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate, can_shutdown,
2482
has_sleep_button, has_hibernate_button, has_power_button, has_battery_button);
2483
2484
xfpm_settings_advanced (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate, has_battery);
2485
2486
/* Light Locker Integration */
2487
xfpm_settings_light_locker (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate);
2488
/* END Light Locker Integration */
2489
2490
if ( !has_lcd_brightness )
2491
{
2303
GtkWidget *plug;
2304
GtkWidget *parent;
2305
GtkWidget *dialog;
2306
GtkWidget *plugged_box;
2307
GtkWidget *viewport;
2308
GtkWidget *hbox;
2309
GtkWidget *frame;
2310
GtkWidget *switch_widget;
2311
GtkWidget *stack;
2312
GtkStyleContext *context;
2313
GtkListStore *list_store;
2314
GtkTreeViewColumn *col;
2315
GtkCellRenderer *renderer;
2316
GError *error = NULL;
2317
guint val;
2318
GtkCssProvider *css_provider;
2319
2320
XFPM_DEBUG ("auth_hibernate=%s auth_suspend=%s can_shutdown=%s can_suspend=%s can_hibernate=%s " \
2321
"has_battery=%s has_lcd_brightness=%s has_lid=%s has_sleep_button=%s " \
2322
"has_hibernate_button=%s has_power_button=%s has_battery_button=%s",
2323
xfpm_bool_to_string (has_battery), xfpm_bool_to_string (auth_hibernate),
2324
xfpm_bool_to_string (can_shutdown), xfpm_bool_to_string (auth_suspend),
2325
xfpm_bool_to_string (can_suspend), xfpm_bool_to_string (can_hibernate),
2326
xfpm_bool_to_string (has_lcd_brightness), xfpm_bool_to_string (has_lid),
2327
xfpm_bool_to_string (has_sleep_button), xfpm_bool_to_string (has_hibernate_button),
2328
xfpm_bool_to_string (has_power_button), xfpm_bool_to_string (has_battery_button));
2329
2330
xml = xfpm_builder_new_from_string (xfpm_settings_ui, &error);
2331
2332
if ( G_UNLIKELY (error) )
2333
{
2334
xfce_dialog_show_error (NULL, error, "%s", _("Check your power manager installation"));
2335
g_error ("%s", error->message);
2336
}
2337
2338
lcd_brightness = has_lcd_brightness;
2339
starting_device_id = device_id;
2340
2341
on_battery_dpms_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-battery"));
2342
on_battery_dpms_off = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-battery"));
2343
on_ac_dpms_sleep = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-sleep-on-ac"));
2344
on_ac_dpms_off = GTK_WIDGET (gtk_builder_get_object (xml, "dpms-off-on-ac"));
2345
2346
on_battery_display_blank = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-battery"));
2347
val = xfconf_channel_get_uint (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_BLANK, 1);
2348
gtk_range_set_value (GTK_RANGE (on_battery_display_blank), val);
2349
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX ON_BATTERY_BLANK,
2350
G_TYPE_INT, gtk_range_get_adjustment (GTK_RANGE (on_battery_display_blank)),
2351
"value");
2352
2353
on_ac_display_blank = GTK_WIDGET (gtk_builder_get_object (xml, "display-blank-on-ac"));
2354
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX ON_AC_BLANK,
2355
G_TYPE_INT, gtk_range_get_adjustment (GTK_RANGE (on_ac_display_blank)),
2356
"value");
2357
2358
switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "handle-brightness-keys"));
2359
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX HANDLE_BRIGHTNESS_KEYS,
2360
G_TYPE_BOOLEAN, switch_widget, "active");
2361
2362
switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "show-notifications"));
2363
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX GENERAL_NOTIFICATION_CFG,
2364
G_TYPE_BOOLEAN, switch_widget, "active");
2365
2366
switch_widget = GTK_WIDGET (gtk_builder_get_object (xml, "show-systray"));
2367
xfconf_g_property_bind (channel, XFPM_PROPERTIES_PREFIX SHOW_TRAY_ICON_CFG,
2368
G_TYPE_BOOLEAN, switch_widget, "active");
2369
2370
dialog = GTK_WIDGET (gtk_builder_get_object (xml, "xfpm-settings-dialog"));
2371
nt = GTK_WIDGET (gtk_builder_get_object (xml, "main-notebook"));
2372
2373
/* Set Gtk style */
2374
css_provider = gtk_css_provider_new ();
2375
gtk_css_provider_load_from_data (css_provider,
2376
".xfce4-scale-label { padding-bottom: 0; }",
2377
-1, NULL);
2378
gtk_style_context_add_provider_for_screen (gdk_screen_get_default(),
2379
GTK_STYLE_PROVIDER(css_provider),
2380
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
2381
g_object_unref (css_provider);
2382
2383
/* Devices listview */
2384
sideview = gtk_tree_view_new ();
2385
list_store = gtk_list_store_new (NCOLS_SIDEBAR,
2386
GDK_TYPE_PIXBUF, /* COL_SIDEBAR_ICON */
2387
G_TYPE_STRING, /* COL_SIDEBAR_NAME */
2388
G_TYPE_INT, /* COL_SIDEBAR_INT */
2389
G_TYPE_POINTER, /* COL_SIDEBAR_BATTERY_DEVICE */
2390
G_TYPE_STRING, /* COL_SIDEBAR_OBJECT_PATH */
2391
G_TYPE_ULONG, /* COL_SIDEBAR_SIGNAL_ID */
2392
G_TYPE_POINTER /* COL_SIDEBAR_VIEW */
2393
);
2394
2395
gtk_tree_view_set_model (GTK_TREE_VIEW (sideview), GTK_TREE_MODEL (list_store));
2396
2397
col = gtk_tree_view_column_new ();
2398
2399
renderer = gtk_cell_renderer_pixbuf_new ();
2400
2401
gtk_tree_view_column_pack_start (col, renderer, FALSE);
2402
gtk_tree_view_column_set_attributes (col, renderer, "pixbuf", 0, NULL);
2403
2404
/* The device label */
2405
renderer = gtk_cell_renderer_text_new ();
2406
gtk_tree_view_column_pack_start (col, renderer, FALSE);
2407
gtk_tree_view_column_set_attributes (col, renderer, "markup", 1, NULL);
2408
2409
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (sideview), FALSE);
2410
gtk_tree_view_append_column (GTK_TREE_VIEW (sideview), col);
2411
2412
g_signal_connect (sideview, "cursor-changed", G_CALLBACK (view_cursor_changed_cb), NULL);
2413
2414
/* Pack the content of the devices tab */
2415
device_details_notebook = gtk_notebook_new ();
2416
2417
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (device_details_notebook), FALSE);
2418
context = gtk_widget_get_style_context (GTK_WIDGET (device_details_notebook));
2419
gtk_style_context_add_class (context, "frame");
2420
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
2421
2422
viewport = gtk_viewport_new (NULL, NULL);
2423
gtk_container_add (GTK_CONTAINER (viewport), sideview);
2424
gtk_box_pack_start (GTK_BOX (hbox), viewport, FALSE, FALSE, 0);
2425
gtk_box_pack_start (GTK_BOX (hbox), device_details_notebook, TRUE, TRUE, 0);
2426
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
2427
devices_page_num = gtk_notebook_append_page (GTK_NOTEBOOK (nt), hbox, gtk_label_new (_("Devices")) );
2428
2429
gtk_widget_show_all (sideview);
2430
gtk_widget_show_all (viewport);
2431
gtk_widget_show_all (hbox);
2432
gtk_widget_hide (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2433
2434
settings_create_devices_list ();
2435
2436
xfpm_settings_on_ac (channel,
2437
auth_suspend,
2438
auth_hibernate,
2439
can_suspend,
2440
can_hibernate,
2441
has_lcd_brightness,
2442
has_lid);
2443
2444
if ( has_battery )
2445
xfpm_settings_on_battery (channel,
2446
auth_suspend,
2447
auth_hibernate,
2448
can_suspend,
2449
can_hibernate,
2450
can_shutdown,
2451
has_lcd_brightness,
2452
has_lid);
2453
else
2454
{
2455
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"critical-power-frame")));
2456
stack = GTK_WIDGET (gtk_builder_get_object (xml ,"system-stack"));
2457
gtk_widget_hide (gtk_stack_get_child_by_name (GTK_STACK (stack), "page0"));
2458
stack = GTK_WIDGET (gtk_builder_get_object (xml ,"display-stack"));
2459
gtk_widget_hide (gtk_stack_get_child_by_name (GTK_STACK (stack), "page0"));
2460
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"system-stack-switcher")));
2461
gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (xml ,"display-stack-switcher")));
2462
}
2463
2464
xfpm_settings_general (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate, can_shutdown,
2465
has_sleep_button, has_hibernate_button, has_power_button, has_battery_button);
2466
2467
xfpm_settings_advanced (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate, has_battery);
2468
2469
/* Light Locker Integration */
2470
xfpm_settings_light_locker (channel, auth_suspend, auth_hibernate, can_suspend, can_hibernate);
2471
/* END Light Locker Integration */
2472
2473
if ( !has_lcd_brightness )
2474
{
2492
2475
frame = GTK_WIDGET (gtk_builder_get_object (xml, "brightness-frame"));
2493
2476
gtk_widget_hide (frame);
2494
2477
frame = GTK_WIDGET (gtk_builder_get_object (xml, "handle-brightness-keys"));
2495
2478
gtk_widget_hide (frame);
2496
2479
frame = GTK_WIDGET (gtk_builder_get_object (xml, "handle-brightness-keys-label"));
2497
2480
gtk_widget_hide (frame);
2498
}
2481
}
2499
2482
2500
if ( id != 0 )
2501
{
2502
plugged_box = GTK_WIDGET (gtk_builder_get_object (xml, "plug-child"));
2503
plug = gtk_plug_new (id);
2504
gtk_widget_show (plug);
2483
if ( id != 0 )
2484
{
2485
plugged_box = GTK_WIDGET (gtk_builder_get_object (xml, "plug-child"));
2486
plug = gtk_plug_new (id);
2487
gtk_widget_show (plug);
2505
2488
2506
2489
parent = gtk_widget_get_parent (plugged_box);
2507
2490
if (parent)
2508
2491
{
2509
g_object_ref (plugged_box);
2510
gtk_container_remove (GTK_CONTAINER (parent), plugged_box);
2511
gtk_container_add (GTK_CONTAINER (plug), plugged_box);
2512
g_object_unref (plugged_box);
2513
}
2514
2515
g_signal_connect (plug, "delete-event",
2516
G_CALLBACK (delete_event_cb), channel);
2517
gdk_notify_startup_complete ();
2518
}
2519
else
2520
{
2521
g_signal_connect (dialog, "response", G_CALLBACK (dialog_response_cb), channel);
2522
gtk_widget_show (dialog);
2523
}
2524
2525
gtk_builder_connect_signals (xml, channel);
2526
2527
/* If we passed in a device to display, show the devices tab now, otherwise hide it */
2528
if (device_id != NULL)
2529
{
2530
gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2531
gtk_notebook_set_current_page (GTK_NOTEBOOK (nt), devices_page_num);
2532
}
2533
2534
/* keep a pointer to the GtkApplication instance so we can signal a
2535
* quit message */
2536
app = gtk_app;
2537
2538
return dialog;
2492
g_object_ref (plugged_box);
2493
gtk_container_remove (GTK_CONTAINER (parent), plugged_box);
2494
gtk_container_add (GTK_CONTAINER (plug), plugged_box);
2495
g_object_unref (plugged_box);
2496
}
2497
2498
g_signal_connect (plug, "delete-event",
2499
G_CALLBACK (delete_event_cb), channel);
2500
gdk_notify_startup_complete ();
2501
}
2502
else
2503
{
2504
g_signal_connect (dialog, "response", G_CALLBACK (dialog_response_cb), channel);
2505
gtk_widget_show (dialog);
2506
}
2507
2508
gtk_builder_connect_signals (xml, channel);
2509
2510
/* If we passed in a device to display, show the devices tab now, otherwise hide it */
2511
if (device_id != NULL)
2512
{
2513
gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2514
gtk_notebook_set_current_page (GTK_NOTEBOOK (nt), devices_page_num);
2515
}
2516
2517
/* keep a pointer to the GtkApplication instance so we can signal a
2518
* quit message */
2519
app = gtk_app;
2520
2521
return dialog;
2539
2522
}
2540
2523
2541
2524
void
2542
2525
xfpm_settings_show_device_id (gchar *device_id)
2543
2526
{
2544
GtkTreeIter *device_iter;
2545
2546
if (device_id == NULL)
2547
return;
2548
2549
gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2550
gtk_notebook_set_current_page (GTK_NOTEBOOK (nt), devices_page_num);
2551
2552
DBG("device_id %s", device_id);
2553
2554
device_iter = find_device_in_tree (device_id);
2555
if (device_iter)
2556
{
2557
GtkTreeSelection *selection;
2558
2559
DBG("device found");
2560
2561
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sideview));
2562
2563
gtk_tree_selection_select_iter (selection, device_iter);
2564
view_cursor_changed_cb (GTK_TREE_VIEW (sideview), NULL);
2565
gtk_tree_iter_free (device_iter);
2566
}
2527
GtkTreeIter *device_iter;
2528
2529
if (device_id == NULL)
2530
return;
2531
2532
gtk_widget_show (gtk_notebook_get_nth_page (GTK_NOTEBOOK (nt), devices_page_num));
2533
gtk_notebook_set_current_page (GTK_NOTEBOOK (nt), devices_page_num);
2534
2535
DBG("device_id %s", device_id);
2536
2537
device_iter = find_device_in_tree (device_id);
2538
if (device_iter)
2539
{
2540
GtkTreeSelection *selection;
2541
2542
DBG("device found");
2543
2544
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (sideview));
2545
2546
gtk_tree_selection_select_iter (selection, device_iter);
2547
view_cursor_changed_cb (GTK_TREE_VIEW (sideview), NULL);
2548
gtk_tree_iter_free (device_iter);
2549
}
2567
2550
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1