← Back to branch summary

~kroq-gar78/ubuntu/precise/gnome-control-center/fix-885947

« back to all changes in this revision

Viewing changes to panels/screen/cc-screen-panel.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Moya
  • Date: 2011-05-17 10:47:27 UTC
  • mfrom: (0.1.11 experimental) (1.1.45 upstream)
  • Revision ID: james.westby@ubuntu.com-20110517104727-lqel6m8vhfw5jby1
Tags: 1:3.0.1.1-1ubuntu1
* Rebase on Debian, remaining Ubuntu changes:
* debian/control:
  - Build-Depend on hardening-wrapper, dpkg-dev and dh-autoreconf
  - Add dependency on ubuntu-system-service
  - Remove dependency on gnome-icon-theme-symbolic
  - Move dependency on apg, gnome-icon-theme-symbolic and accountsservice to
    be a Recommends: until we get them in main
* debian/rules:
  - Use autoreconf
  - Add binary-post-install rule for gnome-control-center-data
  - Run dh-autoreconf
* debian/gnome-control-center.dirs:
* debian/gnome-control-center.links:
  - Add a link to the control center shell for indicators
* debian/patches/00_disable-nm.patch:
  - Temporary patch to disable building with NetworkManager until we get
    the new one in the archive
* debian/patches/01_git_remove_gettext_calls.patch:
  - Remove calls to AM_GNU_GETTEXT, IT_PROG_INTLTOOL should be enough
* debian/patches/01_git_kill_warning.patch:
  - Kill warning
* debian/patches/50_ubuntu_systemwide_prefs.patch:
  - Ubuntu specific proxy preferences
* debian/patches/51_ubuntu_system_keyboard.patch:
  - Implement the global keyboard spec at https://wiki.ubuntu.com/DefaultKeyboardSettings

Show diffs side-by-side

added added

removed removed

Lines of Context:
panels/screen/cc-screen-panel.c
 
1
/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
 
2
 *
 
3
 * Copyright (C) 2010 Red Hat, Inc
 
4
 * Copyright (C) 2008 William Jon McCann <jmccann@redhat.com>
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
19
 *
 
20
 */
 
21
 
 
22
#include "cc-screen-panel.h"
 
23
 
 
24
G_DEFINE_DYNAMIC_TYPE (CcScreenPanel, cc_screen_panel, CC_TYPE_PANEL)
 
25
 
 
26
#define SCREEN_PANEL_PRIVATE(o) \
 
27
  (G_TYPE_INSTANCE_GET_PRIVATE ((o), CC_TYPE_SCREEN_PANEL, CcScreenPanelPrivate))
 
28
 
 
29
#define WID(s) GTK_WIDGET (gtk_builder_get_object (self->priv->builder, s))
 
30
 
 
31
struct _CcScreenPanelPrivate
 
32
{
 
33
  GSettings     *lock_settings;
 
34
  GSettings     *gsd_settings;
 
35
  GSettings     *session_settings;
 
36
  GSettings     *lockdown_settings;
 
37
  GCancellable  *cancellable;
 
38
  GtkBuilder    *builder;
 
39
  GDBusProxy    *proxy;
 
40
  gboolean       setting_brightness;
 
41
};
 
42
 
 
43
 
 
44
static void
 
45
cc_screen_panel_get_property (GObject    *object,
 
46
                              guint       property_id,
 
47
                              GValue     *value,
 
48
                              GParamSpec *pspec)
 
49
{
 
50
  switch (property_id)
 
51
    {
 
52
    default:
 
53
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
54
    }
 
55
}
 
56
 
 
57
static void
 
58
cc_screen_panel_set_property (GObject      *object,
 
59
                              guint         property_id,
 
60
                              const GValue *value,
 
61
                              GParamSpec   *pspec)
 
62
{
 
63
  switch (property_id)
 
64
    {
 
65
    default:
 
66
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
67
    }
 
68
}
 
69
 
 
70
static void
 
71
cc_screen_panel_dispose (GObject *object)
 
