← Back to branch summary

~ubuntu-branches/ubuntu/trusty/unity-control-center/trusty

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Robert Ancell
  • Date: 2014-01-08 16:29:18 UTC
  • Revision ID: package-import@ubuntu.com-20140108162918-g29dd08tr913y2qh
Tags: upstream-14.04.0
Import upstream version 14.04.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
panels/power/cc-power-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
 * Copyright (C) 2010 Richard Hughes <richard@hughsie.com>
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or modify
 
8
 * it under the terms of the GNU General Public License as published by
 
9
 * the Free Software Foundation; either version 2 of the License, or
 
10
 * (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
20
 *
 
21
 */
 
22
 
 
23
#include <config.h>
 
24
 
 
25
#include <libupower-glib/upower.h>
 
26
#include <glib/gi18n.h>
 
27
#include <gnome-settings-daemon/gsd-enums.h>
 
28
 
 
29
#include "cc-power-panel.h"
 
30
 
 
31
#define WID(b, w) (GtkWidget *) gtk_builder_get_object (b, w)
 
32
 
 
33
CC_PANEL_REGISTER (CcPowerPanel, cc_power_panel)
 
34
 
 
35
#define POWER_PANEL_PRIVATE(o) \
 
36
  (G_TYPE_INSTANCE_GET_PRIVATE ((o), CC_TYPE_POWER_PANEL, CcPowerPanelPrivate))
 
37
 
 
38
struct _CcPowerPanelPrivate
 
39
{
 
40
  GSettings     *lock_settings;
 
41
  GSettings     *gsd_settings;
 
42
  GSettings     *power_settings;
 
43
  GCancellable  *cancellable;
 
44
  GtkBuilder    *builder;
 
45
  GDBusProxy    *proxy;
 
46
  UpClient      *up_client;
 
47
  GtkWidget     *levelbar_primary;
 
48
};
 
49
 
 
50
enum
 
51
{
 
52
  ACTION_MODEL_TEXT,
 
53
  ACTION_MODEL_VALUE,
 
54
  ACTION_MODEL_SENSITIVE
 
55
};
 
56
 
 
57
static void
 
58
cc_power_panel_get_property (GObject    *object,
 
59
                              guint       property_id,
 
60
                              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_power_panel_set_property (GObject      *object,
 
72
                              guint         property_id,
 
73
                              const GValue *value,
 
74
                              GParamSpec   *pspec)
 
75
{
 
76
  switch (property_id)
 
77
    {
 
78
    default:
 
79
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
80
    }
 
81
}
 
82
 
 
83
static void
 
84
cc_power_panel_dispose (GObject *object)
 
85
{
 
86
  CcPowerPanelPrivate *priv = CC_POWER_PANEL (object)->priv;
 
87
 
 
88
  if (priv->gsd_settings)
 
89
    {
 
90
      g_object_unref (priv->gsd_settings);
 
91
      priv->gsd_settings = NULL;
 
92
    }
 
93
  if (priv->power_settings)
 
94
    {
 
95
      g_object_unref (priv->power_settings);
 
96
      priv->power_settings = NULL;
 
97
    }
 
98
  if (priv->cancellable != NULL)
 
99
    {
 
100
      g_cancellable_cancel (priv->cancellable);
 
101
      g_object_unref (priv->cancellable);
 
102
      priv->cancellable = NULL;
 
103
    }
 
104
  if (priv->builder != NULL)
 
105
    {
 
106
      g_object_unref (priv->builder);
 
107
      priv->builder = NULL;
 
108
    }
 
109
  if (priv->proxy != NULL)
 
110
    {
 
111
      g_object_unref (priv->proxy);
 
112
      priv->proxy = NULL;
 
113
    }
 
114
  if (priv->up_client != NULL)
 
115
    {
 
116
      g_object_unref (priv->up_client);
 
117
      priv->up_client = NULL;
 
118
    }
 
119
 
 
120
  G_OBJECT_CLASS (cc_power_panel_parent_class)->dispose (object);
 
121
}
 
122
 
 
123
static void
 
124
on_lock_settings_changed (GSettings     *settings,
 
125
                          const char    *key,
 
126
                          CcPowerPanel *panel)
 
127
{
 
128
}
 
129
 
 
130
static const char *
 
131
cc_power_panel_get_help_uri (CcPanel *panel)
 
132
{
 
133
  if (!g_strcmp0(g_getenv("XDG_CURRENT_DESKTOP"), "Unity"))
 
134
    return "help:ubuntu-help/power";
 
135
  else
 
136
    return "help:gnome-help/power";
 
137
}
 
138
 
 
139
static void
 
140
cc_power_panel_class_init (CcPowerPanelClass *klass)
 
141
{
 
142
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
143
  CcPanelClass *panel_class = CC_PANEL_CLASS (klass);
 
144
 
 
145
  g_type_class_add_private (klass, sizeof (CcPowerPanelPrivate));
 
146
 
 
147
  object_class->get_property = cc_power_panel_get_property;
 
148
  object_class->set_property = cc_power_panel_set_property;
 
149
  object_class->dispose = cc_power_panel_dispose;
 
150
 
 
151
  panel_class->get_help_uri = cc_power_panel_get_help_uri;
 
152
}
 
153
 
 
154
static gchar *
 
155
get_timestring (guint64 time_secs)
 
156
{
 
157
  gchar* timestring = NULL;
 
158
  gint  hours;
 
159
  gint  minutes;
 
160
 
 
161
  /* Add 0.5 to do rounding */
 
162
  minutes = (int) ( ( time_secs / 60.0 ) + 0.5 );
 
163
 
 
164
  if (minutes == 0)
 
165
    {
 
166
      timestring = g_strdup (_("Unknown time"));
 
167
      return timestring;
 
168
    }
 
169
 
 
170
  if (minutes < 60)
 
171
    {
 
172
      timestring = g_strdup_printf (ngettext ("%i minute",
 
173
                                    "%i minutes",
 
174
                                    minutes), minutes);
 
175
      return timestring;
 
176
    }
 
177
 
 
178
  hours = minutes / 60;
 
179
  minutes = minutes % 60;
 
180
 
 
181
  if (minutes == 0)
 
182
    {
 
183
      timestring = g_strdup_printf (ngettext (
 
184
                                    "%i hour",
 
185
                                    "%i hours",
 
186
                                    hours), hours);
 
187
      return timestring;
 
188
    }
 
189
 
 
190
  /* TRANSLATOR: "%i %s %i %s" are "%i hours %i minutes"
 
191
   * Swap order with "%2$s %2$i %1$s %1$i if needed */
 
192
  timestring = g_strdup_printf (_("%i %s %i %s"),
 
193
                                hours, ngettext ("hour", "hours", hours),
 
194
                                minutes, ngettext ("minute", "minutes", minutes));
 
195
  return timestring;
 
196
}
 
197
 
 
198
static void
 
199
set_device_battery_primary (CcPowerPanel *panel, GVariant *device)
 
200
{
 
201
  CcPowerPanelPrivate *priv = panel->priv;
 
202
  gchar *details = NULL;
 
203
  gchar *time_string = NULL;
 
204
  gdouble percentage;
 
205
  GtkWidget *widget;
 
206
  guint64 time;
 
207
  UpDeviceState state;
 
208
 
 
209
  /* set the device */
 
210
  g_variant_get (device,
 
211
                 "(susdut)",
 
212
                 NULL, /* object_path */
 
213
                 NULL, /* kind */
 
214
                 NULL, /* icon_name */
 
215
                 &percentage,
 
216
                 &state,
 
217
                 &time);
 
218
 
 
219
  /* set the percentage */
 
220
  gtk_level_bar_set_value (GTK_LEVEL_BAR (priv->levelbar_primary),
 
221
                           percentage / 100.0f);
 
222
 
 
223
  /* clear the warning */
 
224
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
225
                                               "image_primary_warning"));
 
226
  gtk_widget_hide (widget);
 
227
 
 
228
  /* set the description */
 
229
  if (time > 0)
 
230
    {
 
231
      time_string = get_timestring (time);
 
232
      switch (state)
 
233
        {
 
234
          case UP_DEVICE_STATE_CHARGING:
 
235
          case UP_DEVICE_STATE_PENDING_CHARGE:
 
236
            /* TRANSLATORS: %1 is a time string, e.g. "1 hour 5 minutes" */
 
237
            details = g_strdup_printf(_("Charging - %s until fully charged"),
 
238
                                      time_string);
 
239
            break;
 
240
          case UP_DEVICE_STATE_DISCHARGING:
 
241
          case UP_DEVICE_STATE_PENDING_DISCHARGE:
 
242
            if (percentage < 20)
 
243
              {
 
244
                /* TRANSLATORS: %1 is a time string, e.g. "1 hour 5 minutes" */
 
245
                details = g_strdup_printf(_("Caution low battery, %s remaining"),
 
246
                                          time_string);
 
247
                /* show the warning */
 
248
                gtk_widget_show (widget);
 
249
              }
 
250
            else
 
251
              {
 
252
                /* TRANSLATORS: %1 is a time string, e.g. "1 hour 5 minutes" */
 
253
                details = g_strdup_printf(_("Using battery power - %s remaining"),
 
254
                                          time_string);
 
255
              }
 
256
            break;
 
257
          default:
 
258
            details = g_strdup_printf ("error: %s",
 
259
                                       up_device_state_to_string (state));
 
260
            break;
 
261
        }
 
262
    }
 
263
  else
 
264
    {
 
265
      switch (state)
 
266
        {
 
267
          case UP_DEVICE_STATE_CHARGING:
 
268
          case UP_DEVICE_STATE_PENDING_CHARGE:
 
269
            /* TRANSLATORS: primary battery */
 
270
            details = g_strdup(_("Charging"));
 
271
            break;
 
272
          case UP_DEVICE_STATE_DISCHARGING:
 
273
          case UP_DEVICE_STATE_PENDING_DISCHARGE:
 
274
            /* TRANSLATORS: primary battery */
 
275
            details = g_strdup(_("Using battery power"));
 
276
            break;
 
277
          case UP_DEVICE_STATE_FULLY_CHARGED:
 
278
            /* TRANSLATORS: primary battery */
 
279
            details = g_strdup(_("Charging - fully charged"));
 
280
            break;
 
281
          case UP_DEVICE_STATE_EMPTY:
 
282
            /* TRANSLATORS: primary battery */
 
283
            details = g_strdup(_("Empty"));
 
284
            break;
 
285
          default:
 
286
            details = g_strdup_printf ("error: %s",
 
287
                                       up_device_state_to_string (state));
 
288
            break;
 
289
        }
 
290
    }
 
291
  if (details == NULL)
 
292
    goto out;
 
293
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
294
                                               "label_battery_primary"));
 
