0082-Fix-incorrect-check-for-suspend-permissions-bug-8438.patch

   1 From 83b20fd2335a2cc54577019ea9af1a664a93ac28 Mon Sep 17 00:00:00 2001
   2 From: Lionel Le Folgoc <lionel@lefolgoc.net>
   3 Date: Sun, 11 Aug 2013 22:47:24 +0200
   4 Subject: [PATCH 082/219] Fix incorrect check for suspend permissions (bug
   5  #8438).
   6
   7 ---
   8  src/xfpm-power.c | 508 +++++++++++++++++++++++++++----------------------------
   9  1 file changed, 254 insertions(+), 254 deletions(-)
  10
  11 diff --git a/src/xfpm-power.c b/src/xfpm-power.c
  12 index bcf2fbd..d703f8e 100644
  13 --- a/src/xfpm-power.c
  14 +++ b/src/xfpm-power.c
  15 @@ -69,25 +69,25 @@ static void xfpm_power_refresh_adaptor_visible (XfpmPower *power);
  16  struct XfpmPowerPrivate
  17  {
  18      DBusGConnection *bus;
  19 -
  20 +
  21      DBusGProxy      *proxy;
  22      DBusGProxy      *proxy_prop;
  23 -
  24 +
  25      GHashTable      *hash;
  26 -
  27 +
  28      XfpmConsoleKit  *console;
  29      XfpmInhibit            *inhibit;
  30      XfpmXfconf      *conf;
  31      GtkStatusIcon   *adapter_icon;
  32 -
  33 +
  34      XfpmBatteryCharge overall_state;
  35      gboolean         critical_action_done;
  36 -
  37 +
  38      XfpmPowerMode    power_mode;
  39      EggIdletime     *idletime;
  40 -
  41 +
  42      gboolean        inhibited;
  43 -
  44 +
  45      XfpmNotify     *notify;
  46  #ifdef ENABLE_POLKIT
  47      XfpmPolkit             *polkit;
  48 @@ -103,9 +103,9 @@ struct XfpmPowerPrivate
  49      gchar           *daemon_version;
  50      gboolean        can_suspend;
  51      gboolean         can_hibernate;
  52 -
  53 +
  54      /**
  55 -     * Warning dialog to use when notification daemon
  56 +     * Warning dialog to use when notification daemon
  57       * doesn't support actions.
  58       **/
  59      GtkWidget      *dialog;
  60 @@ -144,10 +144,10 @@ G_DEFINE_TYPE (XfpmPower, xfpm_power, G_TYPE_OBJECT)
  61  static void
  62  xfpm_power_check_polkit_auth (XfpmPower *power)
  63  {
  64 -    power->priv->auth_suspend = xfpm_polkit_check_auth (power->priv->polkit,
  65 +    power->priv->auth_suspend = xfpm_polkit_check_auth (power->priv->polkit,
  66                                                         POLKIT_AUTH_SUSPEND);
  67
  68 -    power->priv->auth_hibernate = xfpm_polkit_check_auth (power->priv->polkit,
  69 +    power->priv->auth_hibernate = xfpm_polkit_check_auth (power->priv->polkit,
  70                                                           POLKIT_AUTH_HIBERNATE);
  71
  72  }
  73 @@ -158,30 +158,30 @@ xfpm_power_check_pm (XfpmPower *power, GHashTable *props)
  74  {
  75      GValue *value;
  76      gboolean ret;
  77 -
  78 +
  79      value = g_hash_table_lookup (props, "CanSuspend");
  80 -
  81 -    if (value == NULL)
  82 +
  83 +    if (value == NULL)
  84      {
  85         g_warning ("No 'CanSuspend' property");
  86      }
  87      ret = g_value_get_boolean (value);
  88 -
  89 -    if (ret != power->priv->can_suspend)
  90 +
  91 +    if (ret != power->priv->can_suspend)
  92      {
  93         power->priv->can_suspend = ret;
  94      }
  95
  96      value = g_hash_table_lookup (props, "CanHibernate");
  97 -
  98 -    if (value == NULL)
  99 +
 100 +    if (value == NULL)
 101      {
 102         g_warning ("No 'CanHibernate' property");
 103      }
 104 -
 105 +
 106      ret = g_value_get_boolean (value);
 107 -
 108 -    if (ret != power->priv->can_hibernate)
 109 +
 110 +    if (ret != power->priv->can_hibernate)
 111      {
 112         power->priv->can_hibernate = ret;
 113      }
 114 @@ -192,14 +192,14 @@ xfpm_power_check_power (XfpmPower *power, GHashTable *props)
 115  {
 116      GValue *value;
 117      gboolean on_battery;
 118 -
 119 +
 120      value = g_hash_table_lookup (props, "OnBattery");
 121 -
 122 -    if (G_LIKELY (value))
 123 +
 124 +    if (G_LIKELY (value))
 125      {
 126         on_battery = g_value_get_boolean (value);
 127 -
 128 -       if (on_battery != power->priv->on_battery )
 129 +
 130 +       if (on_battery != power->priv->on_battery )
 131         {
 132             GList *list;
 133             guint len, i;
 134 @@ -209,7 +209,7 @@ xfpm_power_check_power (XfpmPower *power, GHashTable *props)
 135             len = g_list_length (list);
 136             for ( i = 0; i < len; i++)
 137             {
 138 -               g_object_set (G_OBJECT (g_list_nth_data (list, i)),
 139 +               g_object_set (G_OBJECT (g_list_nth_data (list, i)),
 140                               "ac-online", !on_battery,
 141                               NULL);
 142             }
 143 @@ -225,10 +225,10 @@ static void
 144  xfpm_power_check_lid (XfpmPower *power, GHashTable *props)
 145  {
 146      GValue *value;
 147 -
 148 +
 149      value = g_hash_table_lookup (props, "LidIsPresent");
 150 -
 151 -    if (value == NULL)
 152 +
 153 +    if (value == NULL)
 154      {
 155         g_warning ("No 'LidIsPresent' property");
 156         return;
 157 @@ -236,21 +236,21 @@ xfpm_power_check_lid (XfpmPower *power, GHashTable *props)
 158
 159      power->priv->lid_is_present = g_value_get_boolean (value);
 160
 161 -    if (power->priv->lid_is_present)
 162 +    if (power->priv->lid_is_present)
 163      {
 164         gboolean closed;
 165 -
 166 +
 167         value = g_hash_table_lookup (props, "LidIsClosed");
 168 -
 169 -       if (value == NULL)
 170 +
 171 +       if (value == NULL)
 172         {
 173             g_warning ("No 'LidIsClosed' property");
 174             return;
 175         }
 176 -
 177 +
 178         closed = g_value_get_boolean (value);
 179 -
 180 -       if (closed != power->priv->lid_is_closed )
 181 +
 182 +       if (closed != power->priv->lid_is_closed )
 183         {
 184             power->priv->lid_is_closed = closed;
 185             g_signal_emit (G_OBJECT (power), signals [LID_CHANGED], 0, power->priv->lid_is_closed);
 186 @@ -260,7 +260,7 @@ xfpm_power_check_lid (XfpmPower *power, GHashTable *props)
 187
 188  /*
 189   * Get the properties on org.freedesktop.DeviceKit.Power
 190 - *
 191 + *
 192   * DaemonVersion      's'
 193   * CanSuspend'        'b'
 194   * CanHibernate'      'b'
 195 @@ -273,9 +273,9 @@ static void
 196  xfpm_power_get_properties (XfpmPower *power)
 197  {
 198      GHashTable *props;
 199 -
 200 +
 201      props = xfpm_power_get_interface_properties (power->priv->proxy_prop, UPOWER_IFACE);
 202 -
 203 +
 204      xfpm_power_check_pm (power, props);
 205      xfpm_power_check_lid (power, props);
 206      xfpm_power_check_power (power, props);
 207 @@ -289,10 +289,10 @@ xfpm_power_report_error (XfpmPower *power, const gchar *error, const gchar *icon
 208      GtkStatusIcon *battery = NULL;
 209      guint i, len;
 210      GList *list;
 211 -
 212 +
 213      list = g_hash_table_get_values (power->priv->hash);
 214      len = g_list_length (list);
 215 -
 216 +
 217      for ( i = 0; i < len; i++)
 218      {
 219         XfpmDeviceType type;
 220 @@ -302,16 +302,16 @@ xfpm_power_report_error (XfpmPower *power, const gchar *error, const gchar *icon
 221              type == XFPM_DEVICE_TYPE_UPS )
 222              break;
 223      }
 224 -
 225 -    xfpm_notify_show_notification (power->priv->notify,
 226 -                                  _("Power Manager"),
 227 -                                  error,
 228 +
 229 +    xfpm_notify_show_notification (power->priv->notify,
 230 +                                  _("Power Manager"),
 231 +                                  error,
 232                                    icon_name,
 233                                    10000,
 234                                    FALSE,
 235                                    XFPM_NOTIFY_CRITICAL,
 236                                    battery);
 237 -
 238 +
 239  }
 240
 241  static void
 242 @@ -319,7 +319,7 @@ xfpm_power_sleep (XfpmPower *power, const gchar *sleep_time, gboolean force)
 243  {
 244      GError *error = NULL;
 245      gboolean lock_screen;
 246 -
 247 +
 248      if ( power->priv->inhibited && force == FALSE)
 249      {
 250         gboolean ret;
 251 @@ -333,24 +333,24 @@ xfpm_power_sleep (XfpmPower *power, const gchar *sleep_time, gboolean force)
 252         if ( !ret )
 253             return;
 254      }
 255 -
 256 +
 257      g_signal_emit (G_OBJECT (power), signals [SLEEPING], 0);
 258      xfpm_network_manager_sleep (TRUE);
 259 -
 260 +
 261      g_object_get (G_OBJECT (power->priv->conf),
 262                   LOCK_SCREEN_ON_SLEEP, &lock_screen,
 263                   NULL);
 264 -
 265 +
 266      if ( lock_screen )
 267      {
 268         g_usleep (2000000); /* 2 seconds */
 269         xfpm_lock_screen ();
 270      }
 271 -
 272 +
 273      dbus_g_proxy_call (power->priv->proxy, sleep_time, &error,
 274                        G_TYPE_INVALID,
 275                        G_TYPE_INVALID);
 276 -
 277 +
 278      if ( error )
 279      {
 280         if ( g_error_matches (error, DBUS_GERROR, DBUS_GERROR_NO_REPLY) )
 281 @@ -364,12 +364,12 @@ xfpm_power_sleep (XfpmPower *power, const gchar *sleep_time, gboolean force)
 282                 icon_name = XFPM_HIBERNATE_ICON;
 283             else
 284                 icon_name = XFPM_SUSPEND_ICON;
 285 -
 286 +
 287             xfpm_power_report_error (power, error->message, icon_name);
 288             g_error_free (error);
 289         }
 290      }
 291 -
 292 +
 293      g_signal_emit (G_OBJECT (power), signals [WAKING_UP], 0);
 294      xfpm_network_manager_sleep (FALSE);
 295  }
 296 @@ -420,9 +420,9 @@ static void
 297  xfpm_power_tray_exit_activated_cb (gpointer data)
 298  {
 299      gboolean ret;
 300 -
 301 -    ret = xfce_dialog_confirm (NULL,
 302 -                              GTK_STOCK_YES,
 303 +
 304 +    ret = xfce_dialog_confirm (NULL,
 305 +                              GTK_STOCK_YES,
 306                                _("Quit"),
 307                                _("All running instances of the power manager will exit"),
 308                                "%s",
 309 @@ -439,19 +439,19 @@ xfpm_power_change_mode (XfpmPower *power, XfpmPowerMode mode)
 310  {
 311  #ifdef HAVE_DPMS
 312      XfpmDpms *dpms;
 313 -
 314 +
 315      power->priv->power_mode = mode;
 316 -
 317 +
 318      dpms = xfpm_dpms_new ();
 319      xfpm_dpms_refresh (dpms);
 320      g_object_unref (dpms);
 321 -
 322 +
 323      if (mode == XFPM_POWER_MODE_NORMAL)
 324      {
 325         EggIdletime *idletime;
 326         idletime = egg_idletime_new ();
 327         egg_idletime_alarm_reset_all (idletime);
 328 -
 329 +
 330         g_object_unref (idletime);
 331      }
 332  #endif
 333 @@ -470,9 +470,9 @@ xfpm_power_presentation_mode_cb (XfpmPower *power)
 334  }
 335
 336  static void
 337 -xfpm_power_show_tray_menu (XfpmPower *power,
 338 -                        GtkStatusIcon *icon,
 339 -                        guint button,
 340 +xfpm_power_show_tray_menu (XfpmPower *power,
 341 +                        GtkStatusIcon *icon,
 342 +                        guint button,
 343                          guint activate_time,
 344                          gboolean show_info_item)
 345  {
 346 @@ -485,7 +485,7 @@ xfpm_power_show_tray_menu (XfpmPower *power,
 347      img = gtk_image_new_from_icon_name (XFPM_HIBERNATE_ICON, GTK_ICON_SIZE_MENU);
 348      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
 349      gtk_widget_set_sensitive (mi, FALSE);
 350 -
 351 +
 352      if ( power->priv->can_hibernate && power->priv->auth_hibernate)
 353      {
 354         gtk_widget_set_sensitive (mi, TRUE);
 355 @@ -494,21 +494,21 @@ xfpm_power_show_tray_menu (XfpmPower *power,
 356      }
 357      gtk_widget_show (mi);
 358      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 359 -
 360 +
 361      // Suspend menu option
 362      mi = gtk_image_menu_item_new_with_label (_("Suspend"));
 363      img = gtk_image_new_from_icon_name (XFPM_SUSPEND_ICON, GTK_ICON_SIZE_MENU);
 364      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
 365 -
 366 +
 367      gtk_widget_set_sensitive (mi, FALSE);
 368 -
 369 -    if ( power->priv->can_suspend && power->priv->auth_hibernate)
 370 +
 371 +    if ( power->priv->can_suspend && power->priv->auth_suspend)
 372      {
 373         gtk_widget_set_sensitive (mi, TRUE);
 374         g_signal_connect_swapped (mi, "activate",
 375                                   G_CALLBACK (xfpm_power_suspend_cb), power);
 376      }
 377 -
 378 +
 379      gtk_widget_show (mi);
 380      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 381  /*
 382 @@ -518,14 +518,14 @@ xfpm_power_show_tray_menu (XfpmPower *power,
 383      gtk_widget_set_tooltip_text (mi, _("Disable or enable monitor power control, "\
 384                                         "for example you could disable the screen power "\
 385                                        "control to avoid screen blanking when watching a movie."));
 386 -
 387 +
 388      g_signal_connect (G_OBJECT (mi), "activate",
 389                       G_CALLBACK (xfpm_tray_icon_inhibit_active_cb), tray);
 390      gtk_widget_set_sensitive (mi, TRUE);
 391      gtk_widget_show(mi);
 392      gtk_menu_shell_append(GTK_MENU_SHELL(menu),mi);
 393  */
 394 -
 395 +
 396      mi = gtk_separator_menu_item_new ();
 397      gtk_widget_show (mi);
 398      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 399 @@ -536,14 +536,14 @@ xfpm_power_show_tray_menu (XfpmPower *power,
 400      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
 401
 402      gtk_widget_set_sensitive (mi,TRUE);
 403 -
 404 +
 405      g_signal_connect_swapped (mi, "activate",
 406                               G_CALLBACK (xfpm_power_power_info_cb), icon);
 407 -
 408 +
 409      gtk_widget_show (mi);
 410      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 411 -
 412 -    /**
 413 +
 414 +    /**
 415       * Power Mode
 416       **/
 417      /* TRANSLATOR: Mode here is the power profile (presentation, power save, normal) */
 418 @@ -552,55 +552,55 @@ xfpm_power_show_tray_menu (XfpmPower *power,
 419      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
 420      gtk_widget_set_sensitive (mi,TRUE);
 421      gtk_widget_show (mi);
 422 -
 423 +
 424      subm = gtk_menu_new ();
 425      gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), subm);
 426      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 427 -
 428 +
 429      /* Normal*/
 430      mi = gtk_check_menu_item_new_with_label (_("Normal"));
 431      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), power->priv->power_mode == XFPM_POWER_MODE_NORMAL);
 432      gtk_widget_set_sensitive (mi,TRUE);
 433 -
 434 +
 435      g_signal_connect_swapped (mi, "activate",
 436                               G_CALLBACK (xfpm_power_normal_mode_cb), power);
 437      gtk_widget_show (mi);
 438      gtk_menu_shell_append (GTK_MENU_SHELL (subm), mi);
 439 -
 440 +
 441      /* Normal*/
 442      mi = gtk_check_menu_item_new_with_label (_("Presentation"));
 443      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), power->priv->power_mode == XFPM_POWER_MODE_PRESENTATION);
 444      gtk_widget_set_sensitive (mi, TRUE);
 445 -
 446 +
 447      g_signal_connect_swapped (mi, "activate",
 448                               G_CALLBACK (xfpm_power_presentation_mode_cb), power);
 449      gtk_widget_show (mi);
 450      gtk_menu_shell_append (GTK_MENU_SHELL (subm), mi);
 451 -
 452 -
 453 +
 454 +
 455      mi = gtk_separator_menu_item_new ();
 456      gtk_widget_show (mi);
 457      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 458 -
 459 +
 460      mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_HELP, NULL);
 461      gtk_widget_set_sensitive (mi, TRUE);
 462      gtk_widget_show (mi);
 463      g_signal_connect (mi, "activate", G_CALLBACK (xfpm_help), NULL);
 464 -
 465 +
 466      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 467 -
 468 +
 469      mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_ABOUT, NULL);
 470      gtk_widget_set_sensitive (mi, TRUE);
 471      gtk_widget_show (mi);
 472      g_signal_connect (mi, "activate", G_CALLBACK (xfpm_about), _("Power Manager"));
 473 -
 474 +
 475      gtk_menu_shell_append (GTK_MENU_SHELL(menu), mi);
 476 -
 477 +
 478      mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_PREFERENCES, NULL);
 479      gtk_widget_set_sensitive (mi, TRUE);
 480      gtk_widget_show (mi);
 481      g_signal_connect (mi, "activate",G_CALLBACK (xfpm_preferences), NULL);
 482 -
 483 +
 484      gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
 485
 486      mi = gtk_separator_menu_item_new ();
 487 @@ -618,20 +618,20 @@ xfpm_power_show_tray_menu (XfpmPower *power,
 488
 489      // Popup the menu
 490      gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
 491 -                  gtk_status_icon_position_menu,
 492 +                  gtk_status_icon_position_menu,
 493                    icon, button, activate_time);
 494 -
 495 +
 496  }
 497
 498 -static void
 499 -xfpm_power_show_tray_menu_battery (GtkStatusIcon *icon, guint button,
 500 +static void
 501 +xfpm_power_show_tray_menu_battery (GtkStatusIcon *icon, guint button,
 502                                  guint activate_time, XfpmPower *power)
 503  {
 504      xfpm_power_show_tray_menu (power, icon, button, activate_time, TRUE);
 505  }
 506
 507 -static void
 508 -xfpm_power_show_tray_menu_adaptor (GtkStatusIcon *icon, guint button,
 509 +static void
 510 +xfpm_power_show_tray_menu_adaptor (GtkStatusIcon *icon, guint button,
 511                                  guint activate_time, XfpmPower *power)
 512  {
 513      xfpm_power_show_tray_menu (power, icon, button, activate_time, FALSE);
 514 @@ -643,26 +643,26 @@ xfpm_power_get_current_charge_state (XfpmPower *power)
 515      GList *list;
 516      guint len, i;
 517      XfpmBatteryCharge max_charge_status = XFPM_BATTERY_CHARGE_UNKNOWN;
 518 -
 519 +
 520      list = g_hash_table_get_values (power->priv->hash);
 521      len = g_list_length (list);
 522 -
 523 +
 524      for ( i = 0; i < len; i++)
 525      {
 526         XfpmBatteryCharge battery_charge;
 527         XfpmDeviceType type;
 528 -
 529 +
 530         g_object_get (G_OBJECT (g_list_nth_data (list, i)),
 531                       "charge-status", &battery_charge,
 532                       "device-type", &type,
 533                       NULL);
 534 -       if ( type != XFPM_DEVICE_TYPE_BATTERY &&
 535 +       if ( type != XFPM_DEVICE_TYPE_BATTERY &&
 536              type != XFPM_DEVICE_TYPE_UPS )
 537             continue;
 538 -
 539 +
 540         max_charge_status = MAX (max_charge_status, battery_charge);
 541      }
 542 -
 543 +
 544      return max_charge_status;
 545  }
 546
 547 @@ -679,11 +679,11 @@ static void
 548  xfpm_power_add_actions_to_notification (XfpmPower *power, NotifyNotification *n)
 549  {
 550      gboolean can_shutdown;
 551 -
 552 +
 553      g_object_get (G_OBJECT (power->priv->console),
 554                   "can-shutdown", &can_shutdown,
 555                   NULL);
 556 -
 557 +
 558      if (  power->priv->can_hibernate && power->priv->auth_hibernate )
 559      {
 560          xfpm_notify_add_action_to_notification(
 561 @@ -692,9 +692,9 @@ xfpm_power_add_actions_to_notification (XfpmPower *power, NotifyNotification *n)
 562                                 "Hibernate",
 563                                 _("Hibernate the system"),
 564                                 (NotifyActionCallback)xfpm_power_notify_action_callback,
 565 -                               power);
 566 +                               power);
 567      }
 568 -
 569 +
 570      if (  power->priv->can_suspend && power->priv->auth_suspend )
 571      {
 572          xfpm_notify_add_action_to_notification(
 573 @@ -703,9 +703,9 @@ xfpm_power_add_actions_to_notification (XfpmPower *power, NotifyNotification *n)
 574                                 "Suspend",
 575                                 _("Suspend the system"),
 576                                 (NotifyActionCallback)xfpm_power_notify_action_callback,
 577 -                               power);
 578 +                               power);
 579      }
 580 -
 581 +
 582      if (can_shutdown )
 583         xfpm_notify_add_action_to_notification(
 584                                    power->priv->notify,
 585 @@ -713,7 +713,7 @@ xfpm_power_add_actions_to_notification (XfpmPower *power, NotifyNotification *n)
 586                                    "Shutdown",
 587                                    _("Shutdown the system"),
 588                                    (NotifyActionCallback)xfpm_power_notify_action_callback,
 589 -                                  power);
 590 +                                  power);
 591  }
 592
 593  static void
 594 @@ -721,19 +721,19 @@ xfpm_power_show_critical_action_notification (XfpmPower *power, XfpmBattery *bat
 595  {
 596      const gchar *message;
 597      NotifyNotification *n;
 598 -
 599 +
 600      message = _("System is running on low power. "\
 601                 "Save your work to avoid losing data");
 602 -
 603 -    n =
 604 -       xfpm_notify_new_notification (power->priv->notify,
 605 -                                     _("Power Manager"),
 606 -                                     message,
 607 +
 608 +    n =
 609 +       xfpm_notify_new_notification (power->priv->notify,
 610 +                                     _("Power Manager"),
 611 +                                     message,
 612                                       gtk_status_icon_get_icon_name (GTK_STATUS_ICON (battery)),
 613                                       20000,
 614                                       XFPM_NOTIFY_CRITICAL,
 615                                       GTK_STATUS_ICON (battery));
 616 -
 617 +
 618      xfpm_power_add_actions_to_notification (power, n);
 619      xfpm_notify_critical (power->priv->notify, n);
 620
 621 @@ -755,24 +755,24 @@ xfpm_power_show_critical_action_gtk (XfpmPower *power)
 622      GtkWidget *cancel;
 623      const gchar *message;
 624      gboolean can_shutdown;
 625 -
 626 +
 627      g_object_get (G_OBJECT (power->priv->console),
 628                   "can-shutdown", &can_shutdown,
 629                   NULL);
 630 -
 631 +
 632      message = _("System is running on low power. "\
 633                 "Save your work to avoid losing data");
 634 -
 635 +
 636      dialog = gtk_dialog_new_with_buttons (_("Power Manager"), NULL, GTK_DIALOG_MODAL,
 637                                            NULL);
 638 -
 639 +
 640      gtk_dialog_set_default_response (GTK_DIALOG (dialog),
 641                                       GTK_RESPONSE_CANCEL);
 642 -
 643 +
 644      content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
 645
 646      gtk_box_pack_start_defaults (GTK_BOX (content_area), gtk_label_new (message));
 647 -
 648 +
 649      if ( power->priv->can_hibernate && power->priv->auth_hibernate )
 650      {
 651         GtkWidget *hibernate;
 652 @@ -780,50 +780,50 @@ xfpm_power_show_critical_action_gtk (XfpmPower *power)
 653         img = gtk_image_new_from_icon_name (XFPM_HIBERNATE_ICON, GTK_ICON_SIZE_BUTTON);
 654         gtk_button_set_image (GTK_BUTTON (hibernate), img);
 655         gtk_dialog_add_action_widget (GTK_DIALOG (dialog), hibernate, GTK_RESPONSE_NONE);
 656 -
 657 +
 658         g_signal_connect_swapped (hibernate, "clicked",
 659                                   G_CALLBACK (xfpm_power_hibernate_clicked), power);
 660      }
 661 -
 662 +
 663      if ( power->priv->can_suspend && power->priv->auth_suspend )
 664      {
 665         GtkWidget *suspend;
 666 -
 667 +
 668         suspend = gtk_button_new_with_label (_("Suspend"));
 669         img = gtk_image_new_from_icon_name (XFPM_SUSPEND_ICON, GTK_ICON_SIZE_BUTTON);
 670         gtk_button_set_image (GTK_BUTTON (suspend), img);
 671         gtk_dialog_add_action_widget (GTK_DIALOG (dialog), suspend, GTK_RESPONSE_NONE);
 672 -
 673 +
 674         g_signal_connect_swapped (suspend, "clicked",
 675                                   G_CALLBACK (xfpm_power_suspend_clicked), power);
 676      }
 677 -
 678 +
 679      if ( can_shutdown )
 680      {
 681         GtkWidget *shutdown;
 682 -
 683 +
 684         shutdown = gtk_button_new_with_label (_("Shutdown"));
 685         img = gtk_image_new_from_icon_name (XFPM_SUSPEND_ICON, GTK_ICON_SIZE_BUTTON);
 686         gtk_button_set_image (GTK_BUTTON (shutdown), img);
 687         gtk_dialog_add_action_widget (GTK_DIALOG (dialog), shutdown, GTK_RESPONSE_NONE);
 688 -
 689 +
 690         g_signal_connect_swapped (shutdown, "clicked",
 691                                   G_CALLBACK (xfpm_power_shutdown_clicked), power);
 692      }
 693 -
 694 +
 695      cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
 696      gtk_dialog_add_action_widget (GTK_DIALOG (dialog), cancel, GTK_RESPONSE_NONE);
 697 -
 698 +
 699      g_signal_connect_swapped (cancel, "clicked",
 700                               G_CALLBACK (xfpm_power_close_critical_dialog), power);
 701 -
 702 +
 703      g_signal_connect_swapped (dialog, "destroy",
 704                               G_CALLBACK (xfpm_power_close_critical_dialog), power);
 705      if ( power->priv->dialog )
 706      {
 707         gtk_widget_destroy (power->priv->dialog);
 708         power->priv->dialog = NULL;
 709 -
 710 +
 711      }
 712      power->priv->dialog = dialog;
 713      gtk_widget_show_all (dialog);
 714 @@ -833,11 +833,11 @@ static void
 715  xfpm_power_show_critical_action (XfpmPower *power, XfpmBattery *battery)
 716  {
 717      gboolean supports_actions;
 718 -
 719 +
 720      g_object_get (G_OBJECT (power->priv->notify),
 721                   "actions", &supports_actions,
 722                   NULL);
 723 -
 724 +
 725      if ( supports_actions )
 726         xfpm_power_show_critical_action_notification (power, battery);
 727      else
 728 @@ -861,7 +861,7 @@ static void
 729  xfpm_power_system_on_critical_power (XfpmPower *power, XfpmBattery *battery)
 730  {
 731      XfpmShutdownRequest critical_action;
 732 -
 733 +
 734      g_object_get (G_OBJECT (power->priv->conf),
 735                   CRITICAL_BATT_ACTION_CFG, &critical_action,
 736                   NULL);
 737 @@ -893,53 +893,53 @@ xfpm_power_battery_charge_changed_cb (XfpmBattery *battery, XfpmPower *power)
 738      gboolean notify;
 739      XfpmBatteryCharge battery_charge;
 740      XfpmBatteryCharge current_charge;
 741 -
 742 +
 743      battery_charge = xfpm_battery_get_charge (battery);
 744      current_charge = xfpm_power_get_current_charge_state (power);
 745 -
 746 +
 747      XFPM_DEBUG_ENUM (current_charge, XFPM_TYPE_BATTERY_CHARGE, "Current system charge status");
 748 -
 749 +
 750      if (current_charge == power->priv->overall_state)
 751         return;
 752 -
 753 +
 754      if (current_charge >= XFPM_BATTERY_CHARGE_LOW)
 755         power->priv->critical_action_done = FALSE;
 756 -
 757 +
 758      power->priv->overall_state = current_charge;
 759 -
 760 +
 761      if ( current_charge == XFPM_BATTERY_CHARGE_CRITICAL && power->priv->on_battery)
 762      {
 763         xfpm_power_system_on_critical_power (power, battery);
 764 -
 765 +
 766         power->priv->on_low_battery = TRUE;
 767         g_signal_emit (G_OBJECT (power), signals [LOW_BATTERY_CHANGED], 0, power->priv->on_low_battery);
 768         return;
 769      }
 770 -
 771 +
 772      if ( power->priv->on_low_battery )
 773      {
 774         power->priv->on_low_battery = FALSE;
 775         g_signal_emit (G_OBJECT (power), signals [LOW_BATTERY_CHANGED], 0, power->priv->on_low_battery);
 776      }
 777 -
 778 +
 779      g_object_get (G_OBJECT (power->priv->conf),
 780                   GENERAL_NOTIFICATION_CFG, &notify,
 781                   NULL);
 782 -
 783 +
 784      if ( power->priv->on_battery )
 785      {
 786         if ( current_charge == XFPM_BATTERY_CHARGE_LOW )
 787         {
 788             if ( notify )
 789 -               xfpm_notify_show_notification (power->priv->notify,
 790 -                                              _("Power Manager"),
 791 -                                              _("System is running on low power"),
 792 +               xfpm_notify_show_notification (power->priv->notify,
 793 +                                              _("Power Manager"),
 794 +                                              _("System is running on low power"),
 795                                                gtk_status_icon_get_icon_name (GTK_STATUS_ICON (battery)),
 796                                                10000,
 797                                                FALSE,
 798                                                XFPM_NOTIFY_NORMAL,
 799                                                GTK_STATUS_ICON (battery));
 800 -
 801 +
 802         }
 803         else if ( battery_charge == XFPM_BATTERY_CHARGE_LOW )
 804         {
 805 @@ -947,17 +947,17 @@ xfpm_power_battery_charge_changed_cb (XfpmBattery *battery, XfpmPower *power)
 806             {
 807                 gchar *msg;
 808                 gchar *time_str;
 809 -
 810 +
 811                 const gchar *battery_name = xfpm_battery_get_battery_name (battery);
 812 -
 813 +
 814                 time_str = xfpm_battery_get_time_left (battery);
 815 -
 816 +
 817                 msg = g_strdup_printf (_("Your %s charge level is low\nEstimated time left %s"), battery_name, time_str);
 818 -
 819 -
 820 -               xfpm_notify_show_notification (power->priv->notify,
 821 -                                              _("Power Manager"),
 822 -                                              msg,
 823 +
 824 +
 825 +               xfpm_notify_show_notification (power->priv->notify,
 826 +                                              _("Power Manager"),
 827 +                                              msg,
 828                                                gtk_status_icon_get_icon_name (GTK_STATUS_ICON (battery)),
 829                                                10000,
 830                                                FALSE,
 831 @@ -968,7 +968,7 @@ xfpm_power_battery_charge_changed_cb (XfpmBattery *battery, XfpmPower *power)
 832             }
 833         }
 834      }
 835 -
 836 +
 837      /*Current charge is okay now, then close the dialog*/
 838      if ( power->priv->dialog )
 839      {
 840 @@ -983,25 +983,25 @@ xfpm_power_add_device (XfpmPower *power, const gchar *object_path)
 841      DBusGProxy *proxy_prop;
 842      guint device_type = XFPM_DEVICE_TYPE_UNKNOWN;
 843      GValue value;
 844 -
 845 -    proxy_prop = dbus_g_proxy_new_for_name (power->priv->bus,
 846 +
 847 +    proxy_prop = dbus_g_proxy_new_for_name (power->priv->bus,
 848                                             UPOWER_NAME,
 849                                             object_path,
 850                                             DBUS_INTERFACE_PROPERTIES);
 851 -
 852 +
 853      if ( !proxy_prop )
 854      {
 855         g_warning ("Unable to create proxy for : %s", object_path);
 856         return;
 857      }
 858 -
 859 +
 860      value = xfpm_power_get_interface_property (proxy_prop, UPOWER_IFACE_DEVICE, "Type");
 861 -
 862 +
 863      device_type = g_value_get_uint (&value);
 864 -
 865 +
 866      XFPM_DEBUG_ENUM (device_type, XFPM_TYPE_DEVICE_TYPE, " device added");
 867 -
 868 -    if ( device_type == XFPM_DEVICE_TYPE_BATTERY ||
 869 +
 870 +    if ( device_type == XFPM_DEVICE_TYPE_BATTERY ||
 871          device_type == XFPM_DEVICE_TYPE_UPS     ||
 872          device_type == XFPM_DEVICE_TYPE_MOUSE   ||
 873          device_type == XFPM_DEVICE_TYPE_KBD     ||
 874 @@ -1009,7 +1009,7 @@ xfpm_power_add_device (XfpmPower *power, const gchar *object_path)
 875      {
 876         GtkStatusIcon *battery;
 877         DBusGProxy *proxy;
 878 -       XFPM_DEBUG_ENUM (device_type, XFPM_TYPE_DEVICE_TYPE,
 879 +       XFPM_DEBUG_ENUM (device_type, XFPM_TYPE_DEVICE_TYPE,
 880                         "Battery device detected at : %s", object_path);
 881         proxy = dbus_g_proxy_new_for_name (power->priv->bus,
 882                                            UPOWER_NAME,
 883 @@ -1017,19 +1017,19 @@ xfpm_power_add_device (XfpmPower *power, const gchar *object_path)
 884                                            UPOWER_IFACE_DEVICE);
 885         battery = xfpm_battery_new ();
 886         gtk_status_icon_set_visible (battery, FALSE);
 887 -       xfpm_battery_monitor_device (XFPM_BATTERY (battery),
 888 -                                    proxy,
 889 -                                    proxy_prop,
 890 +       xfpm_battery_monitor_device (XFPM_BATTERY (battery),
 891 +                                    proxy,
 892 +                                    proxy_prop,
 893                                      device_type);
 894
 895         g_hash_table_insert (power->priv->hash, g_strdup (object_path), battery);
 896 -
 897 +
 898         g_signal_connect (battery, "popup-menu",
 899                           G_CALLBACK (xfpm_power_show_tray_menu_battery), power);
 900 -
 901 +
 902         g_signal_connect (battery, "battery-charge-changed",
 903                           G_CALLBACK (xfpm_power_battery_charge_changed_cb), power);
 904 -
 905 +
 906         xfpm_power_refresh_adaptor_visible (power);
 907      }
 908      else if ( device_type != XFPM_DEVICE_TYPE_LINE_POWER )
 909 @@ -1044,9 +1044,9 @@ xfpm_power_get_power_devices (XfpmPower *power)
 910  {
 911      GPtrArray *array = NULL;
 912      guint i;
 913 -
 914 +
 915      array = xfpm_power_enumerate_devices (power->priv->proxy);
 916 -
 917 +
 918      if ( array )
 919      {
 920         for ( i = 0; i < array->len; i++)
 921 @@ -1057,7 +1057,7 @@ xfpm_power_get_power_devices (XfpmPower *power)
 922         }
 923         g_ptr_array_free (array, TRUE);
 924      }
 925 -
 926 +
 927  }
 928
 929  static void
 930 @@ -1111,7 +1111,7 @@ static void
 931  xfpm_power_hide_adapter_icon (XfpmPower *power)
 932  {
 933       XFPM_DEBUG ("Hide adaptor icon");
 934 -
 935 +
 936      if ( power->priv->adapter_icon )
 937      {
 938          g_object_unref (power->priv->adapter_icon);
 939 @@ -1123,15 +1123,15 @@ static void
 940  xfpm_power_show_adapter_icon (XfpmPower *power)
 941  {
 942      g_return_if_fail (power->priv->adapter_icon == NULL);
 943 -
 944 +
 945      power->priv->adapter_icon = gtk_status_icon_new ();
 946 -
 947 +
 948      XFPM_DEBUG ("Showing adaptor icon");
 949 -
 950 +
 951      gtk_status_icon_set_from_icon_name (power->priv->adapter_icon, XFPM_AC_ADAPTER_ICON);
 952 -
 953 +
 954      gtk_status_icon_set_visible (power->priv->adapter_icon, TRUE);
 955 -
 956 +
 957      g_signal_connect (power->priv->adapter_icon, "popup-menu",
 958                       G_CALLBACK (xfpm_power_show_tray_menu_adaptor), power);
 959  }
 960 @@ -1140,26 +1140,26 @@ static void
 961  xfpm_power_refresh_adaptor_visible (XfpmPower *power)
 962  {
 963      XfpmShowIcon show_icon;
 964 -
 965 +
 966      g_object_get (G_OBJECT (power->priv->conf),
 967                   SHOW_TRAY_ICON_CFG, &show_icon,
 968                   NULL);
 969 -
 970 +
 971      XFPM_DEBUG_ENUM (show_icon, XFPM_TYPE_SHOW_ICON, "Tray icon configuration: ");
 972 -
 973 +
 974      if ( show_icon == SHOW_ICON_ALWAYS )
 975      {
 976         if ( g_hash_table_size (power->priv->hash) == 0 )
 977         {
 978             xfpm_power_show_adapter_icon (power);
 979  #if GTK_CHECK_VERSION (2, 16, 0)
 980 -           gtk_status_icon_set_tooltip_text (power->priv->adapter_icon,
 981 -                                             power->priv->on_battery ?
 982 +           gtk_status_icon_set_tooltip_text (power->priv->adapter_icon,
 983 +                                             power->priv->on_battery ?
 984                                               _("Adaptor is offline") :
 985                                               _("Adaptor is online") );
 986  #else
 987 -           gtk_status_icon_set_tooltip (power->priv->adapter_icon,
 988 -                                        power->priv->on_battery ?
 989 +           gtk_status_icon_set_tooltip (power->priv->adapter_icon,
 990 +                                        power->priv->on_battery ?
 991                                          _("Adaptor is offline") :
 992                                          _("Adaptor is online") );
 993  #endif
 994 @@ -1184,7 +1184,7 @@ xfpm_power_class_init (XfpmPowerClass *klass)
 995
 996      object_class->get_property = xfpm_power_get_property;
 997
 998 -    signals [ON_BATTERY_CHANGED] =
 999 +    signals [ON_BATTERY_CHANGED] =
1000          g_signal_new ("on-battery-changed",
1001                        XFPM_TYPE_POWER,
1002                        G_SIGNAL_RUN_LAST,
1003 @@ -1193,7 +1193,7 @@ xfpm_power_class_init (XfpmPowerClass *klass)
1004                        g_cclosure_marshal_VOID__BOOLEAN,
1005                        G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
1006
1007 -    signals [LOW_BATTERY_CHANGED] =
1008 +    signals [LOW_BATTERY_CHANGED] =
1009          g_signal_new ("low-battery-changed",
1010                        XFPM_TYPE_POWER,
1011                        G_SIGNAL_RUN_LAST,
1012 @@ -1202,7 +1202,7 @@ xfpm_power_class_init (XfpmPowerClass *klass)
1013                        g_cclosure_marshal_VOID__BOOLEAN,
1014                        G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
1015
1016 -    signals [LID_CHANGED] =
1017 +    signals [LID_CHANGED] =
1018          g_signal_new ("lid-changed",
1019                        XFPM_TYPE_POWER,
1020                        G_SIGNAL_RUN_LAST,
1021 @@ -1211,7 +1211,7 @@ xfpm_power_class_init (XfpmPowerClass *klass)
1022                        g_cclosure_marshal_VOID__BOOLEAN,
1023                        G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
1024
1025 -    signals [WAKING_UP] =
1026 +    signals [WAKING_UP] =
1027          g_signal_new ("waking-up",
1028                        XFPM_TYPE_POWER,
1029                        G_SIGNAL_RUN_LAST,
1030 @@ -1220,7 +1220,7 @@ xfpm_power_class_init (XfpmPowerClass *klass)
1031                        g_cclosure_marshal_VOID__VOID,
1032                        G_TYPE_NONE, 0, G_TYPE_NONE);
1033
1034 -    signals [SLEEPING] =
1035 +    signals [SLEEPING] =
1036          g_signal_new ("sleeping",
1037                        XFPM_TYPE_POWER,
1038                        G_SIGNAL_RUN_LAST,
1039 @@ -1229,7 +1229,7 @@ xfpm_power_class_init (XfpmPowerClass *klass)
1040                        g_cclosure_marshal_VOID__VOID,
1041                        G_TYPE_NONE, 0, G_TYPE_NONE);
1042
1043 -    signals [ASK_SHUTDOWN] =
1044 +    signals [ASK_SHUTDOWN] =
1045          g_signal_new ("ask-shutdown",
1046                        XFPM_TYPE_POWER,
1047                        G_SIGNAL_RUN_LAST,
1048 @@ -1238,7 +1238,7 @@ xfpm_power_class_init (XfpmPowerClass *klass)
1049                        g_cclosure_marshal_VOID__VOID,
1050                        G_TYPE_NONE, 0, G_TYPE_NONE);
1051
1052 -    signals [SHUTDOWN] =
1053 +    signals [SHUTDOWN] =
1054          g_signal_new ("shutdown",
1055                        XFPM_TYPE_POWER,
1056                        G_SIGNAL_RUN_LAST,
1057 @@ -1297,7 +1297,7 @@ xfpm_power_class_init (XfpmPowerClass *klass)
1058                                                            G_PARAM_READABLE));
1059
1060      g_type_class_add_private (klass, sizeof (XfpmPowerPrivate));
1061 -
1062 +
1063      xfpm_power_dbus_class_init (klass);
1064  }
1065
1066 @@ -1305,9 +1305,9 @@ static void
1067  xfpm_power_init (XfpmPower *power)
1068  {
1069      GError *error = NULL;
1070 -
1071 +
1072      power->priv = XFPM_POWER_GET_PRIVATE (power);
1073 -
1074 +
1075      power->priv->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
1076      power->priv->lid_is_present  = FALSE;
1077      power->priv->lid_is_closed   = FALSE;
1078 @@ -1323,26 +1323,26 @@ xfpm_power_init (XfpmPower *power)
1079      power->priv->overall_state   = XFPM_BATTERY_CHARGE_OK;
1080      power->priv->critical_action_done = FALSE;
1081      power->priv->power_mode      = XFPM_POWER_MODE_NORMAL;
1082 -
1083 +
1084      power->priv->inhibit = xfpm_inhibit_new ();
1085      power->priv->notify  = xfpm_notify_new ();
1086      power->priv->conf    = xfpm_xfconf_new ();
1087      power->priv->console = xfpm_console_kit_new ();
1088 -
1089 +
1090      g_signal_connect_swapped (power->priv->conf, "notify::" SHOW_TRAY_ICON_CFG,
1091                               G_CALLBACK (xfpm_power_refresh_adaptor_visible), power);
1092 -
1093 +
1094  #ifdef ENABLE_POLKIT
1095      power->priv->polkit  = xfpm_polkit_get ();
1096      g_signal_connect_swapped (power->priv->polkit, "auth-changed",
1097                               G_CALLBACK (xfpm_power_polkit_auth_changed_cb), power);
1098  #endif
1099 -
1100 +
1101      g_signal_connect (power->priv->inhibit, "has-inhibit-changed",
1102                       G_CALLBACK (xfpm_power_inhibit_changed_cb), power);
1103 -
1104 +
1105      power->priv->bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
1106 -
1107 +
1108      if ( error )
1109      {
1110         g_critical ("Unable to connect to the system bus : %s", error->message);
1111 @@ -1354,18 +1354,18 @@ xfpm_power_init (XfpmPower *power)
1112                                                     UPOWER_NAME,
1113                                                     UPOWER_PATH,
1114                                                     UPOWER_IFACE);
1115 -
1116 -
1117 +
1118 +
1119      power->priv->proxy_prop = dbus_g_proxy_new_for_name (power->priv->bus,
1120                                                          UPOWER_NAME,
1121                                                          UPOWER_PATH,
1122                                                          DBUS_INTERFACE_PROPERTIES);
1123 -    if (power->priv->proxy_prop == NULL)
1124 +    if (power->priv->proxy_prop == NULL)
1125      {
1126         g_critical ("Unable to create proxy for %s", UPOWER_NAME);
1127         goto out;
1128      }
1129 -
1130 +
1131      xfpm_power_get_power_devices (power);
1132      xfpm_power_get_properties (power);
1133  #ifdef ENABLE_POLKIT
1134 @@ -1376,18 +1376,18 @@ xfpm_power_init (XfpmPower *power)
1135      dbus_g_proxy_add_signal (power->priv->proxy, "DeviceAdded", G_TYPE_STRING, G_TYPE_INVALID);
1136      dbus_g_proxy_add_signal (power->priv->proxy, "DeviceRemoved", G_TYPE_STRING, G_TYPE_INVALID);
1137      dbus_g_proxy_add_signal (power->priv->proxy, "DeviceChanged", G_TYPE_STRING, G_TYPE_INVALID);
1138 -
1139 +
1140      dbus_g_proxy_connect_signal (power->priv->proxy, "Changed",
1141                                  G_CALLBACK (xfpm_power_changed_cb), power, NULL);
1142      dbus_g_proxy_connect_signal (power->priv->proxy, "DeviceRemoved",
1143                                  G_CALLBACK (xfpm_power_device_removed_cb), power, NULL);
1144      dbus_g_proxy_connect_signal (power->priv->proxy, "DeviceAdded",
1145                                  G_CALLBACK (xfpm_power_device_added_cb), power, NULL);
1146 -
1147 +
1148      dbus_g_proxy_connect_signal (power->priv->proxy, "DeviceChanged",
1149                                  G_CALLBACK (xfpm_power_device_changed_cb), power, NULL);
1150
1151 -
1152 +
1153  out:
1154      xfpm_power_refresh_adaptor_visible (power);
1155
1156 @@ -1439,18 +1439,18 @@ xfpm_power_finalize (GObject *object)
1157      XfpmPower *power;
1158
1159      power = XFPM_POWER (object);
1160 -
1161 +
1162      g_free (power->priv->daemon_version);
1163 -
1164 +
1165      g_object_unref (power->priv->inhibit);
1166      g_object_unref (power->priv->notify);
1167      g_object_unref (power->priv->conf);
1168      g_object_unref (power->priv->console);
1169 -
1170 +
1171      xfpm_power_hide_adapter_icon (power);
1172 -
1173 +
1174      dbus_g_connection_unref (power->priv->bus);
1175 -
1176 +
1177      if ( power->priv->proxy )
1178      {
1179         dbus_g_proxy_disconnect_signal (power->priv->proxy, "Changed",
1180 @@ -1463,7 +1463,7 @@ xfpm_power_finalize (GObject *object)
1181                                         G_CALLBACK (xfpm_power_device_changed_cb), power);
1182         g_object_unref (power->priv->proxy);
1183      }
1184 -
1185 +
1186      if ( power->priv->proxy_prop )
1187         g_object_unref (power->priv->proxy_prop);
1188
1189 @@ -1480,7 +1480,7 @@ XfpmPower *
1190  xfpm_power_get (void)
1191  {
1192      static gpointer xfpm_power_object = NULL;
1193 -
1194 +
1195      if ( G_LIKELY (xfpm_power_object != NULL ) )
1196      {
1197         g_object_ref (xfpm_power_object);
1198 @@ -1490,7 +1490,7 @@ xfpm_power_get (void)
1199         xfpm_power_object = g_object_new (XFPM_TYPE_POWER, NULL);
1200         g_object_add_weak_pointer (xfpm_power_object, &xfpm_power_object);
1201      }
1202 -
1203 +
1204      return XFPM_POWER (xfpm_power_object);
1205  }
1206
1207 @@ -1509,12 +1509,12 @@ gboolean xfpm_power_has_battery (XfpmPower *power)
1208      GtkStatusIcon *battery = NULL;
1209      guint i, len;
1210      GList *list;
1211 -
1212 +
1213      gboolean ret = FALSE;
1214 -
1215 +
1216      list = g_hash_table_get_values (power->priv->hash);
1217      len = g_list_length (list);
1218 -
1219 +
1220      for ( i = 0; i < len; i++)
1221      {
1222         XfpmDeviceType type;
1223 @@ -1527,28 +1527,28 @@ gboolean xfpm_power_has_battery (XfpmPower *power)
1224             break;
1225         }
1226      }
1227 -
1228 +
1229      return ret;
1230  }
1231
1232  XfpmPowerMode  xfpm_power_get_mode (XfpmPower *power)
1233  {
1234      g_return_val_if_fail (XFPM_IS_POWER (power), XFPM_POWER_MODE_NORMAL);
1235 -
1236 +
1237      return power->priv->power_mode;
1238  }
1239
1240  /*
1241 - *
1242 + *
1243   * DBus server implementation for org.freedesktop.PowerManagement
1244 - *
1245 + *
1246   */
1247  static gboolean xfpm_power_dbus_shutdown (XfpmPower *power,
1248                                         GError **error);
1249
1250  static gboolean xfpm_power_dbus_reboot   (XfpmPower *power,
1251                                         GError **error);
1252 -
1253 +
1254  static gboolean xfpm_power_dbus_hibernate (XfpmPower * power,
1255                                          GError **error);
1256
1257 @@ -1556,11 +1556,11 @@ static gboolean xfpm_power_dbus_suspend (XfpmPower * power,
1258                                        GError ** error);
1259
1260  static gboolean xfpm_power_dbus_can_reboot (XfpmPower * power,
1261 -                                         gboolean * OUT_can_reboot,
1262 +                                         gboolean * OUT_can_reboot,
1263                                           GError ** error);
1264
1265  static gboolean xfpm_power_dbus_can_shutdown (XfpmPower * power,
1266 -                                           gboolean * OUT_can_reboot,
1267 +                                           gboolean * OUT_can_reboot,
1268                                             GError ** error);
1269
1270  static gboolean xfpm_power_dbus_can_hibernate (XfpmPower * power,
1271 @@ -1606,20 +1606,20 @@ static gboolean xfpm_power_dbus_shutdown (XfpmPower *power,
1272                                         GError **error)
1273  {
1274      gboolean can_reboot;
1275 -
1276 +
1277      g_object_get (G_OBJECT (power->priv->console),
1278                   "can-shutdown", &can_reboot,
1279                   NULL);
1280 -
1281 +
1282      if ( !can_reboot)
1283      {
1284         g_set_error (error, XFPM_ERROR, XFPM_ERROR_PERMISSION_DENIED,
1285                      _("Permission denied"));
1286          return FALSE;
1287      }
1288 -
1289 +
1290      xfpm_console_kit_shutdown (power->priv->console, error);
1291 -
1292 +
1293      return TRUE;
1294  }
1295
1296 @@ -1627,23 +1627,23 @@ static gboolean xfpm_power_dbus_reboot   (XfpmPower *power,
1297                                         GError **error)
1298  {
1299      gboolean can_reboot;
1300 -
1301 +
1302      g_object_get (G_OBJECT (power->priv->console),
1303                   "can-restart", &can_reboot,
1304                   NULL);
1305 -
1306 +
1307      if ( !can_reboot)
1308      {
1309         g_set_error (error, XFPM_ERROR, XFPM_ERROR_PERMISSION_DENIED,
1310                      _("Permission denied"));
1311          return FALSE;
1312      }
1313 -
1314 +
1315      xfpm_console_kit_reboot (power->priv->console, error);
1316 -
1317 +
1318      return TRUE;
1319  }
1320 -
1321 +
1322  static gboolean xfpm_power_dbus_hibernate (XfpmPower * power,
1323                                          GError **error)
1324  {
1325 @@ -1652,18 +1652,18 @@ static gboolean xfpm_power_dbus_hibernate (XfpmPower * power,
1326         g_set_error (error, XFPM_ERROR, XFPM_ERROR_PERMISSION_DENIED,
1327                      _("Permission denied"));
1328          return FALSE;
1329 -
1330 +
1331      }
1332 -
1333 +
1334      if (!power->priv->can_hibernate )
1335      {
1336         g_set_error (error, XFPM_ERROR, XFPM_ERROR_NO_HARDWARE_SUPPORT,
1337                      _("Suspend not supported"));
1338          return FALSE;
1339      }
1340 -
1341 +
1342      xfpm_power_sleep (power, "Hibernate", FALSE);
1343 -
1344 +
1345      return TRUE;
1346  }
1347
1348 @@ -1675,34 +1675,34 @@ static gboolean xfpm_power_dbus_suspend (XfpmPower * power,
1349         g_set_error (error, XFPM_ERROR, XFPM_ERROR_PERMISSION_DENIED,
1350                      _("Permission denied"));
1351          return FALSE;
1352 -
1353 +
1354      }
1355 -
1356 +
1357      if (!power->priv->can_suspend )
1358      {
1359         g_set_error (error, XFPM_ERROR, XFPM_ERROR_NO_HARDWARE_SUPPORT,
1360                      _("Suspend not supported"));
1361          return FALSE;
1362      }
1363 -
1364 +
1365      xfpm_power_sleep (power, "Suspend", FALSE);
1366 -
1367 +
1368      return TRUE;
1369  }
1370
1371  static gboolean xfpm_power_dbus_can_reboot (XfpmPower * power,
1372 -                                         gboolean * OUT_can_reboot,
1373 +                                         gboolean * OUT_can_reboot,
1374                                           GError ** error)
1375  {
1376      g_object_get (G_OBJECT (power->priv->console),
1377                   "can-reboot", OUT_can_reboot,
1378                   NULL);
1379 -
1380 +
1381      return TRUE;
1382  }
1383
1384  static gboolean xfpm_power_dbus_can_shutdown (XfpmPower * power,
1385 -                                           gboolean * OUT_can_shutdown,
1386 +                                           gboolean * OUT_can_shutdown,
1387                                             GError ** error)
1388  {
1389      g_object_get (G_OBJECT (power->priv->console),
1390 @@ -1724,7 +1724,7 @@ static gboolean xfpm_power_dbus_can_suspend (XfpmPower * power,
1391                                            GError ** error)
1392  {
1393      *OUT_can_suspend = power->priv->can_suspend;
1394 -
1395 +
1396      return TRUE;
1397  }
1398
1399 @@ -1741,7 +1741,7 @@ static gboolean xfpm_power_dbus_get_on_battery (XfpmPower * power,
1400                                               GError ** error)
1401  {
1402      *OUT_on_battery = power->priv->on_battery;
1403 -
1404 +
1405      return TRUE;
1406  }
1407
1408 @@ -1750,6 +1750,6 @@ static gboolean xfpm_power_dbus_get_low_battery (XfpmPower * power,
1409                                                GError ** error)
1410  {
1411      *OUT_low_battery = power->priv->on_low_battery;
1412 -
1413 +
1414      return TRUE;
1415  }
1416 --
1417 1.9.3
1418