72
{
 
73
  CcScreenPanelPrivate *priv = CC_SCREEN_PANEL (object)->priv;
 
74
 
 
75
  if (priv->lock_settings)
 
76
    {
 
77
      g_object_unref (priv->lock_settings);
 
78
      priv->lock_settings = NULL;
 
79
    }
 
80
  if (priv->gsd_settings)
 
81
    {
 
82
      g_object_unref (priv->gsd_settings);
 
83
      priv->gsd_settings = NULL;
 
84
    }
 
85
  if (priv->session_settings)
 
86
    {
 
87
      g_object_unref (priv->session_settings);
 
88
      priv->session_settings = NULL;
 
89
    }
 
90
  if (priv->lockdown_settings)
 
91
    {
 
92
      g_object_unref (priv->lockdown_settings);
 
93
      priv->lockdown_settings = NULL;
 
94
    }
 
95
  if (priv->cancellable != NULL)
 
96
    {
 
97
      g_object_unref (priv->cancellable);
 
98
      priv->cancellable = NULL;
 
99
    }
 
100
  if (priv->builder != NULL)
 
101
    {
 
102
      g_object_unref (priv->builder);
 
103
      priv->builder = NULL;
 
104
    }
 
105
  if (priv->proxy != NULL)
 
106
    {
 
107
      g_object_unref (priv->proxy);
 
108
      priv->proxy = NULL;
 
109
    }
 
110
 
 
111
  G_OBJECT_CLASS (cc_screen_panel_parent_class)->dispose (object);
 
112
}
 
113
 
 
114
static void
 
115
cc_screen_panel_finalize (GObject *object)
 
116
{
 
117
  CcScreenPanelPrivate *priv = CC_SCREEN_PANEL (object)->priv;
 
118
  g_cancellable_cancel (priv->cancellable);
 
119
  G_OBJECT_CLASS (cc_screen_panel_parent_class)->finalize (object);
 
120
}
 
121
 
 
122
static void
 
123
on_lock_settings_changed (GSettings     *settings,
 
124
                          const char    *key,
 
125
                          CcScreenPanel *panel)
 
126
{
 
127
  if (g_str_equal (key, "lock-delay") == FALSE)
 
128
    return;
 
129
}
 
130
 
 
131
static void
 
132
update_lock_screen_sensitivity (CcScreenPanel *self)
 
133
{
 
134
  GtkWidget *widget;
 
135
  gboolean   locked;
 
136
 
 
137
  widget = WID ("screen_lock_main_box");
 
138
  locked = g_settings_get_boolean (self->priv->lockdown_settings, "disable-lock-screen");
 
139
  gtk_widget_set_sensitive (widget, !locked);
 
140
}
 
141
 
 
142
static void
 
143
on_lockdown_settings_changed (GSettings     *settings,
 
144
                              const char    *key,
 
145
                              CcScreenPanel *panel)
 
146
{
 
147
  if (g_str_equal (key, "disable-lock-screen") == FALSE)
 
148
    return;
 
149
 
 
150
  update_lock_screen_sensitivity (panel);
 
151
}
 
152
 
 
153
static void
 
154
cc_screen_panel_class_init (CcScreenPanelClass *klass)
 
155
{
 
156
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
157
 
 
158
  g_type_class_add_private (klass, sizeof (CcScreenPanelPrivate));
 
159
 
 
160
  object_class->get_property = cc_screen_panel_get_property;
 
161
  object_class->set_property = cc_screen_panel_set_property;
 
162
  object_class->dispose = cc_screen_panel_dispose;
 
163
  object_class->finalize = cc_screen_panel_finalize;
 
164
}
 
165
 
 
166
static void
 
167
cc_screen_panel_class_finalize (CcScreenPanelClass *klass)
 
168
{
 
169
}
 
170
 
 
171
static void
 
172
on_signal (GDBusProxy *proxy,
 
173
           gchar      *sender_name,
 
174
           gchar      *signal_name,
 
175
           GVariant   *parameters,
 
176
           gpointer    user_data)
 
177
{
 
178
  CcScreenPanel *self = CC_SCREEN_PANEL (user_data);
 
179
 
 
180
  if (g_strcmp0 (signal_name, "BrightnessChanged") == 0)
 
181
    {
 
182
      guint brightness;
 
183
      GtkRange *range;
 
184
 
 
185
      /* changed, but ignoring */
 
186
      if (self->priv->setting_brightness)
 
187
        return;
 
188
 
 
189
      /* update the bar */
 
190
      g_variant_get (parameters,
 
191
                     "(u)",
 
192
                     &brightness);
 
193
      range = GTK_RANGE (WID ("screen_brightness_hscale"));
 
194
      gtk_range_set_value (range, brightness);
 
195
    }
 
196
}
 
197
 
 
198
static void
 
199
set_brightness_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
 
200
{
 
201
  GError *error = NULL;
 
202
  GVariant *result;
 
203
 
 
204
  CcScreenPanelPrivate *priv = CC_SCREEN_PANEL (user_data)->priv;
 
205
 
 
206
  /* not setting, so pay attention to changed signals */
 
207
  priv->setting_brightness = FALSE;
 
208
  result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error);
 