295
  gtk_label_set_label (GTK_LABEL (widget), details);
 
296
 
 
297
  /* show the primary device */
 
298
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
299
                                               "box_primary"));
 
300
  gtk_widget_show (widget);
 
301
 
 
302
  /* hide the addon device until we stumble upon the device */
 
303
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
304
                                               "box_battery_addon"));
 
305
  gtk_widget_hide (widget);
 
306
out:
 
307
  g_free (time_string);
 
308
  g_free (details);
 
309
}
 
310
 
 
311
static void
 
312
set_device_ups_primary (CcPowerPanel *panel, GVariant *device)
 
313
{
 
314
  CcPowerPanelPrivate *priv = panel->priv;
 
315
  gchar *details = NULL;
 
316
  gchar *time_string = NULL;
 
317
  gdouble percentage;
 
318
  GtkWidget *widget;
 
319
  guint64 time;
 
320
  UpDeviceState state;
 
321
 
 
322
  /* set the device */
 
323
  g_variant_get (device,
 
324
                 "(susdut)",
 
325
                 NULL, /* object_path */
 
326
                 NULL, /* kind */
 
327
                 NULL, /* icon_name */
 
328
                 &percentage,
 
329
                 &state,
 
330
                 &time);
 
331
 
 
332
  /* set the percentage */
 
333
  gtk_level_bar_set_value (GTK_LEVEL_BAR (priv->levelbar_primary),
 
334
                           percentage / 100.0f);
 
335
 
 
336
  /* always show the warning */
 
337
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
338
                                               "image_primary_warning"));
 
