moved from Mate-Extra

1 files changed, 661 insertions, 0 deletions

diff --git a/src/gpm-upower.c b/src/gpm-upower.c
new file mode 100644
index 0000000..f659c51
--- /dev/null
+++ b/src/gpm-upower.c
@@ -0,0 +1,661 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * Copyright (C) 2008 Richard Hughes <[email protected]>
+ *
+ * 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.
+ */
+
+#include "config.h"
+
+#include <glib/gi18n.h>
+#include <libupower-glib/upower.h>
+
+#include "egg-debug.h"
+#include "egg-precision.h"
+
+#include "gpm-upower.h"
+#include "gpm-common.h"
+
+#define GPM_UP_TIME_PRECISION			5*60
+#define GPM_UP_TEXT_MIN_TIME			120
+
+/**
+ * gpm_upower_get_device_icon_index:
+ * @percent: The charge of the device
+ *
+ * The index value depends on the percentage charge:
+ *	00-10  = 000
+ *	10-30  = 020
+ *	30-50  = 040
+ *	50-70  = 060
+ *	70-90  = 080
+ *	90-100 = 100
+ *
+ * Return value: The character string for the filename suffix.
+ **/
+static const gchar *
+gpm_upower_get_device_icon_index (UpDevice *device)
+{
+	gdouble percentage;
+	/* get device properties */
+	g_object_get (device, "percentage", &percentage, NULL);
+	if (percentage < 10)
+		return "000";
+	else if (percentage < 30)
+		return "020";
+	else if (percentage < 50)
+		return "040";
+	else if (percentage < 70)
+		return "060";
+	else if (percentage < 90)
+		return "080";
+	return "100";
+}
+
+/**
+ * gpm_upower_get_device_icon:
+ *
+ * Need to free the return value
+ *
+ **/
+gchar *
+gpm_upower_get_device_icon (UpDevice *device)
+{
+	gchar *filename = NULL;
+	const gchar *prefix = NULL;
+	const gchar *index_str;
+	UpDeviceKind kind;
+	UpDeviceState state;
+	gboolean is_present;
+	gdouble percentage;
+
+	g_return_val_if_fail (device != NULL, NULL);
+
+	/* get device properties */
+	g_object_get (device,
+		      "kind", &kind,
+		      "state", &state,
+		      "percentage", &percentage,
+		      "is-present", &is_present,
+		      NULL);
+
+	/* get correct icon prefix */
+	prefix = up_device_kind_to_string (kind);
+
+	/* get the icon from some simple rules */
+	if (kind == UP_DEVICE_KIND_LINE_POWER) {
+		filename = g_strdup ("gpm-ac-adapter");
+	} else if (kind == UP_DEVICE_KIND_MONITOR) {
+		filename = g_strdup ("gpm-monitor");
+	} else if (kind == UP_DEVICE_KIND_UPS) {
+		if (!is_present) {
+			/* battery missing */
+			filename = g_strdup_printf ("gpm-%s-missing", prefix);
+
+		} else if (state == UP_DEVICE_STATE_FULLY_CHARGED) {
+			filename = g_strdup_printf ("gpm-%s-100", prefix);
+
+		} else if (state == UP_DEVICE_STATE_CHARGING) {
+			index_str = gpm_upower_get_device_icon_index (device);
+			filename = g_strdup_printf ("gpm-%s-%s-charging", prefix, index_str);
+
+		} else if (state == UP_DEVICE_STATE_DISCHARGING) {
+			index_str = gpm_upower_get_device_icon_index (device);
+			filename = g_strdup_printf ("gpm-%s-%s", prefix, index_str);
+		}
+	} else if (kind == UP_DEVICE_KIND_BATTERY) {
+		if (!is_present) {
+			/* battery missing */
+			filename = g_strdup_printf ("gpm-%s-missing", prefix);
+
+		} else if (state == UP_DEVICE_STATE_EMPTY) {
+			filename = g_strdup_printf ("gpm-%s-empty", prefix);
+
+		} else if (state == UP_DEVICE_STATE_FULLY_CHARGED) {
+			filename = g_strdup_printf ("gpm-%s-charged", prefix);
+
+		} else if (state == UP_DEVICE_STATE_CHARGING) {
+			index_str = gpm_upower_get_device_icon_index (device);
+			filename = g_strdup_printf ("gpm-%s-%s-charging", prefix, index_str);
+
+		} else if (state == UP_DEVICE_STATE_DISCHARGING) {
+			index_str = gpm_upower_get_device_icon_index (device);
+			filename = g_strdup_printf ("gpm-%s-%s", prefix, index_str);
+
+		} else if (state == UP_DEVICE_STATE_PENDING_CHARGE) {
+			index_str = gpm_upower_get_device_icon_index (device);
+			/* FIXME: do new grey icons */
+			filename = g_strdup_printf ("gpm-%s-%s-charging", prefix, index_str);
+
+		} else if (state == UP_DEVICE_STATE_PENDING_DISCHARGE) {
+			index_str = gpm_upower_get_device_icon_index (device);
+			filename = g_strdup_printf ("gpm-%s-%s", prefix, index_str);
+		} else {
+			filename = g_strdup ("gpm-battery-missing");
+		}
+
+	} else if (kind == UP_DEVICE_KIND_MOUSE ||
+		   kind == UP_DEVICE_KIND_KEYBOARD ||
+		   kind == UP_DEVICE_KIND_PHONE) {
+		if (!is_present) {
+			/* battery missing */
+			filename = g_strdup_printf ("gpm-%s-000", prefix);
+
+		} else if (state == UP_DEVICE_STATE_FULLY_CHARGED) {
+			filename = g_strdup_printf ("gpm-%s-100", prefix);
+
+		} else if (state == UP_DEVICE_STATE_DISCHARGING) {
+			index_str = gpm_upower_get_device_icon_index (device);
+			filename = g_strdup_printf ("gpm-%s-%s", prefix, index_str);
+		}
+	}
+
+	/* nothing matched */
+	if (filename == NULL) {
+		egg_warning ("nothing matched, falling back to default icon");
+		filename = g_strdup ("dialog-warning");
+	}
+
+	egg_debug ("got filename: %s", filename);
+	return filename;
+}
+
+/**
+ * gpm_upower_get_device_summary:
+ **/
+gchar *
+gpm_upower_get_device_summary (UpDevice *device)
+{
+	const gchar *kind_desc = NULL;
+	gchar *description = NULL;
+	guint time_to_full_round;
+	guint time_to_empty_round;
+	gchar *time_to_full_str;
+	gchar *time_to_empty_str;
+	UpDeviceKind kind;
+	UpDeviceState state;
+	gdouble percentage;
+	gboolean is_present;
+	gint64 time_to_full;
+	gint64 time_to_empty;
+
+	/* get device properties */
+	g_object_get (device,
+		      "kind", &kind,
+		      "state", &state,
+		      "percentage", &percentage,
+		      "is-present", &is_present,
+		      "time-to-full", &time_to_full,
+		      "time-to-empty", &time_to_empty,
+		      NULL);
+
+	if (!is_present)
+		return NULL;
+
+	kind_desc = gpm_device_kind_to_localised_text (kind, 1);
+
+	/* don't display all the extra stuff for keyboards and mice */
+	if (kind == UP_DEVICE_KIND_MOUSE ||
+	    kind == UP_DEVICE_KIND_KEYBOARD ||
+	    kind == UP_DEVICE_KIND_PDA)
+		return g_strdup_printf ("%s (%.1f%%)", kind_desc, percentage);
+
+	/* we care if we are on AC */
+	if (kind == UP_DEVICE_KIND_PHONE) {
+		if (state == UP_DEVICE_STATE_CHARGING || !state == UP_DEVICE_STATE_DISCHARGING) {
+			/* TRANSLATORS: a phone is charging */
+			return g_strdup_printf (_("%s charging (%.1f%%)"), kind_desc, percentage);
+		}
+		return g_strdup_printf ("%s (%.1f%%)", kind_desc, percentage);
+	}
+
+	/* precalculate so we don't get Unknown time remaining */
+	time_to_full_round = egg_precision_round_down (time_to_full, GPM_UP_TIME_PRECISION);
+	time_to_empty_round = egg_precision_round_down (time_to_empty, GPM_UP_TIME_PRECISION);
+
+	/* we always display "Laptop battery 16 minutes remaining" as we need to clarify what device we are refering to */
+	if (state == UP_DEVICE_STATE_FULLY_CHARGED) {
+
+		if (kind == UP_DEVICE_KIND_BATTERY && time_to_empty_round > GPM_UP_TEXT_MIN_TIME) {
+			time_to_empty_str = gpm_get_timestring (time_to_empty_round);
+			/* TRANSLATORS: The laptop battery is fully charged, and we know a time */
+			description = g_strdup_printf (_("Battery is fully charged.\nProvides %s laptop runtime"),
+							time_to_empty_str);
+			g_free (time_to_empty_str);
+		} else {
+			/* TRANSLATORS: the device is fully charged */
+			description = g_strdup_printf (_("%s is fully charged"), kind_desc);
+		}
+
+	} else if (state == UP_DEVICE_STATE_DISCHARGING) {
+
+		if (time_to_empty_round > GPM_UP_TEXT_MIN_TIME) {
+			time_to_empty_str = gpm_get_timestring (time_to_empty_round);
+			/* TRANSLATORS: the device is discharging, and we have a time remaining */
+			description = g_strdup_printf (_("%s %s remaining (%.1f%%)"),
+							kind_desc, time_to_empty_str, percentage);
+			g_free (time_to_empty_str);
+		} else {
+			/* TRANSLATORS: the device is discharging, but we only have a percentage */
+			description = g_strdup_printf (_("%s discharging (%.1f%%)"),
+							kind_desc, percentage);
+		}
+
+	} else if (state == UP_DEVICE_STATE_CHARGING) {
+
+		if (time_to_full_round > GPM_UP_TEXT_MIN_TIME &&
+		    time_to_empty_round > GPM_UP_TEXT_MIN_TIME) {
+
+			/* display both discharge and charge time */
+			time_to_full_str = gpm_get_timestring (time_to_full_round);
+			time_to_empty_str = gpm_get_timestring (time_to_empty_round);
+
+			/* TRANSLATORS: the device is charging, and we have a time to full and empty */
+			description = g_strdup_printf (_("%s %s until charged (%.1f%%)\nProvides %s battery runtime"),
+							kind_desc, time_to_full_str, percentage, time_to_empty_str);
+			g_free (time_to_full_str);
+			g_free (time_to_empty_str);
+
+		} else if (time_to_full_round > GPM_UP_TEXT_MIN_TIME) {
+
+			/* display only charge time */
+			time_to_full_str = gpm_get_timestring (time_to_full_round);
+
+			/* TRANSLATORS: device is charging, and we have a time to full and a percentage */
+			description = g_strdup_printf (_("%s %s until charged (%.1f%%)"),
+						kind_desc, time_to_full_str, percentage);
+			g_free (time_to_full_str);
+		} else {
+
+			/* TRANSLATORS: device is charging, but we only have a percentage */
+			description = g_strdup_printf (_("%s charging (%.1f%%)"),
+						kind_desc, percentage);
+		}
+
+	} else if (state == UP_DEVICE_STATE_PENDING_DISCHARGE) {
+
+		/* TRANSLATORS: this is only shown for laptops with multiple batteries */
+		description = g_strdup_printf (_("%s waiting to discharge (%.1f%%)"),
+						kind_desc, percentage);
+
+	} else if (state == UP_DEVICE_STATE_PENDING_CHARGE) {
+
+		/* TRANSLATORS: this is only shown for laptops with multiple batteries */
+		description = g_strdup_printf (_("%s waiting to charge (%.1f%%)"), kind_desc, percentage);
+
+	} else {
+		egg_warning ("in an undefined state we are not charging or "
+			     "discharging and the batteries are also not charged");
+		description = g_strdup_printf ("%s (%.1f%%)", kind_desc, percentage);
+	}
+	return description;
+}
+
+/**
+ * gpm_upower_get_device_description:
+ **/
+gchar *
+gpm_upower_get_device_description (UpDevice *device)
+{
+	GString	*details;
+	const gchar *text;
+	gchar *time_str;
+	UpDeviceKind kind;
+	UpDeviceState state;
+	UpDeviceTechnology technology;
+	gdouble percentage;
+	gdouble capacity;
+	gdouble energy;
+	gdouble energy_full;
+	gdouble energy_full_design;
+	gdouble energy_rate;
+	gboolean is_present;
+	gint64 time_to_full;
+	gint64 time_to_empty;
+	gchar *vendor = NULL;
+	gchar *serial = NULL;
+	gchar *model = NULL;
+
+	g_return_val_if_fail (device != NULL, NULL);
+
+	/* get device properties */
+	g_object_get (device,
+		      "kind", &kind,
+		      "state", &state,
+		      "percentage", &percentage,
+		      "is-present", &is_present,
+		      "time-to-full", &time_to_full,
+		      "time-to-empty", &time_to_empty,
+		      "technology", &technology,
+		      "capacity", &capacity,
+		      "energy", &energy,
+		      "energy-full", &energy_full,
+		      "energy-full-design", &energy_full_design,
+		      "energy-rate", &energy_rate,
+		      "vendor", &vendor,
+		      "serial", &serial,
+		      "model", &model,
+		      NULL);
+
+	details = g_string_new ("");
+	text = gpm_device_kind_to_localised_text (kind, 1);
+	/* TRANSLATORS: the type of data, e.g. Laptop battery */
+	g_string_append_printf (details, "<b>%s</b> %s\n", _("Product:"), text);
+
+	if (!is_present) {
+		/* TRANSLATORS: device is missing */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Status:"), _("Missing"));
+	} else if (state == UP_DEVICE_STATE_FULLY_CHARGED) {
+		/* TRANSLATORS: device is charged */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Status:"), _("Charged"));
+	} else if (state == UP_DEVICE_STATE_CHARGING) {
+		/* TRANSLATORS: device is charging */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Status:"), _("Charging"));
+	} else if (state == UP_DEVICE_STATE_DISCHARGING) {
+		/* TRANSLATORS: device is discharging */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Status:"), _("Discharging"));
+	}
+
+	if (percentage >= 0) {
+		/* TRANSLATORS: percentage */
+		g_string_append_printf (details, "<b>%s</b> %.1f%%\n", _("Percentage charge:"), percentage);
+	}
+	if (vendor) {
+		/* TRANSLATORS: manufacturer */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Vendor:"), vendor);
+	}
+	if (technology != UP_DEVICE_TECHNOLOGY_UNKNOWN) {
+		text = gpm_device_technology_to_localised_string (technology);
+		/* TRANSLATORS: how the battery is made, e.g. Lithium Ion */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Technology:"), text);
+	}
+	if (serial) {
+		/* TRANSLATORS: serial number of the battery */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Serial number:"), serial);
+	}
+	if (model) {
+		/* TRANSLATORS: model number of the battery */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Model:"), model);
+	}
+	if (time_to_full > 0) {
+		time_str = gpm_get_timestring (time_to_full);
+		/* TRANSLATORS: time to fully charged */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Charge time:"), time_str);
+		g_free (time_str);
+	}
+	if (time_to_empty > 0) {
+		time_str = gpm_get_timestring (time_to_empty);
+		/* TRANSLATORS: time to empty */
+		g_string_append_printf (details, "<b>%s</b> %s\n", _("Discharge time:"), time_str);
+		g_free (time_str);
+	}
+	if (capacity > 0) {
+		const gchar *condition;
+		if (capacity > 99) {
+			/* TRANSLATORS: Excellent, Good, Fair and Poor are all related to battery Capacity */
+			condition = _("Excellent");
+		} else if (capacity > 90) {
+			condition = _("Good");
+		} else if (capacity > 70) {
+			condition = _("Fair");
+		} else {
+			condition = _("Poor");
+		}
+		/* TRANSLATORS: %.1f is a percentage and %s the condition (Excellent, Good, ...) */
+		g_string_append_printf (details, "<b>%s</b> %.1f%% (%s)\n",
+					_("Capacity:"), capacity, condition);
+	}
+	if (kind == UP_DEVICE_KIND_BATTERY) {
+		if (energy > 0) {
+			/* TRANSLATORS: current charge */
+			g_string_append_printf (details, "<b>%s</b> %.1f Wh\n",
+						_("Current charge:"), energy);
+		}
+		if (energy_full > 0 &&
+		    energy_full_design != energy_full) {
+			/* TRANSLATORS: last full is the charge the battery was seen to charge to */
+			g_string_append_printf (details, "<b>%s</b> %.1f Wh\n",
+						_("Last full charge:"), energy_full);
+		}
+		if (energy_full_design > 0) {
+			/* Translators:  */
+			/* TRANSLATORS: Design charge is the amount of charge the battery is designed to have when brand new */
+			g_string_append_printf (details, "<b>%s</b> %.1f Wh\n",
+						_("Design charge:"), energy_full_design);
+		}
+		if (energy_rate > 0) {
+			/* TRANSLATORS: the charge or discharge rate */
+			g_string_append_printf (details, "<b>%s</b> %.1f W\n",
+						_("Charge rate:"), energy_rate);
+		}
+	}
+	if (kind == UP_DEVICE_KIND_MOUSE ||
+	    kind == UP_DEVICE_KIND_KEYBOARD) {
+		if (energy > 0) {
+			/* TRANSLATORS: the current charge for CSR devices */
+			g_string_append_printf (details, "<b>%s</b> %.0f/7\n",
+						_("Current charge:"), energy);
+		}
+		if (energy_full_design > 0) {
+			/* TRANSLATORS: the design charge for CSR devices */
+			g_string_append_printf (details, "<b>%s</b> %.0f/7\n",
+						_("Design charge:"), energy_full_design);
+		}
+	}
+	/* remove the last \n */
+	g_string_truncate (details, details->len-1);
+
+	g_free (vendor);
+	g_free (serial);
+	g_free (model);
+	return g_string_free (details, FALSE);
+}
+
+/**
+ * gpm_device_kind_to_localised_text:
+ **/
+const gchar *
+gpm_device_kind_to_localised_text (UpDeviceKind kind, guint number)
+{
+	const gchar *text = NULL;
+	switch (kind) {
+	case UP_DEVICE_KIND_LINE_POWER:
+		/* TRANSLATORS: system power cord */
+		text = ngettext ("AC adapter", "AC adapters", number);
+		break;
+	case UP_DEVICE_KIND_BATTERY:
+		/* TRANSLATORS: laptop primary battery */
+		text = ngettext ("Laptop battery", "Laptop batteries", number);
+		break;
+	case UP_DEVICE_KIND_UPS:
+		/* TRANSLATORS: battery-backed AC power source */
+		text = ngettext ("UPS", "UPSs", number);
+		break;
+	case UP_DEVICE_KIND_MONITOR:
+		/* TRANSLATORS: a monitor is a device to measure voltage and current */
+		text = ngettext ("Monitor", "Monitors", number);
+		break;
+	case UP_DEVICE_KIND_MOUSE:
+		/* TRANSLATORS: wireless mice with internal batteries */
+		text = ngettext ("Mouse", "Mice", number);
+		break;
+	case UP_DEVICE_KIND_KEYBOARD:
+		/* TRANSLATORS: wireless keyboard with internal battery */
+		text = ngettext ("Keyboard", "Keyboards", number);
+		break;
+	case UP_DEVICE_KIND_PDA:
+		/* TRANSLATORS: portable device */
+		text = ngettext ("PDA", "PDAs", number);
+		break;
+	case UP_DEVICE_KIND_PHONE:
+		/* TRANSLATORS: cell phone (mobile...) */
+		text = ngettext ("Cell phone", "Cell phones", number);
+		break;
+#if UP_CHECK_VERSION(0,9,5)
+	case UP_DEVICE_KIND_MEDIA_PLAYER:
+		/* TRANSLATORS: media player, mp3 etc */
+		text = ngettext ("Media player", "Media players", number);
+		break;
+	case UP_DEVICE_KIND_TABLET:
+		/* TRANSLATORS: tablet device */
+		text = ngettext ("Tablet", "Tablets", number);
+		break;
+	case UP_DEVICE_KIND_COMPUTER:
+		/* TRANSLATORS: tablet device */
+		text = ngettext ("Computer", "Computers", number);
+		break;
+#endif
+	default:
+		egg_warning ("enum unrecognised: %i", kind);
+		text = up_device_kind_to_string (kind);
+	}
+	return text;
+}
+
+/**
+ * gpm_device_kind_to_icon:
+ **/
+const gchar *
+gpm_device_kind_to_icon (UpDeviceKind kind)
+{
+	const gchar *icon = NULL;
+	switch (kind) {
+	case UP_DEVICE_KIND_LINE_POWER:
+		icon = "gpm-ac-adapter";
+		break;
+	case UP_DEVICE_KIND_BATTERY:
+		icon = "battery";
+		break;
+	case UP_DEVICE_KIND_UPS:
+		icon = "network-wired";
+		break;
+	case UP_DEVICE_KIND_MONITOR:
+		icon = "application-certificate";
+		break;
+	case UP_DEVICE_KIND_MOUSE:
+		icon = "input-mouse";
+		break;
+	case UP_DEVICE_KIND_KEYBOARD:
+		icon = "input-keyboard";
+		break;
+	case UP_DEVICE_KIND_PDA:
+		icon = "pda";
+		break;
+	case UP_DEVICE_KIND_PHONE:
+		icon = "phone";
+		break;
+#if UP_CHECK_VERSION(0,9,5)
+	case UP_DEVICE_KIND_MEDIA_PLAYER:
+		icon = "multimedia-player";
+		break;
+	case UP_DEVICE_KIND_TABLET:
+		icon = "input-tablet";
+		break;
+	case UP_DEVICE_KIND_COMPUTER:
+		icon = "computer-apple-ipad";
+		break;
+#endif
+	default:
+		egg_warning ("enum unrecognised: %i", kind);
+		icon = "gtk-help";
+	}
+	return icon;
+}
+
+/**
+ * gpm_device_technology_to_localised_string:
+ **/
+const gchar *
+gpm_device_technology_to_localised_string (UpDeviceTechnology technology_enum)
+{
+	const gchar *technology = NULL;
+	switch (technology_enum) {
+	case UP_DEVICE_TECHNOLOGY_LITHIUM_ION:
+		/* TRANSLATORS: battery technology */
+		technology = _("Lithium Ion");
+		break;
+	case UP_DEVICE_TECHNOLOGY_LITHIUM_POLYMER:
+		/* TRANSLATORS: battery technology */
+		technology = _("Lithium Polymer");
+		break;
+	case UP_DEVICE_TECHNOLOGY_LITHIUM_IRON_PHOSPHATE:
+		/* TRANSLATORS: battery technology */
+		technology = _("Lithium Iron Phosphate");
+		break;
+	case UP_DEVICE_TECHNOLOGY_LEAD_ACID:
+		/* TRANSLATORS: battery technology */
+		technology = _("Lead acid");
+		break;
+	case UP_DEVICE_TECHNOLOGY_NICKEL_CADMIUM:
+		/* TRANSLATORS: battery technology */
+		technology = _("Nickel Cadmium");
+		break;
+	case UP_DEVICE_TECHNOLOGY_NICKEL_METAL_HYDRIDE:
+		/* TRANSLATORS: battery technology */
+		technology = _("Nickel metal hydride");
+		break;
+	case UP_DEVICE_TECHNOLOGY_UNKNOWN:
+		/* TRANSLATORS: battery technology */
+		technology = _("Unknown technology");
+		break;
+	default:
+		g_assert_not_reached ();
+		break;
+	}
+	return technology;
+}
+
+/**
+ * gpm_device_state_to_localised_string:
+ **/
+const gchar *
+gpm_device_state_to_localised_string (UpDeviceState state)
+{
+	const gchar *state_string = NULL;
+
+	switch (state) {
+	case UP_DEVICE_STATE_CHARGING:
+		/* TRANSLATORS: battery state */
+		state_string = _("Charging");
+		break;
+	case UP_DEVICE_STATE_DISCHARGING:
+		/* TRANSLATORS: battery state */
+		state_string = _("Discharging");
+		break;
+	case UP_DEVICE_STATE_EMPTY:
+		/* TRANSLATORS: battery state */
+		state_string = _("Empty");
+		break;
+	case UP_DEVICE_STATE_FULLY_CHARGED:
+		/* TRANSLATORS: battery state */
+		state_string = _("Charged");
+		break;
+	case UP_DEVICE_STATE_PENDING_CHARGE:
+		/* TRANSLATORS: battery state */
+		state_string = _("Waiting to charge");
+		break;
+	case UP_DEVICE_STATE_PENDING_DISCHARGE:
+		/* TRANSLATORS: battery state */
+		state_string = _("Waiting to discharge");
+		break;
+	default:
+		g_assert_not_reached ();
+		break;
+	}
+	return state_string;
+}
+