209
  if (result == NULL)
 
210
    {
 
211
      g_printerr ("Error setting brightness: %s\n", error->message);
 
212
      g_error_free (error);
 
213
      return;
 
214
    }
 
215
}
 
216
 
 
217
static void
 
218
brightness_slider_value_changed_cb (GtkRange *range, gpointer user_data)
 
219
{
 
220
  guint percentage;
 
221
  CcScreenPanelPrivate *priv = CC_SCREEN_PANEL (user_data)->priv;
 
222
 
 
223
  /* do not loop */
 
224
  priv->setting_brightness = TRUE;
 
225
 
 
226
  /* push this to g-p-m */
 
227
  percentage = (guint) gtk_range_get_value (range);
 
228
  g_dbus_proxy_call (priv->proxy,
 
229
                     "SetBrightness",
 
230
                     g_variant_new ("(u)",
 
231
                                    percentage),
 
232
                     G_DBUS_CALL_FLAGS_NONE,
 
233
                     -1,
 
234
                     priv->cancellable,
 
235
                     set_brightness_cb,
 
236
                     user_data);
 
237
}
 
238
 
 
239
static void
 
240
get_brightness_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
 
241
{
 
242
  GError *error = NULL;
 
243
  GVariant *result;
 
244
  guint brightness;
 
245
  GtkRange *range;
 
246
  CcScreenPanel *self = CC_SCREEN_PANEL (user_data);
 
247
 
 
248
  result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error);
 
249
  if (result == NULL)
 
250
    {
 
251
      gtk_widget_hide (WID ("screen_brightness_hscale"));
 
252
      gtk_widget_hide (WID ("screen_auto_reduce_checkbutton"));
 
253
      g_debug ("Error getting brightness: %s", error->message);
 
254
      g_error_free (error);
 
255
      return;
 
256
    }
 
257
 
 
258
  /* set the slider */
 
259
  g_variant_get (result,
 
260
                 "(u)",
 
261
                 &brightness);
 
262
  range = GTK_RANGE (WID ("screen_brightness_hscale"));
 
263
  gtk_range_set_range (range, 0, 100);
 
264
  gtk_range_set_increments (range, 1, 10);
 
265
  gtk_range_set_value (range, brightness);
 
266
  g_signal_connect (range,
 
267
                    "value-changed",
 
268
                    G_CALLBACK (brightness_slider_value_changed_cb),
 
269
                    user_data);
 
270
  g_variant_unref (result);
 
271
}
 
272
 
 
273
static void
 
274
got_power_proxy_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
 
275
{
 
276
  GError *error = NULL;
 
277
  CcScreenPanelPrivate *priv = CC_SCREEN_PANEL (user_data)->priv;
 
278
 
 
279
  priv->proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
 
280
  if (priv->proxy == NULL)
 
281
    {
 
282
      g_printerr ("Error creating proxy: %s\n", error->message);
 
283
      g_error_free (error);
 
284
      return;
 
285
    }
 
286
 
 
287
  /* we want to change the bar if the user presses brightness buttons */
 
288
  g_signal_connect (priv->proxy,
 
289
                    "g-signal",
 
290
                    G_CALLBACK (on_signal),
 
291
                    user_data);
 
292
 
 
293
  /* get the initial state */
 
294
  g_dbus_proxy_call (priv->proxy,
 
295
                     "GetBrightness",
 
296
                     NULL,
 
297
                     G_DBUS_CALL_FLAGS_NONE,
 
298
                     200, /* we don't want to randomly move the bar */
 
299
                     priv->cancellable,
 
300
                     get_brightness_cb,
 
301
                     user_data);
 
302
}
 
303
 
 
304
static void
 
305
set_idle_delay_from_dpms (CcScreenPanel *self,
 
306
                          int            value)
 
307
{
 
308
  guint off_delay;
 
309
 
 
310
  off_delay = 1;
 
311
 
 
312
  if (value > 0)
 
313
    off_delay = (guint) value;
 
314
 
 
315
  g_settings_set (self->priv->session_settings, "idle-delay", "u", off_delay);
 
316
}
 
317
 
 
318
static void
 
319
dpms_combo_changed_cb (GtkWidget *widget, CcScreenPanel *self)
 