339
  gtk_widget_show (widget);
 
340
 
 
341
  /* set the description */
 
342
  if (time > 0)
 
343
    {
 
344
      time_string = get_timestring (time);
 
345
      switch (state)
 
346
        {
 
347
          case UP_DEVICE_STATE_DISCHARGING:
 
348
            if (percentage < 20)
 
349
              {
 
350
                /* TRANSLATORS: %1 is a time string, e.g. "1 hour 5 minutes" */
 
351
                details = g_strdup_printf(_("Caution low UPS, %s remaining"),
 
352
                                          time_string);
 
353
              }
 
354
            else
 
355
              {
 
356
                /* TRANSLATORS: %1 is a time string, e.g. "1 hour 5 minutes" */
 
357
                details = g_strdup_printf(_("Using UPS power - %s remaining"),
 
358
                                          time_string);
 
359
              }
 
360
            break;
 
361
          default:
 
362
            details = g_strdup_printf ("error: %s",
 
363
                                       up_device_state_to_string (state));
 
364
            break;
 
365
        }
 
366
    }
 
367
  else
 
368
    {
 
369
      switch (state)
 
370
        {
 
371
          case UP_DEVICE_STATE_DISCHARGING:
 
372
            if (percentage < 20)
 
373
              {
 
374
                /* TRANSLATORS: UPS battery */
 
375
                details = g_strdup(_("Caution low UPS"));
 
376
              }
 
377
            else
 
378
              {
 
379
                /* TRANSLATORS: UPS battery */
 
380
                details = g_strdup(_("Using UPS power"));
 
381
              }
 
382
            break;
 
383
          default:
 
384
            details = g_strdup_printf ("error: %s",
 
385
                                       up_device_state_to_string (state));
 
386
            break;
 
387
        }
 
388
    }
 
389
  if (details == NULL)
 
390
    goto out;
 
391
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
392
                                               "label_battery_primary"));
 
393
  gtk_label_set_label (GTK_LABEL (widget), details);
 
394
 
 
395
  /* show the primary device */
 
396
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
397
                                               "box_primary"));
 
398
  gtk_widget_show (widget);
 
399
 
 
400
  /* hide the addon device as extra UPS devices are not possible */
 
401
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
402
                                               "box_battery_addon"));
 
403
  gtk_widget_hide (widget);
 
404
out:
 
405
  g_free (time_string);
 
406
  g_free (details);
 
407
}
 
408
 
 
409
static void
 
410
set_device_battery_additional (CcPowerPanel *panel, GVariant *device)
 
411
{
 
412
  CcPowerPanelPrivate *priv = panel->priv;
 
413
  gchar *details = NULL;
 
414
  GtkWidget *widget;
 
415
  UpDeviceState state;
 
416
 
 
417
  /* set the device */
 
418
  g_variant_get (device,
 
419
                 "(susdut)",
 
420
                 NULL, /* object_path */
 
421
                 NULL, /* kind */
 
422
                 NULL, /* icon_name */
 
423
                 NULL, /* percentage */
 
424
                 &state,
 
425
                 NULL /* time */);
 
426
 
 
427
  /* set the description */
 
428
  switch (state)
 
429
    {
 
430
      case UP_DEVICE_STATE_FULLY_CHARGED:
 
431
        /* TRANSLATORS: secondary battery is normally in the media bay */
 
432
        details = g_strdup(_("Your secondary battery is fully charged"));
 
433
        break;
 
434
      case UP_DEVICE_STATE_EMPTY:
 
435
        /* TRANSLATORS: secondary battery is normally in the media bay */
 
436
        details = g_strdup(_("Your secondary battery is empty"));
 
437
        break;
 
438
      default:
 
439
        break;
 
440
    }
 
441
  if (details == NULL)
 
442
    goto out;
 
443
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
444
                                               "label_battery_addon"));
 
445
  gtk_label_set_label (GTK_LABEL (widget), details);
 
446
 
 
447
  /* show the addon device */
 
448
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
449
                                               "box_battery_addon"));
 
450
  gtk_widget_show (widget);
 
451
out:
 
452
  g_free (details);
 
453
}
 
454
 
 
455
static void
 
456
add_device_secondary (CcPowerPanel *panel,
 
457
                      GVariant *device,
 
458
                      guint *secondary_devices_cnt)
 
