2005-02-09 04:14:08 -08:00
|
|
|
/*
|
|
|
|
* vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
|
|
|
|
*/
|
2004-12-27 00:33:52 -08:00
|
|
|
#include "e.h"
|
|
|
|
#include "e_mod_main.h"
|
|
|
|
|
2005-08-02 02:52:30 -07:00
|
|
|
#ifdef __FreeBSD__
|
2005-08-02 02:55:03 -07:00
|
|
|
# include <sys/types.h>
|
|
|
|
# include <sys/sysctl.h>
|
|
|
|
# include <fcntl.h>
|
|
|
|
# ifdef __i386__
|
|
|
|
# include <machine/apm_bios.h>
|
|
|
|
# endif
|
|
|
|
# include <stdio.h>
|
2005-08-02 02:52:30 -07:00
|
|
|
#endif
|
|
|
|
|
2005-08-17 22:35:02 -07:00
|
|
|
#ifdef HAVE_CFBASE_H
|
|
|
|
#include <CFBase.h>
|
|
|
|
#include <CFNumber.h>
|
|
|
|
#include <CFArray.h>
|
|
|
|
#include <CFDictionary.h>
|
|
|
|
#include <CFRunLoop.h>
|
|
|
|
#include <ps/IOPSKeys.h>
|
|
|
|
#include <ps/IOPowerSources.h>
|
|
|
|
#endif
|
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
/* TODO List:
|
|
|
|
*
|
2005-02-10 04:00:39 -08:00
|
|
|
* which options should be in main menu, and which in face menu?
|
2004-12-27 00:33:52 -08:00
|
|
|
*/
|
|
|
|
|
|
|
|
/* module private routines */
|
2005-02-10 04:00:39 -08:00
|
|
|
static Battery *_battery_new();
|
|
|
|
static void _battery_shutdown(Battery *e);
|
|
|
|
static void _battery_config_menu_new(Battery *e);
|
|
|
|
static int _battery_cb_check(void *data);
|
|
|
|
static Status *_battery_linux_acpi_check(Battery *ef);
|
|
|
|
static Status *_battery_linux_apm_check(Battery *ef);
|
2005-08-30 05:15:36 -07:00
|
|
|
/* linux on powerbook */
|
|
|
|
static Status *_battery_linux_powerbook_check(Battery *ef);
|
2005-08-02 02:52:30 -07:00
|
|
|
/* Should these be #ifdef'd ? */
|
2005-08-02 02:55:03 -07:00
|
|
|
#ifdef __FreeBSD__
|
2005-08-02 02:52:30 -07:00
|
|
|
static Status *_battery_bsd_acpi_check(Battery *ef);
|
|
|
|
static Status *_battery_bsd_apm_check(Battery *ef);
|
2005-08-02 02:55:03 -07:00
|
|
|
#endif
|
2005-02-10 04:00:39 -08:00
|
|
|
|
2005-08-17 22:35:02 -07:00
|
|
|
#ifdef HAVE_CFBASE_H
|
|
|
|
static Status *_battery_darwin_check(Battery *ef);
|
|
|
|
#endif
|
|
|
|
|
2005-02-10 04:00:39 -08:00
|
|
|
static Battery_Face *_battery_face_new(E_Container *con);
|
|
|
|
static void _battery_face_free(Battery_Face *ef);
|
|
|
|
static void _battery_face_menu_new(Battery_Face *face);
|
|
|
|
static void _battery_face_enable(Battery_Face *face);
|
|
|
|
static void _battery_face_disable(Battery_Face *face);
|
|
|
|
static void _battery_face_cb_gmc_change(void *data, E_Gadman_Client *gmc, E_Gadman_Change change);
|
|
|
|
static void _battery_face_cb_mouse_down(void *data, Evas *e, Evas_Object *obj, void *event_info);
|
|
|
|
static void _battery_face_level_set(Battery_Face *ef, double level);
|
|
|
|
static void _battery_face_cb_menu_enabled(void *data, E_Menu *m, E_Menu_Item *mi);
|
2005-02-10 04:51:16 -08:00
|
|
|
static void _battery_face_cb_menu_edit(void *data, E_Menu *m, E_Menu_Item *mi);
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2005-10-25 03:51:58 -07:00
|
|
|
static int _battery_int_get(char *buf);
|
|
|
|
static char *_battery_string_get(char *buf);
|
|
|
|
|
2005-12-14 14:46:51 -08:00
|
|
|
static void _battery_face_cb_menu_configure(void *data, E_Menu *m, E_Menu_Item *mi);
|
|
|
|
|
2005-02-09 04:14:08 -08:00
|
|
|
static E_Config_DD *conf_edd;
|
|
|
|
static E_Config_DD *conf_face_edd;
|
2004-12-27 00:33:52 -08:00
|
|
|
|
2005-02-10 04:00:39 -08:00
|
|
|
static int battery_count;
|
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
/* public module routines. all modules must have these */
|
2005-09-24 06:42:05 -07:00
|
|
|
E_Module_Api e_modapi =
|
2005-09-23 10:13:47 -07:00
|
|
|
{
|
|
|
|
E_MODULE_API_VERSION,
|
|
|
|
"Battery"
|
|
|
|
};
|
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
void *
|
2005-04-11 20:34:31 -07:00
|
|
|
e_modapi_init(E_Module *m)
|
2004-12-27 00:33:52 -08:00
|
|
|
{
|
|
|
|
Battery *e;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
/* actually init battery */
|
2005-02-10 04:00:39 -08:00
|
|
|
e = _battery_new();
|
2005-02-09 04:14:08 -08:00
|
|
|
m->config_menu = e->config_menu;
|
2004-12-27 00:33:52 -08:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-04-11 20:34:31 -07:00
|
|
|
e_modapi_shutdown(E_Module *m)
|
2004-12-27 00:33:52 -08:00
|
|
|
{
|
|
|
|
Battery *e;
|
2005-02-09 04:14:08 -08:00
|
|
|
if (m->config_menu)
|
|
|
|
m->config_menu = NULL;
|
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
e = m->data;
|
|
|
|
if (e)
|
2005-02-09 04:14:08 -08:00
|
|
|
_battery_shutdown(e);
|
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-04-11 20:34:31 -07:00
|
|
|
e_modapi_save(E_Module *m)
|
2004-12-27 00:33:52 -08:00
|
|
|
{
|
|
|
|
Battery *e;
|
|
|
|
|
|
|
|
e = m->data;
|
2005-02-09 04:14:08 -08:00
|
|
|
e_config_domain_save("module.battery", conf_edd, e->conf);
|
2004-12-27 00:33:52 -08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-04-11 20:34:31 -07:00
|
|
|
e_modapi_info(E_Module *m)
|
2004-12-27 00:33:52 -08:00
|
|
|
{
|
|
|
|
char buf[4096];
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
snprintf(buf, sizeof(buf), "%s/module_icon.png", e_module_dir_get(m));
|
|
|
|
m->icon_file = strdup(buf);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2005-04-11 20:34:31 -07:00
|
|
|
e_modapi_about(E_Module *m)
|
2004-12-27 00:33:52 -08:00
|
|
|
{
|
2005-09-22 11:17:18 -07:00
|
|
|
e_module_dialog_show(_("Enlightenment Battery Module"),
|
|
|
|
_("A basic battery meter that uses either"
|
|
|
|
"<hilight>ACPI</hilight> or <hilight>APM</hilight><br>"
|
|
|
|
"on Linux to monitor your battery and AC power adaptor<br>"
|
|
|
|
"status. This will work under Linux and FreeBSD and is only<br>"
|
|
|
|
"as accurate as your BIOS or kernel drivers."));
|
2005-09-20 23:57:36 -07:00
|
|
|
return 1;
|
2004-12-27 00:33:52 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* module private routines */
|
|
|
|
static Battery *
|
2005-02-10 04:00:39 -08:00
|
|
|
_battery_new()
|
2004-12-27 00:33:52 -08:00
|
|
|
{
|
|
|
|
Battery *e;
|
2005-02-09 04:14:08 -08:00
|
|
|
Evas_List *managers, *l, *l2, *cl;
|
|
|
|
|
2005-02-10 04:00:39 -08:00
|
|
|
E_Menu_Item *mi;
|
|
|
|
|
|
|
|
battery_count = 0;
|
2005-02-09 04:14:08 -08:00
|
|
|
e = E_NEW(Battery, 1);
|
2004-12-27 00:33:52 -08:00
|
|
|
if (!e) return NULL;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
|
|
|
conf_face_edd = E_CONFIG_DD_NEW("Battery_Config_Face", Config_Face);
|
|
|
|
#undef T
|
|
|
|
#undef D
|
|
|
|
#define T Config_Face
|
|
|
|
#define D conf_face_edd
|
2005-04-01 08:12:31 -08:00
|
|
|
E_CONFIG_VAL(D, T, enabled, UCHAR);
|
2005-02-09 04:14:08 -08:00
|
|
|
|
|
|
|
conf_edd = E_CONFIG_DD_NEW("Battery_Config", Config);
|
2004-12-27 00:33:52 -08:00
|
|
|
#undef T
|
|
|
|
#undef D
|
|
|
|
#define T Config
|
2005-02-09 04:14:08 -08:00
|
|
|
#define D conf_edd
|
2005-01-01 18:39:44 -08:00
|
|
|
E_CONFIG_VAL(D, T, poll_time, DOUBLE);
|
2005-01-10 23:08:38 -08:00
|
|
|
E_CONFIG_VAL(D, T, alarm, INT);
|
2005-02-09 04:14:08 -08:00
|
|
|
E_CONFIG_LIST(D, T, faces, conf_face_edd);
|
|
|
|
|
|
|
|
e->conf = e_config_domain_load("module.battery", conf_edd);
|
2004-12-27 00:33:52 -08:00
|
|
|
if (!e->conf)
|
|
|
|
{
|
2005-01-10 23:08:38 -08:00
|
|
|
e->conf = E_NEW(Config, 1);
|
|
|
|
e->conf->poll_time = 30.0;
|
|
|
|
e->conf->alarm = 30;
|
2004-12-27 00:33:52 -08:00
|
|
|
}
|
2005-01-01 18:39:44 -08:00
|
|
|
E_CONFIG_LIMIT(e->conf->poll_time, 0.5, 1000.0);
|
2005-01-10 23:08:38 -08:00
|
|
|
E_CONFIG_LIMIT(e->conf->alarm, 0, 60);
|
2005-02-09 04:14:08 -08:00
|
|
|
|
|
|
|
_battery_config_menu_new(e);
|
|
|
|
|
|
|
|
e->battery_check_mode = CHECK_NONE;
|
|
|
|
e->battery_prev_drain = 1;
|
|
|
|
e->battery_prev_ac = -1;
|
|
|
|
e->battery_prev_battery = -1;
|
|
|
|
e->battery_check_timer = ecore_timer_add(e->conf->poll_time, _battery_cb_check, e);
|
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
managers = e_manager_list();
|
2005-02-10 04:00:39 -08:00
|
|
|
cl = e->conf->faces;
|
2004-12-27 00:33:52 -08:00
|
|
|
for (l = managers; l; l = l->next)
|
|
|
|
{
|
|
|
|
E_Manager *man;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
man = l->data;
|
|
|
|
for (l2 = man->containers; l2; l2 = l2->next)
|
|
|
|
{
|
|
|
|
E_Container *con;
|
|
|
|
Battery_Face *ef;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
con = l2->data;
|
2005-02-10 04:00:39 -08:00
|
|
|
ef = _battery_face_new(con);
|
2004-12-27 00:33:52 -08:00
|
|
|
if (ef)
|
|
|
|
{
|
2005-12-14 14:46:51 -08:00
|
|
|
ef->battery = e;
|
2005-02-09 04:14:08 -08:00
|
|
|
e->faces = evas_list_append(e->faces, ef);
|
2005-02-10 04:00:39 -08:00
|
|
|
|
|
|
|
/* Config */
|
|
|
|
if (!cl)
|
|
|
|
{
|
|
|
|
ef->conf = E_NEW(Config_Face, 1);
|
|
|
|
ef->conf->enabled = 1;
|
|
|
|
e->conf->faces = evas_list_append(e->conf->faces, ef->conf);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ef->conf = cl->data;
|
|
|
|
cl = cl->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Menu */
|
|
|
|
/* This menu must be initialized after conf */
|
|
|
|
_battery_face_menu_new(ef);
|
|
|
|
|
|
|
|
/* Add main menu to face menu */
|
2005-12-14 14:46:51 -08:00
|
|
|
mi = e_menu_item_new(e->config_menu);
|
|
|
|
e_menu_item_label_set(mi, _("Config Dialog"));
|
|
|
|
e_menu_item_callback_set(mi, _battery_face_cb_menu_configure, ef);
|
2005-02-10 04:00:39 -08:00
|
|
|
|
|
|
|
mi = e_menu_item_new(e->config_menu);
|
|
|
|
e_menu_item_label_set(mi, con->name);
|
|
|
|
e_menu_item_submenu_set(mi, ef->menu);
|
|
|
|
|
|
|
|
/* Setup */
|
|
|
|
if (!ef->conf->enabled)
|
|
|
|
_battery_face_disable(ef);
|
2004-12-27 00:33:52 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2005-02-09 04:14:08 -08:00
|
|
|
|
|
|
|
_battery_cb_check(e);
|
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
return e;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_battery_shutdown(Battery *e)
|
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
Evas_List *l;
|
|
|
|
|
|
|
|
E_CONFIG_DD_FREE(conf_edd);
|
|
|
|
E_CONFIG_DD_FREE(conf_face_edd);
|
|
|
|
|
|
|
|
for (l = e->faces; l; l = l->next)
|
|
|
|
_battery_face_free(l->data);
|
|
|
|
evas_list_free(e->faces);
|
|
|
|
|
|
|
|
e_object_del(E_OBJECT(e->config_menu));
|
2005-02-10 04:00:39 -08:00
|
|
|
|
|
|
|
ecore_timer_del(e->battery_check_timer);
|
|
|
|
|
2005-02-16 03:38:14 -08:00
|
|
|
evas_list_free(e->conf->faces);
|
2005-02-10 04:00:39 -08:00
|
|
|
free(e->conf);
|
2004-12-27 00:33:52 -08:00
|
|
|
free(e);
|
|
|
|
}
|
|
|
|
|
2005-01-10 23:08:38 -08:00
|
|
|
static void
|
|
|
|
_battery_menu_alarm_disable(void *data, E_Menu *m, E_Menu_Item *mi)
|
|
|
|
{
|
|
|
|
Battery *e;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2005-01-10 23:08:38 -08:00
|
|
|
e = data;
|
|
|
|
e->conf->alarm = 0;
|
2005-02-10 04:00:39 -08:00
|
|
|
e_config_save_queue();
|
2005-01-10 23:08:38 -08:00
|
|
|
}
|
|
|
|
|
2005-02-09 04:14:08 -08:00
|
|
|
static void
|
2004-12-27 00:33:52 -08:00
|
|
|
_battery_config_menu_new(Battery *e)
|
|
|
|
{
|
2005-02-10 08:42:07 -08:00
|
|
|
E_Menu *mn;
|
2004-12-27 00:33:52 -08:00
|
|
|
|
2005-02-10 04:00:39 -08:00
|
|
|
/* Alarm */
|
2004-12-27 00:33:52 -08:00
|
|
|
mn = e_menu_new();
|
2005-02-09 04:14:08 -08:00
|
|
|
e->config_menu = mn;
|
2004-12-27 00:33:52 -08:00
|
|
|
}
|
|
|
|
|
2005-02-10 04:00:39 -08:00
|
|
|
static Battery_Face *
|
|
|
|
_battery_face_new(E_Container *con)
|
2004-12-27 00:33:52 -08:00
|
|
|
{
|
|
|
|
Evas_Object *o;
|
2005-02-10 04:00:39 -08:00
|
|
|
Battery_Face *ef;
|
|
|
|
|
|
|
|
ef = E_NEW(Battery_Face, 1);
|
|
|
|
if (!ef) return NULL;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2005-02-10 04:00:39 -08:00
|
|
|
ef->con = con;
|
|
|
|
e_object_ref(E_OBJECT(con));
|
|
|
|
|
|
|
|
evas_event_freeze(con->bg_evas);
|
|
|
|
o = edje_object_add(con->bg_evas);
|
2004-12-27 00:33:52 -08:00
|
|
|
ef->bat_object = o;
|
|
|
|
|
2005-04-22 22:16:25 -07:00
|
|
|
e_theme_edje_object_set(o, "base/theme/modules/battery",
|
|
|
|
"modules/battery/main");
|
2004-12-27 00:33:52 -08:00
|
|
|
evas_object_show(o);
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2005-02-10 04:00:39 -08:00
|
|
|
o = evas_object_rectangle_add(con->bg_evas);
|
2004-12-27 00:33:52 -08:00
|
|
|
ef->event_object = o;
|
|
|
|
evas_object_layer_set(o, 2);
|
|
|
|
evas_object_repeat_events_set(o, 1);
|
|
|
|
evas_object_color_set(o, 0, 0, 0, 0);
|
2005-02-09 04:14:08 -08:00
|
|
|
evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_DOWN, _battery_face_cb_mouse_down, ef);
|
2004-12-27 00:33:52 -08:00
|
|
|
evas_object_show(o);
|
2005-01-25 06:24:38 -08:00
|
|
|
|
2005-02-10 04:00:39 -08:00
|
|
|
ef->gmc = e_gadman_client_new(con->gadman);
|
|
|
|
e_gadman_client_domain_set(ef->gmc, "module.battery", battery_count++);
|
2005-01-25 06:24:38 -08:00
|
|
|
e_gadman_client_policy_set(ef->gmc,
|
|
|
|
E_GADMAN_POLICY_ANYWHERE |
|
|
|
|
E_GADMAN_POLICY_HMOVE |
|
|
|
|
E_GADMAN_POLICY_VMOVE |
|
|
|
|
E_GADMAN_POLICY_HSIZE |
|
|
|
|
E_GADMAN_POLICY_VSIZE);
|
|
|
|
e_gadman_client_min_size_set(ef->gmc, 4, 4);
|
|
|
|
e_gadman_client_max_size_set(ef->gmc, 128, 128);
|
2005-03-19 04:49:46 -08:00
|
|
|
e_gadman_client_auto_size_set(ef->gmc, 40, 40);
|
2005-01-25 06:24:38 -08:00
|
|
|
e_gadman_client_align_set(ef->gmc, 1.0, 1.0);
|
2005-03-19 04:49:46 -08:00
|
|
|
e_gadman_client_resize(ef->gmc, 40, 40);
|
2005-02-09 04:14:08 -08:00
|
|
|
e_gadman_client_change_func_set(ef->gmc, _battery_face_cb_gmc_change, ef);
|
2005-01-25 06:24:38 -08:00
|
|
|
e_gadman_client_load(ef->gmc);
|
2005-02-10 04:00:39 -08:00
|
|
|
evas_event_thaw(con->bg_evas);
|
|
|
|
|
|
|
|
return ef;
|
2004-12-27 00:33:52 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_battery_face_free(Battery_Face *ef)
|
|
|
|
{
|
2005-02-10 04:00:39 -08:00
|
|
|
e_object_unref(E_OBJECT(ef->con));
|
2005-02-07 03:29:36 -08:00
|
|
|
e_object_del(E_OBJECT(ef->gmc));
|
2005-02-10 04:00:39 -08:00
|
|
|
e_object_del(E_OBJECT(ef->menu));
|
2004-12-27 00:33:52 -08:00
|
|
|
evas_object_del(ef->bat_object);
|
|
|
|
evas_object_del(ef->event_object);
|
2005-02-10 04:00:39 -08:00
|
|
|
|
|
|
|
free(ef->conf);
|
2004-12-27 00:33:52 -08:00
|
|
|
free(ef);
|
2005-02-10 04:00:39 -08:00
|
|
|
battery_count--;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_battery_face_menu_new(Battery_Face *face)
|
|
|
|
{
|
|
|
|
E_Menu *mn;
|
|
|
|
E_Menu_Item *mi;
|
|
|
|
|
|
|
|
mn = e_menu_new();
|
|
|
|
face->menu = mn;
|
|
|
|
|
|
|
|
/* Enabled */
|
2005-04-05 07:47:49 -07:00
|
|
|
/*
|
2005-02-10 04:00:39 -08:00
|
|
|
mi = e_menu_item_new(mn);
|
2005-04-11 14:50:36 -07:00
|
|
|
e_menu_item_label_set(mi, _("Enabled"));
|
2005-02-10 04:00:39 -08:00
|
|
|
e_menu_item_check_set(mi, 1);
|
|
|
|
if (face->conf->enabled) e_menu_item_toggle_set(mi, 1);
|
|
|
|
e_menu_item_callback_set(mi, _battery_face_cb_menu_enabled, face);
|
2005-04-05 07:47:49 -07:00
|
|
|
*/
|
2005-12-14 14:46:51 -08:00
|
|
|
|
|
|
|
/* Config */
|
|
|
|
mi = e_menu_item_new(mn);
|
|
|
|
e_menu_item_label_set(mi, _("Config Dialog"));
|
|
|
|
e_menu_item_callback_set(mi, _battery_face_cb_menu_configure, face);
|
2005-04-05 07:47:49 -07:00
|
|
|
|
2005-02-10 04:51:16 -08:00
|
|
|
/* Edit */
|
|
|
|
mi = e_menu_item_new(mn);
|
2005-04-11 14:50:36 -07:00
|
|
|
e_menu_item_label_set(mi, _("Edit Mode"));
|
2005-02-10 04:51:16 -08:00
|
|
|
e_menu_item_callback_set(mi, _battery_face_cb_menu_edit, face);
|
2005-02-10 04:00:39 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_battery_face_enable(Battery_Face *face)
|
|
|
|
{
|
|
|
|
face->conf->enabled = 1;
|
|
|
|
evas_object_show(face->bat_object);
|
|
|
|
evas_object_show(face->event_object);
|
|
|
|
e_config_save_queue();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_battery_face_disable(Battery_Face *face)
|
|
|
|
{
|
|
|
|
face->conf->enabled = 0;
|
|
|
|
evas_object_hide(face->bat_object);
|
|
|
|
evas_object_hide(face->event_object);
|
|
|
|
e_config_save_queue();
|
2004-12-27 00:33:52 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-02-09 04:14:08 -08:00
|
|
|
_battery_face_cb_gmc_change(void *data, E_Gadman_Client *gmc, E_Gadman_Change change)
|
2004-12-27 00:33:52 -08:00
|
|
|
{
|
2005-01-25 06:24:38 -08:00
|
|
|
Battery_Face *ef;
|
|
|
|
Evas_Coord x, y, w, h;
|
|
|
|
|
|
|
|
ef = data;
|
2005-02-16 03:38:14 -08:00
|
|
|
switch (change)
|
2005-01-25 06:24:38 -08:00
|
|
|
{
|
2005-02-16 03:38:14 -08:00
|
|
|
case E_GADMAN_CHANGE_MOVE_RESIZE:
|
|
|
|
e_gadman_client_geometry_get(ef->gmc, &x, &y, &w, &h);
|
|
|
|
evas_object_move(ef->bat_object, x, y);
|
|
|
|
evas_object_move(ef->event_object, x, y);
|
|
|
|
evas_object_resize(ef->bat_object, w, h);
|
|
|
|
evas_object_resize(ef->event_object, w, h);
|
|
|
|
break;
|
|
|
|
case E_GADMAN_CHANGE_RAISE:
|
|
|
|
evas_object_raise(ef->bat_object);
|
|
|
|
evas_object_raise(ef->event_object);
|
|
|
|
break;
|
|
|
|
case E_GADMAN_CHANGE_EDGE:
|
|
|
|
case E_GADMAN_CHANGE_ZONE:
|
|
|
|
/* FIXME
|
|
|
|
* Must we do something here?
|
|
|
|
*/
|
|
|
|
break;
|
2005-01-25 06:24:38 -08:00
|
|
|
}
|
2004-12-27 00:33:52 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2005-02-09 04:14:08 -08:00
|
|
|
_battery_face_cb_mouse_down(void *data, Evas *e, Evas_Object *obj, void *event_info)
|
2004-12-27 00:33:52 -08:00
|
|
|
{
|
|
|
|
Evas_Event_Mouse_Down *ev;
|
|
|
|
Battery_Face *ef;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 00:33:52 -08:00
|
|
|
ev = event_info;
|
|
|
|
ef = data;
|
|
|
|
if (ev->button == 3)
|
|
|
|
{
|
2005-02-10 04:00:39 -08:00
|
|
|
e_menu_activate_mouse(ef->menu, e_zone_current_get(ef->con),
|
2004-12-27 00:33:52 -08:00
|
|
|
ev->output.x, ev->output.y, 1, 1,
|
2005-07-25 02:55:47 -07:00
|
|
|
E_MENU_POP_DIRECTION_DOWN, ev->timestamp);
|
2004-12-27 00:33:52 -08:00
|
|
|
e_util_container_fake_mouse_up_all_later(ef->con);
|
|
|
|
}
|
|
|
|
}
|
2004-12-27 02:49:46 -08:00
|
|
|
|
|
|
|
static int
|
|
|
|
_battery_cb_check(void *data)
|
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
Battery *ef;
|
|
|
|
Battery_Face *face;
|
|
|
|
Evas_List *l;
|
|
|
|
Status *ret = NULL;
|
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
ef = data;
|
2005-08-02 02:52:30 -07:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
int acline;
|
|
|
|
size_t len;
|
|
|
|
int apm_fd = -1;
|
|
|
|
int acline_mib[3] = {-1};
|
|
|
|
|
|
|
|
if (ef->battery_check_mode == 0)
|
|
|
|
{
|
|
|
|
len = sizeof(acline);
|
|
|
|
if (sysctlbyname("hw.acpi.acline", &acline, &len, NULL, 0) == 0)
|
|
|
|
{
|
2005-08-02 02:55:03 -07:00
|
|
|
len = 3;
|
|
|
|
if (sysctlnametomib("hw.acpi.acline", acline_mib, &len) == 0)
|
2005-08-02 02:52:30 -07:00
|
|
|
ef->battery_check_mode = CHECK_ACPI;
|
2005-08-02 02:55:03 -07:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
apm_fd = open("/dev/apm", O_RDONLY);
|
2005-08-02 02:52:30 -07:00
|
|
|
if (apm_fd != -1)
|
2005-08-02 02:55:03 -07:00
|
|
|
ef->battery_check_mode = CHECK_APM;
|
|
|
|
}
|
2005-08-02 02:52:30 -07:00
|
|
|
}
|
|
|
|
switch (ef->battery_check_mode)
|
|
|
|
{
|
|
|
|
case CHECK_ACPI:
|
|
|
|
ret = _battery_bsd_acpi_check(ef);
|
|
|
|
break;
|
|
|
|
case CHECK_APM:
|
|
|
|
ret = _battery_bsd_apm_check(ef);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2005-08-17 22:35:02 -07:00
|
|
|
#elif defined(HAVE_CFBASE_H) /* OS X */
|
|
|
|
ret = _battery_darwin_check(ef);
|
2005-08-02 02:52:30 -07:00
|
|
|
#else
|
2004-12-27 02:49:46 -08:00
|
|
|
if (ef->battery_check_mode == 0)
|
|
|
|
{
|
2005-02-21 08:08:04 -08:00
|
|
|
if (ecore_file_is_dir("/proc/acpi"))
|
2005-08-02 02:52:30 -07:00
|
|
|
ef->battery_check_mode = CHECK_ACPI;
|
2005-02-21 08:08:04 -08:00
|
|
|
else if (ecore_file_exists("/proc/apm"))
|
2005-08-02 02:52:30 -07:00
|
|
|
ef->battery_check_mode = CHECK_APM;
|
2005-08-30 05:15:36 -07:00
|
|
|
else if (ecore_file_is_dir("/proc/pmu"))
|
|
|
|
ef->battery_check_mode = CHECK_PMU;
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
|
|
|
switch (ef->battery_check_mode)
|
|
|
|
{
|
2005-08-02 02:52:30 -07:00
|
|
|
case CHECK_ACPI:
|
2004-12-27 02:49:46 -08:00
|
|
|
ret = _battery_linux_acpi_check(ef);
|
|
|
|
break;
|
2005-08-02 02:52:30 -07:00
|
|
|
case CHECK_APM:
|
2005-01-03 19:23:08 -08:00
|
|
|
ret = _battery_linux_apm_check(ef);
|
2004-12-27 02:49:46 -08:00
|
|
|
break;
|
2005-08-30 05:15:36 -07:00
|
|
|
case CHECK_PMU:
|
|
|
|
ret = _battery_linux_powerbook_check(ef);
|
|
|
|
break;
|
2004-12-27 02:49:46 -08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2005-08-02 02:52:30 -07:00
|
|
|
#endif
|
2005-02-09 04:14:08 -08:00
|
|
|
if (ret)
|
|
|
|
{
|
|
|
|
if (ret->has_battery)
|
|
|
|
{
|
|
|
|
if (ret->state == BATTERY_STATE_CHARGING)
|
|
|
|
{
|
|
|
|
for (l = ef->faces; l; l = l->next)
|
|
|
|
{
|
|
|
|
face = l->data;
|
|
|
|
if (ef->battery_prev_ac != 1)
|
|
|
|
edje_object_signal_emit(face->bat_object, "charge", "");
|
|
|
|
edje_object_signal_emit(face->bat_object, "pulsestop", "");
|
|
|
|
edje_object_part_text_set(face->bat_object, "reading", ret->reading);
|
|
|
|
edje_object_part_text_set(face->bat_object, "time", ret->time);
|
|
|
|
_battery_face_level_set(face, ret->level);
|
|
|
|
|
|
|
|
}
|
|
|
|
ef->battery_prev_ac = 1;
|
|
|
|
}
|
|
|
|
else if (ret->state == BATTERY_STATE_DISCHARGING)
|
|
|
|
{
|
|
|
|
for (l = ef->faces; l; l = l->next)
|
|
|
|
{
|
|
|
|
face = l->data;
|
|
|
|
if (ef->battery_prev_ac != 0)
|
|
|
|
edje_object_signal_emit(face->bat_object, "discharge", "");
|
|
|
|
if (ret->alarm)
|
|
|
|
{
|
|
|
|
if (!ef->alarm_triggered)
|
|
|
|
{
|
2005-09-20 23:57:36 -07:00
|
|
|
E_Dialog *dia;
|
|
|
|
|
|
|
|
dia = e_dialog_new(e_container_current_get(e_manager_current_get()));
|
|
|
|
if (!dia) return 0;
|
|
|
|
e_dialog_title_set(dia, "Enlightenment Battery Module");
|
|
|
|
e_dialog_icon_set(dia, "enlightenment/e", 64);
|
|
|
|
e_dialog_text_set(dia, _("Battery Running Low<br>"
|
|
|
|
"Your battery is running low.<br>"
|
|
|
|
"You may wish to switch to an AC source."));
|
|
|
|
e_dialog_button_add(dia, _("Ok"), NULL, NULL, NULL);
|
|
|
|
e_win_centered_set(dia->win, 1);
|
|
|
|
e_dialog_show(dia);
|
2005-02-09 04:14:08 -08:00
|
|
|
}
|
|
|
|
edje_object_signal_emit(face->bat_object, "pulse", "");
|
|
|
|
}
|
|
|
|
edje_object_part_text_set(face->bat_object, "reading", ret->reading);
|
|
|
|
edje_object_part_text_set(face->bat_object, "time", ret->time);
|
|
|
|
_battery_face_level_set(face, ret->level);
|
|
|
|
|
|
|
|
}
|
|
|
|
ef->battery_prev_ac = 0;
|
|
|
|
if (ret->alarm)
|
|
|
|
ef->alarm_triggered = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* ret->state == BATTERY_STATE_NONE */
|
|
|
|
for (l = ef->faces; l; l = l->next)
|
|
|
|
{
|
|
|
|
face = l->data;
|
|
|
|
if (ef->battery_prev_ac != 1)
|
|
|
|
edje_object_signal_emit(face->bat_object, "charge", "");
|
|
|
|
if (ef->battery_prev_battery == 0)
|
|
|
|
edje_object_signal_emit(face->bat_object, "charge", "");
|
|
|
|
edje_object_part_text_set(face->bat_object, "reading", ret->reading);
|
|
|
|
edje_object_part_text_set(face->bat_object, "time", ret->time);
|
|
|
|
_battery_face_level_set(face, ret->level);
|
|
|
|
|
|
|
|
}
|
|
|
|
ef->battery_prev_ac = 1;
|
|
|
|
ef->battery_prev_battery = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Hasn't battery */
|
|
|
|
for (l = ef->faces; l; l = l->next)
|
|
|
|
{
|
|
|
|
face = l->data;
|
|
|
|
if (ef->battery_prev_battery != 0)
|
|
|
|
edje_object_signal_emit(face->bat_object, "unknown", "");
|
|
|
|
edje_object_part_text_set(face->bat_object, "reading", ret->reading);
|
|
|
|
edje_object_part_text_set(face->bat_object, "time", ret->time);
|
|
|
|
_battery_face_level_set(face, ret->level);
|
|
|
|
|
|
|
|
}
|
|
|
|
ef->battery_prev_battery = 0;
|
|
|
|
}
|
|
|
|
free(ret->reading);
|
|
|
|
free(ret->time);
|
|
|
|
free(ret);
|
|
|
|
}
|
|
|
|
else
|
2004-12-27 02:49:46 -08:00
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
/* Error reading status */
|
|
|
|
for (l = ef->faces; l; l = l->next)
|
2004-12-27 02:49:46 -08:00
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
face = l->data;
|
|
|
|
|
|
|
|
if (ef->battery_prev_battery != -2)
|
|
|
|
edje_object_signal_emit(face->bat_object, "unknown", "");
|
2005-04-11 14:50:36 -07:00
|
|
|
edje_object_part_text_set(face->bat_object, "reading", _("NO INFO"));
|
2005-02-09 04:14:08 -08:00
|
|
|
edje_object_part_text_set(face->bat_object, "time", "--:--");
|
|
|
|
_battery_face_level_set(face, (double)(rand() & 0xff) / 255.0);
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
2005-02-09 04:14:08 -08:00
|
|
|
ef->battery_prev_battery = -2;
|
2004-12-27 02:49:46 -08:00
|
|
|
ef->battery_check_mode = CHECK_NONE;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2005-02-09 04:14:08 -08:00
|
|
|
static Status *
|
|
|
|
_battery_linux_acpi_check(Battery *ef)
|
2004-12-27 02:49:46 -08:00
|
|
|
{
|
2005-04-14 03:52:58 -07:00
|
|
|
Ecore_List *bats;
|
2004-12-27 02:49:46 -08:00
|
|
|
char buf[4096], buf2[4096];
|
2005-04-14 03:52:58 -07:00
|
|
|
char *name;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
int bat_max = 0;
|
|
|
|
int bat_filled = 0;
|
|
|
|
int bat_level = 0;
|
|
|
|
int bat_drain = 1;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
int bat_val = 0;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
int discharging = 0;
|
|
|
|
int charging = 0;
|
|
|
|
int battery = 0;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
int design_cap_unknown = 0;
|
|
|
|
int last_full_unknown = 0;
|
|
|
|
int rate_unknown = 0;
|
|
|
|
int level_unknown = 0;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
int hours, minutes;
|
2004-12-27 05:17:10 -08:00
|
|
|
|
2005-02-09 04:14:08 -08:00
|
|
|
Status *stat;
|
|
|
|
|
|
|
|
stat = E_NEW(Status, 1);
|
2005-08-30 05:15:36 -07:00
|
|
|
if (!stat) return NULL;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
/* Read some information on first run. */
|
2005-02-21 08:08:04 -08:00
|
|
|
bats = ecore_file_ls("/proc/acpi/battery");
|
2005-10-06 16:49:09 -07:00
|
|
|
if (bats)
|
2004-12-27 02:49:46 -08:00
|
|
|
{
|
2005-10-06 16:49:09 -07:00
|
|
|
while ((name = ecore_list_next(bats)))
|
2004-12-27 02:49:46 -08:00
|
|
|
{
|
2005-10-06 16:49:09 -07:00
|
|
|
FILE *f;
|
2005-10-25 03:51:58 -07:00
|
|
|
char *tmp;
|
2005-10-06 16:49:09 -07:00
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "/proc/acpi/battery/%s/info", name);
|
|
|
|
f = fopen(buf, "r");
|
|
|
|
if (f)
|
2005-08-09 00:13:55 -07:00
|
|
|
{
|
2005-10-06 16:49:09 -07:00
|
|
|
int design_cap = 0;
|
|
|
|
int last_full = 0;
|
|
|
|
|
|
|
|
/* present */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
|
|
|
/* design capacity */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
tmp = _battery_string_get(buf2);
|
|
|
|
if (tmp)
|
|
|
|
{
|
|
|
|
if (!strcmp(tmp, "unknown")) design_cap_unknown = 1;
|
|
|
|
else design_cap = atoi(tmp);
|
|
|
|
free(tmp);
|
|
|
|
}
|
2005-10-06 16:49:09 -07:00
|
|
|
/* last full capacity */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
tmp = _battery_string_get(buf2);
|
|
|
|
if (tmp)
|
|
|
|
{
|
|
|
|
if (!strcmp(tmp, "unknown")) last_full_unknown = 1;
|
|
|
|
else last_full = atoi(tmp);
|
|
|
|
free(tmp);
|
|
|
|
}
|
2005-10-06 16:49:09 -07:00
|
|
|
fclose(f);
|
|
|
|
bat_max += design_cap;
|
|
|
|
bat_filled += last_full;
|
2005-08-09 00:13:55 -07:00
|
|
|
}
|
2005-10-06 16:49:09 -07:00
|
|
|
snprintf(buf, sizeof(buf), "/proc/acpi/battery/%s/state", name);
|
|
|
|
f = fopen(buf, "r");
|
|
|
|
if (f)
|
2005-08-09 00:13:55 -07:00
|
|
|
{
|
2005-10-25 03:51:58 -07:00
|
|
|
char *present;
|
|
|
|
char *capacity_state;
|
|
|
|
char *charging_state;
|
|
|
|
char *tmp;
|
2005-10-06 16:49:09 -07:00
|
|
|
int rate = 1;
|
|
|
|
int level = 0;
|
|
|
|
|
|
|
|
/* present */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
present = _battery_string_get(buf2);
|
2005-10-06 16:49:09 -07:00
|
|
|
/* capacity state */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
capacity_state = _battery_string_get(buf2);
|
2005-10-06 16:49:09 -07:00
|
|
|
/* charging state */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
charging_state = _battery_string_get(buf2);
|
2005-10-06 16:49:09 -07:00
|
|
|
/* present rate */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
tmp = _battery_string_get(buf2);
|
|
|
|
if (tmp)
|
|
|
|
{
|
|
|
|
if (!strcmp(tmp, "unknown")) rate_unknown = 1;
|
|
|
|
else rate = atoi(tmp);
|
|
|
|
free(tmp);
|
|
|
|
}
|
2005-10-06 16:49:09 -07:00
|
|
|
/* remaining capacity */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
tmp = _battery_string_get(buf2);
|
|
|
|
if (tmp)
|
|
|
|
{
|
|
|
|
if (!strcmp(tmp, "unknown")) level_unknown = 1;
|
|
|
|
else level = atoi(tmp);
|
|
|
|
free(tmp);
|
|
|
|
}
|
2005-10-06 16:49:09 -07:00
|
|
|
fclose(f);
|
2005-10-25 03:51:58 -07:00
|
|
|
if (present)
|
2005-10-06 16:49:09 -07:00
|
|
|
{
|
2005-10-25 03:51:58 -07:00
|
|
|
if (!strcmp(present, "yes")) battery++;
|
|
|
|
free(present);
|
2005-10-06 16:49:09 -07:00
|
|
|
}
|
2005-10-25 03:51:58 -07:00
|
|
|
if (charging_state)
|
2005-10-06 16:49:09 -07:00
|
|
|
{
|
2005-10-25 03:51:58 -07:00
|
|
|
if (!strcmp(charging_state, "discharging"))
|
|
|
|
{
|
|
|
|
discharging++;
|
|
|
|
if ((rate == 0) && (rate_unknown == 0)) rate_unknown = 1;
|
|
|
|
}
|
|
|
|
else if (!strcmp(charging_state, "charging"))
|
|
|
|
{
|
|
|
|
charging++;
|
|
|
|
if ((rate == 0) && (rate_unknown == 0)) rate_unknown = 1;
|
|
|
|
}
|
|
|
|
else if (!strcmp(charging_state, "charged"))
|
|
|
|
rate_unknown = 0;
|
|
|
|
free(charging_state);
|
2005-10-06 16:49:09 -07:00
|
|
|
}
|
2005-10-25 03:51:58 -07:00
|
|
|
E_FREE(capacity_state);
|
|
|
|
|
2005-10-06 16:49:09 -07:00
|
|
|
bat_drain += rate;
|
|
|
|
bat_level += level;
|
2005-08-09 00:13:55 -07:00
|
|
|
}
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
2005-10-06 16:49:09 -07:00
|
|
|
ecore_list_destroy(bats);
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
if (ef->battery_prev_drain < 1) ef->battery_prev_drain = 1;
|
|
|
|
if (bat_drain < 1) bat_drain = ef->battery_prev_drain;
|
|
|
|
ef->battery_prev_drain = bat_drain;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
if (bat_filled > 0) bat_val = (100 * bat_level) / bat_filled;
|
|
|
|
else bat_val = 100;
|
2005-09-07 22:03:28 -07:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
if (discharging) minutes = (60 * bat_level) / bat_drain;
|
|
|
|
else
|
|
|
|
{
|
2005-08-30 05:15:36 -07:00
|
|
|
/* FIXME: Batteries charge in paralell! */
|
2004-12-27 02:49:46 -08:00
|
|
|
if (bat_filled > 0)
|
|
|
|
minutes = (60 * (bat_filled - bat_level)) / bat_drain;
|
|
|
|
else
|
|
|
|
minutes = 0;
|
|
|
|
}
|
|
|
|
hours = minutes / 60;
|
|
|
|
minutes -= (hours * 60);
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 05:17:10 -08:00
|
|
|
if (hours < 0) hours = 0;
|
|
|
|
if (minutes < 0) minutes = 0;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
|
|
|
if (!battery)
|
|
|
|
{
|
|
|
|
stat->has_battery = 0;
|
|
|
|
stat->state = BATTERY_STATE_NONE;
|
2005-04-11 14:50:36 -07:00
|
|
|
stat->reading = strdup(_("NO BAT"));
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 1.0;
|
|
|
|
}
|
|
|
|
else if ((charging) || (discharging))
|
2004-12-27 02:49:46 -08:00
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
ef->battery_prev_battery = 1;
|
|
|
|
stat->has_battery = 1;
|
2005-01-11 16:56:58 -08:00
|
|
|
if (charging)
|
2005-01-10 23:08:38 -08:00
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->state = BATTERY_STATE_CHARGING;
|
|
|
|
ef->alarm_triggered = 0;
|
2005-01-10 23:08:38 -08:00
|
|
|
}
|
|
|
|
else if (discharging)
|
2005-02-09 04:14:08 -08:00
|
|
|
{
|
|
|
|
stat->state = BATTERY_STATE_DISCHARGING;
|
2005-03-31 03:40:38 -08:00
|
|
|
if (stat->level < 0.1)
|
|
|
|
{
|
|
|
|
if (((hours * 60) + minutes) <= ef->conf->alarm)
|
|
|
|
stat->alarm = 1;
|
|
|
|
}
|
2005-02-09 04:14:08 -08:00
|
|
|
}
|
2004-12-27 02:49:46 -08:00
|
|
|
if (level_unknown)
|
2005-01-10 23:08:38 -08:00
|
|
|
{
|
2005-04-11 14:50:36 -07:00
|
|
|
stat->reading = strdup(_("BAD DRIVER"));
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 0.0;
|
2005-01-10 23:08:38 -08:00
|
|
|
}
|
2004-12-27 02:49:46 -08:00
|
|
|
else if (rate_unknown)
|
2005-01-10 23:08:38 -08:00
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "%i%%", bat_val);
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->reading = strdup(buf);
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = (double)bat_val / 100.0;
|
2005-01-10 23:08:38 -08:00
|
|
|
}
|
2004-12-27 02:49:46 -08:00
|
|
|
else
|
2005-01-10 23:08:38 -08:00
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "%i%%", bat_val);
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->reading = strdup(buf);
|
2005-01-10 23:08:38 -08:00
|
|
|
snprintf(buf, sizeof(buf), "%i:%02i", hours, minutes);
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->time = strdup(buf);
|
|
|
|
stat->level = (double)bat_val / 100.0;
|
|
|
|
}
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->has_battery = 1;
|
|
|
|
stat->state = BATTERY_STATE_NONE;
|
2005-04-11 14:50:36 -07:00
|
|
|
stat->reading = strdup(_("FULL"));
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 1.0;
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
2005-02-09 04:14:08 -08:00
|
|
|
return stat;
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
|
|
|
|
2005-02-09 04:14:08 -08:00
|
|
|
static Status *
|
|
|
|
_battery_linux_apm_check(Battery *ef)
|
2004-12-27 02:49:46 -08:00
|
|
|
{
|
|
|
|
FILE *f;
|
|
|
|
char s[256], s1[32], s2[32], s3[32], buf[4096];
|
|
|
|
int apm_flags, ac_stat, bat_stat, bat_flags, bat_val, time_val;
|
|
|
|
int hours, minutes;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
|
|
|
Status *stat;
|
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
f = fopen("/proc/apm", "r");
|
2005-02-09 04:14:08 -08:00
|
|
|
if (!f) return NULL;
|
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
fgets(s, sizeof(s), f); s[sizeof(s) - 1] = 0;
|
2005-02-09 04:14:08 -08:00
|
|
|
if (sscanf(s, "%*s %*s %x %x %x %x %s %s %s",
|
2004-12-27 02:49:46 -08:00
|
|
|
&apm_flags, &ac_stat, &bat_stat, &bat_flags, s1, s2, s3) != 7)
|
|
|
|
{
|
|
|
|
fclose(f);
|
2005-02-09 04:14:08 -08:00
|
|
|
return NULL;
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
|
|
|
s1[strlen(s1) - 1] = 0;
|
|
|
|
bat_val = atoi(s1);
|
|
|
|
if (!strcmp(s3, "sec")) time_val = atoi(s2);
|
|
|
|
else if (!strcmp(s3, "min")) time_val = atoi(s2) * 60;
|
|
|
|
fclose(f);
|
2005-02-09 04:14:08 -08:00
|
|
|
|
|
|
|
stat = E_NEW(Status, 1);
|
2005-08-30 05:15:36 -07:00
|
|
|
if (!stat) return NULL;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
if ((bat_flags != 0xff) && (bat_flags & 0x80))
|
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->has_battery = 0;
|
|
|
|
stat->state = BATTERY_STATE_NONE;
|
|
|
|
stat->reading = strdup("NO BAT");
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 1.0;
|
|
|
|
return stat;
|
|
|
|
}
|
2005-03-31 03:40:38 -08:00
|
|
|
|
|
|
|
|
2005-02-09 04:14:08 -08:00
|
|
|
ef->battery_prev_battery = 1;
|
|
|
|
stat->has_battery = 1;
|
2005-03-31 03:40:38 -08:00
|
|
|
if (bat_val >= 0)
|
2005-02-09 04:14:08 -08:00
|
|
|
{
|
2005-03-31 03:40:38 -08:00
|
|
|
if (bat_val > 100) bat_val = 100;
|
2005-02-09 04:14:08 -08:00
|
|
|
snprintf(buf, sizeof(buf), "%i%%", bat_val);
|
|
|
|
stat->reading = strdup(buf);
|
|
|
|
stat->level = (double)bat_val / 100.0;
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
switch (bat_stat)
|
2004-12-27 02:49:46 -08:00
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
case 0:
|
2005-04-11 14:50:36 -07:00
|
|
|
stat->reading = strdup(_("High"));
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->level = 1.0;
|
|
|
|
break;
|
|
|
|
case 1:
|
2005-04-11 14:50:36 -07:00
|
|
|
stat->reading = strdup(_("Low"));
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->level = 0.5;
|
|
|
|
break;
|
|
|
|
case 2:
|
2005-04-11 14:50:36 -07:00
|
|
|
stat->reading = strdup(_("Danger"));
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->level = 0.25;
|
|
|
|
break;
|
|
|
|
case 3:
|
2005-04-11 14:50:36 -07:00
|
|
|
stat->reading = strdup(_("Charging"));
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->level = 1.0;
|
|
|
|
break;
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
|
|
|
}
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
if (ac_stat == 1)
|
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
stat->state = BATTERY_STATE_CHARGING;
|
|
|
|
stat->time = strdup("--:--");
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-02-09 04:14:08 -08:00
|
|
|
/* ac_stat == 0 */
|
|
|
|
stat->state = BATTERY_STATE_DISCHARGING;
|
|
|
|
|
|
|
|
hours = time_val / 3600;
|
|
|
|
minutes = (time_val / 60) % 60;
|
|
|
|
snprintf(buf, sizeof(buf), "%i:%02i", hours, minutes);
|
|
|
|
stat->time = strdup(buf);
|
2005-03-31 03:40:38 -08:00
|
|
|
if (stat->level < 0.1)
|
|
|
|
{
|
|
|
|
if (((hours * 60) + minutes) <= ef->conf->alarm)
|
|
|
|
stat->alarm = 1;
|
|
|
|
}
|
2005-02-09 04:14:08 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
return stat;
|
2004-12-27 02:49:46 -08:00
|
|
|
}
|
|
|
|
|
2005-08-30 05:15:36 -07:00
|
|
|
static Status *
|
|
|
|
_battery_linux_powerbook_check(Battery *ef)
|
|
|
|
{
|
|
|
|
Ecore_List *bats;
|
|
|
|
char buf[4096], buf2[4096];
|
|
|
|
char *name;
|
|
|
|
|
|
|
|
FILE *f;
|
|
|
|
|
|
|
|
int discharging = 0;
|
|
|
|
int charging = 0;
|
|
|
|
|
|
|
|
int battery = 0;
|
|
|
|
int ac = 0;
|
|
|
|
int seconds = 0;
|
|
|
|
int hours, minutes;
|
|
|
|
|
|
|
|
int charge;
|
|
|
|
int max_charge;
|
|
|
|
|
|
|
|
Status *stat;
|
|
|
|
|
|
|
|
stat = E_NEW(Status, 1);
|
|
|
|
if (!stat) return NULL;
|
|
|
|
|
|
|
|
/* Read some information. */
|
|
|
|
f = fopen("/proc/pmu/info", "r");
|
|
|
|
if (f)
|
|
|
|
{
|
|
|
|
/* Skip driver */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
|
|
|
/* Skip firmware */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
|
|
|
/* Read ac */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
ac = _battery_int_get(buf2);
|
2005-08-30 05:15:36 -07:00
|
|
|
fclose(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
bats = ecore_file_ls("/proc/pmu");
|
|
|
|
if (bats)
|
|
|
|
{
|
|
|
|
while ((name = ecore_list_next(bats)))
|
|
|
|
{
|
|
|
|
if (strncmp(name, "battery", 7))
|
2005-10-06 12:31:13 -07:00
|
|
|
continue;
|
2005-08-30 05:15:36 -07:00
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "/proc/pmu/%s", name);
|
|
|
|
f = fopen(buf, "r");
|
|
|
|
if (f)
|
|
|
|
{
|
|
|
|
int tmp = 0;
|
|
|
|
int time = 0;
|
|
|
|
int current = 0;
|
|
|
|
|
|
|
|
/* Skip flag; */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
|
|
|
/* Read charge */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
tmp = _battery_int_get(buf2);
|
2005-08-30 05:15:36 -07:00
|
|
|
charge += tmp;
|
|
|
|
/* Read max charge */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
tmp = _battery_int_get(buf2);
|
2005-08-30 05:15:36 -07:00
|
|
|
max_charge += tmp;
|
|
|
|
/* Read current */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
current = _battery_int_get(buf2);
|
2005-08-30 05:15:36 -07:00
|
|
|
/* Skip voltage */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
|
|
|
/* Get time remaining */
|
|
|
|
fgets(buf2, sizeof(buf2), f); buf2[sizeof(buf2) - 1] = 0;
|
2005-10-25 03:51:58 -07:00
|
|
|
time = _battery_int_get(buf2);
|
2005-08-30 05:15:36 -07:00
|
|
|
fclose(f);
|
|
|
|
|
|
|
|
battery++;
|
|
|
|
if (!current)
|
|
|
|
{
|
|
|
|
/* Neither charging nor discharging */
|
|
|
|
}
|
|
|
|
else if (!ac)
|
|
|
|
{
|
|
|
|
/* When on dc, we are discharging */
|
|
|
|
discharging++;
|
|
|
|
seconds += time;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Charging */
|
|
|
|
charging++;
|
|
|
|
/* Charging works in paralell */
|
|
|
|
seconds = MAX(time, seconds);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ecore_list_destroy(bats);
|
|
|
|
}
|
|
|
|
|
|
|
|
hours = seconds / (60 * 60);
|
|
|
|
seconds -= hours * (60 * 60);
|
|
|
|
minutes = seconds / 60;
|
|
|
|
seconds -= minutes * 60;
|
|
|
|
|
|
|
|
if (hours < 0) hours = 0;
|
|
|
|
if (minutes < 0) minutes = 0;
|
|
|
|
|
|
|
|
if (!battery)
|
|
|
|
{
|
|
|
|
stat->has_battery = 0;
|
|
|
|
stat->state = BATTERY_STATE_NONE;
|
|
|
|
stat->reading = strdup(_("NO BAT"));
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 1.0;
|
|
|
|
}
|
|
|
|
else if ((charging) || (discharging))
|
|
|
|
{
|
|
|
|
stat->has_battery = 1;
|
|
|
|
if (charging)
|
|
|
|
{
|
|
|
|
stat->state = BATTERY_STATE_CHARGING;
|
|
|
|
ef->alarm_triggered = 0;
|
|
|
|
}
|
|
|
|
else if (discharging)
|
|
|
|
{
|
|
|
|
stat->state = BATTERY_STATE_DISCHARGING;
|
|
|
|
if (stat->level < 0.1)
|
|
|
|
{
|
|
|
|
if (((hours * 60) + minutes) <= ef->conf->alarm)
|
|
|
|
stat->alarm = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
stat->level = (double)charge / (double)max_charge;
|
|
|
|
snprintf(buf, sizeof(buf), "%.0f%%", stat->level * 100.0);
|
|
|
|
stat->reading = strdup(buf);
|
|
|
|
snprintf(buf, sizeof(buf), "%i:%02i", hours, minutes);
|
|
|
|
stat->time = strdup(buf);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
stat->has_battery = 1;
|
|
|
|
stat->state = BATTERY_STATE_NONE;
|
|
|
|
stat->reading = strdup(_("FULL"));
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 1.0;
|
|
|
|
}
|
|
|
|
return stat;
|
|
|
|
}
|
|
|
|
|
2005-08-02 08:05:48 -07:00
|
|
|
#ifdef __FreeBSD__
|
2005-08-02 02:52:30 -07:00
|
|
|
static Status *
|
|
|
|
_battery_bsd_acpi_check(Battery *ef)
|
|
|
|
{
|
|
|
|
/* Assumes only a single battery - I don't know how multiple batts
|
|
|
|
* are represented in sysctl */
|
|
|
|
|
|
|
|
Ecore_List *bats;
|
|
|
|
char buf[4096], buf2[4096];
|
|
|
|
char *name;
|
|
|
|
|
|
|
|
int bat_max = 0;
|
|
|
|
int bat_filled = 0;
|
|
|
|
int bat_level = 0;
|
|
|
|
int bat_drain = 1;
|
|
|
|
|
|
|
|
int bat_val = 0;
|
|
|
|
|
|
|
|
int discharging = 0;
|
|
|
|
int charging = 0;
|
|
|
|
int battery = 0;
|
|
|
|
|
|
|
|
int design_cap_unknown = 0;
|
|
|
|
int last_full_unknown = 0;
|
|
|
|
int rate_unknown = 0;
|
|
|
|
int level_unknown = 0;
|
|
|
|
|
|
|
|
int hours, minutes;
|
|
|
|
|
|
|
|
int mib_state[4];
|
|
|
|
int mib_life[4];
|
|
|
|
int mib_time[4];
|
|
|
|
int mib_units[4];
|
|
|
|
size_t len;
|
|
|
|
int state;
|
|
|
|
int level;
|
|
|
|
int time;
|
|
|
|
int life;
|
|
|
|
int batteries;
|
|
|
|
|
|
|
|
Status *stat;
|
|
|
|
|
|
|
|
stat = E_NEW(Status, 1);
|
2005-08-30 05:15:36 -07:00
|
|
|
if (!stat) return NULL;
|
2005-08-02 02:52:30 -07:00
|
|
|
|
|
|
|
/* Read some information on first run. */
|
|
|
|
len = 4;
|
|
|
|
sysctlnametomib("hw.acpi.battery.state", mib_state, &len);
|
|
|
|
len = sizeof(state);
|
|
|
|
if (sysctl(mib_state, 4, &state, &len, NULL, 0) == -1)
|
|
|
|
/* ERROR */
|
|
|
|
state = -1;
|
|
|
|
|
|
|
|
len = 4;
|
|
|
|
sysctlnametomib("hw.acpi.battery.life", mib_life, &len);
|
|
|
|
len = sizeof(life);
|
|
|
|
if (sysctl(mib_life, 4, &life, &len, NULL, 0) == -1)
|
|
|
|
/* ERROR */
|
|
|
|
level = -1;
|
|
|
|
|
|
|
|
bat_val = life;
|
|
|
|
|
|
|
|
len = 4;
|
|
|
|
sysctlnametomib("hw.acpi.battery.time", mib_time, &len);
|
|
|
|
len = sizeof(time);
|
|
|
|
if (sysctl(mib_time, 4, &time, &len, NULL, 0) == -1)
|
|
|
|
/* ERROR */
|
|
|
|
time = -2;
|
|
|
|
|
|
|
|
len = 4;
|
|
|
|
sysctlnametomib("hw.acpi.battery.units", mib_units, &len);
|
|
|
|
len = sizeof(batteries);
|
|
|
|
if (sysctl(mib_time, 4, &batteries, &len, NULL, 0) == -1)
|
|
|
|
/* ERROR */
|
|
|
|
batteries = 1;
|
|
|
|
|
|
|
|
if (ef->battery_prev_drain < 1)
|
|
|
|
ef->battery_prev_drain = 1;
|
|
|
|
|
|
|
|
if (bat_drain < 1)
|
|
|
|
bat_drain = ef->battery_prev_drain;
|
|
|
|
|
|
|
|
ef->battery_prev_drain = bat_drain;
|
|
|
|
|
|
|
|
/*if (bat_filled > 0)
|
|
|
|
bat_val = (100 * bat_level) / bat_filled;
|
|
|
|
else
|
|
|
|
bat_val = 100;
|
|
|
|
|
|
|
|
if (state == BATTERY_STATE_DISCHARGING)
|
|
|
|
minutes = (60 * bat_level) / bat_drain;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (bat_filled > 0)
|
|
|
|
minutes = (60 * (bat_filled - bat_level)) / bat_drain;
|
|
|
|
else
|
|
|
|
minutes = 0;
|
|
|
|
}*/
|
|
|
|
minutes = time;
|
|
|
|
hours = minutes / 60;
|
|
|
|
minutes -= (hours * 60);
|
|
|
|
|
|
|
|
if (hours < 0)
|
|
|
|
hours = 0;
|
|
|
|
if (minutes < 0)
|
|
|
|
minutes = 0;
|
|
|
|
|
|
|
|
if (batteries == 1) /* hw.acpi.battery.units = 1 means NO BATTS */
|
|
|
|
{
|
|
|
|
stat->has_battery = 0;
|
|
|
|
stat->state = BATTERY_STATE_NONE;
|
|
|
|
stat->reading = strdup(_("NO BAT"));
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 1.0;
|
|
|
|
}
|
|
|
|
else if ((state == BATTERY_STATE_CHARGING) ||
|
|
|
|
(state == BATTERY_STATE_DISCHARGING))
|
|
|
|
{
|
|
|
|
ef->battery_prev_battery = 1;
|
|
|
|
stat->has_battery = 1;
|
|
|
|
if (state == BATTERY_STATE_CHARGING)
|
|
|
|
{
|
|
|
|
stat->state = BATTERY_STATE_CHARGING;
|
|
|
|
ef->alarm_triggered = 0;
|
|
|
|
}
|
|
|
|
else if (state == BATTERY_STATE_DISCHARGING)
|
|
|
|
{
|
|
|
|
stat->state = BATTERY_STATE_DISCHARGING;
|
|
|
|
if (stat->level < 0.1) /* Why this if condition */
|
|
|
|
{
|
|
|
|
if (((hours * 60) + minutes) <= ef->conf->alarm)
|
|
|
|
stat->alarm = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!level)
|
|
|
|
{
|
|
|
|
stat->reading = strdup(_("BAD DRIVER"));
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 0.0;
|
|
|
|
}
|
|
|
|
else if (time == -1)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "%i%%", bat_val);
|
|
|
|
stat->reading = strdup(buf);
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = (double)bat_val / 100.0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "%i%%", bat_val);
|
|
|
|
stat->reading = strdup(buf);
|
|
|
|
snprintf(buf, sizeof(buf), "%i:%02i", hours, minutes);
|
|
|
|
stat->time = strdup(buf);
|
|
|
|
stat->level = (double)bat_val / 100.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
stat->has_battery = 1;
|
|
|
|
stat->state = BATTERY_STATE_NONE;
|
|
|
|
stat->reading = strdup(_("FULL"));
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 1.0;
|
|
|
|
}
|
|
|
|
return stat;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Status *
|
|
|
|
_battery_bsd_apm_check(Battery *ef)
|
|
|
|
{
|
2005-11-08 23:56:20 -08:00
|
|
|
#ifdef __i386__
|
2005-08-02 02:52:30 -07:00
|
|
|
int ac_stat, bat_stat, bat_val, time_val;
|
|
|
|
char buf[4096];
|
|
|
|
int hours, minutes;
|
|
|
|
int apm_fd = -1;
|
|
|
|
struct apm_info info;
|
|
|
|
|
|
|
|
Status *stat;
|
|
|
|
|
|
|
|
apm_fd = open("/dev/apm", O_RDONLY);
|
|
|
|
|
|
|
|
if (apm_fd != -1 && ioctl(apm_fd, APMIO_GETINFO, &info) != -1)
|
|
|
|
{
|
|
|
|
/* set values */
|
|
|
|
ac_stat = info.ai_acline;
|
|
|
|
bat_stat = info.ai_batt_stat;
|
|
|
|
bat_val = info.ai_batt_life;
|
|
|
|
time_val = info.ai_batt_time;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
stat = E_NEW(Status, 1);
|
2005-08-30 05:15:36 -07:00
|
|
|
if (!stat) return NULL;
|
2005-08-02 02:52:30 -07:00
|
|
|
|
|
|
|
if (info.ai_batteries == 1) /* ai_batteries == 1 means NO battery,
|
|
|
|
ai_batteries == 2 means 1 battery */
|
|
|
|
{
|
|
|
|
stat->has_battery = 0;
|
|
|
|
stat->state = BATTERY_STATE_NONE;
|
|
|
|
stat->reading = strdup("NO BAT");
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 1.0;
|
|
|
|
return stat;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ef->battery_prev_battery = 1;
|
|
|
|
stat->has_battery = 1;
|
|
|
|
|
|
|
|
if (ac_stat) /* Wallpowered */
|
|
|
|
{
|
|
|
|
stat->state = BATTERY_STATE_CHARGING;
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
switch (bat_stat) /* On FreeBSD the time_val is -1 when AC ist plugged
|
|
|
|
in. This means we don't know how long the battery
|
|
|
|
will recharge */
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
stat->reading = strdup(_("High"));
|
|
|
|
stat->level = 1.0;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
stat->reading = strdup(_("Low"));
|
|
|
|
stat->level = 0.5;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
stat->reading = strdup(_("Danger"));
|
|
|
|
stat->level = 0.25;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
stat->reading = strdup(_("Charging"));
|
|
|
|
stat->level = 1.0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else /* Running on battery */
|
|
|
|
{
|
|
|
|
stat->state = BATTERY_STATE_DISCHARGING;
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "%i%%", bat_val);
|
|
|
|
stat->reading = strdup(buf);
|
|
|
|
stat->level = (double)bat_val / 100.0;
|
|
|
|
|
|
|
|
hours = time_val / 3600;
|
|
|
|
minutes = (time_val / 60) % 60;
|
|
|
|
snprintf(buf, sizeof(buf), "%i:%02i", hours, minutes);
|
|
|
|
stat->time = strdup(buf);
|
|
|
|
|
|
|
|
if (stat->level < 0.1) /* Why this if condition? */
|
|
|
|
{
|
|
|
|
if (((hours * 60) + minutes) <= ef->conf->alarm)
|
|
|
|
stat->alarm = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return stat;
|
2005-11-08 23:56:20 -08:00
|
|
|
#else
|
|
|
|
return NULL;
|
|
|
|
#endif
|
2005-08-02 02:52:30 -07:00
|
|
|
}
|
2005-08-02 08:05:48 -07:00
|
|
|
#endif
|
2005-08-02 02:52:30 -07:00
|
|
|
|
2005-08-17 22:35:02 -07:00
|
|
|
#ifdef HAVE_CFBASE_H
|
|
|
|
/*
|
|
|
|
* There is a good chance this will work with a UPS as well as a battery.
|
|
|
|
*/
|
|
|
|
static Status *
|
|
|
|
_battery_darwin_check(Battery *ef)
|
|
|
|
{
|
|
|
|
const void *values;
|
|
|
|
int device_num;
|
|
|
|
int device_count;
|
|
|
|
int hours, minutes;
|
|
|
|
int currentval = 0;
|
|
|
|
int maxval = 0;
|
|
|
|
char buf[4096];
|
|
|
|
CFTypeRef blob;
|
|
|
|
CFArrayRef sources;
|
|
|
|
CFDictionaryRef device_dict;
|
|
|
|
|
|
|
|
Status *stat;
|
|
|
|
|
|
|
|
stat = E_NEW(Status, 1);
|
2005-08-30 05:15:36 -07:00
|
|
|
if (!stat) return NULL;
|
2005-08-17 22:35:02 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Retrieve the power source data and the array of sources.
|
|
|
|
*/
|
|
|
|
blob = IOPSCopyPowerSourcesInfo();
|
|
|
|
sources = IOPSCopyPowerSourcesList(blob);
|
|
|
|
device_count = CFArrayGetCount(sources);
|
|
|
|
|
|
|
|
for (device_num = 0; device_num < device_count; device_num++)
|
|
|
|
{
|
|
|
|
CFTypeRef ps;
|
|
|
|
|
|
|
|
printf("device %d of %d\n", device_num, device_count);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Retrieve a dictionary of values for this device and the
|
|
|
|
* count of keys in the dictionary.
|
|
|
|
*/
|
|
|
|
ps = CFArrayGetValueAtIndex(sources, device_num);
|
|
|
|
device_dict = IOPSGetPowerSourceDescription(blob, ps);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Retrieve the charging key and save the present charging value if
|
|
|
|
* one exists.
|
|
|
|
*/
|
|
|
|
if (CFDictionaryGetValueIfPresent(device_dict, CFSTR(kIOPSIsChargingKey), &values))
|
|
|
|
{
|
|
|
|
stat->has_battery = 1;
|
2005-08-17 23:09:43 -07:00
|
|
|
printf("%s: %d\n", kIOPSIsChargingKey, CFBooleanGetValue(values));
|
|
|
|
if (CFBooleanGetValue(values) > 0)
|
2005-08-17 22:35:02 -07:00
|
|
|
{
|
|
|
|
stat->state = BATTERY_STATE_CHARGING;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
stat->state = BATTERY_STATE_DISCHARGING;
|
|
|
|
}
|
|
|
|
// CFRelease(values);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for battery.
|
|
|
|
*/
|
|
|
|
if (!stat->has_battery)
|
|
|
|
{
|
|
|
|
CFRelease(sources);
|
|
|
|
CFRelease(blob);
|
|
|
|
stat->state = BATTERY_STATE_NONE;
|
|
|
|
stat->reading = strdup("NO BAT");
|
|
|
|
stat->time = strdup("--:--");
|
|
|
|
stat->level = 1.0;
|
|
|
|
return stat;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A battery was found so move along based on that assumption.
|
|
|
|
*/
|
|
|
|
ef->battery_prev_battery = 1;
|
|
|
|
stat->has_battery = 1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Retrieve the current capacity key.
|
|
|
|
*/
|
|
|
|
values = CFDictionaryGetValue(device_dict, CFSTR(kIOPSCurrentCapacityKey));
|
|
|
|
CFNumberGetValue(values, kCFNumberSInt32Type, ¤tval);
|
|
|
|
// CFRelease(values);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Retrieve the max capacity key.
|
|
|
|
*/
|
|
|
|
values = CFDictionaryGetValue(device_dict, CFSTR(kIOPSMaxCapacityKey));
|
|
|
|
CFNumberGetValue(values, kCFNumberSInt32Type, &maxval);
|
|
|
|
// CFRelease(values);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Calculate the percentage charged.
|
|
|
|
*/
|
|
|
|
stat->level = (double)currentval / (double)maxval;
|
|
|
|
printf("Battery charge %g\n", stat->level);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Retrieve the remaining battery power or time until charged in minutes.
|
|
|
|
*/
|
|
|
|
if (stat->state == BATTERY_STATE_DISCHARGING)
|
|
|
|
{
|
|
|
|
values = CFDictionaryGetValue(device_dict, CFSTR(kIOPSTimeToEmptyKey));
|
|
|
|
CFNumberGetValue(values, kCFNumberSInt32Type, ¤tval);
|
|
|
|
// CFRelease(values);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Display remaining battery percentage.
|
|
|
|
*/
|
|
|
|
snprintf(buf, sizeof(buf), "%i%%", (int)(stat->level * 100));
|
|
|
|
stat->reading = strdup(buf);
|
|
|
|
|
|
|
|
hours = currentval / 60;
|
|
|
|
minutes = currentval % 60;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if an alarm should be raised.
|
|
|
|
*/
|
|
|
|
if (currentval <= ef->conf->alarm)
|
|
|
|
stat->alarm = 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
values = CFDictionaryGetValue(device_dict, CFSTR(kIOPSTimeToFullChargeKey));
|
|
|
|
CFNumberGetValue(values, kCFNumberSInt32Type, ¤tval);
|
|
|
|
// CFRelease(values);
|
|
|
|
|
|
|
|
stat->reading = strdup(_("Charging"));
|
|
|
|
|
|
|
|
hours = currentval / 60;
|
|
|
|
minutes = currentval % 60;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Store the time remaining.
|
|
|
|
*/
|
2005-08-17 23:09:43 -07:00
|
|
|
if (minutes >= 0)
|
|
|
|
{
|
|
|
|
snprintf(buf, sizeof(buf), "%i:%02i", hours, minutes);
|
|
|
|
stat->time = strdup(buf);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
stat->time = strdup("--:--");
|
2005-08-17 22:35:02 -07:00
|
|
|
|
|
|
|
CFRelease(sources);
|
|
|
|
CFRelease(blob);
|
|
|
|
|
|
|
|
return stat;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
static void
|
2005-02-09 04:14:08 -08:00
|
|
|
_battery_face_level_set(Battery_Face *ef, double level)
|
2004-12-27 02:49:46 -08:00
|
|
|
{
|
|
|
|
Edje_Message_Float msg;
|
2005-02-09 04:14:08 -08:00
|
|
|
|
2004-12-27 02:49:46 -08:00
|
|
|
if (level < 0.0) level = 0.0;
|
|
|
|
else if (level > 1.0) level = 1.0;
|
|
|
|
msg.val = level;
|
|
|
|
edje_object_message_send(ef->bat_object, EDJE_MESSAGE_FLOAT, 1, &msg);
|
|
|
|
}
|
2005-02-10 04:00:39 -08:00
|
|
|
|
|
|
|
static void
|
|
|
|
_battery_face_cb_menu_enabled(void *data, E_Menu *m, E_Menu_Item *mi)
|
|
|
|
{
|
|
|
|
Battery_Face *face;
|
|
|
|
unsigned char enabled;
|
|
|
|
|
|
|
|
face = data;
|
|
|
|
enabled = e_menu_item_toggle_get(mi);
|
|
|
|
if ((face->conf->enabled) && (!enabled))
|
|
|
|
{
|
|
|
|
_battery_face_disable(face);
|
|
|
|
}
|
|
|
|
else if ((!face->conf->enabled) && (enabled))
|
|
|
|
{
|
|
|
|
_battery_face_enable(face);
|
|
|
|
}
|
|
|
|
}
|
2005-02-10 04:51:16 -08:00
|
|
|
|
|
|
|
static void
|
|
|
|
_battery_face_cb_menu_edit(void *data, E_Menu *m, E_Menu_Item *mi)
|
|
|
|
{
|
|
|
|
Battery_Face *face;
|
|
|
|
|
|
|
|
face = data;
|
|
|
|
e_gadman_mode_set(face->gmc->gadman, E_GADMAN_MODE_EDIT);
|
|
|
|
}
|
2005-10-25 03:51:58 -07:00
|
|
|
|
|
|
|
static int
|
|
|
|
_battery_int_get(char *buf)
|
|
|
|
{
|
|
|
|
char *p, *q;
|
|
|
|
|
|
|
|
p = strchr(buf, ':');
|
|
|
|
if (!p) return 0;
|
|
|
|
p++;
|
|
|
|
while (*p == ' ') p++;
|
|
|
|
q = p;
|
|
|
|
while ((*q != ' ') && (*q != '\n')) q++;
|
|
|
|
if (q) *q = 0;
|
|
|
|
return atoi(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_battery_string_get(char *buf)
|
|
|
|
{
|
|
|
|
char *p, *q;
|
|
|
|
|
|
|
|
p = strchr(buf, ':');
|
|
|
|
if (!p) return NULL;
|
|
|
|
p++;
|
|
|
|
while (*p == ' ') p++;
|
|
|
|
q = p;
|
|
|
|
while ((*q != ' ') && (*q != '\n')) q++;
|
|
|
|
if (q) *q = 0;
|
|
|
|
return strdup(p);
|
|
|
|
}
|
2005-12-14 14:46:51 -08:00
|
|
|
|
|
|
|
static void
|
|
|
|
_battery_face_cb_menu_configure(void *data, E_Menu *m, E_Menu_Item *mi)
|
|
|
|
{
|
|
|
|
Battery_Face *face;
|
|
|
|
|
|
|
|
face = data;
|
|
|
|
if (!face) return;
|
|
|
|
e_int_config_battery(face->con, face->battery);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
_battery_face_cb_config_updated(Battery *bat)
|
|
|
|
{
|
|
|
|
/* Call all functions needed to update battery */
|
|
|
|
|
|
|
|
/* Update Poll Time */
|
|
|
|
ecore_timer_del(bat->battery_check_timer);
|
|
|
|
bat->battery_check_timer = ecore_timer_add(bat->conf->poll_time, _battery_cb_check, bat);
|
|
|
|
}
|