320
{
 
321
  GtkTreeIter iter;
 
322
  GtkTreeModel *model;
 
323
  gint value;
 
324
  gboolean ret;
 
325
 
 
326
  /* no selection */
 
327
  ret = gtk_combo_box_get_active_iter (GTK_COMBO_BOX(widget), &iter);
 
328
  if (!ret)
 
329
    return;
 
330
 
 
331
  /* get entry */
 
332
  model = gtk_combo_box_get_model (GTK_COMBO_BOX(widget));
 
333
  gtk_tree_model_get (model, &iter,
 
334
                      1, &value,
 
335
                      -1);
 
336
 
 
337
  /* set both battery and ac keys */
 
338
  g_settings_set_int (self->priv->gsd_settings, "sleep-display-ac", value);
 
339
  g_settings_set_int (self->priv->gsd_settings, "sleep-display-battery", value);
 
340
 
 
341
  set_idle_delay_from_dpms (self, value);
 
342
}
 
343
 
 
344
static void
 
345
lock_combo_changed_cb (GtkWidget *widget, CcScreenPanel *self)
 
346
{
 
347
  GtkTreeIter iter;
 
348
  GtkTreeModel *model;
 
349
  guint delay;
 
350
  gboolean ret;
 
351
 
 
352
  /* no selection */
 
353
  ret = gtk_combo_box_get_active_iter (GTK_COMBO_BOX(widget), &iter);
 
354
  if (!ret)
 
355
    return;
 
356
 
 
357
  /* get entry */
 
358
  model = gtk_combo_box_get_model (GTK_COMBO_BOX(widget));
 
359
  gtk_tree_model_get (model, &iter,
 
360
                      1, &delay,
 
361
                      -1);
 
362
  g_settings_set (self->priv->lock_settings, "lock-delay", "u", delay);
 
363
}
 
364
 
 
365
static void
 
366
set_dpms_value_for_combo (GtkComboBox *combo_box, CcScreenPanel *self)
 
367
{
 
368
  GtkTreeIter iter;
 
369
  GtkTreeModel *model;
 
370
  gint value;
 
371
  gint value_tmp, value_prev;
 
372
  gboolean ret;
 
373
  guint i;
 
374
 
 
375
  /* get entry */
 
376
  model = gtk_combo_box_get_model (combo_box);
 
377
  ret = gtk_tree_model_get_iter_first (model, &iter);
 
378
  if (!ret)
 
379
    return;
 
380
 
 
381
  value_prev = 0;
 
382
  i = 0;
 
383
 
 
384
  /* try to make the UI match the AC setting */
 
385
  value = g_settings_get_int (self->priv->gsd_settings, "sleep-display-ac");
 
386
  do
 
387
    {
 
388
      gtk_tree_model_get (model, &iter,
 
389
                          1, &value_tmp,
 
390
                          -1);
 
391
      if (value == value_tmp ||
 
392
          (value_tmp > value_prev && value < value_tmp))
 
393
        {
 
394
          gtk_combo_box_set_active_iter (combo_box, &iter);
 
395
          return;
 
396
        }
 
397
      value_prev = value_tmp;
 
398
      i++;
 
399
    } while (gtk_tree_model_iter_next (model, &iter));
 
400
 
 
401
  /* If we didn't find the setting in the list */
 
402
  gtk_combo_box_set_active (combo_box, i - 1);
 
403
}
 
404
 
 
405
static void
 
406
set_lock_value_for_combo (GtkComboBox *combo_box, CcScreenPanel *self)
 
407
{
 
408
  GtkTreeIter iter;
 
409
  GtkTreeModel *model;
 
410
  guint value;
 
411
  gint value_tmp, value_prev;
 
412
  gboolean ret;
 
413
  guint i;
 
414
 
 
415
  /* get entry */
 
416
  model = gtk_combo_box_get_model (combo_box);
 
417
  ret = gtk_tree_model_get_iter_first (model, &iter);
 
418
  if (!ret)
 
419
    return;
 
420
 
 
421
  value_prev = 0;
 
422
  i = 0;
 
423
 
 
424
  /* try to make the UI match the lock setting */
 
425
  g_settings_get (self->priv->lock_settings, "lock-delay", "u", &value);
 
426
 
 
427
  do
 
428
    {
 
429
      gtk_tree_model_get (model, &iter,
 
430
                          1, &value_tmp,
 
431
                          -1);
 
432
      if (value == value_tmp ||
 
433
          (value_tmp > value_prev && value < value_tmp))
 
434
        {
 
435
          gtk_combo_box_set_active_iter (combo_box, &iter);
 
436
          return;
 
437
        }
 
438
      value_prev = value_tmp;
 
439
      i++;
 
440
    } while (gtk_tree_model_iter_next (model, &iter));
 
441
 
 
442
  /* If we didn't find the setting in the list */
 
443
  gtk_combo_box_set_active (combo_box, i - 1);
 
444
}
 