459
{
 
460
  CcPowerPanelPrivate *priv = panel->priv;
 
461
  const gchar *icon_name = NULL;
 
462
  gdouble percentage;
 
463
  guint64 time;
 
464
  UpDeviceKind kind;
 
465
  UpDeviceState state;
 
466
  GtkWidget *vbox;
 
467
  GtkWidget *hbox;
 
468
  GtkWidget *widget;
 
469
  GString *status;
 
470
  GString *description;
 
471
  gboolean show_caution = FALSE;
 
472
 
 
473
  g_variant_get (device,
 
474
                 "(susdut)",
 
475
                 NULL,
 
476
                 &kind,
 
477
                 NULL,
 
478
                 &percentage,
 
479
                 &state,
 
480
                 &time);
 
481
 
 
482
  switch (kind)
 
483
    {
 
484
      case UP_DEVICE_KIND_UPS:
 
485
        icon_name = "uninterruptible-power-supply";
 
486
        show_caution = TRUE;
 
487
        break;
 
488
      case UP_DEVICE_KIND_MOUSE:
 
489
        icon_name = "input-mouse";
 
490
        break;
 
491
      case UP_DEVICE_KIND_KEYBOARD:
 
492
        icon_name = "input-keyboard";
 
493
        break;
 
494
      case UP_DEVICE_KIND_TABLET:
 
495
        icon_name = "input-tablet";
 
496
        break;
 
497
      case UP_DEVICE_KIND_PDA:
 
498
        icon_name = "pda";
 
499
        break;
 
500
      case UP_DEVICE_KIND_PHONE:
 
501
        icon_name = "phone";
 
502
        break;
 
503
      case UP_DEVICE_KIND_MEDIA_PLAYER:
 
504
        icon_name = "multimedia-player";
 
505
        break;
 
506
      case UP_DEVICE_KIND_COMPUTER:
 
507
        icon_name = "computer";
 
508
        show_caution = TRUE;
 
509
        break;
 
510
      default:
 
511
        icon_name = "battery";
 
512
        break;
 
513
    }
 
514
 
 
515
  switch (kind)
 
516
    {
 
517
      case UP_DEVICE_KIND_MOUSE:
 
518
        /* TRANSLATORS: secondary battery */
 
519
        description = g_string_new (_("Wireless mouse"));
 
520
        break;
 
521
      case UP_DEVICE_KIND_KEYBOARD:
 
522
        /* TRANSLATORS: secondary battery */
 
523
        description = g_string_new (_("Wireless keyboard"));
 
524
        break;
 
525
      case UP_DEVICE_KIND_UPS:
 
526
        /* TRANSLATORS: secondary battery */
 
527
        description = g_string_new (_("Uninterruptible power supply"));
 
528
        break;
 
529
      case UP_DEVICE_KIND_PDA:
 
530
        /* TRANSLATORS: secondary battery */
 
531
        description = g_string_new (_("Personal digital assistant"));
 
532
        break;
 
533
      case UP_DEVICE_KIND_PHONE:
 
534
        /* TRANSLATORS: secondary battery */
 
535
        description = g_string_new (_("Cellphone"));
 
536
        break;
 
537
      case UP_DEVICE_KIND_MEDIA_PLAYER:
 
538
        /* TRANSLATORS: secondary battery */
 
539
        description = g_string_new (_("Media player"));
 
540
        break;
 
541
      case UP_DEVICE_KIND_TABLET:
 
542
        /* TRANSLATORS: secondary battery */
 
543
        description = g_string_new (_("Tablet"));
 
544
        break;
 
545
      case UP_DEVICE_KIND_COMPUTER:
 
546
        /* TRANSLATORS: secondary battery */
 
547
        description = g_string_new (_("Computer"));
 
548
        break;
 
549
      default:
 
550
        /* TRANSLATORS: secondary battery, misc */
 
551
        description = g_string_new (_("Battery"));
 
552
        break;
 
553
    }
 
554
  g_string_prepend (description, "<b>");
 
555
  g_string_append (description, "</b>");
 
556
 
 
557
  switch (state)
 
558
    {
 
559
      case UP_DEVICE_STATE_CHARGING:
 
560
      case UP_DEVICE_STATE_PENDING_CHARGE:
 
561
        /* TRANSLATORS: secondary battery */
 
562
        status = g_string_new(C_("Battery power", "Charging"));
 
563
        break;
 
564
      case UP_DEVICE_STATE_DISCHARGING:
 
565
      case UP_DEVICE_STATE_PENDING_DISCHARGE:
 
566
        if (percentage < 10 && show_caution)
 
567
          {
 
568
            /* TRANSLATORS: secondary battery */
 
569
            status = g_string_new (C_("Battery power", "Caution"));
 
570
          }
 
571
        else if (percentage < 30)
 
572
          {
 
573
            /* TRANSLATORS: secondary battery */
 
574
            status = g_string_new (C_("Battery power", "Low"));
 
575
          }
 
576
        else
 
577
          {
 
578
            /* TRANSLATORS: secondary battery */
 
579
            status = g_string_new (C_("Battery power", "Good"));
 
580
          }
 
581
        break;
 
582
      case UP_DEVICE_STATE_FULLY_CHARGED:
 
583
        /* TRANSLATORS: primary battery */
 
584
        status = g_string_new(C_("Battery power", "Charging - fully charged"));
 
585
        break;
 
586
      case UP_DEVICE_STATE_EMPTY:
 
587
        /* TRANSLATORS: primary battery */
 
588
        status = g_string_new(C_("Battery power", "Empty"));
 
589
        break;
 
590
      default:
 
591
        status = g_string_new (up_device_state_to_string (state));
 
592
        break;
 
593
    }
 
594
  g_string_prepend (status, "<small>");
 
595
  g_string_append (status, "</small>");
 
596
 
 
597
  /* create the new widget */
 
598
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
 
599
  gtk_widget_set_hexpand (hbox, TRUE);
 
600
  widget = gtk_image_new ();
 
601
  gtk_misc_set_alignment (GTK_MISC (widget), 0.5f, 0.0f);
 
602
  gtk_image_set_from_icon_name (GTK_IMAGE (widget), icon_name, GTK_ICON_SIZE_DND);
 
603
  gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
 
604
  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
 
605
  widget = gtk_label_new ("");
 
606
  gtk_misc_set_alignment (GTK_MISC (widget), 0.0f, 0.5f);
 
607
  gtk_label_set_markup (GTK_LABEL (widget), description->str);
 
608
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
 
609
  widget = gtk_label_new ("");
 
610
  gtk_misc_set_alignment (GTK_MISC (widget), 0.0f, 0.5f);
 
611
  gtk_label_set_markup (GTK_LABEL (widget), status->str);
 
612
  gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
 
613
  widget = gtk_level_bar_new ();
 
614
  gtk_widget_set_margin_right (widget, 32);
 
615
  gtk_widget_set_margin_top (widget, 3);
 
616
  gtk_level_bar_set_value (GTK_LEVEL_BAR (widget), percentage / 100.0f);
 
617
  gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0);
 
618
  gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
 
619
 
 
620
  /* add to the grid */
 
621
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
622
                                               "grid_secondary"));
 
