Merge lp:~noskcaj/ubuntu/saucy/xfce4-power-manager/1.2.0-2ubuntu1 into lp:ubuntu/saucy/xfce4-power-manager

[Jackson Doak]

* Merged from debian unstable. Remaining changes:
  - 06_fix-suspend-auth-check.patch: added, correctly check for suspend
    permissions before disabling the corresponding drop-down menu item.
    lp #929537
  - 08_show_preferences_lxde.patch: Hide settings menu only on desktop
    environment which have another power manager.
  - xubuntu_fix-status-icon-other-devices.patch: fix broken status icons
    for other devices (phone, wireless kbd, mouse, etc.).
  - Switch to using logind for session tracking. Depend on systemd-services
    instead of consolekit recommends, and add libsystemd-login-dev build
    dependency.

[Daniel Holbach (dholbach)]

Good work. Uploaded.

review: Approve

Unmerged revisions

34. By Jackson Doak on 2013-08-12

* Merged from debian unstable. Remaining changes:
    - 06_fix-suspend-auth-check.patch: added, correctly check for suspend
      permissions before disabling the corresponding drop-down menu item.
      lp #929537
    - 08_show_preferences_lxde.patch: Hide settings menu only on desktop
      environment which have another power manager.
    - xubuntu_fix-status-icon-other-devices.patch: fix broken status icons
      for other devices (phone, wireless kbd, mouse, etc.).
    - Switch to using logind for session tracking. Depend on systemd-services
    instead of consolekit recommends, and add libsystemd-login-dev build
    dependency.

=== added directory '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch'
=== added file '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/.timestamp'
=== added directory '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/po'
=== added file '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/po/POTFILES.in'
--- .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/po/POTFILES.in	1970-01-01 00:00:00 +0000
+++ .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/po/POTFILES.in	2013-08-12 21:07:54 +0000
@@ -0,0 +1,19 @@
+[encoding: UTF-8]
+[type: gettext/glade]data/interfaces/xfpm-settings.ui
+settings/xfpm-settings.c
+settings/xfpm-settings-main.c
+settings/xfce4-power-manager-settings.desktop.in
+common/xfpm-common.c
+src/xfpm-power.c
+src/xfpm-power-common.c
+src/xfpm-battery.c
+src/xfpm-battery.c
+src/xfpm-main.c
+src/xfpm-network-manager.c
+src/xfpm-dpms.c
+src/xfpm-inhibit.c
+src/xfpm-power-info.c
+src/xfce4-power-manager.desktop.in
+src/org.xfce.power.policy.in2
+panel-plugins/brightness/brightness-button.c
+panel-plugins/brightness/xfce4-brightness-plugin.desktop.in.in

=== added directory '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src'
=== added file '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/Makefile.am'
--- .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/Makefile.am	1970-01-01 00:00:00 +0000
+++ .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/Makefile.am	2013-08-12 21:07:54 +0000
@@ -0,0 +1,211 @@
+bin_PROGRAMS = xfce4-power-manager		\
+	       xfce4-power-information
+
+xfce4_power_manager_SOURCES =                   \
+	$(BUILT_SOURCES)			\
+	xfpm-enum.h				\
+	xfpm-enum-glib.h			\
+	xfpm-main.c				\
+	xfpm-manager.c				\
+	xfpm-manager.h				\
+	xfpm-power.c				\
+	xfpm-power.h				\
+	xfpm-power-common.c			\
+	xfpm-power-common.h			\
+	xfpm-battery.c				\
+	xfpm-battery.h				\
+	xfpm-xfconf.c				\
+	xfpm-xfconf.h				\
+	xfpm-disks.c				\
+	xfpm-disks.h				\
+	xfpm-console-kit.c			\
+	xfpm-console-kit.h			\
+	egg-idletime.c				\
+	egg-idletime.h				\
+	xfpm-backlight.c			\
+	xfpm-backlight.h			\
+	xfpm-dpms.c				\
+	xfpm-dpms.h				\
+	xfpm-button.c				\
+	xfpm-button.h				\
+	xfpm-network-manager.c			\
+	xfpm-network-manager.h			\
+	xfpm-inhibit.c				\
+	xfpm-inhibit.h				\
+	xfpm-notify.c				\
+	xfpm-notify.h				\
+	xfpm-polkit.c				\
+	xfpm-polkit.h				\
+	xfpm-errors.c				\
+	xfpm-errors.h				\
+	gsd-media-keys-window.c			\
+	gsd-media-keys-window.h
+
+xfce4_power_manager_CFLAGS =                    \
+	-I$(top_srcdir)                         \
+	-I$(top_srcdir)/common                  \
+	-I$(top_srcdir)/libdbus                 \
+	-DLOCALEDIR=\"$(localedir)\"            \
+	-DG_LOG_DOMAIN=\"xfce4-power-manager\"  \
+	-DSYSCONFDIR=\"$(sysconfdir)\"		\
+	$(GOBJECT_CFLAGS)                       \
+	$(GTHREAD_CFLAGS)                       \
+	$(DBUS_GLIB_CFLAGS)                     \
+	$(LIBXFCE4UI_CFLAGS)                    \
+	$(XFCONF_CFLAGS)                        \
+	$(LIBNOTIFY_CFLAGS)                     \
+	$(XRANDR_CFLAGS)			\
+	$(DPMS_CFLAGS)           		\
+	$(PLATFORM_CPPFLAGS)			\
+	$(PLATFORM_CFLAGS)
+
+xfce4_power_manager_LDFLAGS =			\
+	-no-undefined				\
+	$(PLATFORM_LDFLAGS)
+
+xfce4_power_manager_LDADD =                     \
+	$(top_builddir)/common/libxfpmcommon.la \
+	$(top_builddir)/libdbus/libxfpmdbus.la  \
+	$(GOBJECT_LIBS)                         \
+	$(GTHREAD_LIBS)                         \
+	$(DBUS_GLIB_LIBS)                       \
+	$(LIBXFCE4UI_LIBS)                      \
+	$(XFCONF_LIBS)                          \
+	$(LIBNOTIFY_LIBS)                       \
+	$(XRANDR_LIBS)				\
+	$(DPMS_LIBS)
+
+xfce4_power_information_SOURCES =		\
+	xfpm-power-info.c			\
+	xfpm-power-common.c			\
+	xfpm-power-common.h
+
+xfce4_power_information_CFLAGS =		\
+	-I$(top_srcdir)                         \
+	-I$(top_srcdir)/common                  \
+	-I$(top_srcdir)/libdbus                 \
+	-DLOCALEDIR=\"$(localedir)\"            \
+	-DG_LOG_DOMAIN=\"xfce4-power-information\"\
+	$(GOBJECT_CFLAGS)                       \
+	$(DBUS_GLIB_CFLAGS)                     \
+	$(LIBXFCE4UI_CFLAGS)			\
+	$(PLATFORM_CPPFLAGS)			\
+	$(PLATFORM_CFLAGS)
+
+xfce4_power_information_LDFLAGS =		\
+	-no-undefined				\
+	$(PLATFORM_LDFLAGS)
+
+xfce4_power_information_LDADD =			\
+	$(GOBJECT_LIBS)                         \
+	$(DBUS_GLIB_LIBS)                       \
+	$(LIBXFCE4UI_LIBS)			\
+	$(top_builddir)/libdbus/libxfpmdbus.la
+
+if ENABLE_POLKIT
+
+sbin_PROGRAMS = xfpm-power-backlight-helper 
+
+xfpm_power_backlight_helper_SOURCES =           \
+       xfpm-backlight-helper.c
+
+xfpm_power_backlight_helper_LDADD =             \
+       $(GLIB_LIBS)                             \
+       -lm
+
+xfpm_power_backlight_helper_CFLAGS =            \
+        $(GLIB_CFLAGS)                          \
+	$(PLATFORM_CPPFLAGS)			\
+	$(PLATFORM_CFLAGS)
+
+polkit_policydir = $(datadir)/polkit-1/actions
+polkit_policy_DATA =					\
+	org.xfce.power.policy
+
+# You will need a recent intltool or the patch from this bug
+# http://bugzilla.gnome.org/show_bug.cgi?id=462312
+@INTLTOOL_POLICY_RULE@
+
+.in2.in:
+	sed "s|[@]sbindir@|${sbindir}|" $< > $@
+
+endif
+
+manpagedir = $(mandir)/man1
+
+manpage_DATA = xfce4-power-manager.1
+
+xfpm_glib_headers =                             \
+        $(srcdir)/xfpm-enum-glib.h
+
+BUILT_SOURCES =					\
+	xfce-power-manager-dbus-server.h	\
+	xfce-power-manager-dbus-client.h	\
+	xfpm-enum-types.c                       \
+	xfpm-enum-types.h			\
+	xfpm-marshal.c                          \
+        xfpm-marshal.h				\
+	org.freedesktop.PowerManagement.h       \
+	org.freedesktop.PowerManagement.Inhibit.h
+
+if MAINTAINER_MODE
+
+xfpm-enum-types.h: $(xfpm_glib_headers)
+	( cd $(srcdir) && glib-mkenums \
+		--fhead "#ifndef _XFPM_ENUM_TYPES_H\n#define _XFPM_ENUM_TYPES_H\n#include <glib-object.h>\nG_BEGIN_DECLS\n" \
+		--fprod "/* enumerations from \"@filename@\" */\n" \
+		--vhead "GType @enum_name@_get_type (void);\n#define XFPM_TYPE_@ENUMSHORT@ (@enum_name@_get_type())\n" \
+		--ftail "G_END_DECLS\n\n#endif /* _XFPM_ENUM_TYPES_H__ */" \
+		$(xfpm_glib_headers) ) >> xgen \
+	&& (cmp -s xgen xfpm-enum-types.h || cp xgen xfpm-enum-types.h ) \
+	&& rm -f xgen xgen~
+
+xfpm-enum-types.c: xfpm-enum-types.h
+	( cd $(srcdir) && glib-mkenums \
+		--fhead "#include <xfpm-enum-types.h>\n" \
+		--fhead "#include \"xfpm-enum-glib.h\"\n\n" \
+		--fprod "\n/* enumerations from \"@filename@\" */\n" \
+		--vhead "GType\n@enum_name@_get_type (void)\n{\n\tstatic GType type = 0;\n\tif (type == 0) {\n\tstatic const G@Type@Value values[] = {"\
+		--vprod "\t{ @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+		--vtail "\t{ 0, NULL, NULL }\n\t};\n\ttype = g_@type@_register_static (\"@EnumName@\", values);\n  }\n\treturn type;\n}\n" \
+		$(xfpm_glib_headers) ) > xgen \
+	&& cp xgen xfpm-enum-types.c  \
+	&& rm -f xgen xgen~
+
+xfpm-marshal.c: xfpm-marshal.list
+	echo "#include \"xfpm-marshal.h\"" > $@ && \
+	glib-genmarshal $< --prefix=_xfpm_marshal --body >> $@
+
+xfpm-marshal.h: xfpm-marshal.list
+	glib-genmarshal $< --prefix=_xfpm_marshal --header > $@
+
+xfce-power-manager-dbus-server.h: $(srcdir)/org.xfce.Power.Manager.xml
+	dbus-binding-tool --mode=glib-server --prefix=xfpm_manager $< >$@
+
+xfce-power-manager-dbus-client.h: $(srcdir)/org.xfce.Power.Manager.xml
+	dbus-binding-tool --mode=glib-client --prefix=xfpm_manager $< >$@
+
+org.freedesktop.PowerManagement.h: $(srcdir)/org.freedesktop.PowerManagement.xml
+	dbus-binding-tool --mode=glib-server --prefix=xfpm_power $< >$@
+
+org.freedesktop.PowerManagement.Inhibit.h: $(srcdir)/org.freedesktop.PowerManagement.Inhibit.xml
+	dbus-binding-tool --mode=glib-server --prefix=xfpm_inhibit $< >$@
+
+endif
+
+@INTLTOOL_DESKTOP_RULE@
+autostartdir = $(sysconfdir)/xdg/autostart
+autostart_in_files = xfce4-power-manager.desktop.in
+autostart_DATA = $(autostart_in_files:.desktop.in=.desktop)
+
+EXTRA_DIST =                                    \
+	xfpm-marshal.list			\
+        $(autostart_in_files)                   \
+        org.xfce.power.policy.in2              \
+        $(manpage_DATA)
+
+DISTCLEANFILES =                                \
+        $(BUILT_SOURCES)                        \
+        xfce4-power-manager.desktop             \
+        org.xfce.power.policy                  \
+        org.xfce.power.policy.in

