diff options
Diffstat (limited to 'src/gpm-upower.c')
| -rw-r--r-- | src/gpm-upower.c | 661 |
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; +} + |