623
 
 
624
  /* two devices wide */
 
625
  gtk_grid_attach (GTK_GRID (widget), hbox,
 
626
                   *secondary_devices_cnt % 2,
 
627
                   (*secondary_devices_cnt / 2) - 1,
 
628
                   1, 1);
 
629
  (*secondary_devices_cnt)++;
 
630
 
 
631
  /* show panel */
 
632
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
633
                                               "box_secondary"));
 
634
  gtk_widget_show_all (widget);
 
635
 
 
636
  g_string_free (description, TRUE);
 
637
  g_string_free (status, TRUE);
 
638
}
 
639
 
 
640
static void
 
641
get_devices_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
 
642
{
 
643
  CcPowerPanel *panel;
 
644
  CcPowerPanelPrivate *priv;
 
645
  gboolean got_primary = FALSE;
 
646
  gboolean ups_as_primary_device = FALSE;
 
647
  GError *error = NULL;
 
648
  gsize n_devices;
 
649
  GList *children;
 
650
  GList *l;
 
651
  GtkWidget *widget;
 
652
  guint i;
 
653
  guint secondary_devices_cnt = 0;
 
654
  GVariant *child;
 
655
  GVariant *result;
 
656
  GVariant *untuple;
 
657
  UpDeviceKind kind;
 
658
  UpDeviceState state;
 
659
 
 
660
  result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error);
 
661
  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
 
662
    {
 
663
      g_error_free (error);
 
664
      return; /* Must exit before accessing freed memory */
 
665
    }
 
666
 
 
667
  panel = CC_POWER_PANEL (user_data);
 
668
  priv = panel->priv;
 
669
 
 
670
  /* empty the secondary box */
 
671
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
672
                                               "grid_secondary"));
 
673
  children = gtk_container_get_children (GTK_CONTAINER (widget));
 
674
  for (l = children; l != NULL; l = l->next)
 
675
    gtk_container_remove (GTK_CONTAINER (widget), l->data);
 
676
  g_list_free (children);
 
677
 
 
678
  /* hide both panels initially */
 
679
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
680
                                               "box_primary"));
 
681
  gtk_widget_hide (widget);
 
682
  widget = GTK_WIDGET (gtk_builder_get_object (priv->builder,
 
683
                                               "box_secondary"));
 
684
  gtk_widget_hide (widget);
 
685
 
 
686
  if (result == NULL)
 
687
    {
 
688
      g_printerr ("Error getting devices: %s\n", error->message);
 
689
      g_error_free (error);
 
690
      return;
 
691
    }
 
692
 
 
693
  untuple = g_variant_get_child_value (result, 0);
 
694
  n_devices = g_variant_n_children (untuple);
 
695
 
 
696
  /* first we look for a discharging UPS, which is promoted to the
 
697
   * primary device if it's discharging. Otherwise we use the first
 
698
   * listed laptop battery as the primary device */
 
699
  for (i = 0; i < n_devices; i++)
 
700
    {
 
701
      child = g_variant_get_child_value (untuple, i);
 
702
      g_variant_get (child,
 
703
                     "(susdut)",
 
704
                     NULL,
 
705
                     &kind,
 
706
                     NULL,
 
707
                     NULL,
 
708
                     &state,
 
709
                     NULL);
 
710
      if (kind == UP_DEVICE_KIND_UPS &&
 
711
          state == UP_DEVICE_STATE_DISCHARGING)
 
712
        {
 
713
          ups_as_primary_device = TRUE;
 
714
        }
 
715
      g_variant_unref (child);
 
716
    }
 
717
 
 
718
  /* add the devices now we know the state-of-play */
 
719
  for (i = 0; i < n_devices; i++)
 
720
    {
 
721
      child = g_variant_get_child_value (untuple, i);
 
722
      g_variant_get (child,
 
723
                     "(susdut)",
 
724
                     NULL,
 
725
                     &kind,
 
726
                     NULL,
 
727
                     NULL,
 
728
                     NULL,
 
729
                     NULL);
 
730
      if (kind == UP_DEVICE_KIND_LINE_POWER)
 
731
        {
 
732
          /* do nothing */
 
733
        }
 
734
      else if (kind == UP_DEVICE_KIND_UPS && ups_as_primary_device)
 
735
        {
 
736
          set_device_ups_primary (panel, child);
 
737
        }
 
738
      else if (kind == UP_DEVICE_KIND_BATTERY && !ups_as_primary_device)
 
739
        {
 
740
          if (!got_primary)
 
741
            {
 
742
              set_device_battery_primary (panel, child);
 
743
              got_primary = TRUE;
 
744
            }
 
745
          else
 
746
            {
 
747
              set_device_battery_additional (panel, child);
 
748
            }
 
749
        }
 
750
      else
 
751
        {
 
752
          add_device_secondary (panel, child, &secondary_devices_cnt);
 
753
        }
 
754
      g_variant_unref (child);
 
755
    }
 
756
 
 
757
  g_variant_unref (untuple);
 
758
  g_variant_unref (result);
 
759
}
 
760
 
 
761
static void
 
762
on_properties_changed (GDBusProxy *proxy,
 
763
                       GVariant   *changed_properties,
 
764
                       GStrv       invalidated_properties,
 
765
                       gpointer    user_data)
 
766
{
 
767
  CcPowerPanelPrivate *priv = CC_POWER_PANEL (user_data)->priv;
 
768
 
 
769
  /* get the new state */
 
770
  g_dbus_proxy_call (priv->proxy,
 
771
                     "GetDevices",
 
772
                     NULL,
 
773
                     G_DBUS_CALL_FLAGS_NONE,
 
774
                     -1,
 
775
                     priv->cancellable,
 
776
                     get_devices_cb,
 
777
                     user_data);
 
778
}
 
779
 
 
780
static void
 
781
got_power_proxy_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
 