=== added file '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/gsd-media-keys-window.c'
--- .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/gsd-media-keys-window.c	1970-01-01 00:00:00 +0000
+++ .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/gsd-media-keys-window.c	2013-08-12 21:07:54 +0000
@@ -0,0 +1,1078 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2006-2007 William Jon McCann <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "gsd-media-keys-window.h"
+
+#include "data/interfaces/acme_ui.h"
+
+#define DIALOG_TIMEOUT 2000     /* dialog timeout in ms */
+#define DIALOG_FADE_TIMEOUT 1500 /* timeout before fade starts */
+#define FADE_TIMEOUT 10        /* timeout in ms between each frame of the fade */
+
+#define BG_ALPHA 0.75
+#define FG_ALPHA 1.00
+
+#define GSD_MEDIA_KEYS_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GSD_TYPE_MEDIA_KEYS_WINDOW, GsdMediaKeysWindowPrivate))
+
+struct GsdMediaKeysWindowPrivate
+{
+        guint                    is_composited : 1;
+        guint                    hide_timeout_id;
+        guint                    fade_timeout_id;
+        double                   fade_out_alpha;
+        GsdMediaKeysWindowAction action;
+        char                    *icon_name;
+        gboolean                 show_level;
+
+        guint                    volume_muted : 1;
+        int                      volume_level;
+
+        GtkImage                *image;
+        GtkWidget               *progress;
+};
+
+G_DEFINE_TYPE (GsdMediaKeysWindow, gsd_media_keys_window, GTK_TYPE_WINDOW)
+
+static gboolean
+fade_timeout (GsdMediaKeysWindow *window)
+{
+        if (window->priv->fade_out_alpha <= 0.0) {
+                gtk_widget_hide (GTK_WIDGET (window));
+
+                /* Reset it for the next time */
+                window->priv->fade_out_alpha = 1.0;
+                window->priv->fade_timeout_id = 0;
+
+                return FALSE;
+        } else {
+                GdkRectangle rect;
+                GtkWidget *win = GTK_WIDGET (window);
+                GtkAllocation allocation;
+
+                window->priv->fade_out_alpha -= 0.10;
+
+                rect.x = 0;
+                rect.y = 0;
+                gtk_widget_get_allocation (win, &allocation);
+                rect.width = allocation.width;
+                rect.height = allocation.height;
+
+                gtk_widget_realize (win);
+                gdk_window_invalidate_rect (gtk_widget_get_window (win), &rect, FALSE);
+        }
+
+        return TRUE;
+}
+
+static gboolean
+hide_timeout (GsdMediaKeysWindow *window)
+{
+        if (window->priv->is_composited) {
+                window->priv->hide_timeout_id = 0;
+                window->priv->fade_timeout_id = g_timeout_add (FADE_TIMEOUT,
+                                                               (GSourceFunc) fade_timeout,
+                                                               window);
+        } else {
+                gtk_widget_hide (GTK_WIDGET (window));
+        }
+
+        return FALSE;
+}
+
+static void
+remove_hide_timeout (GsdMediaKeysWindow *window)
+{
+        if (window->priv->hide_timeout_id != 0) {
+                g_source_remove (window->priv->hide_timeout_id);
+                window->priv->hide_timeout_id = 0;
+        }
+
+        if (window->priv->fade_timeout_id != 0) {
+                g_source_remove (window->priv->fade_timeout_id);
+                window->priv->fade_timeout_id = 0;
+                window->priv->fade_out_alpha = 1.0;
+        }
+}
+
+static void
+add_hide_timeout (GsdMediaKeysWindow *window)
+{
+        int timeout;
+
+        if (window->priv->is_composited) {
+                timeout = DIALOG_FADE_TIMEOUT;
+        } else {
+                timeout = DIALOG_TIMEOUT;
+        }
+        window->priv->hide_timeout_id = g_timeout_add (timeout,
+                                                       (GSourceFunc) hide_timeout,
+                                                       window);
+}
+
+static void
+update_window (GsdMediaKeysWindow *window)
+{
+        remove_hide_timeout (window);
+        add_hide_timeout (window);
+
+        if (window->priv->is_composited) {
+                gtk_widget_queue_draw (GTK_WIDGET (window));
+        }
+}
+
+static void
+volume_controls_set_visible (GsdMediaKeysWindow *window,
+                             gboolean            visible)
+{
+        if (window->priv->progress == NULL)
+                return;
+
+        if (visible) {
+                gtk_widget_show (window->priv->progress);
+        } else {
+                gtk_widget_hide (window->priv->progress);
+        }
+}
+
+static void
+window_set_icon_name (GsdMediaKeysWindow *window,
+                      const char         *name)
+{
+        if (window->priv->image == NULL)
+                return;
+
+        gtk_image_set_from_icon_name (window->priv->image,
+                                      name, GTK_ICON_SIZE_DIALOG);
+}
+
+static void
+action_changed (GsdMediaKeysWindow *window)
+{
+        if (! window->priv->is_composited) {
+                switch (window->priv->action) {
+                case GSD_MEDIA_KEYS_WINDOW_ACTION_VOLUME:
+                        volume_controls_set_visible (window, TRUE);
+
+                        if (window->priv->volume_muted) {
+                                window_set_icon_name (window, "audio-volume-muted");
+                        } else {
+                                window_set_icon_name (window, "audio-volume-high");
+                        }
+
+                        break;
+                case GSD_MEDIA_KEYS_WINDOW_ACTION_CUSTOM:
+                        volume_controls_set_visible (window, window->priv->show_level);
+                        window_set_icon_name (window, window->priv->icon_name);
+                        break;
+                default:
+                        g_assert_not_reached ();
+                        break;
+                }
+        }
+
+        update_window (window);
+}
+
+static void
+volume_level_changed (GsdMediaKeysWindow *window)
+{
+        update_window (window);
+
+        if (!window->priv->is_composited && window->priv->progress != NULL) {
+                double fraction;
+
+                fraction = (double) window->priv->volume_level / 100.0;
+
+                gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (window->priv->progress),
+                                               fraction);
+        }
+}
+
+static void
+volume_muted_changed (GsdMediaKeysWindow *window)
+{
+        update_window (window);
+
+        if (! window->priv->is_composited) {
+                if (window->priv->volume_muted) {
+                        window_set_icon_name (window, "audio-volume-muted");
+                } else {
+                        window_set_icon_name (window, "audio-volume-high");
+                }
+        }
+}
+
+void
+gsd_media_keys_window_set_action (GsdMediaKeysWindow      *window,
+                                  GsdMediaKeysWindowAction action)
+{
+        g_return_if_fail (GSD_IS_MEDIA_KEYS_WINDOW (window));
+        g_return_if_fail (action == GSD_MEDIA_KEYS_WINDOW_ACTION_VOLUME);
+
+        if (window->priv->action != action) {
+                window->priv->action = action;
+                action_changed (window);
+        } else {
+                update_window (window);
+        }
+}
+
+void
+gsd_media_keys_window_set_action_custom (GsdMediaKeysWindow      *window,
+                                         const char              *icon_name,
+                                         gboolean                 show_level)
+{
+        g_return_if_fail (GSD_IS_MEDIA_KEYS_WINDOW (window));
+        g_return_if_fail (icon_name != NULL);
+
+        if (window->priv->action != GSD_MEDIA_KEYS_WINDOW_ACTION_CUSTOM ||
+            g_strcmp0 (window->priv->icon_name, icon_name) != 0 ||
+            window->priv->show_level != show_level) {
+                window->priv->action = GSD_MEDIA_KEYS_WINDOW_ACTION_CUSTOM;
+                g_free (window->priv->icon_name);
+                window->priv->icon_name = g_strdup (icon_name);
+                window->priv->show_level = show_level;
+                action_changed (window);
+        } else {
+                update_window (window);
+        }
+}
+
+void
+gsd_media_keys_window_set_volume_muted (GsdMediaKeysWindow *window,
+                                        gboolean            muted)
+{
+        g_return_if_fail (GSD_IS_MEDIA_KEYS_WINDOW (window));
+
+        if (window->priv->volume_muted != muted) {
+                window->priv->volume_muted = muted;
+                volume_muted_changed (window);
+        }
+}
+
+void
+gsd_media_keys_window_set_volume_level (GsdMediaKeysWindow *window,
+                                        int                 level)
+{
+        g_return_if_fail (GSD_IS_MEDIA_KEYS_WINDOW (window));
+
+        if (window->priv->volume_level != level) {
+                window->priv->volume_level = level;
+                volume_level_changed (window);
+        }
+}
+
+static void
+rounded_rectangle (cairo_t* cr,
+                   gdouble  aspect,
+                   gdouble  x,
+                   gdouble  y,
+                   gdouble  corner_radius,
+                   gdouble  width,
+                   gdouble  height)
+{
+        gdouble radius = corner_radius / aspect;
+
+        cairo_move_to (cr, x + radius, y);
+
+        cairo_line_to (cr,
+                       x + width - radius,
+                       y);
+        cairo_arc (cr,
+                   x + width - radius,
+                   y + radius,
+                   radius,
+                   -90.0f * G_PI / 180.0f,
+                   0.0f * G_PI / 180.0f);
+        cairo_line_to (cr,
+                       x + width,
+                       y + height - radius);
+        cairo_arc (cr,
+                   x + width - radius,
+                   y + height - radius,
+                   radius,
+                   0.0f * G_PI / 180.0f,
+                   90.0f * G_PI / 180.0f);
+        cairo_line_to (cr,
+                       x + radius,
+                       y + height);
+        cairo_arc (cr,
+                   x + radius,
+                   y + height - radius,
+                   radius,
+                   90.0f * G_PI / 180.0f,
+                   180.0f * G_PI / 180.0f);
+        cairo_line_to (cr,
+                       x,
+                       y + radius);
+        cairo_arc (cr,
+                   x + radius,
+                   y + radius,
+                   radius,
+                   180.0f * G_PI / 180.0f,
+                   270.0f * G_PI / 180.0f);
+        cairo_close_path (cr);
+}
+
+static GdkPixbuf *
+load_pixbuf (GsdMediaKeysWindow *window,
+             const char         *name,
+             int                 icon_size)
+{
+        GtkIconTheme *theme;
+        GdkPixbuf    *pixbuf;
+
+        if (window != NULL && gtk_widget_has_screen (GTK_WIDGET (window))) {
+                theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window)));
+        } else {
+                theme = gtk_icon_theme_get_default ();
+        }
+
+        pixbuf = gtk_icon_theme_load_icon (theme,
+                                           name,
+                                           icon_size,
+                                           GTK_ICON_LOOKUP_FORCE_SVG,
+                                           NULL);
+
+        /* make sure the pixbuf is close to the requested size
+         * this is necessary because GTK_ICON_LOOKUP_FORCE_SVG
+         * seems to be broken */
+        if (pixbuf != NULL) {
+                int width;
+
+                width = gdk_pixbuf_get_width (pixbuf);
+                if (width < (float)icon_size * 0.75) {
+                        g_object_unref (pixbuf);
+                        pixbuf = NULL;
+                }
+        }
+
+        return pixbuf;
+}
+
+static void
+draw_eject (cairo_t *cr,
+            double   _x0,
+            double   _y0,
+            double   width,
+            double   height)
+{
+        int box_height;
+        int tri_height;
+        int separation;
+
+        box_height = height * 0.2;
+        separation = box_height / 3;
+        tri_height = height - box_height - separation;
+
+        cairo_rectangle (cr, _x0, _y0 + height - box_height, width, box_height);
+
+        cairo_move_to (cr, _x0, _y0 + tri_height);
+        cairo_rel_line_to (cr, width, 0);
+        cairo_rel_line_to (cr, -width / 2, -tri_height);
+        cairo_rel_line_to (cr, -width / 2, tri_height);
+        cairo_close_path (cr);
+        cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, FG_ALPHA);
+        cairo_fill_preserve (cr);
+
+        cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, FG_ALPHA / 2);
+        cairo_set_line_width (cr, 2);
+        cairo_stroke (cr);
+}
+
+static void
+draw_waves (cairo_t *cr,
+            double   cx,
+            double   cy,
+            double   max_radius,
+            int      volume_level)
+{
+        const int n_waves = 3;
+        int last_wave;
+        int i;
+
+        last_wave = n_waves * volume_level / 100;
+
+        for (i = 0; i < n_waves; i++) {
+                double angle1;
+                double angle2;
+                double radius;
+                double alpha;
+
+                angle1 = -M_PI / 4;
+                angle2 = M_PI / 4;
+
+                if (i < last_wave)
+                        alpha = 1.0;
+                else if (i > last_wave)
+                        alpha = 0.1;
+                else alpha = 0.1 + 0.9 * (n_waves * volume_level % 100) / 100.0;
+
+                radius = (i + 1) * (max_radius / n_waves);
+                cairo_arc (cr, cx, cy, radius, angle1, angle2);
+                cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, alpha / 2);
+                cairo_set_line_width (cr, 14);
+                cairo_set_line_cap  (cr, CAIRO_LINE_CAP_ROUND);
+                cairo_stroke_preserve (cr);
+
+                cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, alpha);
+                cairo_set_line_width (cr, 10);
+                cairo_set_line_cap  (cr, CAIRO_LINE_CAP_ROUND);
+                cairo_stroke (cr);
+        }
+}
+
+static void
+draw_cross (cairo_t *cr,
+            double   cx,
+            double   cy,
+            double   size)
+{
+        cairo_move_to (cr, cx, cy - size/2.0);
+        cairo_rel_line_to (cr, size, size);
+
+        cairo_move_to (cr, cx, cy + size/2.0);
+        cairo_rel_line_to (cr, size, -size);
+
+        cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, FG_ALPHA / 2);
+        cairo_set_line_width (cr, 14);
+        cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+        cairo_stroke_preserve (cr);
+
+        cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, FG_ALPHA);
+        cairo_set_line_width (cr, 10);
+        cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+        cairo_stroke (cr);
+}
+
+static void
+draw_speaker (cairo_t *cr,
+              double   cx,
+              double   cy,
+              double   width,
+              double   height)
+{
+        double box_width;
+        double box_height;
+        double _x0;
+        double _y0;
+
+        box_width = width / 3;
+        box_height = height / 3;
+
+        _x0 = cx - (width / 2) + box_width;
+        _y0 = cy - box_height / 2;
+
+        cairo_move_to (cr, _x0, _y0);
+        cairo_rel_line_to (cr, - box_width, 0);
+        cairo_rel_line_to (cr, 0, box_height);
+        cairo_rel_line_to (cr, box_width, 0);
+
+        cairo_line_to (cr, cx + box_width, cy + height / 2);
+        cairo_rel_line_to (cr, 0, -height);
+        cairo_line_to (cr, _x0, _y0);
+        cairo_close_path (cr);
+
+        cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, FG_ALPHA);
+        cairo_fill_preserve (cr);
+
+        cairo_set_source_rgba (cr, 0.6, 0.6, 0.6, FG_ALPHA / 2);
+        cairo_set_line_width (cr, 2);
+        cairo_stroke (cr);
+}
+
+static gboolean
+render_speaker (GsdMediaKeysWindow *window,
+                cairo_t            *cr,
+                double              _x0,
+                double              _y0,
+                double              width,
+                double              height)
+{
+        GdkPixbuf         *pixbuf;
+        int                icon_size;
+        int                n;
+        static const char *icon_names[] = {
+                "audio-volume-muted",
+                "audio-volume-low",
+                "audio-volume-medium",
+                "audio-volume-high",
+                NULL
+        };
+
+        if (window->priv->volume_muted) {
+                n = 0;
+        } else {
+                /* select image */
+                n = 3 * window->priv->volume_level / 100 + 1;
+                if (n < 1) {
+                        n = 1;
+                } else if (n > 3) {
+                        n = 3;
+                }
+        }
+
+        icon_size = (int)width;
+
+        pixbuf = load_pixbuf (window, icon_names[n], icon_size);
+
+        if (pixbuf == NULL) {
+                return FALSE;
+        }
+
+        gdk_cairo_set_source_pixbuf (cr, pixbuf, _x0, _y0);
+        cairo_paint_with_alpha (cr, FG_ALPHA);
+
+        g_object_unref (pixbuf);
+
+        return TRUE;
+}
+
+static void
+color_reverse (const GdkColor *a,
+               GdkColor       *b)
+{
+        gdouble red;
+        gdouble green;
+        gdouble blue;
+        gdouble h;
+        gdouble s;
+        gdouble v;
+
+        red = (gdouble) a->red / 65535.0;
+        green = (gdouble) a->green / 65535.0;
+        blue = (gdouble) a->blue / 65535.0;
+
+        gtk_rgb_to_hsv (red, green, blue, &h, &s, &v);
+
+        v = 0.5 + (0.5 - v);
+        if (v > 1.0)
+                v = 1.0;
+        else if (v < 0.0)
+                v = 0.0;
+
+        gtk_hsv_to_rgb (h, s, v, &red, &green, &blue);
+
+        b->red = red * 65535.0;
+        b->green = green * 65535.0;
+        b->blue = blue * 65535.0;
+}
+
+static void
+draw_volume_boxes (GsdMediaKeysWindow *window,
+                   cairo_t            *cr,
+                   double              percentage,
+                   double              _x0,
+                   double              _y0,
+                   double              width,
+                   double              height)
+{
+        gdouble   x1;
+        GdkColor  color;
+        double    r, g, b;
+        GtkStyle *style;
+
+        _x0 += 0.5;
+        _y0 += 0.5;
+        height = round (height) - 1;
+        width = round (width) - 1;
+        x1 = round ((width - 1) * percentage);
+        style = gtk_widget_get_style (GTK_WIDGET (window));
+
+        /* bar background */
+        color_reverse (&style->dark[GTK_STATE_NORMAL], &color);
+        r = (float)color.red / 65535.0;
+        g = (float)color.green / 65535.0;
+        b = (float)color.blue / 65535.0;
+        rounded_rectangle (cr, 1.0, _x0, _y0, height / 6, width, height);
+        cairo_set_source_rgba (cr, r, g, b, FG_ALPHA / 2);
+        cairo_fill_preserve (cr);
+
+        /* bar border */
+        color_reverse (&style->light[GTK_STATE_NORMAL], &color);
+        r = (float)color.red / 65535.0;
+        g = (float)color.green / 65535.0;
+        b = (float)color.blue / 65535.0;
+        cairo_set_source_rgba (cr, r, g, b, FG_ALPHA / 2);
+        cairo_set_line_width (cr, 1);
+        cairo_stroke (cr);
+
+        /* bar progress */
+        if (percentage < 0.01)
+                return;
+        color = style->bg[GTK_STATE_NORMAL];
+        r = (float)color.red / 65535.0;
+        g = (float)color.green / 65535.0;
+        b = (float)color.blue / 65535.0;
+        rounded_rectangle (cr, 1.0, _x0 + 0.5, _y0 + 0.5, height / 6 - 0.5, x1, height - 1);
+        cairo_set_source_rgba (cr, r, g, b, FG_ALPHA);
+        cairo_fill (cr);
+}
+
+static void
+draw_action_volume (GsdMediaKeysWindow *window,
+                    cairo_t            *cr)
+{
+        int window_width;
+        int window_height;
+        double icon_box_width;
+        double icon_box_height;
+        double icon_box_x0;
+        double icon_box_y0;
+        double volume_box_x0;
+        double volume_box_y0;
+        double volume_box_width;
+        double volume_box_height;
+        gboolean res;
+
+        gtk_window_get_size (GTK_WINDOW (window), &window_width, &window_height);
+
+        icon_box_width = round (window_width * 0.65);
+        icon_box_height = round (window_height * 0.65);
+        volume_box_width = icon_box_width;
+        volume_box_height = round (window_height * 0.05);
+
+        icon_box_x0 = (window_width - icon_box_width) / 2;
+        icon_box_y0 = (window_height - icon_box_height - volume_box_height) / 2;
+        volume_box_x0 = round (icon_box_x0);
+        volume_box_y0 = round (icon_box_height + icon_box_y0);
+
+#if 0
+        g_message ("icon box: w=%f h=%f _x0=%f _y0=%f",
+                   icon_box_width,
+                   icon_box_height,
+                   icon_box_x0,
+                   icon_box_y0);
+        g_message ("volume box: w=%f h=%f _x0=%f _y0=%f",
+                   volume_box_width,
+                   volume_box_height,
+                   volume_box_x0,
+                   volume_box_y0);
+#endif
+
+        res = render_speaker (window,
+                              cr,
+                              icon_box_x0, icon_box_y0,
+                              icon_box_width, icon_box_height);
+        if (! res) {
+                double speaker_width;
+                double speaker_height;
+                double speaker_cx;
+                double speaker_cy;
+
+                speaker_width = icon_box_width * 0.5;
+                speaker_height = icon_box_height * 0.75;
+                speaker_cx = icon_box_x0 + speaker_width / 2;
+                speaker_cy = icon_box_y0 + speaker_height / 2;
+
+#if 0
+                g_message ("speaker box: w=%f h=%f cx=%f cy=%f",
+                           speaker_width,
+                           speaker_height,
+                           speaker_cx,
+                           speaker_cy);
+#endif
+
+                /* draw speaker symbol */
+                draw_speaker (cr, speaker_cx, speaker_cy, speaker_width, speaker_height);
+
+                if (! window->priv->volume_muted) {
+                        /* draw sound waves */
+                        double wave_x0;
+                        double wave_y0;
+                        double wave_radius;
+
+                        wave_x0 = window_width / 2;
+                        wave_y0 = speaker_cy;
+                        wave_radius = icon_box_width / 2;
+
+                        draw_waves (cr, wave_x0, wave_y0, wave_radius, window->priv->volume_level);
+                } else {
+                        /* draw 'mute' cross */
+                        double cross_x0;
+                        double cross_y0;
+                        double cross_size;
+
+                        cross_size = speaker_width * 3 / 4;
+                        cross_x0 = icon_box_x0 + icon_box_width - cross_size;
+                        cross_y0 = speaker_cy;
+
+                        draw_cross (cr, cross_x0, cross_y0, cross_size);
+                }
+        }
+
+        /* draw volume meter */
+        draw_volume_boxes (window,
+                           cr,
+                           (double)window->priv->volume_level / 100.0,
+                           volume_box_x0,
+                           volume_box_y0,
+                           volume_box_width,
+                           volume_box_height);
+}
+
+static gboolean
+render_custom (GsdMediaKeysWindow *window,
+               cairo_t            *cr,
+               double              _x0,
+               double              _y0,
+               double              width,
+               double              height)
+{
+        GdkPixbuf         *pixbuf;
+        int                icon_size;
+
+        icon_size = (int)width;
+
+        pixbuf = load_pixbuf (window, window->priv->icon_name, icon_size);
+
+        if (pixbuf == NULL) {
+                char *name;
+                if (gtk_widget_get_direction (GTK_WIDGET (window)) == GTK_TEXT_DIR_RTL)
+                        name = g_strdup_printf ("%s-rtl", window->priv->icon_name);
+                else
+                        name = g_strdup_printf ("%s-ltr", window->priv->icon_name);
+                pixbuf = load_pixbuf (window, name, icon_size);
+                g_free (name);
+                if (pixbuf == NULL)
+                        return FALSE;
+        }
+
+        gdk_cairo_set_source_pixbuf (cr, pixbuf, _x0, _y0);
+        cairo_paint_with_alpha (cr, FG_ALPHA);
+
+        g_object_unref (pixbuf);
+
+        return TRUE;
+}
+
+static void
+draw_action_custom (GsdMediaKeysWindow *window,
+                    cairo_t            *cr)
+{
+        int window_width;
+        int window_height;
+        double icon_box_width;
+        double icon_box_height;
+        double icon_box_x0;
+        double icon_box_y0;
+        double bright_box_x0;
+        double bright_box_y0;
+        double bright_box_width;
+        double bright_box_height;
+        gboolean res;
+
+        gtk_window_get_size (GTK_WINDOW (window), &window_width, &window_height);
+
+        icon_box_width = round (window_width * 0.65);
+        icon_box_height = round (window_height * 0.65);
+        bright_box_width = round (icon_box_width);
+        bright_box_height = round (window_height * 0.05);
+
+        icon_box_x0 = (window_width - icon_box_width) / 2;
+        icon_box_y0 = (window_height - icon_box_height - bright_box_height) / 2;
+        bright_box_x0 = round (icon_box_x0);
+        bright_box_y0 = round (icon_box_height + icon_box_y0);
+
+#if 0
+        g_message ("icon box: w=%f h=%f _x0=%f _y0=%f",
+                   icon_box_width,
+                   icon_box_height,
+                   icon_box_x0,
+                   icon_box_y0);
+        g_message ("brightness box: w=%f h=%f _x0=%f _y0=%f",
+                   bright_box_width,
+                   bright_box_height,
+                   bright_box_x0,
+                   bright_box_y0);
+#endif
+
+        res = render_custom (window,
+                             cr,
+                             icon_box_x0, icon_box_y0,
+                             icon_box_width, icon_box_height);
+        if (! res && g_strcmp0 (window->priv->icon_name, "media-eject") == 0) {
+                /* draw eject symbol */
+                draw_eject (cr,
+                            icon_box_x0, icon_box_y0,
+                            icon_box_width, icon_box_height);
+        }
+
+        if (window->priv->show_level != FALSE) {
+                /* draw volume meter */
+                draw_volume_boxes (window,
+                                   cr,
+                                   (double)window->priv->volume_level / 100.0,
+                                   bright_box_x0,
+                                   bright_box_y0,
+                                   bright_box_width,
+                                   bright_box_height);
+        }
+}
+
+static void
+draw_action (GsdMediaKeysWindow *window,
+             cairo_t            *cr)
+{
+        switch (window->priv->action) {
+        case GSD_MEDIA_KEYS_WINDOW_ACTION_VOLUME:
+                draw_action_volume (window, cr);
+                break;
+        case GSD_MEDIA_KEYS_WINDOW_ACTION_CUSTOM:
+                draw_action_custom (window, cr);
+                break;
+        default:
+                break;
+        }
+}
+
+static gboolean
+on_expose_event (GtkWidget          *widget,
+                 GdkEventExpose     *event,
+                 GsdMediaKeysWindow *window)
+{
+        cairo_t         *context;
+        cairo_t         *cr;
+        cairo_surface_t *surface;
+        int              width;
+        int              height;
+        GtkStyle        *style;
+        GdkColor         color;
+        double           r, g, b;
+
+        context = gdk_cairo_create (gtk_widget_get_window (widget));
+
+        style = gtk_widget_get_style (widget);
+        cairo_set_operator (context, CAIRO_OPERATOR_SOURCE);
+        gtk_window_get_size (GTK_WINDOW (widget), &width, &height);
+
+        surface = cairo_surface_create_similar (cairo_get_target (context),
+                                                CAIRO_CONTENT_COLOR_ALPHA,
+                                                width,
+                                                height);
+
+        if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS) {
+                goto done;
+        }
+
+        cr = cairo_create (surface);
+        if (cairo_status (cr) != CAIRO_STATUS_SUCCESS) {
+                goto done;
+        }
+        cairo_set_source_rgba (cr, 1.0, 1.0, 1.0, 0.0);
+        cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
+        cairo_paint (cr);
+
+        /* draw a box */
+        rounded_rectangle (cr, 1.0, 0.5, 0.5, height / 10, width-1, height-1);
+        color_reverse (&style->bg[GTK_STATE_NORMAL], &color);
+        r = (float)color.red / 65535.0;
+        g = (float)color.green / 65535.0;
+        b = (float)color.blue / 65535.0;
+        cairo_set_source_rgba (cr, r, g, b, BG_ALPHA);
+        cairo_fill_preserve (cr);
+
+        color_reverse (&style->text_aa[GTK_STATE_NORMAL], &color);
+        r = (float)color.red / 65535.0;
+        g = (float)color.green / 65535.0;
+        b = (float)color.blue / 65535.0;
+        cairo_set_source_rgba (cr, r, g, b, BG_ALPHA / 2);
+        cairo_set_line_width (cr, 1);
+        cairo_stroke (cr);
+
+        /* draw action */
+        draw_action (window, cr);
+
+        cairo_destroy (cr);
+
+        /* Make sure we have a transparent background */
+        cairo_rectangle (context, 0, 0, width, height);
+        cairo_set_source_rgba (context, 0.0, 0.0, 0.0, 0.0);
+        cairo_fill (context);
+
+        cairo_set_source_surface (context, surface, 0, 0);
+        cairo_paint_with_alpha (context, window->priv->fade_out_alpha);
+
+ done:
+        if (surface != NULL) {
+                cairo_surface_destroy (surface);
+        }
+        cairo_destroy (context);
+
+        return FALSE;
+}
+
+static void
+gsd_media_keys_window_real_show (GtkWidget *widget)
+{
+        GsdMediaKeysWindow *window;
+
+        if (GTK_WIDGET_CLASS (gsd_media_keys_window_parent_class)->show) {
+                GTK_WIDGET_CLASS (gsd_media_keys_window_parent_class)->show (widget);
+        }
+
+        window = GSD_MEDIA_KEYS_WINDOW (widget);
+        remove_hide_timeout (window);
+        add_hide_timeout (window);
+}
+
+static void
+gsd_media_keys_window_real_hide (GtkWidget *widget)
+{
+        GsdMediaKeysWindow *window;
+
+        if (GTK_WIDGET_CLASS (gsd_media_keys_window_parent_class)->hide) {
+                GTK_WIDGET_CLASS (gsd_media_keys_window_parent_class)->hide (widget);
+        }
+
+        window = GSD_MEDIA_KEYS_WINDOW (widget);
+        remove_hide_timeout (window);
+}
+
+static void
+gsd_media_keys_window_real_realize (GtkWidget *widget)
+{
+        GdkColormap *colormap;
+        GtkAllocation allocation;
+        GdkBitmap *mask;
+        cairo_t *cr;
+
+        colormap = gdk_screen_get_rgba_colormap (gtk_widget_get_screen (widget));
+
+        if (colormap != NULL) {
+                gtk_widget_set_colormap (widget, colormap);
+        }
+
+        if (GTK_WIDGET_CLASS (gsd_media_keys_window_parent_class)->realize) {
+                GTK_WIDGET_CLASS (gsd_media_keys_window_parent_class)->realize (widget);
+        }
+
+        gtk_widget_get_allocation (widget, &allocation);
+        mask = gdk_pixmap_new (gtk_widget_get_window (widget),
+                               allocation.width,
+                               allocation.height,
+                               1);
+        cr = gdk_cairo_create (mask);
+
+        cairo_set_source_rgba (cr, 1., 1., 1., 0.);
+        cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
+        cairo_paint (cr);
+
+        /* make the whole window ignore events */
+        gdk_window_input_shape_combine_mask (gtk_widget_get_window (widget), mask, 0, 0);
+        g_object_unref (mask);
+        cairo_destroy (cr);
+}
+
+static void
+gsd_media_keys_window_class_init (GsdMediaKeysWindowClass *klass)
+{
+        GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+        widget_class->show = gsd_media_keys_window_real_show;
+        widget_class->hide = gsd_media_keys_window_real_hide;
+        widget_class->realize = gsd_media_keys_window_real_realize;
+
+        g_type_class_add_private (klass, sizeof (GsdMediaKeysWindowPrivate));
+}
+
+gboolean
+gsd_media_keys_window_is_valid (GsdMediaKeysWindow *window)
+{
+        GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (window));
+        return gdk_screen_is_composited (screen) == window->priv->is_composited;
+}
+
+static void
+gsd_media_keys_window_init (GsdMediaKeysWindow *window)
+{
+        GdkScreen *screen;
+
+        window->priv = GSD_MEDIA_KEYS_WINDOW_GET_PRIVATE (window);
+
+        screen = gtk_widget_get_screen (GTK_WIDGET (window));
+
+        window->priv->is_composited = gdk_screen_is_composited (screen);
+
+        if (window->priv->is_composited) {
+                gdouble scalew, scaleh, scale;
+                gint size;
+
+                gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
+                gtk_widget_set_app_paintable (GTK_WIDGET (window), TRUE);
+
+                /* assume 130x130 on a 640x480 display and scale from there */
+                scalew = gdk_screen_get_width (screen) / 640.0;
+                scaleh = gdk_screen_get_height (screen) / 480.0;
+                scale = MIN (scalew, scaleh);
+                size = 130 * MAX (1, scale);
+
+                gtk_window_set_default_size (GTK_WINDOW (window), size, size);
+                g_signal_connect (window, "expose-event", G_CALLBACK (on_expose_event), window);
+
+                window->priv->fade_out_alpha = 1.0;
+        } else {
+                GtkBuilder *builder;
+                const gchar *objects[] = {"acme_frame", NULL};
+                GtkWidget *frame;
+
+                builder = gtk_builder_new ();
+		gtk_builder_add_objects_from_string (builder, acme_ui, acme_ui_length, (char **)objects, NULL);
+
+                window->priv->image = GTK_IMAGE (gtk_builder_get_object (builder, "acme_image"));
+                window->priv->progress = GTK_WIDGET (gtk_builder_get_object (builder, "acme_volume_progressbar"));
+                frame = GTK_WIDGET (gtk_builder_get_object (builder,
+                                                            "acme_frame"));
+
+                if (frame != NULL) {
+                        gtk_container_add (GTK_CONTAINER (window), frame);
+                        gtk_widget_show_all (frame);
+                }
+
+                /* The builder needs to stay alive until the window
+                   takes ownership of the frame (and its children)  */
+                g_object_unref (builder);
+        }
+}
+
+GtkWidget *
+gsd_media_keys_window_new (void)
+{
+        GObject *object;
+
+        object = g_object_new (GSD_TYPE_MEDIA_KEYS_WINDOW,
+                               "type", GTK_WINDOW_POPUP,
+                               "type-hint", GDK_WINDOW_TYPE_HINT_NOTIFICATION,
+                               "skip-taskbar-hint", TRUE,
+                               "skip-pager-hint", TRUE,
+                               "focus-on-map", FALSE,
+                               NULL);
+
+        return GTK_WIDGET (object);
+}