445
 
 
446
static void
 
447
cc_screen_panel_init (CcScreenPanel *self)
 
448
{
 
449
  GError     *error;
 
450
  GtkWidget  *widget;
 
451
 
 
452
  self->priv = SCREEN_PANEL_PRIVATE (self);
 
453
 
 
454
  self->priv->builder = gtk_builder_new ();
 
455
 
 
456
  error = NULL;
 
457
  gtk_builder_add_from_file (self->priv->builder,
 
458
                             GNOMECC_UI_DIR "/screen.ui",
 
459
                             &error);
 
460
 
 
461
  if (error != NULL)
 
462
    {
 
463
      g_warning ("Could not load interface file: %s", error->message);
 
464
      g_error_free (error);
 
465
      return;
 
466
    }
 
467
 
 
468
  self->priv->cancellable = g_cancellable_new ();
 
469
 
 
470
  /* get initial brightness version */
 
471
  g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
 
472
                            G_DBUS_PROXY_FLAGS_NONE,
 
473
                            NULL,
 
474
                            "org.gnome.PowerManager",
 
475
                            "/org/gnome/PowerManager/Backlight",
 
476
                            "org.gnome.PowerManager.Backlight",
 
477
                            self->priv->cancellable,
 
478
                            got_power_proxy_cb,
 
479
                            self);
 
480
 
 
481
  self->priv->lock_settings = g_settings_new ("org.gnome.desktop.screensaver");
 
482
  g_signal_connect (self->priv->lock_settings,
 
483
                    "changed",
 
484
                    G_CALLBACK (on_lock_settings_changed),
 
485
                    self);
 
486
  self->priv->gsd_settings = g_settings_new ("org.gnome.settings-daemon.plugins.power");
 
487
  self->priv->session_settings = g_settings_new ("org.gnome.desktop.session");
 
488
  self->priv->lockdown_settings = g_settings_new ("org.gnome.desktop.lockdown");
 
489
  g_signal_connect (self->priv->lockdown_settings,
 
490
                    "changed",
 
491
                    G_CALLBACK (on_lockdown_settings_changed),
 
492
                    self);
 
493
 
 
494
  /* bind the auto dim checkbox */
 
495
  widget = WID ("screen_auto_reduce_checkbutton");
 
496
  g_settings_bind (self->priv->gsd_settings,
 
497
                   "idle-dim-battery",
 
498
                   widget, "active",
 
499
                   G_SETTINGS_BIND_DEFAULT);
 
500
 
 
501
  /* display off time */
 
502
  widget = WID ("screen_brightness_combobox");
 
503
  set_dpms_value_for_combo (GTK_COMBO_BOX (widget), self);
 
504
  g_signal_connect (widget, "changed",
 
505
                    G_CALLBACK (dpms_combo_changed_cb),
 
506
                    self);
 
507
 
 
508
  /* bind the screen lock checkbox */
 
509
  widget = WID ("screen_lock_on_switch");
 
510
  g_settings_bind (self->priv->lock_settings,
 
511
                   "lock-enabled",
 
512
                   widget, "active",
 
513
                   G_SETTINGS_BIND_DEFAULT);
 
514
 
 
515
  /* lock time */
 
516
  widget = WID ("screen_lock_combobox");
 
517
  set_lock_value_for_combo (GTK_COMBO_BOX (widget), self);
 
518
  g_signal_connect (widget, "changed",
 
519
                    G_CALLBACK (lock_combo_changed_cb),
 
520
                    self);
 
521
 
 
522
  widget = WID ("screen_lock_hbox");
 
523
  g_settings_bind (self->priv->lock_settings,
 
524
                   "lock-enabled",
 
525
                   widget, "sensitive",
 
526
                   G_SETTINGS_BIND_GET);
 
527
 
 
528
  update_lock_screen_sensitivity (self);
 
529
 
 
530
  widget = WID ("screen_vbox");
 
531
  gtk_widget_reparent (widget, (GtkWidget *) self);
 
532
}
 
533
 
 
534
void
 
535
cc_screen_panel_register (GIOModule *module)
 
536
{
 
537
  cc_screen_panel_register_type (G_TYPE_MODULE (module));
 
538
  g_io_extension_point_implement (CC_SHELL_PANEL_EXTENSION_POINT,
 
539
                                  CC_TYPE_SCREEN_PANEL,
 
540
                                  "screen", 0);
 
541
}
 
542