782
{
 
783
  GError *error = NULL;
 
784
  GDBusProxy *proxy;
 
785
  CcPowerPanelPrivate *priv;
 
786
 
 
787
  proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
 
788
  if (proxy == NULL)
 
789
    {
 
790
      g_printerr ("Error creating proxy: %s\n", error->message);
 
791
      g_error_free (error);
 
792
      return;
 
793
    }
 
794
 
 
795
  /* Access user_data after checking for error because user_data might be
 
796
     disposed already. */
 
797
  priv = CC_POWER_PANEL (user_data)->priv;
 
798
  priv->proxy = proxy;
 
799
 
 
800
  /* we want to change the primary device changes */
 
801
  g_signal_connect (priv->proxy,
 
802
                    "g-properties-changed",
 
803
                    G_CALLBACK (on_properties_changed),
 
804
                    user_data);
 
805
 
 
806
  /* get the initial state */
 
807
  g_dbus_proxy_call (priv->proxy,
 
808
                     "GetDevices",
 
809
                     NULL,
 
810
                     G_DBUS_CALL_FLAGS_NONE,
 
811
                     200, /* we don't want to randomly expand the dialog */
 
812
                     priv->cancellable,
 
813
                     get_devices_cb,
 
814
                     user_data);
 
815
}
 
816
 
 
817
static void
 
818
combo_time_changed_cb (GtkWidget *widget, CcPowerPanel *self)
 
819
{
 
820
  GtkTreeIter iter;
 
821
  GtkTreeModel *model;
 
822
  gint value;
 
823
  gboolean ret;
 
824
  const gchar *key = (const gchar *)g_object_get_data (G_OBJECT(widget), "_gsettings_key");
 
825
 
 
826
  /* no selection */
 
827
  ret = gtk_combo_box_get_active_iter (GTK_COMBO_BOX(widget), &iter);
 
828
  if (!ret)
 
829
    return;
 
830
 
 
831
  /* get entry */
 
832
  model = gtk_combo_box_get_model (GTK_COMBO_BOX(widget));
 
833
  gtk_tree_model_get (model, &iter,
 
834
                      1, &value,
 
835
                      -1);
 
836
 
 
837
  /* set both keys */
 
838
  g_settings_set_int (self->priv->gsd_settings, key, value);
 
839
}
 
840
 
 
841
static void
 
842
combo_enum_changed_cb (GtkWidget *widget, CcPowerPanel *self)
 
843
{
 
844
  GtkTreeIter iter;
 
845
  GtkTreeModel *model;
 
846
  gint value;
 
847
  gboolean ret;
 
848
  const gchar *key = (const gchar *)g_object_get_data (G_OBJECT(widget), "_gsettings_key");
 
849
 
 
850
  /* no selection */
 
851
  ret = gtk_combo_box_get_active_iter (GTK_COMBO_BOX(widget), &iter);
 
852
  if (!ret)
 
853
    return;
 
854
 
 
855
  /* get entry */
 
856
  model = gtk_combo_box_get_model (GTK_COMBO_BOX(widget));
 
857
  gtk_tree_model_get (model, &iter,
 
858
                      1, &value,
 
859
                      -1);
 
860
 
 
861
  /* set both battery and ac keys */
 
862
  g_settings_set_enum (self->priv->gsd_settings, key, value);
 
863
}
 
864
 
 
865
static void
 
866
disable_unavailable_combo_items (CcPowerPanel *self,
 
867
                                 GtkComboBox *combo_box)
 
868
{
 
869
  gboolean enabled;
 
870
  gboolean ret;
 
871
  gint value_tmp;
 
872
  GtkCellRenderer *renderer;
 
873
  GtkTreeIter iter;
 
874
  GtkTreeModel *model;
 
875
 
 
876
  /* setup the renderer */
 
877
  renderer = gtk_cell_renderer_text_new ();
 
878
  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
 
879
  gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer,
 
880
                                  "text", ACTION_MODEL_TEXT,
 
881
                                  "sensitive", ACTION_MODEL_SENSITIVE,
 
882
                                  NULL);
 
883
 
 
884
  /* get entry */
 
885
  model = gtk_combo_box_get_model (combo_box);
 
886
  ret = gtk_tree_model_get_iter_first (model, &iter);
 
887
  if (!ret)
 
888
    return;
 
889
 
 
890
  /* disable any actions we cannot do */
 
891
  do
 
892
    {
 
893
      gtk_tree_model_get (model, &iter,
 
894
                          ACTION_MODEL_VALUE, &value_tmp,
 
895
                          -1);
 
896
      switch (value_tmp) {
 
897
      case GSD_POWER_ACTION_SUSPEND:
 
898
        enabled = up_client_get_can_suspend (self->priv->up_client);
 
899
        break;
 
900
      case GSD_POWER_ACTION_HIBERNATE:
 
901
        enabled = up_client_get_can_hibernate (self->priv->up_client);
 
902
        break;
 
903
      default:
 
904
        enabled = TRUE;
 
905
      }
 
906
      gtk_list_store_set (GTK_LIST_STORE (model), &iter,
 
907
                          ACTION_MODEL_SENSITIVE, enabled,
 
908
                          -1);
 
909
    } while (gtk_tree_model_iter_next (model, &iter));
 
910
}
 
911
 
 
912
static void
 
913
set_value_for_combo (GtkComboBox *combo_box, gint value)
 
914
{
 
915
  GtkTreeIter iter;
 
916
  GtkTreeModel *model;
 
917
  gint value_tmp;
 
918
  gboolean ret;
 
919
 
 
920
  /* get entry */
 
921
  model = gtk_combo_box_get_model (combo_box);
 
922
  ret = gtk_tree_model_get_iter_first (model, &iter);
 
923
  if (!ret)
 
924
    return;
 
925
 
 
926
  /* try to make the UI match the setting */
 
927
  do
 
928
    {
 
929
      gtk_tree_model_get (model, &iter,
 
930
                          1, &value_tmp,
 
931
                          -1);
 
932
      if (value == value_tmp)
 
933
        {
 
934
          gtk_combo_box_set_active_iter (combo_box, &iter);
 
935
          break;
 
936
        }
 
937
    } while (gtk_tree_model_iter_next (model, &iter));
 
938
}
 