=== added file '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/gsd-media-keys-window.h'
--- .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/gsd-media-keys-window.h	1970-01-01 00:00:00 +0000
+++ .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/gsd-media-keys-window.h	2013-08-12 21:07:54 +0000
@@ -0,0 +1,71 @@
+/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 8; tab-width: 8 -*-
+ *
+ * Copyright (C) 2006 William Jon McCann <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ */
+
+#ifndef GSD_MEDIA_KEYS_WINDOW_H
+#define GSD_MEDIA_KEYS_WINDOW_H
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GSD_TYPE_MEDIA_KEYS_WINDOW            (gsd_media_keys_window_get_type ())
+#define GSD_MEDIA_KEYS_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj),  GSD_TYPE_MEDIA_KEYS_WINDOW, GsdMediaKeysWindow))
+#define GSD_MEDIA_KEYS_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),   GSD_TYPE_MEDIA_KEYS_WINDOW, GsdMediaKeysWindowClass))
+#define GSD_IS_MEDIA_KEYS_WINDOW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj),  GSD_TYPE_MEDIA_KEYS_WINDOW))
+#define GSD_IS_MEDIA_KEYS_WINDOW_CLASS(klass) (G_TYPE_INSTANCE_GET_CLASS ((klass), GSD_TYPE_MEDIA_KEYS_WINDOW))
+
+typedef struct GsdMediaKeysWindow                   GsdMediaKeysWindow;
+typedef struct GsdMediaKeysWindowClass              GsdMediaKeysWindowClass;
+typedef struct GsdMediaKeysWindowPrivate            GsdMediaKeysWindowPrivate;
+
+struct GsdMediaKeysWindow {
+        GtkWindow                   parent;
+
+        GsdMediaKeysWindowPrivate  *priv;
+};
+
+struct GsdMediaKeysWindowClass {
+        GtkWindowClass parent_class;
+};
+
+typedef enum {
+        GSD_MEDIA_KEYS_WINDOW_ACTION_VOLUME,
+        GSD_MEDIA_KEYS_WINDOW_ACTION_CUSTOM
+} GsdMediaKeysWindowAction;
+
+GType                 gsd_media_keys_window_get_type          (void);
+
+GtkWidget *           gsd_media_keys_window_new               (void);
+void                  gsd_media_keys_window_set_action        (GsdMediaKeysWindow      *window,
+                                                               GsdMediaKeysWindowAction action);
+void                  gsd_media_keys_window_set_action_custom (GsdMediaKeysWindow      *window,
+                                                               const char              *icon_name,
+                                                               gboolean                 show_level);
+void                  gsd_media_keys_window_set_volume_muted  (GsdMediaKeysWindow      *window,
+                                                               gboolean                 muted);
+void                  gsd_media_keys_window_set_volume_level  (GsdMediaKeysWindow      *window,
+                                                               int                      level);
+gboolean              gsd_media_keys_window_is_valid          (GsdMediaKeysWindow      *window);
+
+G_END_DECLS
+
+#endif

=== added file '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/xfpm-backlight.c'
--- .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/xfpm-backlight.c	1970-01-01 00:00:00 +0000
+++ .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/xfpm-backlight.c	2013-08-12 21:07:54 +0000
@@ -0,0 +1,478 @@
+/*
+ * * Copyright (C) 2009-2011 Ali <[e-mail]>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <math.h>
+
+#include <gtk/gtk.h>
+#include <libxfce4util/libxfce4util.h>
+
+#include "xfpm-backlight.h"
+#include "egg-idletime.h"
+#include "xfpm-notify.h"
+#include "xfpm-xfconf.h"
+#include "xfpm-power.h"
+#include "xfpm-config.h"
+#include "xfpm-button.h"
+#include "xfpm-brightness.h"
+#include "xfpm-debug.h"
+#include "xfpm-icons.h"
+
+#include "gsd-media-keys-window.h"
+
+static void xfpm_backlight_finalize     (GObject *object);
+
+static void xfpm_backlight_create_popup (XfpmBacklight *backlight);
+
+#define ALARM_DISABLED 9
+#define BRIGHTNESS_POPUP_SIZE	180
+
+#define XFPM_BACKLIGHT_GET_PRIVATE(o) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((o), XFPM_TYPE_BACKLIGHT, XfpmBacklightPrivate))
+
+struct XfpmBacklightPrivate
+{
+    XfpmBrightness *brightness;
+    XfpmPower      *power;
+    EggIdletime    *idle;
+    XfpmXfconf     *conf;
+    XfpmButton     *button;
+    XfpmNotify     *notify;
+    
+    GtkWidget	   *osd;
+    NotifyNotification *n;
+    
+    
+    gulong	    destroy_id;
+    
+    gboolean	    has_hw;
+    gboolean	    on_battery;
+    
+    glong            last_level;
+    glong 	    max_level;
+    
+    gboolean        dimmed;
+    gboolean	    block;
+};
+
+G_DEFINE_TYPE (XfpmBacklight, xfpm_backlight, G_TYPE_OBJECT)
+
+static void
+xfpm_backlight_dim_brightness (XfpmBacklight *backlight)
+{
+    gboolean ret;
+    
+    if (xfpm_power_get_mode (backlight->priv->power) == XFPM_POWER_MODE_NORMAL )
+    {
+	glong dim_level;
+	
+	g_object_get (G_OBJECT (backlight->priv->conf),
+		      backlight->priv->on_battery ? BRIGHTNESS_LEVEL_ON_BATTERY : BRIGHTNESS_LEVEL_ON_AC, &dim_level,
+		      NULL);
+	
+	ret = xfpm_brightness_get_level (backlight->priv->brightness, &backlight->priv->last_level);
+	
+	if ( !ret )
+	{
+	    g_warning ("Unable to get current brightness level");
+	    return;
+	}
+	
+	dim_level = dim_level * backlight->priv->max_level / 100;
+	
+	/**
+	 * Only reduce if the current level is brighter than
+	 * the configured dim_level
+	 **/
+	if (backlight->priv->last_level > dim_level)
+	{
+	    XFPM_DEBUG ("Current brightness level before dimming : %li, new %li", backlight->priv->last_level, dim_level);
+	    backlight->priv->dimmed = xfpm_brightness_set_level (backlight->priv->brightness, dim_level);
+	}
+    }
+}
+
+static gboolean
+xfpm_backlight_destroy_popup (gpointer data)
+{
+    XfpmBacklight *backlight;
+    
+    backlight = XFPM_BACKLIGHT (data);
+    
+    if ( backlight->priv->osd )
+    {
+	gtk_widget_destroy (backlight->priv->osd);
+	backlight->priv->osd = NULL;
+    }
+    
+    if ( backlight->priv->n )
+    {
+	g_object_unref (backlight->priv->n);
+	backlight->priv->n = NULL;
+    }
+    
+    return FALSE;
+}
+
+static void
+xfpm_backlight_composited_changed_cb (XfpmBacklight *backlight)
+{
+    xfpm_backlight_destroy_popup (backlight);
+    xfpm_backlight_create_popup (backlight);
+}
+
+static void
+xfpm_backlight_show_notification (XfpmBacklight *backlight, gfloat value)
+{
+    gint i;
+    
+    static const char *display_icon_name[] = 
+    {
+	"notification-display-brightness-off",
+	"notification-display-brightness-low",
+	"notification-display-brightness-medium",
+	"notification-display-brightness-high",
+	"notification-display-brightness-full",
+	NULL
+    };
+    
+    if ( backlight->priv->n == NULL )
+    {
+	backlight->priv->n = xfpm_notify_new_notification (backlight->priv->notify, 
+							   " ", 
+							   "", 
+							   NULL, 
+							   0, 
+							   XFPM_NOTIFY_NORMAL,
+							   NULL);
+    }
+    
+    i = (gint)value / 25;
+    
+    if ( i > 4 || i < 0 )
+	return;
+    
+    notify_notification_set_hint_int32  (backlight->priv->n,
+					 "value",
+					 value);
+    
+    notify_notification_set_hint_string (backlight->priv->n,
+					 "x-canonical-private-synchronous",
+					 "brightness");
+    
+    notify_notification_update (backlight->priv->n,
+			        " ",
+				"",
+				display_icon_name[i]);
+				
+    notify_notification_show (backlight->priv->n, NULL);
+}
+
+static void
+xfpm_backlight_create_popup (XfpmBacklight *backlight)
+{
+    if ( backlight->priv->osd != NULL )
+	return;
+	
+    backlight->priv->osd = gsd_media_keys_window_new ();
+    gsd_media_keys_window_set_action_custom (GSD_MEDIA_KEYS_WINDOW (backlight->priv->osd),
+					     XFPM_DISPLAY_BRIGHTNESS_ICON,
+					     TRUE);
+    gtk_window_set_position (GTK_WINDOW (backlight->priv->osd), GTK_WIN_POS_CENTER);
+    
+    g_signal_connect_swapped (backlight->priv->osd, "composited-changed",
+			      G_CALLBACK (xfpm_backlight_composited_changed_cb), backlight);
+			      
+}
+
+static void
+xfpm_backlight_show (XfpmBacklight *backlight, gint level)
+{
+    gfloat value;
+    gboolean sync_notify;
+    gboolean show_popup;
+    
+    XFPM_DEBUG ("Level %u", level);
+    
+    g_object_get (G_OBJECT (backlight->priv->conf),
+                  SHOW_BRIGHTNESS_POPUP, &show_popup,
+                  NULL);
+		  
+    if ( !show_popup )
+	goto out;
+    
+    g_object_get (G_OBJECT (backlight->priv->notify),
+		  "sync", &sync_notify,
+		  NULL);
+    
+    value = (gfloat) 100 * level / backlight->priv->max_level;
+    
+    if ( !sync_notify ) /*Notification server doesn't support sync notifications*/
+    {
+	xfpm_backlight_create_popup (backlight);
+	gsd_media_keys_window_set_volume_level (GSD_MEDIA_KEYS_WINDOW (backlight->priv->osd),
+						round (value));
+	if ( !GTK_WIDGET_VISIBLE (backlight->priv->osd))
+	    gtk_window_present (GTK_WINDOW (backlight->priv->osd));
+    }
+    else
+    {
+	xfpm_backlight_show_notification (backlight, value);
+    }
+    
+    if ( backlight->priv->destroy_id != 0 )
+    {
+	g_source_remove (backlight->priv->destroy_id);
+	backlight->priv->destroy_id = 0;
+    }
+    
+out:
+    /* Release the memory after 60 seconds */
+    backlight->priv->destroy_id = g_timeout_add_seconds (60, (GSourceFunc) xfpm_backlight_destroy_popup, backlight);
+}
+
+
+static void
+xfpm_backlight_alarm_timeout_cb (EggIdletime *idle, guint id, XfpmBacklight *backlight)
+{
+    backlight->priv->block = FALSE;
+    
+    if ( id == TIMEOUT_BRIGHTNESS_ON_AC && !backlight->priv->on_battery)
+	xfpm_backlight_dim_brightness (backlight);
+    else if ( id == TIMEOUT_BRIGHTNESS_ON_BATTERY && backlight->priv->on_battery)
+	xfpm_backlight_dim_brightness (backlight);
+}
+
+static void
+xfpm_backlight_reset_cb (EggIdletime *idle, XfpmBacklight *backlight)
+{
+    if ( backlight->priv->dimmed)
+    {
+	if ( !backlight->priv->block)
+	{
+	    XFPM_DEBUG ("Alarm reset, setting level to %li", backlight->priv->last_level);
+	    xfpm_brightness_set_level (backlight->priv->brightness, backlight->priv->last_level);
+	}
+	backlight->priv->dimmed = FALSE;
+    }
+}
+
+static void
+xfpm_backlight_button_pressed_cb (XfpmButton *button, XfpmButtonKey type, XfpmBacklight *backlight)
+{
+    glong level;
+    gboolean ret = TRUE;
+    
+    gboolean enable_brightness, show_popup;
+    
+    g_object_get (G_OBJECT (backlight->priv->conf),
+                  ENABLE_BRIGHTNESS_CONTROL, &enable_brightness,
+		  SHOW_BRIGHTNESS_POPUP, &show_popup,
+                  NULL);
+    
+    if ( type == BUTTON_MON_BRIGHTNESS_UP )
+    {
+	backlight->priv->block = TRUE;
+	if ( enable_brightness )
+	    ret = xfpm_brightness_up (backlight->priv->brightness, &level);
+	if ( ret && show_popup)
+	    xfpm_backlight_show (backlight, level);
+    }
+    else if ( type == BUTTON_MON_BRIGHTNESS_DOWN )
+    {
+	backlight->priv->block = TRUE;
+	if ( enable_brightness )
+	    ret = xfpm_brightness_down (backlight->priv->brightness, &level);
+	if ( ret && show_popup)
+	    xfpm_backlight_show (backlight, level);
+    }
+}
+
+static void
+xfpm_backlight_brightness_on_ac_settings_changed (XfpmBacklight *backlight)
+{
+    guint timeout_on_ac;
+    
+    g_object_get (G_OBJECT (backlight->priv->conf),
+		  BRIGHTNESS_ON_AC, &timeout_on_ac,
+		  NULL);
+		  
+    XFPM_DEBUG ("Alarm on ac timeout changed %u", timeout_on_ac);
+    
+    if ( timeout_on_ac == ALARM_DISABLED )
+    {
+	egg_idletime_alarm_remove (backlight->priv->idle, TIMEOUT_BRIGHTNESS_ON_AC );
+    }
+    else
+    {
+	egg_idletime_alarm_set (backlight->priv->idle, TIMEOUT_BRIGHTNESS_ON_AC, timeout_on_ac * 1000);
+    }
+}
+
+static void
+xfpm_backlight_brightness_on_battery_settings_changed (XfpmBacklight *backlight)
+{
+    guint timeout_on_battery ;
+    
+    g_object_get (G_OBJECT (backlight->priv->conf),
+		  BRIGHTNESS_ON_BATTERY, &timeout_on_battery,
+		  NULL);
+    
+    XFPM_DEBUG ("Alarm on battery timeout changed %u", timeout_on_battery);
+    
+    if ( timeout_on_battery == ALARM_DISABLED )
+    {
+	egg_idletime_alarm_remove (backlight->priv->idle, TIMEOUT_BRIGHTNESS_ON_BATTERY );
+    }
+    else
+    {
+	egg_idletime_alarm_set (backlight->priv->idle, TIMEOUT_BRIGHTNESS_ON_BATTERY, timeout_on_battery * 1000);
+    } 
+}
+
+
+static void
+xfpm_backlight_set_timeouts (XfpmBacklight *backlight)
+{
+    xfpm_backlight_brightness_on_ac_settings_changed (backlight);
+    xfpm_backlight_brightness_on_battery_settings_changed (backlight);
+}
+
+static void
+xfpm_backlight_on_battery_changed_cb (XfpmPower *power, gboolean on_battery, XfpmBacklight *backlight)
+{
+    backlight->priv->on_battery = on_battery;
+}
+
+static void
+xfpm_backlight_class_init (XfpmBacklightClass *klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+    object_class->finalize = xfpm_backlight_finalize;
+
+    g_type_class_add_private (klass, sizeof (XfpmBacklightPrivate));
+}
+
+static void
+xfpm_backlight_init (XfpmBacklight *backlight)
+{
+    backlight->priv = XFPM_BACKLIGHT_GET_PRIVATE (backlight);
+    
+    backlight->priv->brightness = xfpm_brightness_new ();
+    backlight->priv->has_hw     = xfpm_brightness_setup (backlight->priv->brightness);
+    
+    backlight->priv->osd    = NULL;
+    backlight->priv->notify = NULL;
+    backlight->priv->idle   = NULL;
+    backlight->priv->conf   = NULL;
+    backlight->priv->button = NULL;
+    backlight->priv->power    = NULL;
+    backlight->priv->dimmed = FALSE;
+    backlight->priv->block = FALSE;
+    backlight->priv->destroy_id = 0;
+    
+    if ( !backlight->priv->has_hw )
+    {
+	g_object_unref (backlight->priv->brightness);
+	backlight->priv->brightness = NULL;
+    }
+    else
+    {
+	backlight->priv->idle   = egg_idletime_new ();
+	backlight->priv->conf   = xfpm_xfconf_new ();
+	backlight->priv->button = xfpm_button_new ();
+	backlight->priv->power    = xfpm_power_get ();
+	backlight->priv->notify = xfpm_notify_new ();
+	backlight->priv->max_level = xfpm_brightness_get_max_level (backlight->priv->brightness);
+	g_signal_connect (backlight->priv->idle, "alarm-expired",
+                          G_CALLBACK (xfpm_backlight_alarm_timeout_cb), backlight);
+        
+        g_signal_connect (backlight->priv->idle, "reset",
+                          G_CALLBACK(xfpm_backlight_reset_cb), backlight);
+			  
+	g_signal_connect (backlight->priv->button, "button-pressed",
+		          G_CALLBACK (xfpm_backlight_button_pressed_cb), backlight);
+			  
+	g_signal_connect_swapped (backlight->priv->conf, "notify::" BRIGHTNESS_ON_AC,
+				  G_CALLBACK (xfpm_backlight_brightness_on_ac_settings_changed), backlight);
+	
+	g_signal_connect_swapped (backlight->priv->conf, "notify::" BRIGHTNESS_ON_BATTERY,
+				  G_CALLBACK (xfpm_backlight_brightness_on_battery_settings_changed), backlight);
+				
+	g_signal_connect (backlight->priv->power, "on-battery-changed",
+			  G_CALLBACK (xfpm_backlight_on_battery_changed_cb), backlight);
+	g_object_get (G_OBJECT (backlight->priv->power),
+		      "on-battery", &backlight->priv->on_battery,
+		      NULL);
+	xfpm_brightness_get_level (backlight->priv->brightness, &backlight->priv->last_level);
+	xfpm_backlight_set_timeouts (backlight);
+    }
+}
+
+static void
+xfpm_backlight_finalize (GObject *object)
+{
+    XfpmBacklight *backlight;
+
+    backlight = XFPM_BACKLIGHT (object);
+
+    xfpm_backlight_destroy_popup (backlight);
+
+    if ( backlight->priv->brightness )
+	g_object_unref (backlight->priv->brightness);
+
+    if ( backlight->priv->idle )
+	g_object_unref (backlight->priv->idle);
+
+    if ( backlight->priv->conf )
+	g_object_unref (backlight->priv->conf);
+
+    if ( backlight->priv->button )
+	g_object_unref (backlight->priv->button);
+
+    if ( backlight->priv->power )
+	g_object_unref (backlight->priv->power);
+
+    if ( backlight->priv->notify)
+	g_object_unref (backlight->priv->notify);
+
+    G_OBJECT_CLASS (xfpm_backlight_parent_class)->finalize (object);
+}
+
+XfpmBacklight *
+xfpm_backlight_new (void)
+{
+    XfpmBacklight *backlight = NULL;
+    backlight = g_object_new (XFPM_TYPE_BACKLIGHT, NULL);
+    return backlight;
+}
+
+gboolean xfpm_backlight_has_hw (XfpmBacklight *backlight)
+{
+    return backlight->priv->has_hw;
+}

