initial

1 files changed, 1714 insertions, 0 deletions

diff --git a/battstat/battstat_applet.c b/battstat/battstat_applet.c
new file mode 100644
index 00000000..f610b66c
--- /dev/null
+++ b/battstat/battstat_applet.c
@@ -0,0 +1,1714 @@
+/* battstat        A MATE battery meter for laptops.
+ * Copyright (C) 2000 by Jörgen Pehrson <[email protected]>
+ * Copyright (C) 2002 Free Software Foundation
+ *
+ *  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 Street #330, Boston, MA 02111-1307, USA.
+ *
+ $Id$
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#ifdef HAVE_ERR_H
+#include <err.h>
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <gtk/gtk.h>
+
+#include <mate-panel-applet.h>
+#include <mate-panel-applet-mateconf.h>
+
+#ifdef HAVE_LIBMATENOTIFY
+#include <libmatenotify/notify.h>
+#endif
+
+#include "battstat.h"
+#include "pixmaps.h"
+
+#ifndef gettext_noop
+#define gettext_noop(String) (String)
+#endif
+
+#define MATECONF_PATH ""
+
+static gboolean check_for_updates (gpointer data);
+static void about_cb( GtkAction *, ProgressData * );
+static void help_cb( GtkAction *, ProgressData * );
+
+static const GtkActionEntry battstat_menu_actions [] = {
+	{ "BattstatProperties", GTK_STOCK_PROPERTIES, N_("_Preferences"),
+	  NULL, NULL,
+	  G_CALLBACK (prop_cb) },
+	{ "BattstatHelp", GTK_STOCK_HELP, N_("_Help"),
+	  NULL, NULL,
+	  G_CALLBACK (help_cb) },
+	{ "BattstatAbout", GTK_STOCK_ABOUT, N_("_About"),
+	  NULL, NULL,
+	  G_CALLBACK (about_cb) }
+};
+
+#define AC_POWER_STRING _("System is running on AC power")
+#define DC_POWER_STRING _("System is running on battery power")
+
+/* The icons for Battery, Critical, AC and Charging */
+static GdkPixmap *statusimage[STATUS_PIXMAP_NUM];
+static GdkBitmap *statusmask[STATUS_PIXMAP_NUM];
+
+/* Assuming a horizontal battery, the colour is drawn into it one horizontal
+   line at a time as a vertical gradient.  The following arrays decide where
+   each horizontal line starts (the length of the lines varies with the
+   percentage battery life remaining).
+*/
+static const int pixel_offset_top[]={ 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5 };
+static const int pixel_top_length[]={ 2, 3, 4, 4, 4, 4, 4, 4, 4, 4, 3, 2 };
+static const int pixel_offset_bottom[]={ 38, 38, 39, 39, 39, 39, 39, 39, 39, 39, 38, 38 };
+
+
+/* The following array is the colour of each line.  The (slightly) varying
+   colours are what makes for the gradient effect.  The 'dark' colours are
+   used to draw the end of the bar, giving it more of a 3D look.  The code
+   assumes that all of these arrays will have the same number of elements.
+*/
+static GdkColor green[] = {
+  {0,0x7A00,0xDB00,0x7000},
+  {0,0x9100,0xE900,0x8500},
+  {0,0xA000,0xF100,0x9500},
+  {0,0x9600,0xEE00,0x8A00},
+  {0,0x8E00,0xE900,0x8100},
+  {0,0x8500,0xE500,0x7700},
+  {0,0x7C00,0xDF00,0x6E00},
+  {0,0x7300,0xDA00,0x6500},
+  {0,0x6A00,0xD600,0x5B00},
+  {0,0x6000,0xD000,0x5100},
+  {0,0x5600,0xCA00,0x4600},
+  {0,0x5100,0xC100,0x4200},
+};
+
+static GdkColor red[] = {
+  {0,0xD900,0x7200,0x7400},
+  {0,0xE600,0x8800,0x8C00},
+  {0,0xF000,0x9600,0x9A00},
+  {0,0xEB00,0x8D00,0x9100},
+  {0,0xE700,0x8300,0x8800},
+  {0,0xE200,0x7A00,0x7F00},
+  {0,0xDD00,0x7100,0x7600},
+  {0,0xD800,0x6700,0x6D00},
+  {0,0xD300,0x5D00,0x6300},
+  {0,0xCD00,0x5400,0x5900},
+  {0,0xC800,0x4900,0x4F00},
+  {0,0xC100,0x4200,0x4700},
+};
+
+static GdkColor yellow[] = {
+  {0,0xD800,0xD900,0x7200},
+  {0,0xE600,0xE500,0x8800},
+  {0,0xF000,0xEF00,0x9600},
+  {0,0xEB00,0xEA00,0x8D00},
+  {0,0xE700,0xE600,0x8300},
+  {0,0xE200,0xE100,0x7A00},
+  {0,0xDD00,0xDC00,0x7100},
+  {0,0xD800,0xD700,0x6700},
+  {0,0xD300,0xD200,0x5D00},
+  {0,0xCD00,0xCC00,0x5400},
+  {0,0xC800,0xC600,0x4900},
+  {0,0xC100,0xBF00,0x4200},
+};
+
+static GdkColor orange[] = {
+  {0,0xD900,0xAD00,0x7200},
+  {0,0xE600,0xBB00,0x8800},
+  {0,0xF000,0xC700,0x9600},
+  {0,0xEB00,0xC000,0x8D00},
+  {0,0xE700,0xB900,0x8300},
+  {0,0xE200,0xB300,0x7A00},
+  {0,0xDD00,0xAB00,0x7100},
+  {0,0xD800,0xA400,0x6700},
+  {0,0xD300,0x9E00,0x5D00},
+  {0,0xCD00,0x9600,0x5400},
+  {0,0xC800,0x8D00,0x4900},
+  {0,0xC100,0x8600,0x4200},
+};
+
+static GdkColor darkgreen[] = {
+  {0,0x6500,0xC600,0x5B00},
+  {0,0x7B00,0xD300,0x6F00},
+  {0,0x8A00,0xDB00,0x7F00},
+  {0,0x8000,0xD800,0x7400},
+  {0,0x7800,0xD400,0x6B00},
+  {0,0x6F00,0xCF00,0x6200},
+  {0,0x6600,0xCA00,0x5900},
+  {0,0x5D00,0xC500,0x5000},
+  {0,0x5400,0xC100,0x4600},
+  {0,0x4B00,0xBB00,0x3C00},
+  {0,0x4100,0xB600,0x3100},
+  {0,0x3C00,0xAC00,0x2D00},
+};
+
+static GdkColor darkorange[] = {
+  {0,0xC400,0x9700,0x5C00},
+  {0,0xD000,0xA500,0x7200},
+  {0,0xDA00,0xB100,0x8000},
+  {0,0xD500,0xAA00,0x7700},
+  {0,0xD100,0xA300,0x6D00},
+  {0,0xCD00,0x9D00,0x6400},
+  {0,0xC700,0x9600,0x5B00},
+  {0,0xC300,0x8F00,0x5200},
+  {0,0xBE00,0x8800,0x4800},
+  {0,0xB800,0x8100,0x3F00},
+  {0,0xB300,0x7900,0x3400},
+  {0,0xAC00,0x7200,0x2D00},
+};
+
+static GdkColor darkyellow[] = {
+  {0,0xC200,0xC400,0x5C00},
+  {0,0xD000,0xCF00,0x7200},
+  {0,0xDA00,0xD900,0x8000},
+  {0,0xD500,0xD400,0x7700},
+  {0,0xD100,0xD000,0x6D00},
+  {0,0xCD00,0xCB00,0x6400},
+  {0,0xC700,0xC600,0x5B00},
+  {0,0xC300,0xC200,0x5200},
+  {0,0xBE00,0xBD00,0x4800},
+  {0,0xB800,0xB700,0x3F00},
+  {0,0xB300,0xB200,0x3400},
+  {0,0xAC00,0xAA00,0x2D00},
+};
+
+static GdkColor darkred[] = {
+  {0,0xC900,0x6200,0x6400},
+  {0,0xD600,0x7800,0x7C00},
+  {0,0xDA00,0x8000,0x8500},
+  {0,0xD500,0x7700,0x7B00},
+  {0,0xD100,0x6D00,0x7200},
+  {0,0xCD00,0x6400,0x6900},
+  {0,0xC700,0x5B00,0x6100},
+  {0,0xC300,0x5200,0x5700},
+  {0,0xBE00,0x4800,0x4E00},
+  {0,0xB800,0x3F00,0x4400},
+  {0,0xB100,0x3200,0x3700},
+  {0,0xA200,0x3200,0x3700},
+};
+
+/* Initialise the global static variables that store our status pixmaps from
+   their XPM format (as stored in pixmaps.h).  This should only be done once
+   since they are global variables.
+*/
+static void
+initialise_global_pixmaps( void )
+{
+  GdkDrawable *defaults;
+
+  defaults = gdk_screen_get_root_window( gdk_screen_get_default() );
+
+  statusimage[STATUS_PIXMAP_BATTERY] =
+    gdk_pixmap_create_from_xpm_d( defaults, &statusmask[STATUS_PIXMAP_BATTERY],
+                                  NULL, battery_small_xpm );
+
+  statusimage[STATUS_PIXMAP_METER] =
+    gdk_pixmap_create_from_xpm_d( defaults, &statusmask[STATUS_PIXMAP_METER],
+                                  NULL, battery_small_meter_xpm );
+
+  statusimage[STATUS_PIXMAP_AC] =
+    gdk_pixmap_create_from_xpm_d( defaults, &statusmask[STATUS_PIXMAP_AC],
+                                  NULL, ac_small_xpm );
+
+  statusimage[STATUS_PIXMAP_CHARGE] =
+    gdk_pixmap_create_from_xpm_d( defaults, &statusmask[STATUS_PIXMAP_CHARGE],
+                                  NULL, charge_small_xpm );
+
+  statusimage[STATUS_PIXMAP_WARNING] =
+    gdk_pixmap_create_from_xpm_d( defaults, &statusmask[STATUS_PIXMAP_WARNING],
+                                  NULL, warning_small_xpm );
+}
+
+/* For non-truecolour displays, each GdkColor has to have a palette entry
+   allocated for it.  This should only be done once for the entire display.
+*/
+static void
+allocate_battery_colours( void )
+{
+  GdkColormap *colourmap;
+  int i;
+
+  colourmap = gdk_colormap_get_system();
+
+  /* assumed: all the colour arrays have the same number of elements */
+  for( i = 0; i < G_N_ELEMENTS( orange ); i++ )
+  {
+     gdk_colormap_alloc_color( colourmap, &darkorange[i], FALSE, TRUE );
+     gdk_colormap_alloc_color( colourmap, &darkyellow[i], FALSE, TRUE );
+     gdk_colormap_alloc_color( colourmap, &darkred[i], FALSE, TRUE );
+     gdk_colormap_alloc_color( colourmap, &darkgreen[i], FALSE, TRUE );
+     gdk_colormap_alloc_color( colourmap, &orange[i], FALSE, TRUE );
+     gdk_colormap_alloc_color( colourmap, &yellow[i], FALSE, TRUE );
+     gdk_colormap_alloc_color( colourmap, &red[i], FALSE, TRUE );
+     gdk_colormap_alloc_color( colourmap, &green[i], FALSE, TRUE );
+  }
+}
+
+/* Our backends may be either event driven or poll-based.
+ * If they are event driven then we know this the first time we
+ * receive an event.
+ */
+static gboolean event_driven = FALSE;
+static GSList *instances;
+
+static void
+status_change_callback (void)
+{
+  GSList *instance;
+
+  for (instance = instances; instance; instance = instance->next)
+  {
+    ProgressData *battstat = instance->data;
+
+    if (battstat->timeout_id)
+    {
+      g_source_remove (battstat->timeout_id);
+      battstat->timeout_id = 0;
+    }
+
+    check_for_updates (battstat);
+  }
+
+  event_driven = TRUE;
+}
+
+/* The following two functions keep track of how many instances of the applet
+   are currently running.  When the first instance is started, some global
+   initialisation is done.  When the last instance exits, cleanup occurs.
+
+   The teardown code here isn't entirely complete (for example, it doesn't
+   deallocate the GdkColors or free the GdkPixmaps.  This is OK so long
+   as the process quits immediately when the last applet is removed (which
+   it does.)
+*/
+static const char *
+static_global_initialisation (int no_hal, ProgressData *battstat)
+{
+  gboolean first_time;
+  const char *err;
+
+  first_time = !instances;
+
+  instances = g_slist_prepend (instances, battstat);
+
+  if (!first_time)
+    return NULL;
+
+  allocate_battery_colours();
+  initialise_global_pixmaps();
+  err = power_management_initialise (no_hal, status_change_callback);
+
+  return err;
+}
+
+static void
+static_global_teardown (ProgressData *battstat)
+{
+  instances = g_slist_remove (instances, battstat);
+
+  /* remaining instances... */
+  if (instances)
+    return;
+
+  /* instances == 0 */
+
+  power_management_cleanup();
+}
+
+/* Pop up an error dialog on the same screen as 'applet' saying 'msg'.
+ */
+static void
+battstat_error_dialog( GtkWidget *applet, const char *msg )
+{
+  GtkWidget *dialog;
+
+  dialog = gtk_message_dialog_new( NULL, 0, GTK_MESSAGE_ERROR,
+                                   GTK_BUTTONS_OK, "%s", msg);
+
+  gtk_window_set_screen( GTK_WINDOW (dialog),
+                         gtk_widget_get_screen (GTK_WIDGET (applet)) );
+
+  g_signal_connect_swapped( GTK_OBJECT (dialog), "response",
+                            G_CALLBACK (gtk_widget_destroy),
+                            GTK_OBJECT (dialog) );
+
+  gtk_widget_show_all( dialog );
+}
+
+/* Format a string describing how much time is left to fully (dis)charge
+   the battery. The return value must be g_free()d.
+*/
+static char *
+get_remaining (BatteryStatus *info)
+{
+	int hours;
+	int mins;
+
+	hours = info->minutes / 60;
+	mins = info->minutes % 60;
+
+	if (info->on_ac_power && !info->charging)
+		return g_strdup_printf (_("Battery charged (%d%%)"), info->percent);
+	else if (info->minutes < 0 && !info->on_ac_power)
+		return g_strdup_printf (_("Unknown time (%d%%) remaining"), info->percent);
+	else if (info->minutes < 0 && info->on_ac_power)
+		return g_strdup_printf (_("Unknown time (%d%%) until charged"), info->percent);
+	else
+		if (hours == 0)
+			if (!info->on_ac_power)
+				return g_strdup_printf (ngettext (
+						"%d minute (%d%%) remaining",
+						"%d minutes (%d%%) remaining",
+						mins), mins, info->percent);
+			else
+				return g_strdup_printf (ngettext (
+						"%d minute until charged (%d%%)",
+						"%d minutes until charged (%d%%)",
+						mins), mins, info->percent);
+		else if (mins == 0)
+			if (!info->on_ac_power)
+				return g_strdup_printf (ngettext (
+						"%d hour (%d%%) remaining",
+						"%d hours (%d%%) remaining",
+						hours), hours, info->percent);
+			else
+				return g_strdup_printf (ngettext (
+						"%d hour until charged (%d%%)",
+						"%d hours until charged (%d%%)",
+						hours), hours, info->percent);
+		else
+			if (!info->on_ac_power)
+				/* TRANSLATOR: "%d %s %d %s" are "%d hours %d minutes"
+				 * Swap order with "%2$s %2$d %1$s %1$d if needed */
+				return g_strdup_printf (_("%d %s %d %s (%d%%) remaining"),
+						hours, ngettext ("hour", "hours", hours),
+						mins, ngettext ("minute", "minutes", mins),
+						info->percent);
+			else
+				/* TRANSLATOR: "%d %s %d %s" are "%d hours %d minutes"
+				 * Swap order with "%2$s %2$d %1$s %1$d if needed */
+				return g_strdup_printf (_("%d %s %d %s until charged (%d%%)"),
+						hours, ngettext ("hour", "hours", hours),
+						mins, ngettext ("minute", "minutes", mins),
+						info->percent);
+}
+
+static gboolean
+battery_full_notify (GtkWidget *applet)
+{
+#ifdef HAVE_LIBMATENOTIFY
+	GError *error = NULL;
+	GdkPixbuf *icon;
+	gboolean result;
+
+	if (!notify_is_initted () && !notify_init (_("Battery Monitor")))
+		return FALSE;
+
+  	icon = gtk_icon_theme_load_icon (
+			gtk_icon_theme_get_default (),
+			"battery",
+			48,
+			GTK_ICON_LOOKUP_USE_BUILTIN,
+			NULL);
+
+	NotifyNotification *n = notify_notification_new (_("Your battery is now fully recharged"), "", /* "battery" */ NULL, applet);
+
+	/* XXX: it would be nice to pass this as a named icon */
+	notify_notification_set_icon_from_pixbuf (n, icon);
+	g_object_unref (icon);
+
+	result = notify_notification_show (n, &error);
+
+	if (error)
+	{
+	   g_warning ("%s", error->message);
+	   g_error_free (error);
+	}
+
+	g_object_unref (G_OBJECT (n));
+
+	return result;
+#else
+	return FALSE;
+#endif
+}
+
+/* Show a dialog notifying the user that their battery is done charging.
+ */
+static void
+battery_full_dialog (GtkWidget *applet)
+{
+  /* first attempt to use libmatenotify */
+  if (battery_full_notify (applet))
+	  return;
+
+  GtkWidget *dialog, *hbox, *image, *label;
+  GdkPixbuf *pixbuf;
+
+  gchar *new_label;
+  dialog = gtk_dialog_new_with_buttons (
+		_("Battery Notice"),
+		NULL,
+		GTK_DIALOG_DESTROY_WITH_PARENT,
+		GTK_STOCK_OK,
+		GTK_RESPONSE_ACCEPT,
+		NULL);
+  g_signal_connect_swapped (GTK_OBJECT (dialog), "response",
+			    G_CALLBACK (gtk_widget_destroy),
+			    GTK_OBJECT (dialog));
+
+  gtk_container_set_border_width (GTK_CONTAINER (dialog), 6);
+  gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
+  hbox = gtk_hbox_new (FALSE, 6);
+  pixbuf = gtk_icon_theme_load_icon (
+		gtk_icon_theme_get_default (),
+		"battery",
+		48,
+		GTK_ICON_LOOKUP_USE_BUILTIN,
+		NULL);
+  image = gtk_image_new_from_pixbuf (pixbuf);
+  g_object_unref (pixbuf);
+  gtk_box_pack_start (GTK_BOX (hbox), image, TRUE, TRUE, 6);
+  new_label = g_strdup_printf (
+		"<span weight=\"bold\" size=\"larger\">%s</span>",
+ 		_("Your battery is now fully recharged"));
+  label = gtk_label_new (new_label);
+  g_free (new_label);
+  gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
+  gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
+  gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 6);
+  gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox);
+  gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE);
+  gtk_window_stick (GTK_WINDOW (dialog));
+  gtk_window_set_skip_pager_hint (GTK_WINDOW (dialog), TRUE);
+  gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE);
+  gtk_widget_show_all (dialog);
+}
+
+/* Destroy the low battery notification dialog and mark it as such.
+ */
+static void
+battery_low_dialog_destroy( ProgressData *battstat )
+{
+  gtk_widget_destroy( battstat->battery_low_dialog );
+  battstat->battery_low_dialog = NULL;
+  battstat->battery_low_label = NULL;
+}
+
+/* Determine if suspend is unsupported.  For the time being this involves
+ * distribution-specific magic :(
+ */
+/* #define HAVE_PMI */
+static gboolean
+is_suspend_unavailable( void )
+{
+#ifdef HAVE_PMI
+  int status;
+
+  status = system( "pmi query suspend" );
+
+  /* -1 - fail (pmi unavailable?).     return 'false' since we don't know.
+   * 0  - success (can suspend).       return 'false' since not unavailable.
+   * 1  - success (cannot suspend).    return 'true' since unavailable.
+   */
+  if( WEXITSTATUS( status ) == 1 )
+    return TRUE;
+  else
+    return FALSE;
+#else
+  return FALSE; /* return 'false' since we don't know. */
+#endif
+}
+
+/* Update the text label in the battery low dialog.
+ */
+static void
+battery_low_update_text( ProgressData *battstat, BatteryStatus *info )
+{
+  const char *suggest;
+  gchar *remaining, *new_label;
+  GtkRequisition size;
+
+  /* If we're not displaying the dialog then don't update it. */
+  if( battstat->battery_low_label == NULL ||
+      battstat->battery_low_dialog == NULL )
+    return;
+
+  gtk_widget_size_request( GTK_WIDGET( battstat->battery_low_label ), &size );
+
+  /* If the label has never been set before, the width will be 0.  If it
+     has been set before (width > 0) then we want to keep the size of
+     the old widget (to keep the dialog from changing sizes) so we set it
+     explicitly here.
+   */
+  if( size.width > 0 )
+    gtk_widget_set_size_request( GTK_WIDGET( battstat->battery_low_label ),
+                                 size.width, size.height );
+
+  if (info->minutes < 0 && !info->on_ac_power)
+  {
+	  /* we don't know the remaining time */
+	  remaining = g_strdup_printf (_("You have %d%% of your total battery "
+				  	 "capacity remaining."), info->percent);
+  }
+  else
+  {
+	  remaining = g_strdup_printf( ngettext(
+                                 "You have %d minute of battery power "
+				   "remaining (%d%% of the total capacity).",
+                                 "You have %d minutes of battery power "
+				   "remaining (%d%% of the total capacity).",
+                                 info->minutes ),
+                               info->minutes,info->percent );
+  }
+
+  if( is_suspend_unavailable() )
+    /* TRANSLATORS: this is a list, it is left as a single string
+     * to allow you to make it appear like a list would in your
+     * locale.  This is if the laptop does not support suspend. */
+    suggest = _("To avoid losing your work:\n"
+                " \xE2\x80\xA2 plug your laptop into external power, or\n"
+                " \xE2\x80\xA2 save open documents and shut your laptop down."
+               );
+  else
+    /* TRANSLATORS: this is a list, it is left as a single string
+     * to allow you to make it appear like a list would in your
+     * locale.  This is if the laptop supports suspend. */
+    suggest = _("To avoid losing your work:\n"
+                " \xE2\x80\xA2 suspend your laptop to save power,\n"
+                " \xE2\x80\xA2 plug your laptop into external power, or\n"
+                " \xE2\x80\xA2 save open documents and shut your laptop down."
+               );
+
+  new_label = g_strdup_printf(
+		"<span weight=\"bold\" size=\"larger\">%s</span>\n\n%s\n\n%s",
+		_("Your battery is running low"), remaining, suggest );
+
+  gtk_label_set_markup( battstat->battery_low_label, new_label );
+  g_free( remaining );
+  g_free( new_label );
+}
+
+/* Show a dialog notifying the user that their battery is running low.
+ */
+static void
+battery_low_dialog( ProgressData *battery, BatteryStatus *info )
+{
+  GtkWidget *hbox, *image, *label;
+  GtkWidget *vbox;
+  GdkPixbuf *pixbuf;
+
+  /* If the dialog is already displayed then don't display it again. */
+  if( battery->battery_low_dialog != NULL )
+    return;
+
+  battery->battery_low_dialog = gtk_dialog_new_with_buttons (
+		 _("Battery Notice"),
+		 NULL,
+		 GTK_DIALOG_DESTROY_WITH_PARENT,
+		 GTK_STOCK_OK,
+		 GTK_RESPONSE_ACCEPT,
+		 NULL);
+  gtk_dialog_set_default_response( GTK_DIALOG (battery->battery_low_dialog),
+                                   GTK_RESPONSE_ACCEPT );
+
+  g_signal_connect_swapped( GTK_OBJECT (battery->battery_low_dialog),
+                            "response",
+                            G_CALLBACK (battery_low_dialog_destroy),
+                            battery );
+
+  gtk_container_set_border_width (GTK_CONTAINER (battery->battery_low_dialog),
+		  6);
+  gtk_dialog_set_has_separator (GTK_DIALOG (battery->battery_low_dialog),
+		  FALSE);
+  hbox = gtk_hbox_new (FALSE, 6);
+  gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
+  pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
+		 "battery",
+		 48,
+		 GTK_ICON_LOOKUP_USE_BUILTIN,
+		 NULL);
+  image = gtk_image_new_from_pixbuf (pixbuf);
+  g_object_unref (pixbuf);
+  vbox = gtk_vbox_new (FALSE, 0);
+  gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6);
+  gtk_box_pack_start (GTK_BOX (vbox), image, FALSE, FALSE, 0);
+  label = gtk_label_new ("");
+  battery->battery_low_label = GTK_LABEL( label );
+  gtk_label_set_line_wrap( battery->battery_low_label, TRUE );
+  gtk_label_set_selectable( battery->battery_low_label, TRUE );
+  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 6);
+  gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (battery->battery_low_dialog))), hbox);
+
+  gtk_window_set_keep_above (GTK_WINDOW (battery->battery_low_dialog), TRUE);
+  gtk_window_stick (GTK_WINDOW (battery->battery_low_dialog));
+  gtk_window_set_focus_on_map (GTK_WINDOW (battery->battery_low_dialog),
+		  FALSE);
+  gtk_window_set_skip_pager_hint (GTK_WINDOW (battery->battery_low_dialog),
+		  TRUE);
+
+  battery_low_update_text( battery, info );
+
+  gtk_window_set_position (GTK_WINDOW (battery->battery_low_dialog),
+		  GTK_WIN_POS_CENTER);
+  gtk_widget_show_all (battery->battery_low_dialog);
+}
+
+/* Update the text of the tooltip from the provided info.
+ */
+static void
+update_tooltip( ProgressData *battstat, BatteryStatus *info )
+{
+  gchar *powerstring;
+  gchar *remaining;
+  gchar *tiptext;
+
+  if (info->present)
+  {
+    if (info->on_ac_power)
+      powerstring = AC_POWER_STRING;
+    else
+      powerstring = DC_POWER_STRING;
+
+    remaining = get_remaining (info);
+
+    tiptext = g_strdup_printf ("%s\n%s", powerstring, remaining);
+    g_free (remaining);
+  }
+  else
+  {
+    if (info->on_ac_power)
+      tiptext = g_strdup_printf ("%s\n%s", AC_POWER_STRING,
+                                 _("No battery present"));
+    else
+      tiptext = g_strdup_printf ("%s\n%s", DC_POWER_STRING,
+                                 _("Battery status unknown"));
+  }
+
+  gtk_widget_set_tooltip_text (battstat->applet, tiptext);
+  g_free (tiptext);
+}
+
+/* Redraw the battery meter image.
+ */
+static void
+update_battery_image (ProgressData *battstat, int batt_percent, int batt_time)
+{
+  GdkColor *color, *darkcolor;
+  GdkPixmap *pixmap;
+  GdkBitmap *pixmask;
+  guint progress_value;
+  gint i, x;
+  int batt_life;
+
+  if (!battstat->showbattery)
+    return;
+
+  batt_life = !battstat->red_value_is_time ? batt_percent : batt_time;
+
+  if (batt_life <= battstat->red_val)
+  {
+    color = red;
+    darkcolor = darkred;
+  }
+  else if (batt_life <= battstat->orange_val)
+  {
+    color = orange;
+    darkcolor = darkorange;
+  }
+  else if (batt_life <= battstat->yellow_val)
+  {
+    color = yellow;
+    darkcolor = darkyellow;
+  }
+  else
+  {
+    color = green;
+    darkcolor = darkgreen;
+  }
+
+  /* We keep this pixgc allocated so we don't have to alloc/free it every
+     time.  A widget has to be realized before it has a valid ->window so
+     we do that here for battstat->applet just in case it's not already done.
+  */
+  if( battstat->pixgc == NULL )
+  {
+    gtk_widget_realize( battstat->applet );
+    battstat->pixgc = gdk_gc_new( gtk_widget_get_window (battstat->applet) );
+  }
+
+  /* Depending on if the meter is horizontally oriented start out with the
+     appropriate XPM image (from pixmaps.h)
+  */
+  if (battstat->horizont)
+    pixmap = gdk_pixmap_create_from_xpm_d( gtk_widget_get_window (battstat->applet), &pixmask,
+                                           NULL, battery_gray_xpm );
+  else
+    pixmap = gdk_pixmap_create_from_xpm_d( gtk_widget_get_window (battstat->applet), &pixmask,
+                                           NULL, battery_y_gray_xpm );
+
+  /* The core code responsible for painting the battery meter.  For each
+     colour in our gradient array, draw a vertical or horizontal line
+     depending on the current orientation of the meter.
+  */
+  if (battstat->draintop) {
+    progress_value = PROGLEN * batt_life / 100.0;
+
+    for( i = 0; i < G_N_ELEMENTS( orange ); i++ )
+    {
+      gdk_gc_set_foreground (battstat->pixgc, &color[i]);
+
+      if (battstat->horizont)
+        gdk_draw_line (pixmap, battstat->pixgc, pixel_offset_top[i], i + 2,
+                       pixel_offset_top[i] + progress_value, i + 2);
+      else
+        gdk_draw_line (pixmap, battstat->pixgc, i + 2, pixel_offset_top[i],
+                       i + 2, pixel_offset_top[i] + progress_value);
+    }
+  }
+  else
+  {
+    progress_value = PROGLEN * batt_life / 100.0;
+
+    for( i = 0; i < G_N_ELEMENTS( orange ); i++)
+    {
+      gdk_gc_set_foreground (battstat->pixgc, &color[i]);
+
+      if (battstat->horizont)
+        gdk_draw_line (pixmap, battstat->pixgc, pixel_offset_bottom[i], i + 2,
+                       pixel_offset_bottom[i] - progress_value, i + 2);
+      else
+        gdk_draw_line (pixmap, battstat->pixgc, i + 2,
+                       pixel_offset_bottom[i] - 1, i + 2,
+                       pixel_offset_bottom[i] - progress_value);
+    }
+
+    for( i = 0; i < G_N_ELEMENTS( orange ); i++ )
+    {
+      x = pixel_offset_bottom[i] - progress_value - pixel_top_length[i];
+      if (x < pixel_offset_top[i])
+        x = pixel_offset_top[i];
+
+      if (progress_value < 33)
+      {
+        gdk_gc_set_foreground (battstat->pixgc, &darkcolor[i]);
+
+        if (battstat->horizont)
+          gdk_draw_line (pixmap, battstat->pixgc,
+                         pixel_offset_bottom[i] - progress_value - 1,
+                         i + 2, x, i + 2);
+        else
+          gdk_draw_line (pixmap, battstat->pixgc, i + 2,
+                         pixel_offset_bottom[i] - progress_value - 1,
+                         i + 2, x);
+      }
+    }
+  }
+
+  /* Store our newly created pixmap into the GtkImage.  This results in
+     the last reference to the old pixmap/mask being dropped.
+  */
+  gtk_image_set_from_pixmap( GTK_IMAGE(battstat->battery),
+                             pixmap, pixmask );
+
+  /* The GtkImage does not assume a reference to the pixmap or mask;
+     you still need to unref them if you own references. GtkImage will
+     add its own reference rather than adopting yours.
+  */
+  g_object_unref( G_OBJECT(pixmap) );
+  g_object_unref( G_OBJECT(pixmask) );
+}
+
+/* Update the text label that either shows the percentage of time left.
+ */
+static void
+update_percent_label( ProgressData *battstat, BatteryStatus *info )
+{
+  gchar *new_label;
+
+  if (info->present && battstat->showtext == APPLET_SHOW_PERCENT)
+    new_label = g_strdup_printf ("%d%%", info->percent);
+  else if (info->present && battstat->showtext == APPLET_SHOW_TIME)
+  {
+    /* Fully charged or unknown (-1) time remaining displays -:-- */
+    if ((info->on_ac_power && info->percent == 100) || info->minutes < 0)
+      new_label = g_strdup ("-:--");
+    else
+    {
+      int time;
+      time = info->minutes;
+      new_label = g_strdup_printf ("%d:%02d", time/60, time%60);
+    }
+  }
+  else
+    new_label = g_strdup (_("N/A"));
+
+  gtk_label_set_text (GTK_LABEL (battstat->percent), new_label);
+  g_free (new_label);
+}
+
+/* Utility function to create a copy of a GdkPixmap */
+static GdkPixmap *
+copy_gdk_pixmap( GdkPixmap *src, GdkGC *gc )
+{
+  gint height, width;
+  GdkPixmap *dest;
+
+	#if GTK_CHECK_VERSION(3, 0, 0)
+		width = gdk_window_get_width(GDK_WINDOW(src));
+		height = gdk_window_get_height(GDK_WINDOW(src));
+	#else
+		gdk_drawable_get_size(GDK_DRAWABLE(src), &width, &height);
+	#endif
+
+  dest = gdk_pixmap_new( GDK_DRAWABLE( src ), width, height, -1 );
+
+  gdk_draw_drawable( GDK_DRAWABLE( dest ), gc, GDK_DRAWABLE( src ),
+                     0, 0, 0, 0, width, height );
+
+  return dest;
+}
+
+/* Determine what status icon we ought to be displaying and change the
+   status icon to display it if it is different from what we are currently
+   showing.
+ */
+static void
+possibly_update_status_icon( ProgressData *battstat, BatteryStatus *info )
+{
+  StatusPixmapIndex pixmap_index;
+  int batt_life, last_batt_life;
+
+  batt_life = !battstat->red_value_is_time ? info->percent : info->minutes;
+  last_batt_life = !battstat->red_value_is_time ? battstat->last_batt_life :
+	  					 battstat->last_minutes;
+
+  if( info->on_ac_power )
+  {
+    if( info->charging )
+      pixmap_index = STATUS_PIXMAP_CHARGE;
+    else
+      pixmap_index = STATUS_PIXMAP_AC;
+  }
+  else /* on battery */
+  {
+    if (batt_life > battstat->red_val)
+      pixmap_index = STATUS_PIXMAP_BATTERY;
+    else
+      pixmap_index = STATUS_PIXMAP_WARNING;
+  }
+
+  /* If we are showing the full length battery meter then the status icon
+     should display static icons.  If we are not showing the full meter
+     then the status icon will show a smaller meter if we are on battery.
+   */
+  if( !battstat->showbattery &&
+      (pixmap_index == STATUS_PIXMAP_BATTERY ||
+       pixmap_index == STATUS_PIXMAP_WARNING) )
+    pixmap_index = STATUS_PIXMAP_METER;
+
+
+  /* Take care of drawing the smaller meter. */
+  if( pixmap_index == STATUS_PIXMAP_METER &&
+      (batt_life != last_batt_life ||
+       battstat->last_pixmap_index != STATUS_PIXMAP_METER) )
+  {
+    GdkColor *colour;
+    GdkPixmap *meter;
+    guint progress_value;
+    gint i, x;
+
+    /* We keep this pixgc allocated so we don't have to alloc/free it every
+       time.  A widget has to be realized before it has a valid ->window so
+       we do that here for battstat->applet just in case it's not already done.
+    */
+    if( battstat->pixgc == NULL )
+    {
+      gtk_widget_realize( battstat->applet );
+      battstat->pixgc = gdk_gc_new( gtk_widget_get_window (battstat->applet) );
+    }
+
+    /* Pull in a clean version of the icons so that we don't paint over
+       top of the same icon over and over.  We neglect to free/update the
+       statusmask here since it will always stay the same.
+     */
+    meter = copy_gdk_pixmap( statusimage[STATUS_PIXMAP_METER],
+                             battstat->pixgc );
+
+    if (batt_life <= battstat->red_val)
+    {
+      colour = red;
+    }
+    else if (batt_life <= battstat->orange_val)
+    {
+      colour = orange;
+    }
+    else if (batt_life <= battstat->yellow_val)
+    {
+      colour = yellow;
+    }
+    else
+    {
+      colour = green;
+    }
+
+    progress_value = 12 * info->percent / 100.0;
+
+    for( i = 0; i < 10; i++ )
+    {
+      gdk_gc_set_foreground( battstat->pixgc, &colour[(i * 13 / 10)] );
+
+      if( i >= 2 && i <= 7 )
+	x = 17;
+      else
+	x = 16;
+
+      gdk_draw_line( meter, battstat->pixgc,
+		     i + 1, x - progress_value,
+		     i + 1, x );
+    }
+
+    /* force a redraw immediately */
+    gtk_image_set_from_pixmap( GTK_IMAGE (battstat->status),
+                               meter, statusmask[STATUS_PIXMAP_METER] );
+
+    /* free our private pixmap copy */
+    g_object_unref( G_OBJECT( meter ) );
+    battstat->last_pixmap_index = STATUS_PIXMAP_METER;
+  }
+  else if( pixmap_index != battstat->last_pixmap_index )
+  {
+    gtk_image_set_from_pixmap (GTK_IMAGE (battstat->status),
+                               statusimage[pixmap_index],
+                               statusmask[pixmap_index]);
+    battstat->last_pixmap_index = pixmap_index;
+  }
+}
+
+/* Gets called as a gtk_timeout once per second.  Checks for updates and
+   makes any changes as appropriate.
+ */
+static gboolean
+check_for_updates( gpointer data )
+{
+  ProgressData *battstat = data;
+  BatteryStatus info;
+  const char *err;
+
+  if (DEBUG) g_print("check_for_updates()\n");
+
+  if( (err = power_management_getinfo( &info )) )
+    battstat_error_dialog( battstat->applet, err );
+
+  if (!event_driven)
+  {
+    int timeout;
+
+    /* if on AC and not event driven scale back the polls to once every 10 */
+    if (info.on_ac_power)
+      timeout = 10;
+    else
+      timeout = 2;
+
+    if (timeout != battstat->timeout)
+    {
+      battstat->timeout = timeout;
+
+      if (battstat->timeout_id)
+        g_source_remove (battstat->timeout_id);
+
+      battstat->timeout_id = g_timeout_add_seconds (battstat->timeout,
+                                            check_for_updates,
+                                            battstat);
+    }
+  }
+
+
+  possibly_update_status_icon( battstat, &info );
+
+  if (!info.on_ac_power &&
+      battstat->last_batt_life != 1000 &&
+      (
+        /* if percentage drops below red_val */
+        (!battstat->red_value_is_time &&
+         battstat->last_batt_life > battstat->red_val &&
+         info.percent <= battstat->red_val) ||
+	/* if time drops below red_val */
+	(battstat->red_value_is_time &&
+	 battstat->last_minutes > battstat->red_val &&
+	 info.minutes <= battstat->red_val)
+      ) &&
+      info.present)
+  {
+    /* Warn that battery dropped below red_val */
+    if(battstat->lowbattnotification)
+    {
+      battery_low_dialog(battstat, &info);
+
+      if(battstat->beep)
+        gdk_beep();
+    }
+#if 0
+    /* FIXME: mate-applets doesn't depend on libmate anymore */
+    mate_triggers_do ("", NULL, "battstat_applet", "LowBattery", NULL);
+#endif
+  }
+
+  if( battstat->last_charging &&
+      battstat->last_acline_status &&
+      battstat->last_acline_status!=1000 &&
+      !info.charging &&
+      info.on_ac_power &&
+      info.present &&
+      info.percent > 99)
+  {
+    /* Inform that battery now fully charged */
+#if 0
+    /* FIXME: mate-applets doesn't depend on libmate anymore */
+    mate_triggers_do ("", NULL, "battstat_applet", "BatteryFull", NULL);
+#endif
+
+    if(battstat->fullbattnot)
+    {
+      battery_full_dialog (battstat->applet);
+
+      if (battstat->beep)
+        gdk_beep();
+    }
+  }
+
+  /* If the warning dialog is displayed and we just got plugged in then
+     stop displaying it.
+   */
+  if( battstat->battery_low_dialog && info.on_ac_power )
+    battery_low_dialog_destroy( battstat );
+
+  if( info.on_ac_power != battstat->last_acline_status ||
+      info.percent != battstat->last_batt_life ||
+      info.minutes != battstat->last_minutes ||
+      info.charging != battstat->last_charging )
+  {
+    /* Update the tooltip */
+    update_tooltip( battstat, &info );
+
+    /* If the warning dialog box is currently displayed, update that too. */
+    if( battstat->battery_low_dialog != NULL )
+      battery_low_update_text( battstat, &info );
+  }
+
+  if( info.percent != battstat->last_batt_life )
+  {
+    /* Update the battery meter image */
+    update_battery_image (battstat, info.percent, info.minutes);
+  }
+
+  if( (battstat->showtext == APPLET_SHOW_PERCENT &&
+       battstat->last_batt_life != info.percent) ||
+      (battstat->showtext == APPLET_SHOW_TIME &&
+       battstat->last_minutes != info.minutes) ||
+       battstat->last_acline_status != info.on_ac_power ||
+       battstat->last_present != info.present ||
+       battstat->refresh_label ) /* set by properties dialog */
+  {
+    /* Update the label */
+    update_percent_label( battstat, &info );
+
+    /* done */
+    battstat->refresh_label = FALSE;
+  }
+
+  battstat->last_charging = info.charging;
+  battstat->last_batt_life = info.percent;
+  battstat->last_minutes = info.minutes;
+  battstat->last_acline_status = info.on_ac_power;
+  battstat->last_present = info.present;
+
+  return TRUE;
+}
+
+/* Gets called when the user removes the applet from the panel.  Clean up
+   all instance-specific data and call the global teardown function to
+   decrease our applet count (and possibly perform global cleanup)
+ */
+static void
+destroy_applet( GtkWidget *widget, ProgressData *battstat )
+{
+  if (DEBUG) g_print("destroy_applet()\n");
+
+  if (battstat->prop_win)
+    gtk_widget_destroy (GTK_WIDGET (battstat->prop_win));
+
+  if( battstat->battery_low_dialog )
+    battery_low_dialog_destroy( battstat );
+
+  if (battstat->timeout_id)
+    g_source_remove (battstat->timeout_id);
+
+  if( battstat->pixgc )
+    g_object_unref( G_OBJECT(battstat->pixgc) );
+
+  g_object_unref( G_OBJECT(battstat->status) );
+  g_object_unref( G_OBJECT(battstat->percent) );
+  g_object_unref( G_OBJECT(battstat->battery) );
+
+  g_free( battstat );
+
+  static_global_teardown (battstat);
+}
+
+/* Common function invoked by the 'Help' context menu item and the 'Help'
+ * button in the preferences dialog.
+ */
+void
+battstat_show_help( ProgressData *battstat, const char *section )
+{
+  GError *error = NULL;
+  char *uri;
+
+  if (section)
+    uri = g_strdup_printf ("ghelp:battstat?%s", section);
+  else
+    uri = g_strdup ("ghelp:battstat");
+
+  gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (battstat->applet)),
+                uri,
+                gtk_get_current_event_time (),
+                &error);
+
+  g_free (uri);
+
+  if( error )
+  {
+    char *message;
+
+    message = g_strdup_printf( _("There was an error displaying help: %s"),
+                               error->message );
+    battstat_error_dialog( battstat->applet, message );
+    g_error_free( error );
+    g_free( message );
+  }
+}
+
+
+/* Called when the user selects the 'help' menu item.
+ */
+static void
+help_cb( GtkAction *action, ProgressData *battstat )
+{
+  battstat_show_help( battstat, NULL );
+}
+
+/* Called when the user selects the 'about' menu item.
+ */
+static void
+about_cb( GtkAction *action, ProgressData *battstat )
+{
+  const gchar *authors[] = {
+    "J\xC3\xB6rgen Pehrson <[email protected]>",
+    "Lennart Poettering <[email protected]> (Linux ACPI support)",
+    "Seth Nickell <[email protected]> (MATE2 port)",
+    "Davyd Madeley <[email protected]>",
+    "Ryan Lortie <[email protected]>",
+    "Joe Marcus Clarke <[email protected]> (FreeBSD ACPI support)",
+    NULL
+   };
+
+  const gchar *documenters[] = {
+    "J\xC3\xB6rgen Pehrson <[email protected]>",
+    "Trevor Curtis <[email protected]>",
+    "Davyd Madeley <[email protected]>",
+    NULL
+  };
+
+  char *comments = g_strdup_printf ("%s\n\n%s",
+		  _("This utility shows the status of your laptop battery."),
+		  power_management_using_hal () ?
+		  	/* true */ _("HAL backend enabled.") :
+			/* false */ _("Legacy (non-HAL) backend enabled."));
+
+  gtk_show_about_dialog( NULL,
+    "version",             VERSION,
+    "copyright",           "\xC2\xA9 2000 The Gnulix Society, "
+                           "\xC2\xA9 2002-2005 Free Software Foundation and "
+                           "others",
+    "comments",            comments,
+    "authors",             authors,
+    "documenters",         documenters,
+    "translator-credits",  _("translator-credits"),
+    "logo-icon-name",      "battery",
+    NULL );
+
+  g_free (comments);
+}
+
+/* Rotate text on side panels.  Called on initial startup and when the
+ * orientation changes (ie: the panel we were on moved or we moved to
+ * another panel).
+ */
+static void
+setup_text_orientation( ProgressData *battstat )
+{
+  if( battstat->orienttype == MATE_PANEL_APPLET_ORIENT_RIGHT )
+    gtk_label_set_angle( GTK_LABEL( battstat->percent ), 90 );
+  else if( battstat->orienttype == MATE_PANEL_APPLET_ORIENT_LEFT )
+    gtk_label_set_angle( GTK_LABEL( battstat->percent ), 270 );
+  else
+    gtk_label_set_angle( GTK_LABEL( battstat->percent ), 0 );
+}
+
+
+/* This signal is delivered by the panel when the orientation of the applet
+   has changed.  This is either because the applet has just been created,
+   has just been moved to a new panel or the panel that the applet was on
+   has changed orientation.
+*/
+static void
+change_orient (MatePanelApplet       *applet,
+	       MatePanelAppletOrient  orient,
+	       ProgressData      *battstat)
+{
+  if (DEBUG) g_print("change_orient()\n");
+
+  /* Ignore the update if we already know. */
+  if( orient != battstat->orienttype )
+  {
+    battstat->orienttype = orient;
+
+    /* The applet changing orientation very likely involves the layout
+       being changed to better fit the new shape of the panel.
+    */
+    setup_text_orientation( battstat );
+    reconfigure_layout( battstat );
+  }
+}
+
+/* This is delivered when our size has changed.  This happens when the applet
+   is just created or if the size of the panel has changed.
+*/
+static void
+size_allocate( MatePanelApplet *applet, GtkAllocation *allocation,
+               ProgressData *battstat)
+{
+  if (DEBUG) g_print("applet_change_pixel_size()\n");
+
+  /* Ignore the update if we already know. */
+  if( battstat->width == allocation->width &&
+      battstat->height == allocation->height )
+    return;
+
+  battstat->width = allocation->width;
+  battstat->height = allocation->height;
+
+  /* The applet changing size could result in the layout changing. */
+  reconfigure_layout( battstat );
+}
+
+/* Get our settings out of mateconf.
+ */
+static void
+load_preferences(ProgressData *battstat)
+{
+  MatePanelApplet *applet = MATE_PANEL_APPLET (battstat->applet);
+
+  if (DEBUG) g_print("load_preferences()\n");
+
+  battstat->red_val = mate_panel_applet_mateconf_get_int (applet, MATECONF_PATH "red_value", NULL);
+  battstat->red_val = CLAMP (battstat->red_val, 0, 100);
+  battstat->red_value_is_time = mate_panel_applet_mateconf_get_bool (applet,
+		  MATECONF_PATH "red_value_is_time",
+		  NULL);
+
+  /* automatically calculate orangle and yellow values from the red value */
+  battstat->orange_val = battstat->red_val * ORANGE_MULTIPLIER;
+  battstat->orange_val = CLAMP (battstat->orange_val, 0, 100);
+
+  battstat->yellow_val = battstat->red_val * YELLOW_MULTIPLIER;
+  battstat->yellow_val = CLAMP (battstat->yellow_val, 0, 100);
+
+  battstat->lowbattnotification = mate_panel_applet_mateconf_get_bool (applet, MATECONF_PATH "low_battery_notification", NULL);
+  battstat->fullbattnot = mate_panel_applet_mateconf_get_bool (applet, MATECONF_PATH "full_battery_notification", NULL);
+  battstat->beep = mate_panel_applet_mateconf_get_bool (applet, MATECONF_PATH "beep", NULL);
+  battstat->draintop = mate_panel_applet_mateconf_get_bool (applet, MATECONF_PATH "drain_from_top", NULL);
+
+  battstat->showstatus = mate_panel_applet_mateconf_get_bool (applet, MATECONF_PATH "show_status", NULL);
+  battstat->showbattery = mate_panel_applet_mateconf_get_bool (applet, MATECONF_PATH "show_battery", NULL);
+
+  /* for miagration from older versions */
+  if (battstat->showstatus && battstat->showbattery)
+	  battstat->showbattery = FALSE;
+
+  battstat->showtext = mate_panel_applet_mateconf_get_int (applet, MATECONF_PATH "show_text", NULL);
+}
+
+/* Convenience function to attach a child widget to a GtkTable in the
+   position indicated by 'loc'.  This is very special-purpose for 3x3
+   tables and only supports positions that are used in this applet.
+ */
+static void
+table_layout_attach( GtkTable *table, LayoutLocation loc, GtkWidget *child )
+{
+  GtkAttachOptions flags;
+
+  flags = GTK_FILL | GTK_EXPAND;
+
+  switch( loc )
+  {
+    case LAYOUT_LONG:
+      gtk_table_attach( table, child, 1, 2, 0, 2, flags, flags, 2, 2 );
+      break;
+
+    case LAYOUT_TOPLEFT:
+      gtk_table_attach( table, child, 0, 1, 0, 1, flags, flags, 2, 2 );
+      break;
+
+    case LAYOUT_TOP:
+      gtk_table_attach( table, child, 1, 2, 0, 1, flags, flags, 2, 2 );
+      break;
+
+    case LAYOUT_LEFT:
+      gtk_table_attach( table, child, 0, 1, 1, 2, flags, flags, 2, 2 );
+      break;
+
+    case LAYOUT_CENTRE:
+      gtk_table_attach( table, child, 1, 2, 1, 2, flags, flags, 2, 2 );
+      break;
+
+    case LAYOUT_RIGHT:
+      gtk_table_attach( table, child, 2, 3, 1, 2, flags, flags, 2, 2 );
+      break;
+
+    case LAYOUT_BOTTOM:
+      gtk_table_attach( table, child, 1, 2, 2, 3, flags, flags, 2, 2 );
+      break;
+
+    default:
+      break;
+  }
+}
+
+/* The layout has (maybe) changed.  Calculate what layout we ought to be
+   using and update some things if anything has changed.  This is called
+   from size/orientation change callbacks and from the preferences dialog
+   when elements get added or removed.
+ */
+void
+reconfigure_layout( ProgressData *battstat )
+{
+  gboolean up_down_order = FALSE;
+  gboolean do_square = FALSE;
+  LayoutConfiguration c;
+  int battery_horiz = 0;
+  int needwidth;
+
+  /* Decide if we are doing to do 'square' mode. */
+  switch( battstat->orienttype )
+  {
+    case MATE_PANEL_APPLET_ORIENT_UP:
+    case MATE_PANEL_APPLET_ORIENT_DOWN:
+      up_down_order = TRUE;
+
+      /* Need to be at least 46px tall to do square mode on a horiz. panel */
+      if( battstat->height >= 46 )
+        do_square = TRUE;
+      break;
+
+    case MATE_PANEL_APPLET_ORIENT_LEFT:
+    case MATE_PANEL_APPLET_ORIENT_RIGHT:
+      /* We need 64px to fix the text beside anything. */
+      if( battstat->showtext )
+        needwidth = 64;
+      /* We need 48px to fix the icon and battery side-by-side. */
+      else
+        needwidth = 48;
+
+      if( battstat->width >= needwidth )
+        do_square = TRUE;
+      break;
+  }
+
+  /* Default to no elements being displayed. */
+  c.status = c.text = c.battery = LAYOUT_NONE;
+
+  if( do_square )
+  {
+    /* Square mode is only useful if we have the battery meter shown. */
+    if( battstat->showbattery )
+    {
+       c.battery = LAYOUT_LONG;
+
+      /* if( battstat->showstatus ) */ /* make this always true */
+        c.status = LAYOUT_TOPLEFT;
+
+      if( battstat->showtext )
+        c.text = LAYOUT_LEFT;
+    }
+    else
+    {
+      /* We have enough room to do 'square' mode but the battery meter is
+         not requested.  We can, instead, take up the extra space by stacking
+         our items in the opposite order that we normally would (ie: stack
+         horizontally on a vertical panel and vertically on horizontal).
+      */
+      up_down_order = !up_down_order;
+      do_square = FALSE;
+    }
+  }
+
+  if( !do_square )
+  {
+    if( up_down_order )
+    {
+      /* Stack horizontally for top and bottom panels. */
+      /* if( battstat->showstatus ) */ /* make this always true */
+        c.status = LAYOUT_LEFT;
+      if( battstat->showbattery )
+        c.battery = LAYOUT_CENTRE;
+      if( battstat->showtext )
+        c.text = LAYOUT_RIGHT;
+
+      battery_horiz = 1;
+    }
+    else
+    {
+      /* Stack vertically for left and right panels. */
+      /* if( battstat->showstatus ) */ /* make this always true */
+        c.status = LAYOUT_TOP;
+      if( battstat->showbattery )
+        c.battery = LAYOUT_CENTRE;
+      if( battstat->showtext )
+        c.text = LAYOUT_BOTTOM;
+    }
+  }
+
+  if( memcmp( &c, &battstat->layout, sizeof (LayoutConfiguration) ) )
+  {
+    /* Something in the layout has changed.  Rebuild. */
+
+    /* Start by removing any elements in the table from the table. */
+    if( battstat->layout.text )
+      gtk_container_remove( GTK_CONTAINER( battstat->table ),
+                            battstat->percent );
+    if( battstat->layout.status )
+      gtk_container_remove( GTK_CONTAINER( battstat->table ),
+                            battstat->status );
+    if( battstat->layout.battery )
+      gtk_container_remove( GTK_CONTAINER( battstat->table ),
+                            battstat->battery );
+
+    /* Attach the elements to their new locations. */
+    table_layout_attach( GTK_TABLE(battstat->table),
+                         c.battery, battstat->battery );
+    table_layout_attach( GTK_TABLE(battstat->table),
+                         c.status, battstat->status );
+    table_layout_attach( GTK_TABLE(battstat->table),
+                         c.text, battstat->percent );
+
+    gtk_widget_show_all( battstat->applet );
+  }
+
+  /* If we are showing the battery meter and we weren't showing it before or
+     if the orientation has changed, we had better update it right now.
+  */
+  if( (c.battery && !battstat->layout.battery) ||
+       battery_horiz != battstat->horizont )
+  {
+    battstat->horizont = battery_horiz;
+    update_battery_image (battstat,
+		    battstat->last_batt_life, battstat->last_minutes);
+  }
+
+  battstat->layout = c;
+
+  /* Check for generic updates. This is required, for example, to make sure
+     the text label is immediately updated to show the time remaining or
+     percentage.
+  */
+  check_for_updates( battstat );
+}
+
+/* Allocate the widgets for the applet and connect our signals.
+ */
+static gint
+create_layout(ProgressData *battstat)
+{
+  if (DEBUG) g_print("create_layout()\n");
+
+  /* Have our background automatically painted. */
+  mate_panel_applet_set_background_widget( MATE_PANEL_APPLET( battstat->applet ),
+                                      GTK_WIDGET( battstat->applet ) );
+
+  /* Allocate the four widgets that we need. */
+  battstat->table = gtk_table_new( 3, 3, FALSE );
+  battstat->percent = gtk_label_new( "" );
+  battstat->status = gtk_image_new();
+  battstat->battery = gtk_image_new();
+
+  /* When you first get a pointer to a newly created GtkWidget it has one
+     'floating' reference.  When you first add this widget to a container
+     the container adds a real reference and removes the floating reference
+     if one exists.  Since we insert/remove these widgets from the table
+     when our layout is reconfigured, we need to keep our own 'real'
+     reference to each widget.  This adds a real reference to each widget
+     and "sinks" the floating reference.
+  */
+  g_object_ref( battstat->status );
+  g_object_ref( battstat->percent );
+  g_object_ref( battstat->battery );
+  g_object_ref_sink( GTK_OBJECT( battstat->status ) );
+  g_object_ref_sink( GTK_OBJECT( battstat->percent ) );
+  g_object_ref_sink( GTK_OBJECT( battstat->battery ) );
+
+  /* Let reconfigure_layout know that the table is currently empty. */
+  battstat->layout.status = LAYOUT_NONE;
+  battstat->layout.text = LAYOUT_NONE;
+  battstat->layout.battery = LAYOUT_NONE;
+
+  /* Put the table directly inside the applet and show everything. */
+  gtk_container_add (GTK_CONTAINER (battstat->applet), battstat->table);
+  gtk_widget_show_all (battstat->applet);
+
+  /* Attach all sorts of signals to the applet. */
+  g_signal_connect(G_OBJECT(battstat->applet),
+                   "destroy",
+                   G_CALLBACK(destroy_applet),
+                   battstat);
+
+  g_signal_connect (battstat->applet,
+		    "change_orient",
+		    G_CALLBACK(change_orient),
+		    battstat);
+
+  g_signal_connect (battstat->applet,
+		    "size_allocate",
+   		    G_CALLBACK (size_allocate),
+		    battstat);
+
+  return FALSE;
+}
+
+/* Called by the factory to fill in the fields for the applet.
+ */
+static gboolean
+battstat_applet_fill (MatePanelApplet *applet)
+{
+  ProgressData *battstat;
+  AtkObject *atk_widget;
+  GtkActionGroup *action_group;
+  gchar *ui_path;
+  const char *err;
+  int no_hal;
+
+  if (DEBUG) g_print("main()\n");
+
+  g_set_application_name (_("Battery Charge Monitor"));
+
+  gtk_window_set_default_icon_name ("battery");
+
+  mate_panel_applet_add_preferences (applet, "/schemas/apps/battstat-applet/prefs",
+                                NULL);
+  mate_panel_applet_set_flags (applet, MATE_PANEL_APPLET_EXPAND_MINOR);
+
+  battstat = g_new0 (ProgressData, 1);
+
+  /* Some starting values... */
+  battstat->applet = GTK_WIDGET (applet);
+  battstat->refresh_label = TRUE;
+  battstat->last_batt_life = 1000;
+  battstat->last_acline_status = 1000;
+  battstat->last_pixmap_index = 1000;
+  battstat->last_charging = 1000;
+  battstat->orienttype = mate_panel_applet_get_orient (applet);
+  battstat->horizont = TRUE;
+  battstat->battery_low_dialog = NULL;
+  battstat->battery_low_label = NULL;
+  battstat->pixgc = NULL;
+  battstat->timeout = -1;
+  battstat->timeout_id = 0;
+
+  /* The first received size_allocate event will cause a reconfigure. */
+  battstat->height = -1;
+  battstat->width = -1;
+
+  load_preferences (battstat);
+  create_layout (battstat);
+  setup_text_orientation( battstat );
+
+  action_group = gtk_action_group_new ("Battstat Applet Actions");
+  gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
+  gtk_action_group_add_actions (action_group,
+				battstat_menu_actions,
+				G_N_ELEMENTS (battstat_menu_actions),
+				battstat);
+  ui_path = g_build_filename (BATTSTAT_MENU_UI_DIR, "battstat-applet-menu.xml", NULL);
+  mate_panel_applet_setup_menu_from_file (MATE_PANEL_APPLET (battstat->applet),
+				     ui_path, action_group);
+  g_free (ui_path);
+
+  if (mate_panel_applet_get_locked_down (MATE_PANEL_APPLET (battstat->applet))) {
+	  GtkAction *action;
+
+	  action = gtk_action_group_get_action (action_group, "BattstatProperties");
+	  gtk_action_set_visible (action, FALSE);
+  }
+  g_object_unref (action_group);
+
+  atk_widget = gtk_widget_get_accessible (battstat->applet);
+  if (GTK_IS_ACCESSIBLE (atk_widget)) {
+	  atk_object_set_name (atk_widget, _("Battery Charge Monitor"));
+	  atk_object_set_description(atk_widget, _("Monitor a laptop's remaining power"));
+  }
+
+  no_hal = mate_panel_applet_mateconf_get_bool( applet, "no_hal", NULL );
+
+  if ((err = static_global_initialisation (no_hal, battstat)))
+    battstat_error_dialog (GTK_WIDGET (applet), err);
+
+  return TRUE;
+}
+
+/* Boilerplate... */
+static gboolean
+battstat_applet_factory (MatePanelApplet *applet,
+			 const gchar          *iid,
+			 gpointer              data)
+{
+  gboolean retval = FALSE;
+
+  if (!strcmp (iid, "BattstatApplet"))
+    retval = battstat_applet_fill (applet);
+
+  return retval;
+}
+
+
+MATE_PANEL_APPLET_OUT_PROCESS_FACTORY ("BattstatAppletFactory",
+				  PANEL_TYPE_APPLET,
+				  "battstat",
+				  battstat_applet_factory,
+				  NULL)
+
+