939
 
 
940
static void
 
941
set_ac_battery_ui_mode (CcPowerPanel *self)
 
942
{
 
943
  gboolean has_batteries = FALSE;
 
944
  gboolean has_lid = FALSE;
 
945
  gboolean ret;
 
946
  GError *error = NULL;
 
947
  GPtrArray *devices;
 
948
  guint i;
 
949
  UpDevice *device;
 
950
  UpDeviceKind kind;
 
951
  CcPowerPanelPrivate *priv = self->priv;
 
952
 
 
953
  /* this is sync, but it's cached in the daemon and so quick */
 
954
  ret = up_client_enumerate_devices_sync (self->priv->up_client, NULL, &error);
 
955
  if (!ret)
 
956
    {
 
957
      g_warning ("failed to get device list: %s", error->message);
 
958
      g_error_free (error);
 
959
      goto out;
 
960
    }
 
961
 
 
962
  devices = up_client_get_devices (self->priv->up_client);
 
963
  for (i=0; i<devices->len; i++)
 
964
    {
 
965
      device = g_ptr_array_index (devices, i);
 
966
      g_object_get (device,
 
967
                    "kind", &kind,
 
968
                    NULL);
 
969
      if (kind == UP_DEVICE_KIND_BATTERY ||
 
970
          kind == UP_DEVICE_KIND_UPS)
 
971
        {
 
972
          has_batteries = TRUE;
 
973
          break;
 
974
        }
 
975
    }
 
976
  g_ptr_array_unref (devices);
 
977
 
 
978
  has_lid = up_client_get_lid_is_present (self->priv->up_client);
 
979
 
 
980
out:
 
981
  gtk_widget_set_visible (WID (priv->builder, "combobox_lid_ac"), has_lid);
 
982
  gtk_widget_set_visible (WID (priv->builder, "label_lid_action"), has_lid);
 
983
  gtk_widget_set_visible (WID (priv->builder, "combobox_lid_battery"), has_batteries && has_lid);
 
984
  gtk_widget_set_visible (WID (priv->builder, "label_header_battery"), has_batteries);
 
985
  gtk_widget_set_visible (WID (priv->builder, "label_header_ac"), has_batteries);
 
986
  gtk_widget_set_visible (WID (priv->builder, "combobox_sleep_battery"), has_batteries);
 
987
  gtk_widget_set_visible (WID (priv->builder, "label_critical"), has_batteries);
 
988
  gtk_widget_set_visible (WID (priv->builder, "combobox_critical"), has_batteries);
 
989
}
 
990
 
 
991
static gboolean
 
992
activate_link_cb (GtkLabel *label, gchar *uri, CcPowerPanel *self)
 
993
{
 
994
  CcShell *shell;
 
995
  GError *error = NULL;
 
996
 
 
997
  shell = cc_panel_get_shell (CC_PANEL (self));
 
998
  if (cc_shell_set_active_panel_from_id (shell, uri, NULL, &error) == FALSE)
 
999
    {
 
1000
      g_warning ("Failed to activate %s panel: %s", uri, error->message);
 
1001
      g_error_free (error);
 
1002
    }
 
1003
  return TRUE;
 
1004
}
 
1005
 
 
1006
static void
 
1007
cc_power_panel_init (CcPowerPanel *self)
 
1008
{
 
1009
  GError     *error;
 
1010
  GtkWidget  *widget;
 
1011
  gint        value;
 
1012
  char       *text;
 
1013
 
 
1014
  self->priv = POWER_PANEL_PRIVATE (self);
 
1015
 
 
1016
  self->priv->builder = gtk_builder_new ();
 
1017
 
 
1018
  error = NULL;
 
1019
  gtk_builder_add_from_file (self->priv->builder,
 
1020
                             GNOMECC_UI_DIR "/power.ui",
 
1021
                             &error);
 
1022
 
 
1023
  if (error != NULL)
 
1024
    {
 
1025
      g_warning ("Could not load interface file: %s", error->message);
 
1026
      g_error_free (error);
 
1027
      return;
 
1028
    }
 
1029
 
 
1030
  /* add levelbar */
 
1031
  self->priv->levelbar_primary = GTK_WIDGET
 
1032
    (gtk_builder_get_object (self->priv->builder, "levelbar_primary"));
 
1033
  self->priv->cancellable = g_cancellable_new ();
 
1034
 
 
1035
  /* get initial icon state */
 
1036
  g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
 
1037
                            G_DBUS_PROXY_FLAGS_NONE,
 
1038
                            NULL,
 
1039
                            "org.gnome.SettingsDaemon.Power",
 
1040
                            "/org/gnome/SettingsDaemon/Power",
 
1041
                            "org.gnome.SettingsDaemon.Power",
 
1042
                            self->priv->cancellable,
 
1043
                            got_power_proxy_cb,
 
1044
                            self);
 
1045
 
 
1046
  /* find out if there are any battery or UPS devices attached
 
1047
   * and setup UI accordingly */
 
1048
  self->priv->up_client = up_client_new ();
 
1049
  set_ac_battery_ui_mode (self);
 
1050
 
 
1051
  self->priv->gsd_settings = g_settings_new ("org.gnome.settings-daemon.plugins.power");
 
1052
  g_signal_connect (self->priv->gsd_settings,
 
1053
                    "changed",
 
1054
                    G_CALLBACK (on_lock_settings_changed),
 
1055
                    self);
 
1056
 
 
1057
  /* auto-sleep time */
 
1058
  value = g_settings_get_int (self->priv->gsd_settings, "sleep-inactive-ac-timeout");
 
1059
  widget = GTK_WIDGET (gtk_builder_get_object (self->priv->builder,
 
1060
                                               "combobox_sleep_ac"));
 
1061
  set_value_for_combo (GTK_COMBO_BOX (widget), value);
 
1062
  g_object_set_data (G_OBJECT(widget), "_gsettings_key", "sleep-inactive-ac-timeout");
 