=== added file '.pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/xfpm-notify.c'
--- .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/xfpm-notify.c	1970-01-01 00:00:00 +0000
+++ .pc/01_Remove_custom_OSD_brightness_popup,_use_libnotify_instead.patch/src/xfpm-notify.c	2013-08-12 21:07:54 +0000
@@ -0,0 +1,409 @@
+/*
+ * * Copyright (C) 2008-2011 Ali <[e-mail]>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif
+
+#include <gtk/gtk.h>
+
+#include <libxfce4util/libxfce4util.h>
+
+#include <libnotify/notify.h>
+
+#include "xfpm-common.h"
+#include "xfpm-notify.h"
+#include "xfpm-dbus-monitor.h"
+
+static void xfpm_notify_finalize   (GObject *object);
+
+static NotifyNotification * xfpm_notify_new_notification_internal (const gchar *title, 
+								   const gchar *message, 
+								   const gchar *icon_name, 
+								   guint timeout, 
+								   XfpmNotifyUrgency urgency, 
+								   GtkStatusIcon *icon) G_GNUC_MALLOC;
+
+#define XFPM_NOTIFY_GET_PRIVATE(o) \
+(G_TYPE_INSTANCE_GET_PRIVATE((o), XFPM_TYPE_NOTIFY, XfpmNotifyPrivate))
+
+struct XfpmNotifyPrivate
+{
+    XfpmDBusMonitor    *monitor;
+    
+    NotifyNotification *notification;
+    NotifyNotification *critical;
+    
+    gulong		critical_id;
+    gulong		notify_id;
+    
+    gboolean	        supports_actions;
+    gboolean		supports_sync; /*For x-canonical-private-synchronous */
+};
+
+enum
+{
+    PROP_0,
+    PROP_ACTIONS,
+    PROP_SYNC
+};
+
+G_DEFINE_TYPE(XfpmNotify, xfpm_notify, G_TYPE_OBJECT)
+
+static void
+xfpm_notify_get_server_caps (XfpmNotify *notify)
+{
+    GList *caps = NULL;
+    notify->priv->supports_actions = FALSE;
+    notify->priv->supports_sync    = FALSE;
+    
+    caps = notify_get_server_caps ();
+    
+    if (caps != NULL) 
+    {
+	if (g_list_find_custom (caps, "x-canonical-private-synchronous", (GCompareFunc) g_strcmp0) != NULL)
+	    notify->priv->supports_sync = TRUE;
+    
+	if (g_list_find_custom (caps, "actions", (GCompareFunc) g_strcmp0) != NULL)
+	    notify->priv->supports_actions = TRUE;
+
+	g_list_foreach(caps, (GFunc)g_free, NULL);
+	g_list_free(caps);
+    }
+}
+
+static void
+xfpm_notify_check_server (XfpmDBusMonitor *monitor, 
+			  gchar *service_name, 
+			  gboolean connected,
+			  gboolean on_session,
+			  XfpmNotify *notify)
+{
+    if ( !g_strcmp0 (service_name, "org.freedesktop.Notifications") && on_session && connected )
+	xfpm_notify_get_server_caps (notify);
+}
+
+static void xfpm_notify_get_property (GObject *object,
+				      guint prop_id,
+				      GValue *value,
+				      GParamSpec *pspec)
+{
+    XfpmNotify *notify;
+    
+    notify = XFPM_NOTIFY (object);
+    
+    switch (prop_id)
+    {
+	case PROP_ACTIONS:
+	    g_value_set_boolean (value, notify->priv->supports_actions);
+	    break;
+	case PROP_SYNC:
+	    g_value_set_boolean (value, notify->priv->supports_sync);
+	    break;
+	default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+            break;
+    }
+}
+
+static void
+xfpm_notify_class_init (XfpmNotifyClass *klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+    object_class->finalize = xfpm_notify_finalize;
+    object_class->get_property = xfpm_notify_get_property;
+
+    g_object_class_install_property (object_class,
+                                     PROP_ACTIONS,
+                                     g_param_spec_boolean ("actions",
+                                                           NULL, NULL,
+                                                           FALSE,
+                                                           G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+                                     PROP_SYNC,
+                                     g_param_spec_boolean ("sync",
+                                                           NULL, NULL,
+                                                           FALSE,
+                                                           G_PARAM_READABLE));
+
+    g_type_class_add_private (klass, sizeof (XfpmNotifyPrivate));
+}
+
+static void
+xfpm_notify_init (XfpmNotify *notify)
+{
+    notify->priv = XFPM_NOTIFY_GET_PRIVATE (notify);
+    
+    notify->priv->notification = NULL;
+    notify->priv->critical = NULL;
+    
+    notify->priv->critical_id = 0;
+    notify->priv->notify_id   = 0;
+    
+    notify->priv->monitor = xfpm_dbus_monitor_new ();
+    xfpm_dbus_monitor_add_service (notify->priv->monitor, DBUS_BUS_SESSION, "org.freedesktop.Notifications");
+    g_signal_connect (notify->priv->monitor, "service-connection-changed",
+		      G_CALLBACK (xfpm_notify_check_server), notify);
+    
+    xfpm_notify_get_server_caps (notify);
+}
+
+static void
+xfpm_notify_finalize (GObject *object)
+{
+    XfpmNotify *notify;
+
+    notify = XFPM_NOTIFY (object);
+    
+    xfpm_notify_close_normal (notify);
+    xfpm_notify_close_critical (notify);
+    
+    G_OBJECT_CLASS (xfpm_notify_parent_class)->finalize(object);
+}
+
+static void
+xfpm_notify_set_notification_icon (NotifyNotification *n, const gchar *icon_name )
+{
+    GdkPixbuf *pix = xfpm_icon_load (icon_name, 48);
+    
+    if ( pix )
+    {
+	notify_notification_set_icon_from_pixbuf (n,
+						  pix);
+	g_object_unref ( G_OBJECT(pix));
+    }
+    
+}
+
+static NotifyNotification *
+xfpm_notify_new_notification_internal (const gchar *title, const gchar *message,
+				       const gchar *icon_name, guint timeout,
+				       XfpmNotifyUrgency urgency, GtkStatusIcon *icon)
+{
+    NotifyNotification *n;
+    
+#ifdef NOTIFY_CHECK_VERSION
+#if NOTIFY_CHECK_VERSION (0, 7, 0) 
+    n = notify_notification_new (title, message, NULL);
+#else
+    n = notify_notification_new (title, message, NULL, NULL);
+#endif
+#else
+    n = notify_notification_new (title, message, NULL, NULL);
+#endif
+
+    
+    if ( icon_name )
+    	xfpm_notify_set_notification_icon (n, icon_name);
+
+#ifdef NOTIFY_CHECK_VERSION
+#if !NOTIFY_CHECK_VERSION (0, 7, 0) 
+    if ( icon )
+    	notify_notification_attach_to_status_icon (n, icon);
+#endif
+#else
+     if ( icon )
+     	notify_notification_attach_to_status_icon (n, icon);
+#endif
+	
+    notify_notification_set_urgency (n, (NotifyUrgency)urgency);
+    
+    if ( timeout != 0)
+	notify_notification_set_timeout (n, timeout);
+    
+    return n;
+}
+
+static void
+xfpm_notify_closed_cb (NotifyNotification *n, XfpmNotify *notify)
+{
+    notify->priv->notification = NULL;
+    g_object_unref (G_OBJECT (n));
+}
+
+static void
+xfpm_notify_close_critical_cb (NotifyNotification *n, XfpmNotify *notify)
+{
+    notify->priv->critical = NULL;
+    g_object_unref (G_OBJECT (n));
+}
+
+static gboolean
+xfpm_notify_show (NotifyNotification *n)
+{
+    notify_notification_show (n, NULL);
+    return FALSE;
+}
+
+static void
+xfpm_notify_close_notification (XfpmNotify *notify )
+{
+    if (notify->priv->notify_id != 0)
+    {
+	g_source_remove (notify->priv->notify_id);
+	notify->priv->notify_id = 0;
+    }
+    
+    if ( notify->priv->notification )
+    {
+    	if (!notify_notification_close (notify->priv->notification, NULL))
+	    g_warning ("Failed to close notification\n");
+	
+	g_object_unref (G_OBJECT(notify->priv->notification) );
+	notify->priv->notification  = NULL;
+    }
+}
+
+XfpmNotify *
+xfpm_notify_new (void)
+{
+    static gpointer xfpm_notify_object = NULL;
+    
+    if ( xfpm_notify_object != NULL )
+    {
+	g_object_ref (xfpm_notify_object);
+    }
+    else
+    {
+	xfpm_notify_object = g_object_new (XFPM_TYPE_NOTIFY, NULL);
+	g_object_add_weak_pointer (xfpm_notify_object, &xfpm_notify_object);
+    }
+    return XFPM_NOTIFY (xfpm_notify_object);
+}
+
+void xfpm_notify_show_notification (XfpmNotify *notify, const gchar *title,
+				    const gchar *text,  const gchar *icon_name,
+				    gint timeout, gboolean simple,
+				    XfpmNotifyUrgency urgency, GtkStatusIcon *icon)
+{
+    NotifyNotification *n;
+    
+    if ( !simple )
+        xfpm_notify_close_notification (notify);
+    
+    n = xfpm_notify_new_notification_internal (title, 
+				               text, icon_name, 
+					       timeout, urgency, 
+					       icon);
+					       
+    xfpm_notify_present_notification (notify, n, simple);
+}
+
+NotifyNotification *xfpm_notify_new_notification (XfpmNotify *notify,
+						  const gchar *title,
+						  const gchar *text,
+						  const gchar *icon_name,
+						  guint timeout,
+						  XfpmNotifyUrgency urgency,
+						  GtkStatusIcon *icon)
+{
+    NotifyNotification *n = xfpm_notify_new_notification_internal (title, 
+							           text, icon_name, 
+								   timeout, urgency, 
+								   icon);
+    return n;
+}
+
+void xfpm_notify_add_action_to_notification (XfpmNotify *notify, NotifyNotification *n,
+					    const gchar *id, const gchar *action_label,
+					    NotifyActionCallback callback, gpointer data)
+{
+    g_return_if_fail (XFPM_IS_NOTIFY(notify));
+    
+    notify_notification_add_action (n, id, action_label,
+				   (NotifyActionCallback)callback,
+				    data, NULL);
+    
+}
+
+void xfpm_notify_present_notification (XfpmNotify *notify, NotifyNotification *n, gboolean simple)
+{
+    g_return_if_fail (XFPM_IS_NOTIFY(notify));
+    
+    if ( !simple )
+        xfpm_notify_close_notification (notify);
+    
+    if ( !simple )
+    {
+	g_signal_connect (G_OBJECT(n),"closed",
+			G_CALLBACK(xfpm_notify_closed_cb), notify);
+	notify->priv->notification = n;
+    }
+    
+    notify->priv->notify_id = g_idle_add ((GSourceFunc) xfpm_notify_show, n);
+}
+
+void xfpm_notify_critical (XfpmNotify *notify, NotifyNotification *n)
+{
+    g_return_if_fail (XFPM_IS_NOTIFY (notify));
+
+    xfpm_notify_close_critical (notify);
+    
+    notify->priv->critical = n;
+    
+    g_signal_connect (G_OBJECT (n), "closed", 
+		      G_CALLBACK (xfpm_notify_close_critical_cb), notify);
+		      
+    notify->priv->critical_id = g_idle_add ((GSourceFunc) xfpm_notify_show, n);
+}
+
+void xfpm_notify_close_critical (XfpmNotify *notify)
+{
+    g_return_if_fail (XFPM_IS_NOTIFY (notify));
+    
+    
+    if (notify->priv->critical_id != 0)
+    {
+	g_source_remove (notify->priv->critical_id);
+	notify->priv->critical_id = 0;
+    }
+    
+    if ( notify->priv->critical )
+    {
+    	if (!notify_notification_close (notify->priv->critical, NULL))
+	    g_warning ("Failed to close notification\n");
+	
+	g_object_unref (G_OBJECT(notify->priv->critical) );
+	notify->priv->critical  = NULL;
+    }
+}
+
+void xfpm_notify_close_normal  (XfpmNotify *notify)
+{
+    g_return_if_fail (XFPM_IS_NOTIFY (notify));
+    
+    xfpm_notify_close_notification (notify);
+}

=== added file '.pc/02_translations-fix-invalid-format-strings.patch/.timestamp'
=== added directory '.pc/03_fix-insert-battery.patch'
=== added file '.pc/03_fix-insert-battery.patch/.timestamp'
=== added directory '.pc/03_fix-insert-battery.patch/src'
=== added file '.pc/03_fix-insert-battery.patch/src/xfpm-battery.c'
--- .pc/03_fix-insert-battery.patch/src/xfpm-battery.c	1970-01-01 00:00:00 +0000
+++ .pc/03_fix-insert-battery.patch/src/xfpm-battery.c	2013-08-12 21:07:54 +0000
@@ -0,0 +1,916 @@
+/*
+ * * Copyright (C) 2009-2011 Ali <[e-mail]>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gtk/gtk.h>
+
+#include <libxfce4util/libxfce4util.h>
+
+#include "xfpm-battery.h"
+#include "xfpm-dbus.h"
+#include "xfpm-icons.h"
+#include "xfpm-xfconf.h"
+#include "xfpm-notify.h"
+#include "xfpm-config.h"
+#include "xfpm-button.h"
+#include "xfpm-enum-glib.h"
+#include "xfpm-enum-types.h"
+#include "xfpm-debug.h"
+#include "xfpm-power-common.h"
+#include "xfpm-common.h"
+
+static void xfpm_battery_finalize   (GObject *object);
+
+#define XFPM_BATTERY_GET_PRIVATE(o) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((o), XFPM_TYPE_BATTERY, XfpmBatteryPrivate))
+
+struct XfpmBatteryPrivate
+{
+    XfpmXfconf             *conf;
+    XfpmNotify		   *notify;
+    XfpmButton             *button;
+    DBusGProxy             *proxy;
+    DBusGProxy 		   *proxy_prop;
+    
+    gchar		   *icon_prefix;
+    
+    XfpmBatteryCharge       charge;
+    XfpmDeviceState         state;
+    XfpmDeviceType          type;
+    gboolean		    ac_online;
+    gboolean                present;
+    guint 		    percentage;
+    gint64		    time_to_full;
+    gint64		    time_to_empty;
+
+    const gchar            *battery_name;
+    
+    gulong		    sig;
+    gulong		    sig_bt;
+    
+    guint                   notify_idle;
+};
+
+enum
+{
+    PROP_0,
+    PROP_AC_ONLINE,
+    PROP_CHARGE_STATUS,
+    PROP_DEVICE_TYPE
+};
+    
+enum
+{
+    BATTERY_CHARGE_CHANGED,
+    LAST_SIGNAL
+};
+
+static guint signals [LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE (XfpmBattery, xfpm_battery, GTK_TYPE_STATUS_ICON)
+
+static const gchar * G_GNUC_CONST
+xfpm_battery_get_icon_index (XfpmDeviceType type, guint percent)
+{
+    if (percent < 10) 
+    {
+        return "000";
+    } 
+    else if (percent < 30) 
+    {
+        return ( (type == XFPM_DEVICE_TYPE_BATTERY || type == XFPM_DEVICE_TYPE_UPS) ? "020" : "030");
+    } 
+    else if (percent < 50) 
+    {
+        return ( (type == XFPM_DEVICE_TYPE_BATTERY || type == XFPM_DEVICE_TYPE_UPS ) ? "040" : "030");
+    } 
+    else if (percent < 70) 
+    {
+        return "060";
+    } 
+    else if (percent < 90) 
+    {
+        return ((type == XFPM_DEVICE_TYPE_BATTERY || type == XFPM_DEVICE_TYPE_UPS) ? "080" : "060");
+    }
+    
+    return "100";
+}
+
+static void
+xfpm_battery_refresh_visible (XfpmBattery *battery)
+{
+    XfpmShowIcon show_icon;
+    gboolean visible = TRUE;
+    
+    g_object_get (G_OBJECT (battery->priv->conf),
+		  SHOW_TRAY_ICON_CFG, &show_icon,
+		  NULL);
+		  
+    if ( show_icon == SHOW_ICON_ALWAYS )
+    	visible = TRUE;
+    else if ( show_icon == NEVER_SHOW_ICON )
+	visible = FALSE;
+    else if ( show_icon == SHOW_ICON_WHEN_BATTERY_PRESENT )
+    {
+	if ( battery->priv->present )
+	    visible = TRUE;
+	else visible = FALSE;
+    }
+    else if ( show_icon == SHOW_ICON_WHEN_BATTERY_CHARGING_DISCHARGING )
+    {
+	if ( battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
+	    visible = FALSE;
+	else visible = TRUE;
+    }
+
+    XFPM_DEBUG_ENUM (show_icon, XFPM_TYPE_SHOW_ICON, "visible=%s", xfpm_bool_to_string (visible));
+			  
+    gtk_status_icon_set_visible (GTK_STATUS_ICON (battery), visible);
+}
+
+
+/*
+ * Taken from gpm
+ */
+static gchar *
+xfpm_battery_get_time_string (guint seconds)
+{
+    char* timestring = NULL;
+    gint  hours;
+    gint  minutes;
+
+    /* Add 0.5 to do rounding */
+    minutes = (int) ( ( seconds / 60.0 ) + 0.5 );
+
+    if (minutes == 0) 
+    {
+	timestring = g_strdup (_("Unknown time"));
+	return timestring;
+    }
+
+    if (minutes < 60) 
+    {
+	timestring = g_strdup_printf (ngettext ("%i minute",
+			              "%i minutes",
+				      minutes), minutes);
+	return timestring;
+    }
+
+    hours = minutes / 60;
+    minutes = minutes % 60;
+
+    if (minutes == 0)
+	timestring = g_strdup_printf (ngettext (
+			    "%i hour",
+			    "%i hours",
+			    hours), hours);
+    else
+	/* TRANSLATOR: "%i %s %i %s" are "%i hours %i minutes"
+	 * Swap order with "%2$s %2$i %1$s %1$i if needed */
+	timestring = g_strdup_printf (_("%i %s %i %s"),
+			    hours, ngettext ("hour", "hours", hours),
+			    minutes, ngettext ("minute", "minutes", minutes));
+    return timestring;
+}
+
+static gchar *
+xfpm_battery_get_message_from_battery_state (XfpmBattery *battery)
+{
+    gchar *msg  = NULL;
+    
+    
+    if (battery->priv->type == XFPM_DEVICE_TYPE_BATTERY || battery->priv->type == XFPM_DEVICE_TYPE_UPS)
+    {
+	switch (battery->priv->state)
+	{
+	    case XFPM_DEVICE_STATE_FULLY_CHARGED:
+		msg = g_strdup_printf (_("Your %s is fully charged"), battery->priv->battery_name);
+		break;
+	    case XFPM_DEVICE_STATE_CHARGING:
+		msg = g_strdup_printf (_("Your %s is charging"), battery->priv->battery_name);
+		
+		if ( battery->priv->time_to_full != 0 )
+		{
+		    gchar *tmp, *est_time_str;
+		    tmp = g_strdup (msg);
+		    g_free (msg);
+		    
+		    est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_full);
+		    
+		    msg = g_strdup_printf (_("%s (%i%%)\n%s until is fully charged."), tmp, battery->priv->percentage, est_time_str);
+		    g_free (est_time_str);
+		    g_free (tmp);
+		}
+
+		break;
+	    case XFPM_DEVICE_STATE_DISCHARGING:
+		if (battery->priv->ac_online)
+		    msg =  g_strdup_printf (_("Your %s is discharging"), battery->priv->battery_name);
+		else
+		    msg =  g_strdup_printf (_("System is running on %s power"), battery->priv->battery_name);
+		    
+		    if ( battery->priv->time_to_empty != 0 )
+		    {
+			gchar *tmp, *est_time_str;
+			tmp = g_strdup (msg);
+			g_free (msg);
+			
+			est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_empty);
+			
+			msg = g_strdup_printf (_("%s (%i%%)\nEstimated time left is %s."), tmp, battery->priv->percentage, est_time_str);
+			g_free (tmp);
+			g_free (est_time_str);
+		    }
+		break;
+	    case XFPM_DEVICE_STATE_EMPTY:
+		msg = g_strdup_printf (_("Your %s is empty"), battery->priv->battery_name);
+		break;
+	    default:
+		break;
+	}
+	
+    }
+    else if (battery->priv->type >= XFPM_DEVICE_TYPE_MONITOR)
+    {
+	switch (battery->priv->state)
+	{
+	    case XFPM_DEVICE_STATE_FULLY_CHARGED:
+		msg = g_strdup_printf (_("Your %s is fully charged"), battery->priv->battery_name);
+		break;
+	    case XFPM_DEVICE_STATE_CHARGING:
+		msg = g_strdup_printf (_("Your %s is charging"), battery->priv->battery_name);
+		break;
+	    case XFPM_DEVICE_STATE_DISCHARGING:
+		msg =  g_strdup_printf (_("Your %s is discharging"), battery->priv->battery_name);
+		break;
+	    case XFPM_DEVICE_STATE_EMPTY:
+		msg = g_strdup_printf (_("Your %s is empty"), battery->priv->battery_name);
+		break;
+	    default:
+		break;
+	}
+    }
+    
+    return msg;
+}
+
+static void
+xfpm_battery_refresh_icon (XfpmBattery *battery)
+{
+    gchar icon_name[128];
+    
+    XFPM_DEBUG ("Battery state %d", battery->priv->state);
+    
+    if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY || 
+	 battery->priv->type == XFPM_DEVICE_TYPE_UPS )
+    {
+	if (!battery->priv->present)
+	{
+	    g_snprintf (icon_name, 128, "%s%s", battery->priv->icon_prefix, "missing");
+	}
+	else if (battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
+	{
+	    g_snprintf (icon_name, 128, "%s%s", battery->priv->icon_prefix, battery->priv->ac_online ? "charged" : "100");
+	}
+	else if ( battery->priv->state == XFPM_DEVICE_STATE_CHARGING || 
+		  battery->priv->state == XFPM_DEVICE_STATE_PENDING_CHARGING)
+	{
+	    g_snprintf (icon_name, 128, "%s%s-%s", 
+			battery->priv->icon_prefix, 
+			xfpm_battery_get_icon_index (battery->priv->type, battery->priv->percentage),
+			"charging");
+	}
+	else if ( battery->priv->state == XFPM_DEVICE_STATE_DISCHARGING ||
+		  battery->priv->state == XFPM_DEVICE_STATE_PENDING_DISCHARGING)
+	{
+	    g_snprintf (icon_name, 128, "%s%s", 
+			battery->priv->icon_prefix, 
+			xfpm_battery_get_icon_index (battery->priv->type, battery->priv->percentage));
+	}
+	else if ( battery->priv->state == XFPM_DEVICE_STATE_EMPTY)
+	{
+	    g_snprintf (icon_name, 128, "%s%s", battery->priv->icon_prefix, battery->priv->ac_online ? "000-charging" : "000");
+	}
+    }
+    else
+    {
+	if ( !battery->priv->present || battery->priv->state == XFPM_DEVICE_STATE_EMPTY )
+	{
+	    g_snprintf (icon_name, 128, "%s-000", battery->priv->icon_prefix);
+	}
+	else if ( battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
+	{
+	    g_snprintf (icon_name, 128, "%s-100", battery->priv->icon_prefix);
+	}
+	else if ( battery->priv->state == XFPM_DEVICE_STATE_DISCHARGING )
+	{
+	    g_snprintf (icon_name, 128, "%s-%s", 
+			battery->priv->icon_prefix, 
+			xfpm_battery_get_icon_index (battery->priv->type, battery->priv->percentage));
+	}
+    }
+    
+    gtk_status_icon_set_from_icon_name (GTK_STATUS_ICON (battery), icon_name);
+}
+
+static void
+xfpm_battery_notify (XfpmBattery *battery)
+{
+    gchar *message = NULL;
+    
+    message = xfpm_battery_get_message_from_battery_state (battery);
+    
+    if ( !message )
+	return;
+	
+    xfpm_notify_show_notification (battery->priv->notify, 
+				   _("Power Manager"), 
+				   message, 
+				   gtk_status_icon_get_icon_name (GTK_STATUS_ICON (battery)),
+				   8000,
+				   FALSE,
+				   XFPM_NOTIFY_NORMAL,
+				   GTK_STATUS_ICON (battery));
+    
+    g_free (message);
+}
+
+static gboolean
+xfpm_battery_notify_idle (gpointer data)
+{
+    XfpmBattery *battery = XFPM_BATTERY (data);
+    
+    xfpm_battery_notify (battery);
+    battery->priv->notify_idle = 0;
+    
+    return FALSE;
+}
+
+static void
+xfpm_battery_notify_state (XfpmBattery *battery)
+{
+    gboolean notify;
+    static gboolean starting_up = TRUE;
+    
+    if ( !gtk_status_icon_get_visible (GTK_STATUS_ICON (battery)) )
+	return;
+    
+    if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
+	 battery->priv->type == XFPM_DEVICE_TYPE_UPS )
+    {
+	if ( starting_up )
+	{
+	    starting_up = FALSE;
+	    return;
+	}
+    
+	g_object_get (G_OBJECT (battery->priv->conf),
+		      GENERAL_NOTIFICATION_CFG, &notify,
+		      NULL);
+		      
+	if ( notify )
+	{
+	    if (battery->priv->notify_idle == 0)
+	        battery->priv->notify_idle = g_idle_add (xfpm_battery_notify_idle, battery);
+	}
+    }
+}
+
+/*
+ * Refresh tooltip function for UPS and battery device only.
+ */
+static void
+xfpm_battery_set_tooltip_primary (XfpmBattery *battery, GtkTooltip *tooltip)
+{
+    gchar *tip;
+    gchar *est_time_str = NULL;
+    gchar *power_status = NULL;
+    
+    power_status = g_strdup_printf (battery->priv->ac_online ? _("Adaptor is online") : _("System is running on battery power"));
+    
+    if ( battery->priv->state == XFPM_DEVICE_STATE_FULLY_CHARGED )
+    {
+	if ( battery->priv->time_to_empty > 0 )
+	{
+	    est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_empty);
+	    tip = g_strdup_printf (_("%s\nYour %s is fully charged (%i%%).\nProvides %s runtime"), 
+				   power_status,
+				   battery->priv->battery_name, 
+				   battery->priv->percentage,
+				   est_time_str);
+	    g_free (est_time_str);
+	}
+	else
+	{
+	    tip = g_strdup_printf (_("%s\nYour %s is fully charged (%i%%)."), 
+				   power_status,
+				   battery->priv->battery_name,
+				   battery->priv->percentage);
+	}
+    }
+    else if ( battery->priv->state == XFPM_DEVICE_STATE_CHARGING )
+    {
+	if ( battery->priv->time_to_full != 0 )
+	{
+	    est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_full);
+	    tip = g_strdup_printf (_("%s\nYour %s is charging (%i%%)\n%s until is fully charged."), 
+				   power_status,
+				   battery->priv->battery_name, 
+				   battery->priv->percentage, 
+				   est_time_str);
+	    g_free (est_time_str);
+	}
+	else
+	{
+	    tip = g_strdup_printf (_("%s\nYour %s is charging (%i%%)."),
+				   power_status,
+				   battery->priv->battery_name,
+				   battery->priv->percentage);
+	}
+    }
+    else if ( battery->priv->state == XFPM_DEVICE_STATE_DISCHARGING )
+    {
+	if ( battery->priv->time_to_empty != 0 )
+	{
+	    est_time_str = xfpm_battery_get_time_string (battery->priv->time_to_empty);
+	    tip = g_strdup_printf (_("%s\nYour %s is discharging (%i%%)\nEstimated time left is %s."), 
+				   power_status,
+				   battery->priv->battery_name, 
+				   battery->priv->percentage, 
+				   est_time_str);
+	    g_free (est_time_str);
+	}
+	else
+	{
+	    tip = g_strdup_printf (_("%s\nYour %s is discharging (%i%%)."),
+				   power_status,
+				   battery->priv->battery_name,
+				   battery->priv->percentage);
+	}
+	
+    }
+    else if ( battery->priv->state == XFPM_DEVICE_STATE_PENDING_CHARGING )
+    {
+	tip = g_strdup_printf (_("%s\n%s waiting to discharge (%i%%)."), power_status, battery->priv->battery_name, battery->priv->percentage);
+    }
+    else if ( battery->priv->state == XFPM_DEVICE_STATE_PENDING_DISCHARGING )
+    {
+	tip = g_strdup_printf (_("%s\n%s waiting to charge (%i%%)."), power_status, battery->priv->battery_name, battery->priv->percentage);
+    }
+    else if ( battery->priv->state == XFPM_DEVICE_STATE_EMPTY )
+    {
+	tip = g_strdup_printf (_("%s\nYour %s is empty"), power_status, battery->priv->battery_name);
+    }
+    
+    gtk_tooltip_set_text (tooltip, tip);
+    g_free (power_status);
+    g_free (tip);
+}
+
+static void
+xfpm_battery_check_charge (XfpmBattery *battery)
+{
+    XfpmBatteryCharge charge;
+    guint critical_level, low_level;
+    
+    g_object_get (G_OBJECT (battery->priv->conf),
+		  CRITICAL_POWER_LEVEL, &critical_level,
+		  NULL);
+		  
+    low_level = critical_level + 10;
+    
+    if ( battery->priv->percentage > low_level )
+	charge = XFPM_BATTERY_CHARGE_OK;
+    else if ( battery->priv->percentage <= low_level && battery->priv->percentage > critical_level )
+	charge = XFPM_BATTERY_CHARGE_LOW;
+    else if ( battery->priv->percentage <= critical_level )
+	charge = XFPM_BATTERY_CHARGE_CRITICAL;
+	
+    if ( charge != battery->priv->charge)
+    {
+	battery->priv->charge = charge;
+	/*
+	 * only emit signal when when battery charge changes from ok->low->critical
+	 * and not the other way round.
+	 */
+	if ( battery->priv->charge != XFPM_BATTERY_CHARGE_CRITICAL || charge != XFPM_BATTERY_CHARGE_LOW )
+	    g_signal_emit (G_OBJECT (battery), signals [BATTERY_CHARGE_CHANGED], 0);
+    }
+}
+
+static void
+xfpm_battery_refresh (XfpmBattery *battery, GHashTable *props)
+{
+    GValue *value;
+    guint state;
+    
+    value = g_hash_table_lookup (props, "IsPresent");
+    
+    if ( value == NULL )
+    {
+	g_warning ("No 'IsPresent' property found");
+	goto out;
+    }
+    
+    battery->priv->present = g_value_get_boolean (value);
+    
+    value = g_hash_table_lookup (props, "State");
+    
+    if ( value == NULL )
+    {
+	g_warning ("No 'State' property found");
+    }
+    
+    state = g_value_get_uint (value);
+    if ( state != battery->priv->state )
+    {
+	battery->priv->state = state;
+	xfpm_battery_refresh_visible (battery);
+	xfpm_battery_notify_state (battery);
+    }
+    
+    value = g_hash_table_lookup (props, "Percentage");
+    
+    if ( value == NULL )
+    {
+	g_warning ("No 'Percentage' property found on battery device");
+	goto out;
+    }
+    
+    battery->priv->percentage = (guint) g_value_get_double (value);
+    
+    xfpm_battery_check_charge (battery);
+    
+    xfpm_battery_refresh_icon (battery);
+    
+    if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
+	 battery->priv->type == XFPM_DEVICE_TYPE_UPS )
+    {
+	value = g_hash_table_lookup (props, "TimeToEmpty");
+	
+	if ( value == NULL )
+	{
+	    g_warning ("No 'TimeToEmpty' property found on battery device");
+	    goto out;
+	}
+	
+	battery->priv->time_to_empty = g_value_get_int64 (value);
+	
+	value = g_hash_table_lookup (props, "TimeToFull");
+	
+	if ( value == NULL )
+	{
+	    g_warning ("No 'TimeToFull' property found on battery device");
+	    goto out;
+	}
+	
+	battery->priv->time_to_full = g_value_get_int64 (value);
+    }
+    
+    out:
+	g_hash_table_destroy (props);
+}
+
+static void
+xfpm_battery_button_pressed_cb (XfpmButton *button, XfpmButtonKey type, XfpmBattery *battery)
+{
+    if (type == BUTTON_BATTERY)
+	xfpm_battery_notify (battery);
+}
+
+static void
+xfpm_battery_changed_cb (DBusGProxy *proxy, XfpmBattery *battery)
+{
+    GHashTable *props;
+    
+    props = xfpm_power_get_interface_properties (battery->priv->proxy_prop, 
+						 UPOWER_IFACE_DEVICE);
+    
+    if ( props )
+	xfpm_battery_refresh (battery, props);
+}
+
+static gboolean
+xfpm_battery_query_tooltip (GtkStatusIcon *icon, 
+			    gint x,
+			    gint y,
+			    gboolean keyboard_mode,
+			    GtkTooltip *tooltip)
+{
+    XfpmBattery *battery;
+    
+    battery = XFPM_BATTERY (icon);
+
+    if ( battery->priv->type == XFPM_DEVICE_TYPE_BATTERY ||
+	 battery->priv->type == XFPM_DEVICE_TYPE_UPS )
+    {
+	xfpm_battery_set_tooltip_primary (battery, tooltip);
+	return TRUE;
+    }
+    
+    return FALSE;
+}
+
+static void
+xfpm_battery_tray_icon_settings_changed (GObject *obj, GParamSpec *spec, XfpmBattery *battery)
+{
+    xfpm_battery_refresh_visible (battery);
+}
+
+static void xfpm_battery_get_property (GObject *object,
+				       guint prop_id,
+				       GValue *value,
+				       GParamSpec *pspec)
+{
+    XfpmBattery *battery;
+    
+    battery = XFPM_BATTERY (object);
+    
+    switch (prop_id)
+    {
+	case PROP_AC_ONLINE:
+	    g_value_set_boolean (value, battery->priv->ac_online);
+	    break;
+	case PROP_DEVICE_TYPE:
+	    g_value_set_enum (value, battery->priv->type);
+	    break;
+	case PROP_CHARGE_STATUS:
+	    g_value_set_enum (value, battery->priv->charge);
+	    break;
+	default:
+	    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+            break;
+    }
+}
+
+static void xfpm_battery_set_property (GObject *object,
+				       guint prop_id,
+				       const GValue *value,
+				       GParamSpec *pspec)
+{
+    XfpmBattery *battery;
+    
+    battery = XFPM_BATTERY (object);
+    
+    switch (prop_id)
+    {
+	case PROP_AC_ONLINE:
+	    battery->priv->ac_online = g_value_get_boolean (value);
+	    xfpm_battery_refresh_icon (battery);
+	    break;
+	default:
+	    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+            break;
+    }
+}
+
+
+static void
+xfpm_battery_class_init (XfpmBatteryClass *klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
+    GtkStatusIconClass *status_icon_class = GTK_STATUS_ICON_CLASS (klass);
+
+    object_class->finalize = xfpm_battery_finalize;
+    object_class->get_property = xfpm_battery_get_property;
+    object_class->set_property = xfpm_battery_set_property;
+
+    status_icon_class->query_tooltip = xfpm_battery_query_tooltip;
+    
+    signals [BATTERY_CHARGE_CHANGED] = 
+        g_signal_new ("battery-charge-changed",
+                      XFPM_TYPE_BATTERY,
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET(XfpmBatteryClass, battery_charge_changed),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__VOID,
+                      G_TYPE_NONE, 0, G_TYPE_NONE);
+    
+    g_object_class_install_property (object_class,
+                                     PROP_AC_ONLINE,
+                                     g_param_spec_boolean("ac-online",
+                                                          NULL, NULL,
+                                                          FALSE,
+                                                          G_PARAM_READWRITE));
+
+    g_object_class_install_property (object_class,
+                                     PROP_DEVICE_TYPE,
+                                     g_param_spec_enum ("device-type",
+                                                        NULL, NULL,
+							XFPM_TYPE_DEVICE_TYPE,
+							XFPM_DEVICE_TYPE_UNKNOWN,
+                                                        G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+                                     PROP_CHARGE_STATUS,
+                                     g_param_spec_enum ("charge-status",
+                                                        NULL, NULL,
+							XFPM_TYPE_BATTERY_CHARGE,
+							XFPM_BATTERY_CHARGE_UNKNOWN,
+                                                        G_PARAM_READABLE));
+
+    g_type_class_add_private (klass, sizeof (XfpmBatteryPrivate));
+}
+
+static void
+xfpm_battery_init (XfpmBattery *battery)
+{
+    battery->priv = XFPM_BATTERY_GET_PRIVATE (battery);
+    
+    battery->priv->conf          = xfpm_xfconf_new ();
+    battery->priv->notify        = xfpm_notify_new ();
+    battery->priv->proxy_prop    = NULL;
+    battery->priv->state         = XFPM_DEVICE_STATE_UNKNOWN;
+    battery->priv->type          = XFPM_DEVICE_TYPE_UNKNOWN;
+    battery->priv->charge        = XFPM_BATTERY_CHARGE_UNKNOWN;
+    battery->priv->icon_prefix   = NULL;
+    battery->priv->time_to_full  = 0;
+    battery->priv->time_to_empty = 0;
+    battery->priv->button        = xfpm_button_new ();
+    battery->priv->ac_online     = TRUE;
+    
+    battery->priv->sig = g_signal_connect (G_OBJECT (battery->priv->conf), "notify::" SHOW_TRAY_ICON_CFG,
+					   G_CALLBACK (xfpm_battery_tray_icon_settings_changed), battery);
+					   
+    
+    battery->priv->sig_bt = g_signal_connect (G_OBJECT (battery->priv->button), "button-pressed",
+					   G_CALLBACK (xfpm_battery_button_pressed_cb), battery);
+}
+
+static void
+xfpm_battery_finalize (GObject *object)
+{
+    XfpmBattery *battery;
+
+    battery = XFPM_BATTERY (object);
+    
+    g_free (battery->priv->icon_prefix);
+
+    if (battery->priv->notify_idle != 0)
+        g_source_remove (battery->priv->notify_idle);
+
+    dbus_g_proxy_disconnect_signal (battery->priv->proxy, "Changed",
+				    G_CALLBACK (xfpm_battery_changed_cb), battery);
+				    
+    if ( g_signal_handler_is_connected (battery->priv->conf, battery->priv->sig ) )
+	g_signal_handler_disconnect (G_OBJECT (battery->priv->conf), battery->priv->sig);
+	
+     if ( g_signal_handler_is_connected (battery->priv->button, battery->priv->sig_bt ) )
+	g_signal_handler_disconnect (G_OBJECT (battery->priv->button), battery->priv->sig_bt);
+				    
+    g_object_unref (battery->priv->proxy);
+    g_object_unref (battery->priv->proxy_prop);
+    g_object_unref (battery->priv->conf);
+    g_object_unref (battery->priv->notify);
+    g_object_unref (battery->priv->button);
+
+    G_OBJECT_CLASS (xfpm_battery_parent_class)->finalize (object);
+}
+
+static gchar *
+xfpm_battery_get_icon_prefix_device_enum_type (XfpmDeviceType type)
+{
+    if ( type == XFPM_DEVICE_TYPE_BATTERY )
+    {
+	return g_strdup (XFPM_PRIMARY_ICON_PREFIX);
+    }
+    else if ( type == XFPM_DEVICE_TYPE_UPS ) 
+    {
+	return g_strdup (XFPM_UPS_ICON_PREFIX);
+    }
+    else if ( type == XFPM_DEVICE_TYPE_MOUSE ) 
+    {
+	return g_strdup (XFPM_MOUSE_ICON_PREFIX);
+    }
+    else if ( type == XFPM_DEVICE_TYPE_KBD ) 
+    {
+	return g_strdup (XFPM_KBD_ICON_PREFIX);
+    }
+    else if ( type == XFPM_DEVICE_TYPE_PHONE ) 
+    {
+	return g_strdup (XFPM_PHONE_ICON_PREFIX);
+    }
+    
+    return g_strdup (XFPM_PRIMARY_ICON_PREFIX);
+}
+
+static const gchar *
+xfpm_battery_get_name (XfpmDeviceType type)
+{
+    const gchar *name = NULL;
+    
+    switch (type)
+    {
+	case XFPM_DEVICE_TYPE_BATTERY:
+	    name = _("battery");
+	    break;
+	case XFPM_DEVICE_TYPE_UPS:
+	    name = _("UPS");
+	    break;
+	case XFPM_DEVICE_TYPE_MONITOR:
+	    name = _("monitor battery");
+	    break;
+	case XFPM_DEVICE_TYPE_MOUSE:
+	    name = _("mouse battery");
+	    break;
+	case XFPM_DEVICE_TYPE_KBD:
+	    name = _("keyboard battery");
+	    break;
+	case XFPM_DEVICE_TYPE_PDA:
+	    name = _("PDA battery");
+	    break;
+	case XFPM_DEVICE_TYPE_PHONE:
+	    name = _("Phone battery");
+	    break;
+	default:
+	    name = _("Unknown");
+	    break;
+    }
+    
+    return name;
+}
+
+GtkStatusIcon *
+xfpm_battery_new (void)
+{
+    XfpmBattery *battery = NULL;
+    
+    battery = g_object_new (XFPM_TYPE_BATTERY, NULL);
+    
+    return GTK_STATUS_ICON (battery);
+}
+
+void xfpm_battery_monitor_device (XfpmBattery *battery,
+				  DBusGProxy *proxy,
+				  DBusGProxy *proxy_prop,
+				  XfpmDeviceType device_type)
+{
+    battery->priv->type = device_type;
+    battery->priv->proxy_prop = proxy_prop;
+    battery->priv->proxy = proxy;
+    battery->priv->icon_prefix = xfpm_battery_get_icon_prefix_device_enum_type (device_type);
+    battery->priv->battery_name = xfpm_battery_get_name (device_type);
+    
+    
+    dbus_g_proxy_add_signal (proxy, "Changed", G_TYPE_INVALID);
+    dbus_g_proxy_connect_signal (proxy, "Changed",
+				 G_CALLBACK (xfpm_battery_changed_cb), battery, NULL);
+
+    g_object_set (G_OBJECT (battery),
+		  "has-tooltip", TRUE,
+		  NULL);
+
+    xfpm_battery_changed_cb (proxy, battery);
+}
+
+XfpmDeviceType xfpm_battery_get_device_type (XfpmBattery *battery)
+{
+    g_return_val_if_fail (XFPM_IS_BATTERY (battery), XFPM_DEVICE_TYPE_UNKNOWN );
+    
+    return battery->priv->type;
+}
+
+XfpmBatteryCharge xfpm_battery_get_charge (XfpmBattery *battery)
+{
+    g_return_val_if_fail (XFPM_IS_BATTERY (battery), XFPM_BATTERY_CHARGE_UNKNOWN);
+    
+    return battery->priv->charge;
+}
+
+const gchar *xfpm_battery_get_battery_name (XfpmBattery *battery)
+{
+    g_return_val_if_fail (XFPM_IS_BATTERY (battery), NULL);
+    
+    return battery->priv->battery_name;
+}
+
+gchar *xfpm_battery_get_time_left (XfpmBattery *battery)
+{
+    g_return_val_if_fail (XFPM_IS_BATTERY (battery), NULL);
+    
+    return xfpm_battery_get_time_string (battery->priv->time_to_empty);
+}

=== added file '.pc/03_fix-insert-battery.patch/src/xfpm-power.c'
--- .pc/03_fix-insert-battery.patch/src/xfpm-power.c	1970-01-01 00:00:00 +0000
+++ .pc/03_fix-insert-battery.patch/src/xfpm-power.c	2013-08-12 21:07:54 +0000
@@ -0,0 +1,1755 @@
+/*
+ * * Copyright (C) 2009-2011 Ali <[e-mail]>
+ *
+ * Licensed under the GNU General Public License Version 2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include <libxfce4util/libxfce4util.h>
+#include <libxfce4ui/libxfce4ui.h>
+
+#include "xfpm-power.h"
+#include "xfpm-dbus.h"
+#include "xfpm-dpms.h"
+#include "xfpm-battery.h"
+#include "xfpm-xfconf.h"
+#include "xfpm-notify.h"
+#include "xfpm-errors.h"
+#include "xfpm-console-kit.h"
+#include "xfpm-inhibit.h"
+#include "xfpm-polkit.h"
+#include "xfpm-network-manager.h"
+#include "xfpm-icons.h"
+#include "xfpm-common.h"
+#include "xfpm-power-common.h"
+#include "xfpm-config.h"
+#include "xfpm-debug.h"
+#include "xfpm-enum-types.h"
+#include "egg-idletime.h"
+
+static void xfpm_power_finalize     (GObject *object);
+
+static void xfpm_power_get_property (GObject *object,
+				     guint prop_id,
+				     GValue *value,
+				     GParamSpec *pspec);
+
+static void xfpm_power_dbus_class_init (XfpmPowerClass * klass);
+static void xfpm_power_dbus_init (XfpmPower *power);
+
+static void xfpm_power_refresh_adaptor_visible (XfpmPower *power);
+
+#define XFPM_POWER_GET_PRIVATE(o) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((o), XFPM_TYPE_POWER, XfpmPowerPrivate))
+
+struct XfpmPowerPrivate
+{
+    DBusGConnection *bus;
+    
+    DBusGProxy      *proxy;
+    DBusGProxy      *proxy_prop;
+    
+    GHashTable      *hash;
+    
+    XfpmConsoleKit  *console;
+    XfpmInhibit	    *inhibit;
+    XfpmXfconf      *conf;
+    GtkStatusIcon   *adapter_icon;
+    
+    XfpmBatteryCharge overall_state;
+    gboolean         critical_action_done;
+    
+    XfpmPowerMode    power_mode;
+    EggIdletime     *idletime;
+    
+    gboolean	     inhibited;
+    
+    XfpmNotify	    *notify;
+#ifdef ENABLE_POLKIT
+    XfpmPolkit 	    *polkit;
+#endif
+    gboolean	     auth_suspend;
+    gboolean	     auth_hibernate;
+
+    /* Properties */
+    gboolean	     on_low_battery;
+    gboolean	     lid_is_present;
+    gboolean         lid_is_closed;
+    gboolean	     on_battery;
+    gchar           *daemon_version;
+    gboolean	     can_suspend;
+    gboolean         can_hibernate;
+    
+    /**
+     * Warning dialog to use when notification daemon 
+     * doesn't support actions.
+     **/
+    GtkWidget 	    *dialog;
+};
+
+enum
+{
+    PROP_0,
+    PROP_ON_LOW_BATTERY,
+    PROP_ON_BATTERY,
+    PROP_AUTH_SUSPEND,
+    PROP_AUTH_HIBERNATE,
+    PROP_CAN_SUSPEND,
+    PROP_CAN_HIBERNATE,
+    PROP_HAS_LID
+};
+
+enum
+{
+    ON_BATTERY_CHANGED,
+    LOW_BATTERY_CHANGED,
+    LID_CHANGED,
+    WAKING_UP,
+    SLEEPING,
+    ASK_SHUTDOWN,
+    SHUTDOWN,
+    LAST_SIGNAL
+};
+
+static guint signals [LAST_SIGNAL] = { 0 };
+
+
+G_DEFINE_TYPE (XfpmPower, xfpm_power, G_TYPE_OBJECT)
+
+#ifdef ENABLE_POLKIT
+static void
+xfpm_power_check_polkit_auth (XfpmPower *power)
+{
+    power->priv->auth_suspend = xfpm_polkit_check_auth (power->priv->polkit, 
+							POLKIT_AUTH_SUSPEND);
+
+    power->priv->auth_hibernate = xfpm_polkit_check_auth (power->priv->polkit, 
+							  POLKIT_AUTH_HIBERNATE);
+
+}
+#endif
+
+static void
+xfpm_power_check_pm (XfpmPower *power, GHashTable *props)
+{
+    GValue *value;
+    gboolean ret;
+    
+    value = g_hash_table_lookup (props, "CanSuspend");
+    
+    if (value == NULL) 
+    {
+	g_warning ("No 'CanSuspend' property");
+    }
+    ret = g_value_get_boolean (value);
+    
+    if (ret != power->priv->can_suspend) 
+    {
+	power->priv->can_suspend = ret;
+    }
+
+    value = g_hash_table_lookup (props, "CanHibernate");
+    
+    if (value == NULL) 
+    {
+	g_warning ("No 'CanHibernate' property");
+    }
+    
+    ret = g_value_get_boolean (value);
+    
+    if (ret != power->priv->can_hibernate) 
+    {
+	power->priv->can_hibernate = ret;
+    }
+}
+
+static void
+xfpm_power_check_power (XfpmPower *power, GHashTable *props)
+{
+    GValue *value;
+    gboolean on_battery;
+    
+    value = g_hash_table_lookup (props, "OnBattery");
+    
+    if (G_LIKELY (value)) 
+    {
+	on_battery = g_value_get_boolean (value);
+    
+	if (on_battery != power->priv->on_battery ) 
+	{
+	    GList *list;
+	    guint len, i;
+	    g_signal_emit (G_OBJECT (power), signals [ON_BATTERY_CHANGED], 0, on_battery);
+	    power->priv->on_battery = on_battery;
+	    list = g_hash_table_get_values (power->priv->hash);
+	    len = g_list_length (list);
+	    for ( i = 0; i < len; i++)
+	    {
+		g_object_set (G_OBJECT (g_list_nth_data (list, i)), 
+			      "ac-online", !on_battery,
+			      NULL);
+	    }
+	}
+    }
+    else
+    {
+	g_warning ("No 'OnBattery' property");
+    }
+}
+
+static void
+xfpm_power_check_lid (XfpmPower *power, GHashTable *props)
+{
+    GValue *value;
+    
+    value = g_hash_table_lookup (props, "LidIsPresent");
+    
+    if (value == NULL) 
+    {
+	g_warning ("No 'LidIsPresent' property");
+	return;
+    }
+
+    power->priv->lid_is_present = g_value_get_boolean (value);
+
+    if (power->priv->lid_is_present) 
+    {
+	gboolean closed;
+	
+	value = g_hash_table_lookup (props, "LidIsClosed");
+    
+	if (value == NULL) 
+	{
+	    g_warning ("No 'LidIsClosed' property");
+	    return;
+	}
+	
+	closed = g_value_get_boolean (value);
+	
+	if (closed != power->priv->lid_is_closed ) 
+	{
+	    power->priv->lid_is_closed = closed;
+	    g_signal_emit (G_OBJECT (power), signals [LID_CHANGED], 0, power->priv->lid_is_closed);
+	}
+    }
+}
+
+/*
+ * Get the properties on org.freedesktop.DeviceKit.Power
+ * 
+ * DaemonVersion      's'
+ * CanSuspend'        'b'
+ * CanHibernate'      'b'
+ * OnBattery'         'b'
+ * OnLowBattery'      'b'
+ * LidIsClosed'       'b'
+ * LidIsPresent'      'b'
+ */
+static void
+xfpm_power_get_properties (XfpmPower *power)
+{
+    GHashTable *props;
+    
+    props = xfpm_power_get_interface_properties (power->priv->proxy_prop, UPOWER_IFACE);
+    
+    xfpm_power_check_pm (power, props);
+    xfpm_power_check_lid (power, props);
+    xfpm_power_check_power (power, props);
+
+    g_hash_table_destroy (props);
+}
+
+static void
+xfpm_power_report_error (XfpmPower *power, const gchar *error, const gchar *icon_name)
+{
+    GtkStatusIcon *battery = NULL;
+    guint i, len;
+    GList *list;
+    
+    list = g_hash_table_get_values (power->priv->hash);
+    len = g_list_length (list);
+    
+    for ( i = 0; i < len; i++)
+    {
+	XfpmDeviceType type;
+	battery = g_list_nth_data (list, i);
+	type = xfpm_battery_get_device_type (XFPM_BATTERY (battery));
+	if ( type == XFPM_DEVICE_TYPE_BATTERY ||
+	     type == XFPM_DEVICE_TYPE_UPS )
+	     break;
+    }
+    
+    xfpm_notify_show_notification (power->priv->notify, 
+				   _("Power Manager"), 
+				   error, 
+				   icon_name,
+				   10000,
+				   FALSE,
+				   XFPM_NOTIFY_CRITICAL,
+				   battery);
+    
+}
+
+static void
+xfpm_power_sleep (XfpmPower *power, const gchar *sleep_time, gboolean force)
+{
+    GError *error = NULL;
+    gboolean lock_screen;
+    
+    if ( power->priv->inhibited && force == FALSE)
+    {
+	gboolean ret;
+
+	ret = xfce_dialog_confirm (NULL,
+				   GTK_STOCK_OK, _("_Hibernate"),
+				   _("An application is currently disabling the automatic sleep. "
+				     "Doing this action now may damage the working state of this application."),
+				   _("Are you sure you want to hibernate the system?"));
+
+	if ( !ret )
+	    return;
+    }
+    
+    g_signal_emit (G_OBJECT (power), signals [SLEEPING], 0);
+    xfpm_network_manager_sleep (TRUE);
+        
+    g_object_get (G_OBJECT (power->priv->conf),
+		  LOCK_SCREEN_ON_SLEEP, &lock_screen,
+		  NULL);
+    
+    if ( lock_screen )
+    {
+	g_usleep (2000000); /* 2 seconds */
+	xfpm_lock_screen ();
+    }
+    
+    dbus_g_proxy_call (power->priv->proxy, sleep_time, &error,
+		       G_TYPE_INVALID,
+		       G_TYPE_INVALID);
+    
+    if ( error )
+    {
+	if ( g_error_matches (error, DBUS_GERROR, DBUS_GERROR_NO_REPLY) )
+	{
+	    XFPM_DEBUG ("D-Bus time out, but should be harmless");
+	}
+	else
+	{
+	    const gchar *icon_name;
+	    if ( !g_strcmp0 (sleep_time, "Hibernate") )
+		icon_name = XFPM_HIBERNATE_ICON;
+	    else
+		icon_name = XFPM_SUSPEND_ICON;
+	    
+	    xfpm_power_report_error (power, error->message, icon_name);
+	    g_error_free (error);
+	}
+    }
+    
+    g_signal_emit (G_OBJECT (power), signals [WAKING_UP], 0);
+    xfpm_network_manager_sleep (FALSE);
+}
+
+static void
+xfpm_power_hibernate_cb (XfpmPower *power)
+{
+    xfpm_power_sleep (power, "Hibernate", FALSE);
+}
+
+static void
+xfpm_power_suspend_cb (XfpmPower *power)
+{
+    xfpm_power_sleep (power, "Suspend", FALSE);
+}
+
+static void
+xfpm_power_hibernate_clicked (XfpmPower *power)
+{
+    gtk_widget_destroy (power->priv->dialog );
+    power->priv->dialog = NULL;
+    xfpm_power_sleep (power, "Hibernate", TRUE);
+}
+
+static void
+xfpm_power_suspend_clicked (XfpmPower *power)
+{
+    gtk_widget_destroy (power->priv->dialog );
+    power->priv->dialog = NULL;
+    xfpm_power_sleep (power, "Suspend", TRUE);
+}
+
+static void
+xfpm_power_shutdown_clicked (XfpmPower *power)
+{
+    gtk_widget_destroy (power->priv->dialog );
+    power->priv->dialog = NULL;
+    g_signal_emit (G_OBJECT (power), signals [SHUTDOWN], 0);
+}
+
+static void
+xfpm_power_power_info_cb (gpointer data)
+{
+    g_spawn_command_line_async ("xfce4-power-information", NULL);
+}
+
+static void
+xfpm_power_tray_exit_activated_cb (gpointer data)
+{
+    gboolean ret;
+    
+    ret = xfce_dialog_confirm (NULL, 
+			       GTK_STOCK_YES, 
+			       _("Quit"),
+			       _("All running instances of the power manager will exit"),
+			       "%s",
+			        _("Quit the power manager?"));
+    if ( ret )
+    {
+	xfpm_quit ();
+    }
+}
+
+
+static void
+xfpm_power_change_mode (XfpmPower *power, XfpmPowerMode mode)
+{
+#ifdef HAVE_DPMS
+    XfpmDpms *dpms;
+    
+    power->priv->power_mode = mode;
+    
+    dpms = xfpm_dpms_new ();
+    xfpm_dpms_refresh (dpms);
+    g_object_unref (dpms);
+    
+    if (mode == XFPM_POWER_MODE_NORMAL)
+    {
+	EggIdletime *idletime;
+	idletime = egg_idletime_new ();
+	egg_idletime_alarm_reset_all (idletime);
+    
+	g_object_unref (idletime);
+    }
+#endif
+}
+
+static void
+xfpm_power_normal_mode_cb (XfpmPower *power)
+{
+    xfpm_power_change_mode (power, XFPM_POWER_MODE_NORMAL);
+}
+
+static void
+xfpm_power_presentation_mode_cb (XfpmPower *power)
+{
+    xfpm_power_change_mode (power, XFPM_POWER_MODE_PRESENTATION);
+}
+
+static void
+xfpm_power_show_tray_menu (XfpmPower *power, 
+			 GtkStatusIcon *icon, 
+			 guint button, 
+			 guint activate_time,
+			 gboolean show_info_item)
+{
+    GtkWidget *menu, *mi, *img, *subm;
+
+    menu = gtk_menu_new();
+
+    // Hibernate menu option
+    mi = gtk_image_menu_item_new_with_label (_("Hibernate"));
+    img = gtk_image_new_from_icon_name (XFPM_HIBERNATE_ICON, GTK_ICON_SIZE_MENU);
+    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
+    gtk_widget_set_sensitive (mi, FALSE);
+    
+    if ( power->priv->can_hibernate && power->priv->auth_hibernate)
+    {
+	gtk_widget_set_sensitive (mi, TRUE);
+	g_signal_connect_swapped (G_OBJECT (mi), "activate",
+				  G_CALLBACK (xfpm_power_hibernate_cb), power);
+    }
+    gtk_widget_show (mi);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+    
+    // Suspend menu option
+    mi = gtk_image_menu_item_new_with_label (_("Suspend"));
+    img = gtk_image_new_from_icon_name (XFPM_SUSPEND_ICON, GTK_ICON_SIZE_MENU);
+    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
+    
+    gtk_widget_set_sensitive (mi, FALSE);
+    
+    if ( power->priv->can_suspend && power->priv->auth_hibernate)
+    {
+	gtk_widget_set_sensitive (mi, TRUE);
+	g_signal_connect_swapped (mi, "activate",
+				  G_CALLBACK (xfpm_power_suspend_cb), power);
+    }
+    
+    gtk_widget_show (mi);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+/*
+    saver_inhibited = xfpm_screen_saver_get_inhibit (tray->priv->srv);
+    mi = gtk_check_menu_item_new_with_label (_("Monitor power control"));
+    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), !saver_inhibited);
+    gtk_widget_set_tooltip_text (mi, _("Disable or enable monitor power control, "\
+                                       "for example you could disable the screen power "\
+				       "control to avoid screen blanking when watching a movie."));
+    
+    g_signal_connect (G_OBJECT (mi), "activate",
+		      G_CALLBACK (xfpm_tray_icon_inhibit_active_cb), tray);
+    gtk_widget_set_sensitive (mi, TRUE);
+    gtk_widget_show(mi);
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu),mi);
+*/
+    
+    mi = gtk_separator_menu_item_new ();
+    gtk_widget_show (mi);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+    // Power information
+    mi = gtk_image_menu_item_new_with_label (_("Power Information"));
+    img = gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_MENU);
+    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
+
+    gtk_widget_set_sensitive (mi,TRUE);
+    
+    g_signal_connect_swapped (mi, "activate",
+			      G_CALLBACK (xfpm_power_power_info_cb), icon);
+		     
+    gtk_widget_show (mi);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+    
+    /** 
+     * Power Mode
+     **/
+    /* TRANSLATOR: Mode here is the power profile (presentation, power save, normal) */
+    mi = gtk_image_menu_item_new_with_label (_("Mode"));
+    img = gtk_image_new_from_icon_name (XFPM_AC_ADAPTER_ICON, GTK_ICON_SIZE_MENU);
+    gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), img);
+    gtk_widget_set_sensitive (mi,TRUE);
+    gtk_widget_show (mi);
+    
+    subm = gtk_menu_new ();
+    gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), subm);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+    
+    /* Normal*/
+    mi = gtk_check_menu_item_new_with_label (_("Normal"));
+    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), power->priv->power_mode == XFPM_POWER_MODE_NORMAL);
+    gtk_widget_set_sensitive (mi,TRUE);
+    
+    g_signal_connect_swapped (mi, "activate",
+			      G_CALLBACK (xfpm_power_normal_mode_cb), power);
+    gtk_widget_show (mi);
+    gtk_menu_shell_append (GTK_MENU_SHELL (subm), mi);
+    
+    /* Normal*/
+    mi = gtk_check_menu_item_new_with_label (_("Presentation"));
+    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi), power->priv->power_mode == XFPM_POWER_MODE_PRESENTATION);
+    gtk_widget_set_sensitive (mi, TRUE);
+    
+    g_signal_connect_swapped (mi, "activate",
+			      G_CALLBACK (xfpm_power_presentation_mode_cb), power);
+    gtk_widget_show (mi);
+    gtk_menu_shell_append (GTK_MENU_SHELL (subm), mi);
+    
+    
+    mi = gtk_separator_menu_item_new ();
+    gtk_widget_show (mi);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+		     
+    mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_HELP, NULL);
+    gtk_widget_set_sensitive (mi, TRUE);
+    gtk_widget_show (mi);
+    g_signal_connect (mi, "activate", G_CALLBACK (xfpm_help), NULL);
+	
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+    
+    mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_ABOUT, NULL);
+    gtk_widget_set_sensitive (mi, TRUE);
+    gtk_widget_show (mi);
+    g_signal_connect (mi, "activate", G_CALLBACK (xfpm_about), _("Power Manager"));
+    
+    gtk_menu_shell_append (GTK_MENU_SHELL(menu), mi);
+    
+    mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_PREFERENCES, NULL);
+    gtk_widget_set_sensitive (mi, TRUE);
+    gtk_widget_show (mi);
+    g_signal_connect (mi, "activate",G_CALLBACK (xfpm_preferences), NULL);
+    
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+    mi = gtk_separator_menu_item_new ();
+    gtk_widget_show (mi);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+    mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL);
+    gtk_widget_set_sensitive (mi, TRUE);
+    gtk_widget_show (mi);
+    g_signal_connect_swapped (mi, "activate", G_CALLBACK (xfpm_power_tray_exit_activated_cb), NULL);
+    gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
+
+    g_signal_connect (menu, "selection-done",
+		      G_CALLBACK (gtk_widget_destroy), NULL);
+
+    // Popup the menu
+    gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
+		   gtk_status_icon_position_menu, 
+		   icon, button, activate_time);
+    
+}
+
+static void 
+xfpm_power_show_tray_menu_battery (GtkStatusIcon *icon, guint button, 
+			         guint activate_time, XfpmPower *power)
+{
+    xfpm_power_show_tray_menu (power, icon, button, activate_time, TRUE);
+}
+
+static void 
+xfpm_power_show_tray_menu_adaptor (GtkStatusIcon *icon, guint button, 
+			         guint activate_time, XfpmPower *power)
+{
+    xfpm_power_show_tray_menu (power, icon, button, activate_time, FALSE);
+}
+
+static XfpmBatteryCharge
+xfpm_power_get_current_charge_state (XfpmPower *power)
+{
+    GList *list;
+    guint len, i;
+    XfpmBatteryCharge max_charge_status = XFPM_BATTERY_CHARGE_UNKNOWN;
+    
+    list = g_hash_table_get_values (power->priv->hash);
+    len = g_list_length (list);
+    
+    for ( i = 0; i < len; i++)
+    {
+	XfpmBatteryCharge battery_charge;
+	XfpmDeviceType type;
+	
+	g_object_get (G_OBJECT (g_list_nth_data (list, i)),
+		      "charge-status", &battery_charge,
+		      "device-type", &type,
+		      NULL);
+	if ( type != XFPM_DEVICE_TYPE_BATTERY && 
+	     type != XFPM_DEVICE_TYPE_UPS )
+	    continue;
+	
+	max_charge_status = MAX (max_charge_status, battery_charge);
+    }
+    
+    return max_charge_status;
+}
+
+static void
+xfpm_power_notify_action_callback (NotifyNotification *n, gchar *action, XfpmPower *power)
+{
+    if ( !g_strcmp0 (action, "Shutdown") )
+	g_signal_emit (G_OBJECT (power), signals [SHUTDOWN], 0);
+    else
+	xfpm_power_sleep (power, action, TRUE);
+}
+
+static void
+xfpm_power_add_actions_to_notification (XfpmPower *power, NotifyNotification *n)
+{
+    gboolean can_shutdown;
+    
+    g_object_get (G_OBJECT (power->priv->console),
+		  "can-shutdown", &can_shutdown,
+		  NULL);
+		  
+    if (  power->priv->can_hibernate && power->priv->auth_hibernate )
+    {
+        xfpm_notify_add_action_to_notification(
+			       power->priv->notify,
+			       n,
+                               "Hibernate",
+                               _("Hibernate the system"),
+                               (NotifyActionCallback)xfpm_power_notify_action_callback,
+                               power);      
+    }
+    
+    if (  power->priv->can_suspend && power->priv->auth_suspend )
+    {
+        xfpm_notify_add_action_to_notification(
+			       power->priv->notify,
+			       n,
+                               "Suspend",
+                               _("Suspend the system"),
+                               (NotifyActionCallback)xfpm_power_notify_action_callback,
+                               power);      
+    }
+    
+    if (can_shutdown )
+	xfpm_notify_add_action_to_notification(
+				   power->priv->notify,
+				   n,
+				   "Shutdown",
+				   _("Shutdown the system"),
+				   (NotifyActionCallback)xfpm_power_notify_action_callback,
+				   power);    
+}
+
+static void
+xfpm_power_show_critical_action_notification (XfpmPower *power, XfpmBattery *battery)
+{
+    const gchar *message;
+    NotifyNotification *n;
+    
+    message = _("System is running on low power. "\
+               "Save your work to avoid losing data");
+	      
+    n = 
+	xfpm_notify_new_notification (power->priv->notify, 
+				      _("Power Manager"), 
+				      message, 
+				      gtk_status_icon_get_icon_name (GTK_STATUS_ICON (battery)),
+				      20000,
+				      XFPM_NOTIFY_CRITICAL,
+				      GTK_STATUS_ICON (battery));
+    
+    xfpm_power_add_actions_to_notification (power, n);
+    xfpm_notify_critical (power->priv->notify, n);
+
+}
+
+static void
+xfpm_power_close_critical_dialog (XfpmPower *power)
+{
+    gtk_widget_destroy (power->priv->dialog);
+    power->priv->dialog = NULL;
+}
+
+static void
+xfpm_power_show_critical_action_gtk (XfpmPower *power)
+{
+    GtkWidget *dialog;
+    GtkWidget *content_area;
+    GtkWidget *img;
+    GtkWidget *cancel;
+    const gchar *message;
+    gboolean can_shutdown;
+    
+    g_object_get (G_OBJECT (power->priv->console),
+		  "can-shutdown", &can_shutdown,
+		  NULL);
+    
+    message = _("System is running on low power. "\
+               "Save your work to avoid losing data");
+    
+    dialog = gtk_dialog_new_with_buttons (_("Power Manager"), NULL, GTK_DIALOG_MODAL,
+                                          NULL);
+    
+    gtk_dialog_set_default_response (GTK_DIALOG (dialog),
+                                     GTK_RESPONSE_CANCEL);
+    
+    content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
+
+    gtk_box_pack_start_defaults (GTK_BOX (content_area), gtk_label_new (message));
+    
+    if ( power->priv->can_hibernate && power->priv->auth_hibernate )
+    {
+	GtkWidget *hibernate;
+	hibernate = gtk_button_new_with_label (_("Hibernate"));
+	img = gtk_image_new_from_icon_name (XFPM_HIBERNATE_ICON, GTK_ICON_SIZE_BUTTON);
+	gtk_button_set_image (GTK_BUTTON (hibernate), img);
+	gtk_dialog_add_action_widget (GTK_DIALOG (dialog), hibernate, GTK_RESPONSE_NONE);
+	
+	g_signal_connect_swapped (hibernate, "clicked",
+			          G_CALLBACK (xfpm_power_hibernate_clicked), power);
+    }
+    
+    if ( power->priv->can_suspend && power->priv->auth_suspend )
+    {
+	GtkWidget *suspend;
+	
+	suspend = gtk_button_new_with_label (_("Suspend"));
+	img = gtk_image_new_from_icon_name (XFPM_SUSPEND_ICON, GTK_ICON_SIZE_BUTTON);
+	gtk_button_set_image (GTK_BUTTON (suspend), img);
+	gtk_dialog_add_action_widget (GTK_DIALOG (dialog), suspend, GTK_RESPONSE_NONE);
+	
+	g_signal_connect_swapped (suspend, "clicked",
+			          G_CALLBACK (xfpm_power_suspend_clicked), power);
+    }
+    
+    if ( can_shutdown )
+    {
+	GtkWidget *shutdown;
+	
+	shutdown = gtk_button_new_with_label (_("Shutdown"));
+	img = gtk_image_new_from_icon_name (XFPM_SUSPEND_ICON, GTK_ICON_SIZE_BUTTON);
+	gtk_button_set_image (GTK_BUTTON (shutdown), img);
+	gtk_dialog_add_action_widget (GTK_DIALOG (dialog), shutdown, GTK_RESPONSE_NONE);
+	
+	g_signal_connect_swapped (shutdown, "clicked",
+			          G_CALLBACK (xfpm_power_shutdown_clicked), power);
+    }
+    
+    cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
+    gtk_dialog_add_action_widget (GTK_DIALOG (dialog), cancel, GTK_RESPONSE_NONE);
+    
+    g_signal_connect_swapped (cancel, "clicked",
+			      G_CALLBACK (xfpm_power_close_critical_dialog), power);
+    
+    g_signal_connect_swapped (dialog, "destroy",
+			      G_CALLBACK (xfpm_power_close_critical_dialog), power);
+    if ( power->priv->dialog )
+    {
+	gtk_widget_destroy (power->priv->dialog);
+	power->priv->dialog = NULL;
+	
+    }
+    power->priv->dialog = dialog;
+    gtk_widget_show_all (dialog);
+}
+
+static void
+xfpm_power_show_critical_action (XfpmPower *power, XfpmBattery *battery)
+{
+    gboolean supports_actions;
+    
+    g_object_get (G_OBJECT (power->priv->notify),
+		  "actions", &supports_actions,
+		  NULL);
+		  
+    if ( supports_actions )
+	xfpm_power_show_critical_action_notification (power, battery);
+    else
+	xfpm_power_show_critical_action_gtk (power);
+}
+
+static void
+xfpm_power_process_critical_action (XfpmPower *power, XfpmShutdownRequest req)
+{
+    if ( req == XFPM_ASK )
+	g_signal_emit (G_OBJECT (power), signals [ASK_SHUTDOWN], 0);
+    else if ( req == XFPM_DO_SUSPEND )
+	xfpm_power_sleep (power, "Suspend", TRUE);
+    else if ( req == XFPM_DO_HIBERNATE )
+	xfpm_power_sleep (power, "Hibernate", TRUE);
+    else if ( req == XFPM_DO_SHUTDOWN )
+	g_signal_emit (G_OBJECT (power), signals [SHUTDOWN], 0);
+}
+
+static void
+xfpm_power_system_on_critical_power (XfpmPower *power, XfpmBattery *battery)
+{
+    XfpmShutdownRequest critical_action;
+    
+    g_object_get (G_OBJECT (power->priv->conf),
+	          CRITICAL_BATT_ACTION_CFG, &critical_action,
+		  NULL);
+
+    XFPM_DEBUG ("System is running on low power");
+    XFPM_DEBUG_ENUM (critical_action, XFPM_TYPE_SHUTDOWN_REQUEST, "Critical battery action");
+
+    if ( critical_action == XFPM_DO_NOTHING )
+    {
+	xfpm_power_show_critical_action (power, battery);
+    }
+    else
+    {
+	if (power->priv->critical_action_done == FALSE)
+	{
+	    power->priv->critical_action_done = TRUE;
+	    xfpm_power_process_critical_action (power, critical_action);
+	}
+	else
+	{
+	    xfpm_power_show_critical_action (power, battery);
+	}
+    }
+}
+
+static void
+xfpm_power_battery_charge_changed_cb (XfpmBattery *battery, XfpmPower *power)
+{
+    gboolean notify;
+    XfpmBatteryCharge battery_charge;
+    XfpmBatteryCharge current_charge;
+    
+    battery_charge = xfpm_battery_get_charge (battery);
+    current_charge = xfpm_power_get_current_charge_state (power);
+    
+    XFPM_DEBUG_ENUM (current_charge, XFPM_TYPE_BATTERY_CHARGE, "Current system charge status");
+    
+    if (current_charge == power->priv->overall_state)
+	return;
+    
+    if (current_charge >= XFPM_BATTERY_CHARGE_LOW)
+	power->priv->critical_action_done = FALSE;
+    
+    power->priv->overall_state = current_charge;
+    
+    if ( current_charge == XFPM_BATTERY_CHARGE_CRITICAL && power->priv->on_battery)
+    {
+	xfpm_power_system_on_critical_power (power, battery);
+	
+	power->priv->on_low_battery = TRUE;
+	g_signal_emit (G_OBJECT (power), signals [LOW_BATTERY_CHANGED], 0, power->priv->on_low_battery);
+	return;
+    }
+    
+    if ( power->priv->on_low_battery )
+    {
+	power->priv->on_low_battery = FALSE;
+	g_signal_emit (G_OBJECT (power), signals [LOW_BATTERY_CHANGED], 0, power->priv->on_low_battery);
+    }
+    
+    g_object_get (G_OBJECT (power->priv->conf),
+		  GENERAL_NOTIFICATION_CFG, &notify,
+		  NULL);
+    
+    if ( power->priv->on_battery )
+    {
+	if ( current_charge == XFPM_BATTERY_CHARGE_LOW )
+	{
+	    if ( notify )
+		xfpm_notify_show_notification (power->priv->notify, 
+					       _("Power Manager"), 
+					       _("System is running on low power"), 
+					       gtk_status_icon_get_icon_name (GTK_STATUS_ICON (battery)),
+					       10000,
+					       FALSE,
+					       XFPM_NOTIFY_NORMAL,
+					       GTK_STATUS_ICON (battery));
+	    
+	}
+	else if ( battery_charge == XFPM_BATTERY_CHARGE_LOW )
+	{
+	    if ( notify )
+	    {
+		gchar *msg;
+		gchar *time_str;
+		
+		const gchar *battery_name = xfpm_battery_get_battery_name (battery);
+		
+		time_str = xfpm_battery_get_time_left (battery);
+		
+		msg = g_strdup_printf (_("Your %s charge level is low\nEstimated time left %s"), battery_name, time_str);
+		
+		
+		xfpm_notify_show_notification (power->priv->notify, 
+					       _("Power Manager"), 
+					       msg, 
+					       gtk_status_icon_get_icon_name (GTK_STATUS_ICON (battery)),
+					       10000,
+					       FALSE,
+					       XFPM_NOTIFY_NORMAL,
+					       GTK_STATUS_ICON (battery));
+		g_free (msg);
+		g_free (time_str);
+	    }
+	}
+    }
+    
+    /*Current charge is okay now, then close the dialog*/
+    if ( power->priv->dialog )
+    {
+	gtk_widget_destroy (power->priv->dialog);
+	power->priv->dialog = NULL;
+    }
+}
+
+static void
+xfpm_power_add_device (XfpmPower *power, const gchar *object_path)
+{
+    DBusGProxy *proxy_prop;
+    guint device_type = XFPM_DEVICE_TYPE_UNKNOWN;
+    GValue value;
+    
+    proxy_prop = dbus_g_proxy_new_for_name (power->priv->bus, 
+					    UPOWER_NAME,
+					    object_path,
+					    DBUS_INTERFACE_PROPERTIES);
+				       
+    if ( !proxy_prop )
+    {
+	g_warning ("Unable to create proxy for : %s", object_path);
+	return;
+    }
+    
+    value = xfpm_power_get_interface_property (proxy_prop, UPOWER_IFACE_DEVICE, "Type");
+    
+    device_type = g_value_get_uint (&value);
+    
+    XFPM_DEBUG_ENUM (device_type, XFPM_TYPE_DEVICE_TYPE, " device added");
+    
+    if ( device_type == XFPM_DEVICE_TYPE_BATTERY || 
+	 device_type == XFPM_DEVICE_TYPE_UPS     ||
+	 device_type == XFPM_DEVICE_TYPE_MOUSE   ||
+	 device_type == XFPM_DEVICE_TYPE_KBD     ||
+	 device_type == XFPM_DEVICE_TYPE_PHONE)
+    {
+	GtkStatusIcon *battery;
+	DBusGProxy *proxy;
+	XFPM_DEBUG_ENUM (device_type, XFPM_TYPE_DEVICE_TYPE, 
+			"Battery device detected at : %s", object_path);
+	proxy = dbus_g_proxy_new_for_name (power->priv->bus,
+					   UPOWER_NAME,
+					   object_path,
+					   UPOWER_IFACE_DEVICE);
+	battery = xfpm_battery_new ();
+	gtk_status_icon_set_visible (battery, FALSE);
+	xfpm_battery_monitor_device (XFPM_BATTERY (battery), 
+				     proxy, 
+				     proxy_prop, 
+				     device_type);
+
+	g_hash_table_insert (power->priv->hash, g_strdup (object_path), battery);
+	
+	g_signal_connect (battery, "popup-menu",
+			  G_CALLBACK (xfpm_power_show_tray_menu_battery), power);
+	
+	g_signal_connect (battery, "battery-charge-changed",
+			  G_CALLBACK (xfpm_power_battery_charge_changed_cb), power);
+			  
+	xfpm_power_refresh_adaptor_visible (power);
+    }
+    else if ( device_type != XFPM_DEVICE_TYPE_LINE_POWER )
+    {
+	g_warning ("Unable to monitor unkown power device with object_path : %s", object_path);
+	g_object_unref (proxy_prop);
+    }
+}
+
+static void
+xfpm_power_get_power_devices (XfpmPower *power)
+{
+    GPtrArray *array = NULL;
+    guint i;
+    
+    array = xfpm_power_enumerate_devices (power->priv->proxy);
+    
+    if ( array )
+    {
+	for ( i = 0; i < array->len; i++)
+	{
+	    const gchar *object_path = ( const gchar *) g_ptr_array_index (array, i);
+	    XFPM_DEBUG ("Power device detected at : %s", object_path);
+	    xfpm_power_add_device (power, object_path);
+	}
+	g_ptr_array_free (array, TRUE);
+    }
+    
+}
+
+static void
+xfpm_power_remove_device (XfpmPower *power, const gchar *object_path)
+{
+    g_hash_table_remove (power->priv->hash, object_path);
+    xfpm_power_refresh_adaptor_visible (power);
+}
+
+static void
+xfpm_power_inhibit_changed_cb (XfpmInhibit *inhibit, gboolean is_inhibit, XfpmPower *power)
+{
+    power->priv->inhibited = is_inhibit;
+}
+
+static void
+xfpm_power_changed_cb (DBusGProxy *proxy, XfpmPower *power)
+{
+    xfpm_power_get_properties (power);
+    xfpm_power_refresh_adaptor_visible (power);
+}
+
+static void
+xfpm_power_device_added_cb (DBusGProxy *proxy, const gchar *object_path, XfpmPower *power)
+{
+    xfpm_power_add_device (power, object_path);
+}
+
+static void
+xfpm_power_device_removed_cb (DBusGProxy *proxy, const gchar *object_path, XfpmPower *power)
+{
+    xfpm_power_remove_device (power, object_path);
+}
+
+static void
+xfpm_power_device_changed_cb (DBusGProxy *proxy, const gchar *object_path, XfpmPower *power)
+{
+    xfpm_power_refresh_adaptor_visible (power);
+}
+
+#ifdef ENABLE_POLKIT
+static void
+xfpm_power_polkit_auth_changed_cb (XfpmPower *power)
+{
+    XFPM_DEBUG ("Auth configuration changed");
+    xfpm_power_check_polkit_auth (power);
+}
+#endif
+
+static void
+xfpm_power_hide_adapter_icon (XfpmPower *power)
+{
+     XFPM_DEBUG ("Hide adaptor icon");
+     
+    if ( power->priv->adapter_icon )
+    {
+        g_object_unref (power->priv->adapter_icon);
+        power->priv->adapter_icon = NULL;
+    }
+}
+
+static void
+xfpm_power_show_adapter_icon (XfpmPower *power)
+{
+    g_return_if_fail (power->priv->adapter_icon == NULL);
+    
+    power->priv->adapter_icon = gtk_status_icon_new ();
+    
+    XFPM_DEBUG ("Showing adaptor icon");
+    
+    gtk_status_icon_set_from_icon_name (power->priv->adapter_icon, XFPM_AC_ADAPTER_ICON);
+    
+    gtk_status_icon_set_visible (power->priv->adapter_icon, TRUE);
+    
+    g_signal_connect (power->priv->adapter_icon, "popup-menu",
+		      G_CALLBACK (xfpm_power_show_tray_menu_adaptor), power);
+}
+
+static void
+xfpm_power_refresh_adaptor_visible (XfpmPower *power)
+{
+    XfpmShowIcon show_icon;
+    
+    g_object_get (G_OBJECT (power->priv->conf),
+		  SHOW_TRAY_ICON_CFG, &show_icon,
+		  NULL);
+		  
+    XFPM_DEBUG_ENUM (show_icon, XFPM_TYPE_SHOW_ICON, "Tray icon configuration: ");
+    
+    if ( show_icon == SHOW_ICON_ALWAYS )
+    {
+	if ( g_hash_table_size (power->priv->hash) == 0 )
+	{
+	    xfpm_power_show_adapter_icon (power);
+#if GTK_CHECK_VERSION (2, 16, 0)
+	    gtk_status_icon_set_tooltip_text (power->priv->adapter_icon, 
+					      power->priv->on_battery ? 
+					      _("Adaptor is offline") :
+					      _("Adaptor is online") );
+#else
+	    gtk_status_icon_set_tooltip (power->priv->adapter_icon, 
+					 power->priv->on_battery ? 
+					 _("Adaptor is offline") :
+					 _("Adaptor is online") );
+#endif
+	}
+	else
+	{
+	    xfpm_power_hide_adapter_icon (power);
+	}
+    }
+    else
+    {
+	xfpm_power_hide_adapter_icon (power);
+    }
+}
+
+static void
+xfpm_power_class_init (XfpmPowerClass *klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+    object_class->finalize = xfpm_power_finalize;
+
+    object_class->get_property = xfpm_power_get_property;
+
+    signals [ON_BATTERY_CHANGED] = 
+        g_signal_new ("on-battery-changed",
+                      XFPM_TYPE_POWER,
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET(XfpmPowerClass, on_battery_changed),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__BOOLEAN,
+                      G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
+
+    signals [LOW_BATTERY_CHANGED] = 
+        g_signal_new ("low-battery-changed",
+                      XFPM_TYPE_POWER,
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET(XfpmPowerClass, low_battery_changed),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__BOOLEAN,
+                      G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
+
+    signals [LID_CHANGED] = 
+        g_signal_new ("lid-changed",
+                      XFPM_TYPE_POWER,
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET(XfpmPowerClass, lid_changed),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__BOOLEAN,
+                      G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
+
+    signals [WAKING_UP] = 
+        g_signal_new ("waking-up",
+                      XFPM_TYPE_POWER,
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET(XfpmPowerClass, waking_up),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__VOID,
+                      G_TYPE_NONE, 0, G_TYPE_NONE);
+
+    signals [SLEEPING] = 
+        g_signal_new ("sleeping",
+                      XFPM_TYPE_POWER,
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET(XfpmPowerClass, sleeping),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__VOID,
+                      G_TYPE_NONE, 0, G_TYPE_NONE);
+
+    signals [ASK_SHUTDOWN] = 
+        g_signal_new ("ask-shutdown",
+                      XFPM_TYPE_POWER,
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET(XfpmPowerClass, ask_shutdown),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__VOID,
+                      G_TYPE_NONE, 0, G_TYPE_NONE);
+
+    signals [SHUTDOWN] = 
+        g_signal_new ("shutdown",
+                      XFPM_TYPE_POWER,
+                      G_SIGNAL_RUN_LAST,
+                      G_STRUCT_OFFSET(XfpmPowerClass, shutdown),
+                      NULL, NULL,
+                      g_cclosure_marshal_VOID__VOID,
+                      G_TYPE_NONE, 0, G_TYPE_NONE);
+
+    g_object_class_install_property (object_class,
+                                     PROP_ON_BATTERY,
+                                     g_param_spec_boolean ("on-battery",
+                                                          NULL, NULL,
+                                                          FALSE,
+                                                          G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+                                     PROP_ON_LOW_BATTERY,
+                                     g_param_spec_boolean ("on-low-battery",
+                                                          NULL, NULL,
+                                                          FALSE,
+                                                          G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+                                     PROP_AUTH_SUSPEND,
+                                     g_param_spec_boolean ("auth-suspend",
+                                                          NULL, NULL,
+                                                          FALSE,
+                                                          G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+                                     PROP_AUTH_HIBERNATE,
+                                     g_param_spec_boolean ("auth-hibernate",
+                                                          NULL, NULL,
+                                                          FALSE,
+                                                          G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+                                     PROP_CAN_HIBERNATE,
+                                     g_param_spec_boolean ("can-hibernate",
+                                                          NULL, NULL,
+                                                          FALSE,
+                                                          G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+                                     PROP_CAN_SUSPEND,
+                                     g_param_spec_boolean ("can-suspend",
+                                                          NULL, NULL,
+                                                          FALSE,
+                                                          G_PARAM_READABLE));
+
+    g_object_class_install_property (object_class,
+                                     PROP_HAS_LID,
+                                     g_param_spec_boolean ("has-lid",
+                                                          NULL, NULL,
+                                                          FALSE,
+                                                          G_PARAM_READABLE));
+
+    g_type_class_add_private (klass, sizeof (XfpmPowerPrivate));
+    
+    xfpm_power_dbus_class_init (klass);
+}
+
+static void
+xfpm_power_init (XfpmPower *power)
+{
+    GError *error = NULL;
+    
+    power->priv = XFPM_POWER_GET_PRIVATE (power);
+    
+    power->priv->hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
+    power->priv->lid_is_present  = FALSE;
+    power->priv->lid_is_closed   = FALSE;
+    power->priv->on_battery      = FALSE;
+    power->priv->on_low_battery  = FALSE;
+    power->priv->daemon_version  = NULL;
+    power->priv->can_suspend     = FALSE;
+    power->priv->can_hibernate   = FALSE;
+    power->priv->auth_hibernate  = TRUE;
+    power->priv->auth_suspend    = TRUE;
+    power->priv->dialog          = NULL;
+    power->priv->adapter_icon    = NULL;
+    power->priv->overall_state   = XFPM_BATTERY_CHARGE_OK;
+    power->priv->critical_action_done = FALSE;
+    power->priv->power_mode      = XFPM_POWER_MODE_NORMAL;
+    
+    power->priv->inhibit = xfpm_inhibit_new ();
+    power->priv->notify  = xfpm_notify_new ();
+    power->priv->conf    = xfpm_xfconf_new ();
+    power->priv->console = xfpm_console_kit_new ();
+    
+    g_signal_connect_swapped (power->priv->conf, "notify::" SHOW_TRAY_ICON_CFG,
+			      G_CALLBACK (xfpm_power_refresh_adaptor_visible), power);
+    
+#ifdef ENABLE_POLKIT
+    power->priv->polkit  = xfpm_polkit_get ();
+    g_signal_connect_swapped (power->priv->polkit, "auth-changed",
+			      G_CALLBACK (xfpm_power_polkit_auth_changed_cb), power);
+#endif
+    
+    g_signal_connect (power->priv->inhibit, "has-inhibit-changed",
+		      G_CALLBACK (xfpm_power_inhibit_changed_cb), power);
+    
+    power->priv->bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
+    
+    if ( error )
+    {
+	g_critical ("Unable to connect to the system bus : %s", error->message);
+	g_error_free (error);
+	goto out;
+    }
+
+    power->priv->proxy = dbus_g_proxy_new_for_name (power->priv->bus,
+						    UPOWER_NAME,
+						    UPOWER_PATH,
+						    UPOWER_IFACE);
+    
+    
+    power->priv->proxy_prop = dbus_g_proxy_new_for_name (power->priv->bus,
+							 UPOWER_NAME,
+							 UPOWER_PATH,
+							 DBUS_INTERFACE_PROPERTIES);
+    if (power->priv->proxy_prop == NULL) 
+    {
+	g_critical ("Unable to create proxy for %s", UPOWER_NAME);
+	goto out;
+    }
+    
+    xfpm_power_get_power_devices (power);
+    xfpm_power_get_properties (power);
+#ifdef ENABLE_POLKIT
+    xfpm_power_check_polkit_auth (power);
+#endif
+
+    dbus_g_proxy_add_signal (power->priv->proxy, "Changed", G_TYPE_INVALID);
+    dbus_g_proxy_add_signal (power->priv->proxy, "DeviceAdded", G_TYPE_STRING, G_TYPE_INVALID);
+    dbus_g_proxy_add_signal (power->priv->proxy, "DeviceRemoved", G_TYPE_STRING, G_TYPE_INVALID);
+    dbus_g_proxy_add_signal (power->priv->proxy, "DeviceChanged", G_TYPE_STRING, G_TYPE_INVALID);
+    
+    dbus_g_proxy_connect_signal (power->priv->proxy, "Changed",
+				 G_CALLBACK (xfpm_power_changed_cb), power, NULL);
+    dbus_g_proxy_connect_signal (power->priv->proxy, "DeviceRemoved",
+				 G_CALLBACK (xfpm_power_device_removed_cb), power, NULL);
+    dbus_g_proxy_connect_signal (power->priv->proxy, "DeviceAdded",
+				 G_CALLBACK (xfpm_power_device_added_cb), power, NULL);
+   
+    dbus_g_proxy_connect_signal (power->priv->proxy, "DeviceChanged",
+				 G_CALLBACK (xfpm_power_device_changed_cb), power, NULL);
+
+    
+out:
+    xfpm_power_refresh_adaptor_visible (power);
+
+    xfpm_power_dbus_init (power);
+
+    /*
+     * Emit org.freedesktop.PowerManagement session signals on startup
+     */
+    g_signal_emit (G_OBJECT (power), signals [ON_BATTERY_CHANGED], 0, power->priv->on_battery);
+}
+
+static void xfpm_power_get_property (GObject *object,
+				   guint prop_id,
+				   GValue *value,
+				   GParamSpec *pspec)
+{
+    XfpmPower *power;
+    power = XFPM_POWER (object);
+
+    switch (prop_id)
+    {
+	case PROP_ON_BATTERY:
+	    g_value_set_boolean (value, power->priv->on_battery);
+	    break;
+	case PROP_AUTH_HIBERNATE:
+	    g_value_set_boolean (value, power->priv->auth_hibernate);
+	    break;
+	case PROP_AUTH_SUSPEND:
+	    g_value_set_boolean (value, power->priv->auth_suspend);
+	    break;
+	case PROP_CAN_SUSPEND:
+	    g_value_set_boolean (value, power->priv->can_suspend);
+	    break;
+	case PROP_CAN_HIBERNATE:
+	    g_value_set_boolean (value, power->priv->can_hibernate);
+	    break;
+	case PROP_HAS_LID:
+	    g_value_set_boolean (value, power->priv->lid_is_present);
+	    break;
+        default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+            break;
+    }
+}
+
+static void
+xfpm_power_finalize (GObject *object)
+{
+    XfpmPower *power;
+
+    power = XFPM_POWER (object);
+    
+    g_free (power->priv->daemon_version);
+    
+    g_object_unref (power->priv->inhibit);
+    g_object_unref (power->priv->notify);
+    g_object_unref (power->priv->conf);
+    g_object_unref (power->priv->console);
+    
+    xfpm_power_hide_adapter_icon (power);
+    
+    dbus_g_connection_unref (power->priv->bus);
+    
+    if ( power->priv->proxy )
+    {
+	dbus_g_proxy_disconnect_signal (power->priv->proxy, "Changed",
+					G_CALLBACK (xfpm_power_changed_cb), power);
+	dbus_g_proxy_disconnect_signal (power->priv->proxy, "DeviceRemoved",
+					G_CALLBACK (xfpm_power_device_removed_cb), power);
+	dbus_g_proxy_disconnect_signal (power->priv->proxy, "DeviceAdded",
+					G_CALLBACK (xfpm_power_device_added_cb), power);
+	dbus_g_proxy_disconnect_signal (power->priv->proxy, "DeviceChanged",
+					G_CALLBACK (xfpm_power_device_changed_cb), power);
+	g_object_unref (power->priv->proxy);
+    }
+    
+    if ( power->priv->proxy_prop )
+	g_object_unref (power->priv->proxy_prop);
+
+    g_hash_table_destroy (power->priv->hash);
+
+#ifdef ENABLE_POLKIT
+    g_object_unref (power->priv->polkit);
+#endif
+
+    G_OBJECT_CLASS (xfpm_power_parent_class)->finalize (object);
+}
+
+XfpmPower *
+xfpm_power_get (void)
+{
+    static gpointer xfpm_power_object = NULL;
+    
+    if ( G_LIKELY (xfpm_power_object != NULL ) )
+    {
+	g_object_ref (xfpm_power_object);
+    }
+    else
+    {
+	xfpm_power_object = g_object_new (XFPM_TYPE_POWER, NULL);
+	g_object_add_weak_pointer (xfpm_power_object, &xfpm_power_object);
+    }
+    
+    return XFPM_POWER (xfpm_power_object);
+}
+
+void xfpm_power_suspend (XfpmPower *power, gboolean force)
+{
+    xfpm_power_sleep (power, "Suspend", force);
+}
+
+void xfpm_power_hibernate (XfpmPower *power, gboolean force)
+{
+    xfpm_power_sleep (power, "Hibernate", force);
+}
+
+gboolean xfpm_power_has_battery (XfpmPower *power)
+{
+    GtkStatusIcon *battery = NULL;
+    guint i, len;
+    GList *list;
+    
+    gboolean ret = FALSE;
+    
+    list = g_hash_table_get_values (power->priv->hash);
+    len = g_list_length (list);
+    
+    for ( i = 0; i < len; i++)
+    {
+	XfpmDeviceType type;
+	battery = g_list_nth_data (list, i);
+	type = xfpm_battery_get_device_type (XFPM_BATTERY (battery));
+	if ( type == XFPM_DEVICE_TYPE_BATTERY ||
+	     type == XFPM_DEVICE_TYPE_UPS )
+	{
+	    ret = TRUE;
+	    break;
+	}
+    }
+    
+    return ret;
+}
+
+XfpmPowerMode  xfpm_power_get_mode (XfpmPower *power)
+{
+    g_return_val_if_fail (XFPM_IS_POWER (power), XFPM_POWER_MODE_NORMAL);
+    
+    return power->priv->power_mode;
+}
+
+/*
+ * 
+ * DBus server implementation for org.freedesktop.PowerManagement
+ * 
+ */
+static gboolean xfpm_power_dbus_shutdown (XfpmPower *power,
+				        GError **error);
+
+static gboolean xfpm_power_dbus_reboot   (XfpmPower *power,
+					GError **error);
+					   
+static gboolean xfpm_power_dbus_hibernate (XfpmPower * power,
+					 GError **error);
+
+static gboolean xfpm_power_dbus_suspend (XfpmPower * power,
+				       GError ** error);
+
+static gboolean xfpm_power_dbus_can_reboot (XfpmPower * power,
+					  gboolean * OUT_can_reboot, 
+					  GError ** error);
+
+static gboolean xfpm_power_dbus_can_shutdown (XfpmPower * power,
+					    gboolean * OUT_can_reboot, 
+					    GError ** error);
+
+static gboolean xfpm_power_dbus_can_hibernate (XfpmPower * power,
+					     gboolean * OUT_can_hibernate,
+					     GError ** error);
+
+static gboolean xfpm_power_dbus_can_suspend (XfpmPower * power,
+					   gboolean * OUT_can_suspend,
+					   GError ** error);
+
+static gboolean xfpm_power_dbus_get_power_save_status (XfpmPower * power,
+						     gboolean * OUT_save_power,
+						     GError ** error);
+
+static gboolean xfpm_power_dbus_get_on_battery (XfpmPower * power,
+					      gboolean * OUT_on_battery,
+					      GError ** error);
+
+static gboolean xfpm_power_dbus_get_low_battery (XfpmPower * power,
+					       gboolean * OUT_low_battery,
+					       GError ** error);
+
+#include "org.freedesktop.PowerManagement.h"
+
+static void
+xfpm_power_dbus_class_init (XfpmPowerClass * klass)
+{
+    dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (klass),
+                                     &dbus_glib_xfpm_power_object_info);
+}
+
+static void
+xfpm_power_dbus_init (XfpmPower *power)
+{
+    DBusGConnection *bus = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
+
+    dbus_g_connection_register_g_object (bus,
+                                         "/org/freedesktop/PowerManagement",
+                                         G_OBJECT (power));
+}
+
+static gboolean xfpm_power_dbus_shutdown (XfpmPower *power,
+				        GError **error)
+{
+    gboolean can_reboot;
+    
+    g_object_get (G_OBJECT (power->priv->console),
+		  "can-shutdown", &can_reboot,
+		  NULL);
+    
+    if ( !can_reboot)
+    {
+	g_set_error (error, XFPM_ERROR, XFPM_ERROR_PERMISSION_DENIED,
+                    _("Permission denied"));
+        return FALSE;
+    }
+    
+    xfpm_console_kit_shutdown (power->priv->console, error);
+    
+    return TRUE;
+}
+
+static gboolean xfpm_power_dbus_reboot   (XfpmPower *power,
+					GError **error)
+{
+    gboolean can_reboot;
+    
+    g_object_get (G_OBJECT (power->priv->console),
+		  "can-restart", &can_reboot,
+		  NULL);
+    
+    if ( !can_reboot)
+    {
+	g_set_error (error, XFPM_ERROR, XFPM_ERROR_PERMISSION_DENIED,
+                    _("Permission denied"));
+        return FALSE;
+    }
+    
+    xfpm_console_kit_reboot (power->priv->console, error);
+    
+    return TRUE;
+}
+					   
+static gboolean xfpm_power_dbus_hibernate (XfpmPower * power,
+					 GError **error)
+{
+    if ( !power->priv->auth_suspend )
+    {
+	g_set_error (error, XFPM_ERROR, XFPM_ERROR_PERMISSION_DENIED,
+                    _("Permission denied"));
+        return FALSE;
+	
+    }
+    
+    if (!power->priv->can_hibernate )
+    {
+	g_set_error (error, XFPM_ERROR, XFPM_ERROR_NO_HARDWARE_SUPPORT,
+                    _("Suspend not supported"));
+        return FALSE;
+    }
+    
+    xfpm_power_sleep (power, "Hibernate", FALSE);
+    
+    return TRUE;
+}
+
+static gboolean xfpm_power_dbus_suspend (XfpmPower * power,
+				       GError ** error)
+{
+    if ( !power->priv->auth_suspend )
+    {
+	g_set_error (error, XFPM_ERROR, XFPM_ERROR_PERMISSION_DENIED,
+                    _("Permission denied"));
+        return FALSE;
+	
+    }
+    
+    if (!power->priv->can_suspend )
+    {
+	g_set_error (error, XFPM_ERROR, XFPM_ERROR_NO_HARDWARE_SUPPORT,
+                    _("Suspend not supported"));
+        return FALSE;
+    }
+    
+    xfpm_power_sleep (power, "Suspend", FALSE);
+    
+    return TRUE;
+}
+
+static gboolean xfpm_power_dbus_can_reboot (XfpmPower * power,
+					  gboolean * OUT_can_reboot, 
+					  GError ** error)
+{
+    g_object_get (G_OBJECT (power->priv->console),
+		  "can-reboot", OUT_can_reboot,
+		  NULL);
+		  
+    return TRUE;
+}
+
+static gboolean xfpm_power_dbus_can_shutdown (XfpmPower * power,
+					    gboolean * OUT_can_shutdown, 
+					    GError ** error)
+{
+    g_object_get (G_OBJECT (power->priv->console),
+		  "can-shutdown", OUT_can_shutdown,
+		  NULL);
+    return TRUE;
+}
+
+static gboolean xfpm_power_dbus_can_hibernate (XfpmPower * power,
+					     gboolean * OUT_can_hibernate,
+					     GError ** error)
+{
+    *OUT_can_hibernate = power->priv->can_hibernate;
+    return TRUE;
+}
+
+static gboolean xfpm_power_dbus_can_suspend (XfpmPower * power,
+					   gboolean * OUT_can_suspend,
+					   GError ** error)
+{
+    *OUT_can_suspend = power->priv->can_suspend;
+    
+    return TRUE;
+}
+
+static gboolean xfpm_power_dbus_get_power_save_status (XfpmPower * power,
+						     gboolean * OUT_save_power,
+						     GError ** error)
+{
+    //FIXME
+    return TRUE;
+}
+
+static gboolean xfpm_power_dbus_get_on_battery (XfpmPower * power,
+					      gboolean * OUT_on_battery,
+					      GError ** error)
+{
+    *OUT_on_battery = power->priv->on_battery;
+    
+    return TRUE;
+}
+
+static gboolean xfpm_power_dbus_get_low_battery (XfpmPower * power,
+					       gboolean * OUT_low_battery,
+					       GError ** error)
+{
+    *OUT_low_battery = power->priv->on_low_battery;
+    
+    return TRUE;
+}

=== added file '.pc/06_fix-suspend-auth-check.patch/.timestamp'
=== modified file '.pc/06_fix-suspend-auth-check.patch/src/xfpm-power.c'
--- .pc/06_fix-suspend-auth-check.patch/src/xfpm-power.c	2012-05-18 21:50:54 +0000
+++ .pc/06_fix-suspend-auth-check.patch/src/xfpm-power.c	2013-08-12 21:07:54 +0000
@@ -1114,6 +1114,7 @@
      
     if ( power->priv->adapter_icon )
     {
+        gtk_status_icon_set_visible (power->priv->adapter_icon, FALSE);
         g_object_unref (power->priv->adapter_icon);
         power->priv->adapter_icon = NULL;
     }

=== added file '.pc/08_show_preferences_lxde.patch/.timestamp'
=== removed directory '.pc/09_fix_insert_battery.patch'