1063
  g_signal_connect (widget, "changed",
 
1064
                    G_CALLBACK (combo_time_changed_cb),
 
1065
                    self);
 
1066
  value = g_settings_get_int (self->priv->gsd_settings, "sleep-inactive-battery-timeout");
 
1067
  widget = GTK_WIDGET (gtk_builder_get_object (self->priv->builder,
 
1068
                                               "combobox_sleep_battery"));
 
1069
  set_value_for_combo (GTK_COMBO_BOX (widget), value);
 
1070
  g_object_set_data (G_OBJECT(widget), "_gsettings_key", "sleep-inactive-battery-timeout");
 
1071
  g_signal_connect (widget, "changed",
 
1072
                    G_CALLBACK (combo_time_changed_cb),
 
1073
                    self);
 
1074
 
 
1075
  /* actions */
 
1076
  value = g_settings_get_enum (self->priv->gsd_settings, "critical-battery-action");
 
1077
  widget = GTK_WIDGET (gtk_builder_get_object (self->priv->builder,
 
1078
                                               "combobox_critical"));
 
1079
  disable_unavailable_combo_items (self, GTK_COMBO_BOX (widget));
 
1080
  set_value_for_combo (GTK_COMBO_BOX (widget), value);
 
1081
  g_object_set_data (G_OBJECT(widget), "_gsettings_key", "critical-battery-action");
 
1082
  g_signal_connect (widget, "changed",
 
1083
                    G_CALLBACK (combo_enum_changed_cb),
 
1084
                    self);
 
1085
 
 
1086
  /* set screen link */
 
1087
  widget = GTK_WIDGET (gtk_builder_get_object (self->priv->builder,
 
1088
                                               "label_screen_settings"));
 
1089
  /* TRANSLATORS: this is a link to the "Brightness and Lock" control center panel */
 
1090
  text = g_strdup_printf ("<span size=\"small\">%s</span>",
 
1091
                          _("Tip: <a href=\"screen\">screen brightness</a> affects how much power is used"));
 
1092
  gtk_label_set_markup (GTK_LABEL (widget), text);
 
1093
  g_free (text);
 
1094
 
 
1095
  g_signal_connect (widget, "activate-link",
 
1096
                    G_CALLBACK (activate_link_cb),
 
1097
                    self);
 
1098
 
 
1099
  value = g_settings_get_enum (self->priv->gsd_settings, "lid-close-ac-action");
 
1100
  widget = GTK_WIDGET (gtk_builder_get_object (self->priv->builder,
 
1101
                                               "combobox_lid_ac"));
 
1102
  disable_unavailable_combo_items (self, GTK_COMBO_BOX (widget));
 
1103
  set_value_for_combo (GTK_COMBO_BOX (widget), value);
 
1104
  g_object_set_data (G_OBJECT(widget), "_gsettings_key", "lid-close-ac-action");
 
1105
  g_signal_connect (widget, "changed",
 
1106
                    G_CALLBACK (combo_enum_changed_cb),
 
1107
                    self);
 
1108
 
 
1109
  value = g_settings_get_enum (self->priv->gsd_settings, "lid-close-battery-action");
 
1110
  widget = GTK_WIDGET (gtk_builder_get_object (self->priv->builder,
 
1111
                                               "combobox_lid_battery"));
 
1112
  disable_unavailable_combo_items (self, GTK_COMBO_BOX (widget));
 
1113
  set_value_for_combo (GTK_COMBO_BOX (widget), value);
 
1114
  g_object_set_data (G_OBJECT(widget), "_gsettings_key", "lid-close-battery-action");
 
1115
  g_signal_connect (widget, "changed",
 
1116
                    G_CALLBACK (combo_enum_changed_cb),
 
1117
                    self);
 
1118
 
 
1119
  widget = WID (self->priv->builder, "vbox_power");
 
1120
  gtk_widget_reparent (widget, (GtkWidget *) self);
 
1121
 
 
1122
  /* Set up Unity-specific controls */
 
1123
  /* References:
 
1124
   *  https://wiki.ubuntu.com/Power
 
1125
   *  https://docs.google.com/document/d/1ILTJDiDCd25Npt2AmgzF8aOnZZECxTfM0hvsbWT2BxA/edit?pli=1#heading=h.i5lg1g344bsb
 
1126
   */
 
1127
  // First check the schema is installed
 
1128
  GSettingsSchemaSource *schema_source = g_settings_schema_source_ref (
 
1129
              g_settings_schema_source_get_default ());
 
1130
  GSettingsSchema *schema = g_settings_schema_source_lookup (
 
1131
              schema_source,
 
1132
              "com.canonical.indicator.power",
 
1133
              TRUE);
 
1134
  g_settings_schema_source_unref (schema_source);
 
1135
 
 
1136
  if (schema)
 
1137
    {
 
1138
      widget = GTK_WIDGET (gtk_builder_get_object (self->priv->builder,
 
1139
                                                   "combobox_indicator"));
 
1140
      self->priv->power_settings = g_settings_new ("com.canonical.indicator.power");
 
1141
      g_settings_bind (self->priv->power_settings, "icon-policy",
 
1142
                       widget, "active-id", G_SETTINGS_BIND_DEFAULT);
 
1143
      g_settings_schema_unref (schema);
 
1144
    }
 
1145
  else
 
1146
    {
 
1147
      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "separator_indicator")));
 
1148
      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "label_indicator")));
 
1149
      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "combobox_indicator")));
 
1150
    }
 
1151
 
 
1152
}
 
1153
 
 
1154
void
 
1155
cc_power_panel_register (GIOModule *module)
 
1156
{
 
1157
  cc_power_panel_register_type (G_TYPE_MODULE (module));
 
1158
  g_io_extension_point_implement (CC_SHELL_PANEL_EXTENSION_POINT,
 
1159
                                  CC_TYPE_POWER_PANEL,
 
1160
                                  "power", 0);
 
1161
}
 
1162