Mabox/tint2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Changed indentation everywhere

Browse Source
This commit is contained in:
o9000
2017-04-13 14:07:23 +02:00
parent c1e5a7b172
commit affac4cfa6
68 changed files with 23280 additions and 22941 deletions
Download Patch File Download Diff File Expand all files Collapse all files

632
src/battery/battery.c
View File

@@ -56,7 +56,7 @@ char *battery_uwheel_command;
char *battery_dwheel_command;
gboolean battery_found;
char *battery_sys_prefix = (char*)"";
char *battery_sys_prefix = (char *)"";
void battery_init_fonts();
char *battery_get_tooltip(void *obj);
@@ -65,407 +65,397 @@ void battery_dump_geometry(void *obj, int indent);
void default_battery()
{
battery_enabled = FALSE;
battery_tooltip_enabled = TRUE;
battery_found = FALSE;
percentage_hide = 101;
battery_low_cmd_sent = FALSE;
battery_timeout = NULL;
bat1_has_font = FALSE;
bat1_font_desc = NULL;
bat2_has_font = FALSE;
bat2_font_desc = NULL;
ac_connected_cmd = NULL;
ac_disconnected_cmd = NULL;
battery_low_cmd = NULL;
battery_lclick_command = NULL;
battery_mclick_command = NULL;
battery_rclick_command = NULL;
battery_uwheel_command = NULL;
battery_dwheel_command = NULL;
battery_state.percentage = 0;
battery_state.time.hours = 0;
battery_state.time.minutes = 0;
battery_state.time.seconds = 0;
battery_state.state = BATTERY_UNKNOWN;
battery_enabled = FALSE;
battery_tooltip_enabled = TRUE;
battery_found = FALSE;
percentage_hide = 101;
battery_low_cmd_sent = FALSE;
battery_timeout = NULL;
bat1_has_font = FALSE;
bat1_font_desc = NULL;
bat2_has_font = FALSE;
bat2_font_desc = NULL;
ac_connected_cmd = NULL;
ac_disconnected_cmd = NULL;
battery_low_cmd = NULL;
battery_lclick_command = NULL;
battery_mclick_command = NULL;
battery_rclick_command = NULL;
battery_uwheel_command = NULL;
battery_dwheel_command = NULL;
battery_state.percentage = 0;
battery_state.time.hours = 0;
battery_state.time.minutes = 0;
battery_state.time.seconds = 0;
battery_state.state = BATTERY_UNKNOWN;
}
void cleanup_battery()
{
pango_font_description_free(bat1_font_desc);
bat1_font_desc = NULL;
pango_font_description_free(bat2_font_desc);
bat2_font_desc = NULL;
free(battery_low_cmd);
battery_low_cmd = NULL;
free(battery_lclick_command);
battery_lclick_command = NULL;
free(battery_mclick_command);
battery_mclick_command = NULL;
free(battery_rclick_command);
battery_rclick_command = NULL;
free(battery_uwheel_command);
battery_uwheel_command = NULL;
free(battery_dwheel_command);
battery_dwheel_command = NULL;
free(ac_connected_cmd);
ac_connected_cmd = NULL;
free(ac_disconnected_cmd);
ac_disconnected_cmd = NULL;
stop_timeout(battery_timeout);
battery_timeout = NULL;
battery_found = FALSE;
pango_font_description_free(bat1_font_desc);
bat1_font_desc = NULL;
pango_font_description_free(bat2_font_desc);
bat2_font_desc = NULL;
free(battery_low_cmd);
battery_low_cmd = NULL;
free(battery_lclick_command);
battery_lclick_command = NULL;
free(battery_mclick_command);
battery_mclick_command = NULL;
free(battery_rclick_command);
battery_rclick_command = NULL;
free(battery_uwheel_command);
battery_uwheel_command = NULL;
free(battery_dwheel_command);
battery_dwheel_command = NULL;
free(ac_connected_cmd);
ac_connected_cmd = NULL;
free(ac_disconnected_cmd);
ac_disconnected_cmd = NULL;
stop_timeout(battery_timeout);
battery_timeout = NULL;
battery_found = FALSE;
battery_os_free();
battery_os_free();
}
void init_battery()
{
if (!battery_enabled)
return;
if (!battery_enabled)
return;
battery_found = battery_os_init();
battery_found = battery_os_init();
if (!battery_timeout)
battery_timeout = add_timeout(10, 30000, update_battery_tick, 0, &battery_timeout);
if (!battery_timeout)
battery_timeout = add_timeout(10, 30000, update_battery_tick, 0, &battery_timeout);
update_battery();
update_battery();
}
void reinit_battery()
{
battery_os_free();
battery_found = battery_os_init();
update_battery();
battery_os_free();
battery_found = battery_os_init();
update_battery();
}
void init_battery_panel(void *p)
{
Panel *panel = (Panel *)p;
Battery *battery = &panel->battery;
Panel *panel = (Panel *)p;
Battery *battery = &panel->battery;
if (!battery_enabled)
return;
if (!battery_enabled)
return;
battery_init_fonts();
battery_init_fonts();
if (!battery->area.bg)
battery->area.bg = &g_array_index(backgrounds, Background, 0);
if (!battery->area.bg)
battery->area.bg = &g_array_index(backgrounds, Background, 0);
battery->area.parent = p;
battery->area.panel = p;
snprintf(battery->area.name, sizeof(battery->area.name), "Battery");
battery->area._draw_foreground = draw_battery;
battery->area.size_mode = LAYOUT_FIXED;
battery->area._resize = resize_battery;
battery->area._compute_desired_size = battery_compute_desired_size;
battery->area._is_under_mouse = full_width_area_is_under_mouse;
battery->area.on_screen = TRUE;
battery->area.resize_needed = 1;
battery->area.has_mouse_over_effect =
panel_config.mouse_effects && (battery_lclick_command || battery_mclick_command || battery_rclick_command ||
battery_uwheel_command || battery_dwheel_command);
battery->area.has_mouse_press_effect = battery->area.has_mouse_over_effect;
if (battery_tooltip_enabled)
battery->area._get_tooltip_text = battery_get_tooltip;
instantiate_area_gradients(&battery->area);
battery->area.parent = p;
battery->area.panel = p;
snprintf(battery->area.name, sizeof(battery->area.name), "Battery");
battery->area._draw_foreground = draw_battery;
battery->area.size_mode = LAYOUT_FIXED;
battery->area._resize = resize_battery;
battery->area._compute_desired_size = battery_compute_desired_size;
battery->area._is_under_mouse = full_width_area_is_under_mouse;
battery->area.on_screen = TRUE;
battery->area.resize_needed = 1;
battery->area.has_mouse_over_effect =
panel_config.mouse_effects && (battery_lclick_command || battery_mclick_command || battery_rclick_command ||
battery_uwheel_command || battery_dwheel_command);
battery->area.has_mouse_press_effect = battery->area.has_mouse_over_effect;
if (battery_tooltip_enabled)
battery->area._get_tooltip_text = battery_get_tooltip;
instantiate_area_gradients(&battery->area);
}
void battery_init_fonts()
{
if (!bat1_font_desc) {
bat1_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_size(bat1_font_desc, pango_font_description_get_size(bat1_font_desc) - PANGO_SCALE);
}
if (!bat2_font_desc) {
bat2_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_size(bat2_font_desc, pango_font_description_get_size(bat2_font_desc) - PANGO_SCALE);
}
if (!bat1_font_desc) {
bat1_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_size(bat1_font_desc, pango_font_description_get_size(bat1_font_desc) - PANGO_SCALE);
}
if (!bat2_font_desc) {
bat2_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_size(bat2_font_desc, pango_font_description_get_size(bat2_font_desc) - PANGO_SCALE);
}
}
void battery_default_font_changed()
{
if (!battery_enabled)
return;
if (bat1_has_font && bat2_has_font)
return;
if (!bat1_has_font) {
pango_font_description_free(bat1_font_desc);
bat1_font_desc = NULL;
}
if (!bat2_has_font) {
pango_font_description_free(bat2_font_desc);
bat2_font_desc = NULL;
}
battery_init_fonts();
for (int i = 0; i < num_panels; i++) {
panels[i].battery.area.resize_needed = TRUE;
schedule_redraw(&panels[i].battery.area);
}
schedule_panel_redraw();
if (!battery_enabled)
return;
if (bat1_has_font && bat2_has_font)
return;
if (!bat1_has_font) {
pango_font_description_free(bat1_font_desc);
bat1_font_desc = NULL;
}
if (!bat2_has_font) {
pango_font_description_free(bat2_font_desc);
bat2_font_desc = NULL;
}
battery_init_fonts();
for (int i = 0; i < num_panels; i++) {
panels[i].battery.area.resize_needed = TRUE;
schedule_redraw(&panels[i].battery.area);
}
schedule_panel_redraw();
}
void update_battery_tick(void *arg)
{
if (!battery_enabled)
return;
if (!battery_enabled)
return;
gboolean old_found = battery_found;
int old_percentage = battery_state.percentage;
gboolean old_ac_connected = battery_state.ac_connected;
int16_t old_hours = battery_state.time.hours;
int8_t old_minutes = battery_state.time.minutes;
gboolean old_found = battery_found;
int old_percentage = battery_state.percentage;
gboolean old_ac_connected = battery_state.ac_connected;
int16_t old_hours = battery_state.time.hours;
int8_t old_minutes = battery_state.time.minutes;
if (!battery_found) {
init_battery();
old_ac_connected = battery_state.ac_connected;
}
if (update_battery() != 0) {
// Try to reconfigure on failed update
init_battery();
}
if (!battery_found) {
init_battery();
old_ac_connected = battery_state.ac_connected;
}
if (update_battery() != 0) {
// Try to reconfigure on failed update
init_battery();
}
if (old_ac_connected != battery_state.ac_connected) {
if (battery_state.ac_connected)
tint_exec(ac_connected_cmd);
else
tint_exec(ac_disconnected_cmd);
}
if (old_ac_connected != battery_state.ac_connected) {
if (battery_state.ac_connected)
tint_exec(ac_connected_cmd);
else
tint_exec(ac_disconnected_cmd);
}
if (battery_state.percentage < battery_low_status && battery_state.state == BATTERY_DISCHARGING &&
!battery_low_cmd_sent) {
tint_exec(battery_low_cmd);
battery_low_cmd_sent = TRUE;
}
if (battery_state.percentage > battery_low_status && battery_state.state == BATTERY_CHARGING &&
battery_low_cmd_sent) {
battery_low_cmd_sent = FALSE;
}
if (battery_state.percentage < battery_low_status && battery_state.state == BATTERY_DISCHARGING &&
!battery_low_cmd_sent) {
tint_exec(battery_low_cmd);
battery_low_cmd_sent = TRUE;
}
if (battery_state.percentage > battery_low_status && battery_state.state == BATTERY_CHARGING &&
battery_low_cmd_sent) {
battery_low_cmd_sent = FALSE;
}
for (int i = 0; i < num_panels; i++) {
// Show/hide if needed
if (!battery_found) {
hide(&panels[i].battery.area);
} else {
if (battery_state.percentage >= percentage_hide)
hide(&panels[i].battery.area);
else
show(&panels[i].battery.area);
}
// Redraw if needed
if (panels[i].battery.area.on_screen) {
if (old_found != battery_found || old_percentage != battery_state.percentage ||
old_hours != battery_state.time.hours || old_minutes != battery_state.time.minutes) {
panels[i].battery.area.resize_needed = TRUE;
schedule_panel_redraw();
}
}
}
for (int i = 0; i < num_panels; i++) {
// Show/hide if needed
if (!battery_found) {
hide(&panels[i].battery.area);
} else {
if (battery_state.percentage >= percentage_hide)
hide(&panels[i].battery.area);
else
show(&panels[i].battery.area);
}
// Redraw if needed
if (panels[i].battery.area.on_screen) {
if (old_found != battery_found || old_percentage != battery_state.percentage ||
old_hours != battery_state.time.hours || old_minutes != battery_state.time.minutes) {
panels[i].battery.area.resize_needed = TRUE;
schedule_panel_redraw();
}
}
}
}
int update_battery()
{
// Reset
battery_state.state = BATTERY_UNKNOWN;
battery_state.percentage = 0;
battery_state.ac_connected = FALSE;
battery_state_set_time(&battery_state, 0);
// Reset
battery_state.state = BATTERY_UNKNOWN;
battery_state.percentage = 0;
battery_state.ac_connected = FALSE;
battery_state_set_time(&battery_state, 0);
int err = battery_os_update(&battery_state);
int err = battery_os_update(&battery_state);
// Clamp percentage to 100 in case battery is misreporting that its current charge is more than its max
if (battery_state.percentage > 100) {
battery_state.percentage = 100;
}
// Clamp percentage to 100 in case battery is misreporting that its current charge is more than its max
if (battery_state.percentage > 100) {
battery_state.percentage = 100;
}
return err;
return err;
}
int battery_compute_desired_size(void *obj)
{
Battery *battery = (Battery *)obj;
Panel *panel = (Panel *)battery->area.panel;
int bat_percentage_height, bat_percentage_width, bat_percentage_height_ink;
int bat_time_height, bat_time_width, bat_time_height_ink;
Battery *battery = (Battery *)obj;
Panel *panel = (Panel *)battery->area.panel;
int bat_percentage_height, bat_percentage_width, bat_percentage_height_ink;
int bat_time_height, bat_time_width, bat_time_height_ink;
snprintf(buf_bat_percentage, sizeof(buf_bat_percentage), "%d%%", battery_state.percentage);
if (battery_state.state == BATTERY_FULL) {
strcpy(buf_bat_time, "Full");
} else {
snprintf(buf_bat_time, sizeof(buf_bat_time), "%02d:%02d", battery_state.time.hours, battery_state.time.minutes);
}
get_text_size2(bat1_font_desc,
&bat_percentage_height_ink,
&bat_percentage_height,
&bat_percentage_width,
panel->area.height,
panel->area.width,
buf_bat_percentage,
strlen(buf_bat_percentage),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
get_text_size2(bat2_font_desc,
&bat_time_height_ink,
&bat_time_height,
&bat_time_width,
panel->area.height,
panel->area.width,
buf_bat_time,
strlen(buf_bat_time),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
snprintf(buf_bat_percentage, sizeof(buf_bat_percentage), "%d%%", battery_state.percentage);
if (battery_state.state == BATTERY_FULL) {
strcpy(buf_bat_time, "Full");
} else {
snprintf(buf_bat_time, sizeof(buf_bat_time), "%02d:%02d", battery_state.time.hours, battery_state.time.minutes);
}
get_text_size2(bat1_font_desc,
&bat_percentage_height_ink,
&bat_percentage_height,
&bat_percentage_width,
panel->area.height,
panel->area.width,
buf_bat_percentage,
strlen(buf_bat_percentage),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
get_text_size2(bat2_font_desc,
&bat_time_height_ink,
&bat_time_height,
&bat_time_width,
panel->area.height,
panel->area.width,
buf_bat_time,
strlen(buf_bat_time),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
if (panel_horizontal) {
int new_size = (bat_percentage_width > bat_time_width) ? bat_percentage_width : bat_time_width;
new_size += 2 * battery->area.paddingxlr + left_right_border_width(&battery->area);
return new_size;
} else {
int new_size = bat_percentage_height + bat_time_height + 2 * battery->area.paddingxlr +
top_bottom_border_width(&battery->area);
return new_size;
}
if (panel_horizontal) {
int new_size = (bat_percentage_width > bat_time_width) ? bat_percentage_width : bat_time_width;
new_size += 2 * battery->area.paddingxlr + left_right_border_width(&battery->area);
return new_size;
} else {
int new_size = bat_percentage_height + bat_time_height + 2 * battery->area.paddingxlr +
top_bottom_border_width(&battery->area);
return new_size;
}
}
gboolean resize_battery(void *obj)
{
Battery *battery = (Battery *)obj;
Panel *panel = (Panel *)battery->area.panel;
int bat_percentage_height, bat_percentage_width, bat_percentage_height_ink;
int bat_time_height, bat_time_width, bat_time_height_ink;
int ret = 0;
Battery *battery = (Battery *)obj;
Panel *panel = (Panel *)battery->area.panel;
int bat_percentage_height, bat_percentage_width, bat_percentage_height_ink;
int bat_time_height, bat_time_width, bat_time_height_ink;
int ret = 0;
snprintf(buf_bat_percentage, sizeof(buf_bat_percentage), "%d%%", battery_state.percentage);
if (battery_state.state == BATTERY_FULL) {
strcpy(buf_bat_time, "Full");
} else {
snprintf(buf_bat_time, sizeof(buf_bat_time), "%02d:%02d", battery_state.time.hours, battery_state.time.minutes);
}
get_text_size2(bat1_font_desc,
&bat_percentage_height_ink,
&bat_percentage_height,
&bat_percentage_width,
panel->area.height,
panel->area.width,
buf_bat_percentage,
strlen(buf_bat_percentage),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
get_text_size2(bat2_font_desc,
&bat_time_height_ink,
&bat_time_height,
&bat_time_width,
panel->area.height,
panel->area.width,
buf_bat_time,
strlen(buf_bat_time),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
snprintf(buf_bat_percentage, sizeof(buf_bat_percentage), "%d%%", battery_state.percentage);
if (battery_state.state == BATTERY_FULL) {
strcpy(buf_bat_time, "Full");
} else {
snprintf(buf_bat_time, sizeof(buf_bat_time), "%02d:%02d", battery_state.time.hours, battery_state.time.minutes);
}
get_text_size2(bat1_font_desc,
&bat_percentage_height_ink,
&bat_percentage_height,
&bat_percentage_width,
panel->area.height,
panel->area.width,
buf_bat_percentage,
strlen(buf_bat_percentage),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
get_text_size2(bat2_font_desc,
&bat_time_height_ink,
&bat_time_height,
&bat_time_width,
panel->area.height,
panel->area.width,
buf_bat_time,
strlen(buf_bat_time),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
if (panel_horizontal) {
int new_size = (bat_percentage_width > bat_time_width) ? bat_percentage_width : bat_time_width;
new_size += 2 * battery->area.paddingxlr + left_right_border_width(&battery->area);
if (new_size > battery->area.width || new_size < battery->area.width - 2) {
// we try to limit the number of resize
battery->area.width = new_size;
battery->bat1_posy = (battery->area.height - bat_percentage_height - bat_time_height) / 2;
battery->bat2_posy = battery->bat1_posy + bat_percentage_height;
ret = 1;
}
} else {
int new_size = bat_percentage_height + bat_time_height + 2 * battery->area.paddingxlr +
top_bottom_border_width(&battery->area);
if (new_size > battery->area.height || new_size < battery->area.height - 2) {
battery->area.height = new_size;
battery->bat1_posy = (battery->area.height - bat_percentage_height - bat_time_height - 2) / 2;
battery->bat2_posy = battery->bat1_posy + bat_percentage_height + 2;
ret = 1;
}
}
if (panel_horizontal) {
int new_size = (bat_percentage_width > bat_time_width) ? bat_percentage_width : bat_time_width;
new_size += 2 * battery->area.paddingxlr + left_right_border_width(&battery->area);
if (new_size > battery->area.width || new_size < battery->area.width - 2) {
// we try to limit the number of resize
battery->area.width = new_size;
battery->bat1_posy = (battery->area.height - bat_percentage_height - bat_time_height) / 2;
battery->bat2_posy = battery->bat1_posy + bat_percentage_height;
ret = 1;
}
} else {
int new_size = bat_percentage_height + bat_time_height + 2 * battery->area.paddingxlr +
top_bottom_border_width(&battery->area);
if (new_size > battery->area.height || new_size < battery->area.height - 2) {
battery->area.height = new_size;
battery->bat1_posy = (battery->area.height - bat_percentage_height - bat_time_height - 2) / 2;
battery->bat2_posy = battery->bat1_posy + bat_percentage_height + 2;
ret = 1;
}
}
schedule_redraw(&battery->area);
return ret;
schedule_redraw(&battery->area);
return ret;
}
void draw_battery(void *obj, cairo_t *c)
{
Battery *battery = obj;
Battery *battery = obj;
PangoLayout *layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, bat1_font_desc);
pango_layout_set_width(layout, battery->area.width * PANGO_SCALE);
pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
pango_layout_set_text(layout, buf_bat_percentage, strlen(buf_bat_percentage));
PangoLayout *layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, bat1_font_desc);
pango_layout_set_width(layout, battery->area.width * PANGO_SCALE);
pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
pango_layout_set_text(layout, buf_bat_percentage, strlen(buf_bat_percentage));
cairo_set_source_rgba(c,
battery->font_color.rgb[0],
battery->font_color.rgb[1],
battery->font_color.rgb[2],
battery->font_color.alpha);
cairo_set_source_rgba(c,
battery->font_color.rgb[0],
battery->font_color.rgb[1],
battery->font_color.rgb[2],
battery->font_color.alpha);
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, battery->bat1_posy, &battery->font_color, ((Panel *)battery->area.panel)->font_shadow);
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, battery->bat1_posy, &battery->font_color, ((Panel *)battery->area.panel)->font_shadow);
pango_layout_set_font_description(layout, bat2_font_desc);
pango_layout_set_indent(layout, 0);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
pango_layout_set_text(layout, buf_bat_time, strlen(buf_bat_time));
pango_layout_set_width(layout, battery->area.width * PANGO_SCALE);
pango_layout_set_font_description(layout, bat2_font_desc);
pango_layout_set_indent(layout, 0);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_NONE);
pango_layout_set_text(layout, buf_bat_time, strlen(buf_bat_time));
pango_layout_set_width(layout, battery->area.width * PANGO_SCALE);
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, battery->bat2_posy, &battery->font_color, ((Panel *)battery->area.panel)->font_shadow);
pango_cairo_show_layout(c, layout);
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, battery->bat2_posy, &battery->font_color, ((Panel *)battery->area.panel)->font_shadow);
pango_cairo_show_layout(c, layout);
g_object_unref(layout);
g_object_unref(layout);
}
void battery_dump_geometry(void *obj, int indent)
{
Battery *battery = obj;
fprintf(stderr,
"%*sText 1: y = %d, text = %s\n",
indent,
"",
battery->bat1_posy,
buf_bat_percentage);
fprintf(stderr,
"%*sText 2: y = %d, text = %s\n",
indent,
"",
battery->bat2_posy,
buf_bat_time);
Battery *battery = obj;
fprintf(stderr, "%*sText 1: y = %d, text = %s\n", indent, "", battery->bat1_posy, buf_bat_percentage);
fprintf(stderr, "%*sText 2: y = %d, text = %s\n", indent, "", battery->bat2_posy, buf_bat_time);
}
char *battery_get_tooltip(void *obj)
{
return battery_os_tooltip();
return battery_os_tooltip();
}
void battery_action(int button)
{
char *command = NULL;
switch (button) {
case 1:
command = battery_lclick_command;
break;
case 2:
command = battery_mclick_command;
break;
case 3:
command = battery_rclick_command;
break;
case 4:
command = battery_uwheel_command;
break;
case 5:
command = battery_dwheel_command;
break;
}
tint_exec(command);
char *command = NULL;
switch (button) {
case 1:
command = battery_lclick_command;
break;
case 2:
command = battery_mclick_command;
break;
case 3:
command = battery_rclick_command;
break;
case 4:
command = battery_uwheel_command;
break;
case 5:
command = battery_dwheel_command;
break;
}
tint_exec(command);
}

62
src/battery/battery.h
View File

@@ -17,30 +17,30 @@
#include "area.h"
typedef struct Battery {
Area area;
Color font_color;
int bat1_posy;
int bat2_posy;
Area area;
Color font_color;
int bat1_posy;
int bat2_posy;
} Battery;
typedef enum ChargeState {
BATTERY_UNKNOWN = 0,
BATTERY_CHARGING,
BATTERY_DISCHARGING,
BATTERY_FULL,
BATTERY_UNKNOWN = 0,
BATTERY_CHARGING,
BATTERY_DISCHARGING,
BATTERY_FULL,
} ChargeState;
typedef struct BatteryTime {
int16_t hours;
int8_t minutes;
int8_t seconds;
int16_t hours;
int8_t minutes;
int8_t seconds;
} BatteryTime;
typedef struct BatteryState {
int percentage;
BatteryTime time;
ChargeState state;
gboolean ac_connected;
int percentage;
BatteryTime time;
ChargeState state;
gboolean ac_connected;
} BatteryState;
extern struct BatteryState battery_state;
@@ -68,26 +68,26 @@ extern char *battery_sys_prefix;
static inline gchar *chargestate2str(ChargeState state)
{
switch (state) {
case BATTERY_CHARGING:
return "Charging";
case BATTERY_DISCHARGING:
return "Discharging";
case BATTERY_FULL:
return "Full";
case BATTERY_UNKNOWN:
default:
return "Unknown";
};
switch (state) {
case BATTERY_CHARGING:
return "Charging";
case BATTERY_DISCHARGING:
return "Discharging";
case BATTERY_FULL:
return "Full";
case BATTERY_UNKNOWN:
default:
return "Unknown";
};
}
static inline void battery_state_set_time(BatteryState *state, int seconds)
{
state->time.hours = seconds / 3600;
seconds -= 3600 * state->time.hours;
state->time.minutes = seconds / 60;
seconds -= 60 * state->time.minutes;
state->time.seconds = seconds;
state->time.hours = seconds / 3600;
seconds -= 3600 * state->time.hours;
state->time.minutes = seconds / 60;
seconds -= 60 * state->time.minutes;
state->time.seconds = seconds;
}
// default global data

8
src/battery/dummy.c
View File

@@ -25,20 +25,20 @@
gboolean battery_os_init()
{
return FALSE;
return FALSE;
}
void battery_os_free()
{
return;
return;
}
int battery_os_update(BatteryState *state)
{
return -1;
return -1;
}
char *battery_os_tooltip()
{
return strdup("Operating System not supported");
return strdup("Operating System not supported");
}

94
src/battery/freebsd.c
View File

@@ -26,77 +26,77 @@
gboolean battery_os_init()
{
int sysctl_out = 0;
size_t len = sizeof(sysctl_out);
int sysctl_out = 0;
size_t len = sizeof(sysctl_out);
return (sysctlbyname("hw.acpi.battery.state", &sysctl_out, &len, NULL, 0) == 0) ||
(sysctlbyname("hw.acpi.battery.time", &sysctl_out, &len, NULL, 0) == 0) ||
(sysctlbyname("hw.acpi.battery.life", &sysctl_out, &len, NULL, 0) == 0);
return (sysctlbyname("hw.acpi.battery.state", &sysctl_out, &len, NULL, 0) == 0) ||
(sysctlbyname("hw.acpi.battery.time", &sysctl_out, &len, NULL, 0) == 0) ||
(sysctlbyname("hw.acpi.battery.life", &sysctl_out, &len, NULL, 0) == 0);
}
void battery_os_free()
{
return;
return;
}
int battery_os_update(BatteryState *state)
{
int sysctl_out = 0;
size_t len = sizeof(sysctl_out);
gboolean err = 0;
int sysctl_out = 0;
size_t len = sizeof(sysctl_out);
gboolean err = 0;
if (sysctlbyname("hw.acpi.battery.state", &sysctl_out, &len, NULL, 0) == 0) {
switch (sysctl_out) {
case 1:
state->state = BATTERY_DISCHARGING;
break;
case 2:
state->state = BATTERY_CHARGING;
break;
default:
state->state = BATTERY_FULL;
break;
}
} else {
fprintf(stderr, "power update: no such sysctl");
err = -1;
}
if (sysctlbyname("hw.acpi.battery.state", &sysctl_out, &len, NULL, 0) == 0) {
switch (sysctl_out) {
case 1:
state->state = BATTERY_DISCHARGING;
break;
case 2:
state->state = BATTERY_CHARGING;
break;
default:
state->state = BATTERY_FULL;
break;
}
} else {
fprintf(stderr, "power update: no such sysctl");
err = -1;
}
if (sysctlbyname("hw.acpi.battery.time", &sysctl_out, &len, NULL, 0) == 0)
battery_state_set_time(state, sysctl_out * 60);
else
err = -1;
if (sysctlbyname("hw.acpi.battery.time", &sysctl_out, &len, NULL, 0) == 0)
battery_state_set_time(state, sysctl_out * 60);
else
err = -1;
if (sysctlbyname("hw.acpi.battery.life", &sysctl_out, &len, NULL, 0) == 0)
state->percentage = sysctl_out;
else
err = -1;
if (sysctlbyname("hw.acpi.battery.life", &sysctl_out, &len, NULL, 0) == 0)
state->percentage = sysctl_out;
else
err = -1;
if (sysctlbyname("hw.acpi.acline", &sysctl_out, &len, NULL, 0) == 0)
state->ac_connected = sysctl_out;
if (sysctlbyname("hw.acpi.acline", &sysctl_out, &len, NULL, 0) == 0)
state->ac_connected = sysctl_out;
return err;
return err;
}
char *battery_os_tooltip()
{
GString *tooltip = g_string_new("");
gchar *result;
GString *tooltip = g_string_new("");
gchar *result;
g_string_append_printf(tooltip, "Battery\n");
g_string_append_printf(tooltip, "Battery\n");
gchar *state = (battery_state.state == BATTERY_UNKNOWN) ? "Level" : chargestate2str(battery_state.state);
gchar *state = (battery_state.state == BATTERY_UNKNOWN) ? "Level" : chargestate2str(battery_state.state);
g_string_append_printf(tooltip, "\t%s: %d%%", state, battery_state.percentage);
g_string_append_printf(tooltip, "\t%s: %d%%", state, battery_state.percentage);
g_string_append_c(tooltip, '\n');
g_string_append_printf(tooltip, "AC\n");
g_string_append_printf(tooltip, battery_state.ac_connected ? "\tConnected" : "\tDisconnected");
g_string_append_c(tooltip, '\n');
g_string_append_printf(tooltip, "AC\n");
g_string_append_printf(tooltip, battery_state.ac_connected ? "\tConnected" : "\tDisconnected");
result = tooltip->str;
g_string_free(tooltip, FALSE);
result = tooltip->str;
g_string_free(tooltip, FALSE);
return result;
return result;
}
#endif

707
src/battery/linux.c
View File

@@ -26,513 +26,514 @@
#include "uevent.h"
enum psy_type {
PSY_UNKNOWN,
PSY_BATTERY,
PSY_MAINS,
PSY_UNKNOWN,
PSY_BATTERY,
PSY_MAINS,
};
struct psy_battery {
/* generic properties */
gchar *name;
/* monotonic time, in microseconds */
gint64 timestamp;
/* sysfs files */
gchar *path_present;
gchar *path_level_now;
gchar *path_level_full;
gchar *path_rate_now;
gchar *path_status;
/* values */
gboolean present;
gint level_now;
gint level_full;
gint rate_now;
gchar unit;
ChargeState status;
/* generic properties */
gchar *name;
/* monotonic time, in microseconds */
gint64 timestamp;
/* sysfs files */
gchar *path_present;
gchar *path_level_now;
gchar *path_level_full;
gchar *path_rate_now;
gchar *path_status;
/* values */
gboolean present;
gint level_now;
gint level_full;
gint rate_now;
gchar unit;
ChargeState status;
};
struct psy_mains {
/* generic properties */
gchar *name;
/* sysfs files */
gchar *path_online;
/* values */
gboolean online;
/* generic properties */
gchar *name;
/* sysfs files */
gchar *path_online;
/* values */
gboolean online;
};
static void uevent_battery_update()
{
update_battery_tick(NULL);
update_battery_tick(NULL);
}
static struct uevent_notify psy_change = {UEVENT_CHANGE, "power_supply", NULL, uevent_battery_update};
static void uevent_battery_plug()
{
printf("reinitialize batteries after HW change\n");
reinit_battery();
printf("reinitialize batteries after HW change\n");
reinit_battery();
}
static struct uevent_notify psy_plug = {UEVENT_ADD | UEVENT_REMOVE, "power_supply", NULL, uevent_battery_plug};
#define RETURN_ON_ERROR(err) \
if (err) { \
g_error_free(err); \
fprintf(stderr, RED "%s:%d: errror" RESET "\n", __FILE__, __LINE__); \
return FALSE; \
}
#define RETURN_ON_ERROR(err) \
if (err) { \
g_error_free(err); \
fprintf(stderr, RED "%s:%d: errror" RESET "\n", __FILE__, __LINE__); \
return FALSE; \
}
static GList *batteries = NULL;
static GList *mains = NULL;
static guint8 level_to_percent(gint level_now, gint level_full)
{
return 0.5 + ((level_now <= level_full ? level_now : level_full) * 100.0) / level_full;
return 0.5 + ((level_now <= level_full ? level_now : level_full) * 100.0) / level_full;
}
static enum psy_type power_supply_get_type(const gchar *entryname)
{
gchar *path_type = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "type", NULL);
GError *error = NULL;
gchar *type;
gsize typelen;
gchar *path_type = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "type", NULL);
GError *error = NULL;
gchar *type;
gsize typelen;
g_file_get_contents(path_type, &type, &typelen, &error);
g_free(path_type);
if (error) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
g_error_free(error);
return PSY_UNKNOWN;
}
g_file_get_contents(path_type, &type, &typelen, &error);
g_free(path_type);
if (error) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
g_error_free(error);
return PSY_UNKNOWN;
}
if (!g_strcmp0(type, "Battery\n")) {
g_free(type);
return PSY_BATTERY;
}
if (!g_strcmp0(type, "Battery\n")) {
g_free(type);
return PSY_BATTERY;
}
if (!g_strcmp0(type, "Mains\n")) {
g_free(type);
return PSY_MAINS;
}
if (!g_strcmp0(type, "Mains\n")) {
g_free(type);
return PSY_MAINS;
}
g_free(type);
g_free(type);
return PSY_UNKNOWN;
return PSY_UNKNOWN;
}
static gboolean init_linux_battery(struct psy_battery *bat)
{
const gchar *entryname = bat->name;
const gchar *entryname = bat->name;
bat->path_present = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "present", NULL);
if (!g_file_test(bat->path_present, G_FILE_TEST_EXISTS)) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
goto err0;
}
bat->path_present = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "present", NULL);
if (!g_file_test(bat->path_present, G_FILE_TEST_EXISTS)) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
goto err0;
}
bat->path_level_now = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "energy_now", NULL);
bat->path_level_full =
g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "energy_full", NULL);
bat->path_rate_now = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "power_now", NULL);
bat->unit = 'W';
bat->path_level_now =
g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "energy_now", NULL);
bat->path_level_full =
g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "energy_full", NULL);
bat->path_rate_now = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "power_now", NULL);
bat->unit = 'W';
if (!g_file_test(bat->path_level_now, G_FILE_TEST_EXISTS) ||
!g_file_test(bat->path_level_full, G_FILE_TEST_EXISTS) ||
!g_file_test(bat->path_rate_now, G_FILE_TEST_EXISTS)) {
g_free(bat->path_level_now);
g_free(bat->path_level_full);
g_free(bat->path_rate_now);
bat->path_level_now =
g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "charge_now", NULL);
bat->path_level_full =
g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "charge_full", NULL);
bat->path_rate_now =
g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "current_now", NULL);
bat->unit = 'A';
}
if (!g_file_test(bat->path_level_now, G_FILE_TEST_EXISTS) ||
!g_file_test(bat->path_level_full, G_FILE_TEST_EXISTS) ||
!g_file_test(bat->path_rate_now, G_FILE_TEST_EXISTS)) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
goto err1;
}
if (!g_file_test(bat->path_level_now, G_FILE_TEST_EXISTS) ||
!g_file_test(bat->path_level_full, G_FILE_TEST_EXISTS) ||
!g_file_test(bat->path_rate_now, G_FILE_TEST_EXISTS)) {
g_free(bat->path_level_now);
g_free(bat->path_level_full);
g_free(bat->path_rate_now);
bat->path_level_now =
g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "charge_now", NULL);
bat->path_level_full =
g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "charge_full", NULL);
bat->path_rate_now =
g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "current_now", NULL);
bat->unit = 'A';
}
if (!g_file_test(bat->path_level_now, G_FILE_TEST_EXISTS) ||
!g_file_test(bat->path_level_full, G_FILE_TEST_EXISTS) ||
!g_file_test(bat->path_rate_now, G_FILE_TEST_EXISTS)) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
goto err1;
}
bat->path_status = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "status", NULL);
if (!g_file_test(bat->path_status, G_FILE_TEST_EXISTS)) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
goto err2;
}
bat->path_status = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "status", NULL);
if (!g_file_test(bat->path_status, G_FILE_TEST_EXISTS)) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
goto err2;
}
return TRUE;
return TRUE;
err2:
g_free(bat->path_status);
g_free(bat->path_status);
err1:
g_free(bat->path_level_now);
g_free(bat->path_level_full);
g_free(bat->path_rate_now);
g_free(bat->path_level_now);
g_free(bat->path_level_full);
g_free(bat->path_rate_now);
err0:
g_free(bat->path_present);
g_free(bat->path_present);
return FALSE;
return FALSE;
}
static gboolean init_linux_mains(struct psy_mains *ac)
{
const gchar *entryname = ac->name;
const gchar *entryname = ac->name;
ac->path_online = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "online", NULL);
if (!g_file_test(ac->path_online, G_FILE_TEST_EXISTS)) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
g_free(ac->path_online);
return FALSE;
}
ac->path_online = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", entryname, "online", NULL);
if (!g_file_test(ac->path_online, G_FILE_TEST_EXISTS)) {
fprintf(stderr, RED "%s:%d: read failed" RESET "\n", __FILE__, __LINE__);
g_free(ac->path_online);
return FALSE;
}
return TRUE;
return TRUE;
}
static void psy_battery_free(gpointer data)
{
struct psy_battery *bat = data;
g_free(bat->name);
g_free(bat->path_status);
g_free(bat->path_rate_now);
g_free(bat->path_level_full);
g_free(bat->path_level_now);
g_free(bat->path_present);
g_free(bat);
struct psy_battery *bat = data;
g_free(bat->name);
g_free(bat->path_status);
g_free(bat->path_rate_now);
g_free(bat->path_level_full);
g_free(bat->path_level_now);
g_free(bat->path_present);
g_free(bat);
}
static void psy_mains_free(gpointer data)
{
struct psy_mains *ac = data;
g_free(ac->name);
g_free(ac->path_online);
g_free(ac);
struct psy_mains *ac = data;
g_free(ac->name);
g_free(ac->path_online);
g_free(ac);
}
void battery_os_free()
{
uevent_unregister_notifier(&psy_change);
uevent_unregister_notifier(&psy_plug);
uevent_unregister_notifier(&psy_change);
uevent_unregister_notifier(&psy_plug);
g_list_free_full(batteries, psy_battery_free);
batteries = NULL;
g_list_free_full(mains, psy_mains_free);
mains = NULL;
g_list_free_full(batteries, psy_battery_free);
batteries = NULL;
g_list_free_full(mains, psy_mains_free);
mains = NULL;
}
static void add_battery(const char *entryname)
{
struct psy_battery *bat = g_malloc0(sizeof(*bat));
bat->name = g_strdup(entryname);
struct psy_battery *bat = g_malloc0(sizeof(*bat));
bat->name = g_strdup(entryname);
if (init_linux_battery(bat)) {
batteries = g_list_append(batteries, bat);
fprintf(stdout, GREEN "Found battery \"%s\"" RESET "\n", bat->name);
} else {
g_free(bat);
fprintf(stderr, RED "Failed to initialize battery \"%s\"" RESET "\n", entryname);
}
if (init_linux_battery(bat)) {
batteries = g_list_append(batteries, bat);
fprintf(stdout, GREEN "Found battery \"%s\"" RESET "\n", bat->name);
} else {
g_free(bat);
fprintf(stderr, RED "Failed to initialize battery \"%s\"" RESET "\n", entryname);
}
}
static void add_mains(const char *entryname)
{
struct psy_mains *ac = g_malloc0(sizeof(*ac));
ac->name = g_strdup(entryname);
struct psy_mains *ac = g_malloc0(sizeof(*ac));
ac->name = g_strdup(entryname);
if (init_linux_mains(ac)) {
mains = g_list_append(mains, ac);
fprintf(stdout, GREEN "Found mains \"%s\"" RESET "\n", ac->name);
} else {
g_free(ac);
fprintf(stderr, RED "Failed to initialize mains \"%s\"" RESET "\n", entryname);
}
if (init_linux_mains(ac)) {
mains = g_list_append(mains, ac);
fprintf(stdout, GREEN "Found mains \"%s\"" RESET "\n", ac->name);
} else {
g_free(ac);
fprintf(stderr, RED "Failed to initialize mains \"%s\"" RESET "\n", entryname);
}
}
gboolean battery_os_init()
{
GDir *directory = 0;
GError *error = NULL;
const char *entryname;
GDir *directory = 0;
GError *error = NULL;
const char *entryname;
battery_os_free();
battery_os_free();
gchar *dir_path = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", NULL);
directory = g_dir_open(dir_path, 0, &error);
g_free(dir_path);
RETURN_ON_ERROR(error);
gchar *dir_path = g_build_filename(battery_sys_prefix, "/sys/class/power_supply", NULL);
directory = g_dir_open(dir_path, 0, &error);
g_free(dir_path);
RETURN_ON_ERROR(error);
while ((entryname = g_dir_read_name(directory))) {
fprintf(stderr, GREEN "Found power device %s" RESET "\n", entryname);
enum psy_type type = power_supply_get_type(entryname);
while ((entryname = g_dir_read_name(directory))) {
fprintf(stderr, GREEN "Found power device %s" RESET "\n", entryname);
enum psy_type type = power_supply_get_type(entryname);
switch (type) {
case PSY_BATTERY:
add_battery(entryname);
break;
case PSY_MAINS:
add_mains(entryname);
break;
default:
break;
}
}
switch (type) {
case PSY_BATTERY:
add_battery(entryname);
break;
case PSY_MAINS:
add_mains(entryname);
break;
default:
break;
}
}
g_dir_close(directory);
g_dir_close(directory);
uevent_register_notifier(&psy_change);
uevent_register_notifier(&psy_plug);
uevent_register_notifier(&psy_change);
uevent_register_notifier(&psy_plug);
return batteries != NULL;
return batteries != NULL;
}
static gint estimate_rate_usage(struct psy_battery *bat, gint old_level_now, gint64 old_timestamp)
{
gint64 diff_level = ABS(bat->level_now - old_level_now);
gint64 diff_time = bat->timestamp - old_timestamp;
gint64 diff_level = ABS(bat->level_now - old_level_now);
gint64 diff_time = bat->timestamp - old_timestamp;
/* µW = (µWh * 3600) / (µs / 1000000) */
gint rate = diff_level * 3600 * 1000000 / MAX(1, diff_time);
/* µW = (µWh * 3600) / (µs / 1000000) */
gint rate = diff_level * 3600 * 1000000 / MAX(1, diff_time);
return rate;
return rate;
}
static gboolean update_linux_battery(struct psy_battery *bat)
{
GError *error = NULL;
gchar *data;
gsize datalen;
GError *error = NULL;
gchar *data;
gsize datalen;
gint64 old_timestamp = bat->timestamp;
int old_level_now = bat->level_now;
gint old_rate_now = bat->rate_now;
gint64 old_timestamp = bat->timestamp;
int old_level_now = bat->level_now;
gint old_rate_now = bat->rate_now;
/* reset values */
bat->present = 0;
bat->status = BATTERY_UNKNOWN;
bat->level_now = 0;
bat->level_full = 0;
bat->rate_now = 0;
bat->timestamp = g_get_monotonic_time();
/* reset values */
bat->present = 0;
bat->status = BATTERY_UNKNOWN;
bat->level_now = 0;
bat->level_full = 0;
bat->rate_now = 0;
bat->timestamp = g_get_monotonic_time();
/* present */
g_file_get_contents(bat->path_present, &data, &datalen, &error);
RETURN_ON_ERROR(error);
bat->present = (atoi(data) == 1);
g_free(data);
/* present */
g_file_get_contents(bat->path_present, &data, &datalen, &error);
RETURN_ON_ERROR(error);
bat->present = (atoi(data) == 1);
g_free(data);
/* we are done, if battery is not present */
if (!bat->present)
return TRUE;
/* we are done, if battery is not present */
if (!bat->present)
return TRUE;
/* status */
bat->status = BATTERY_UNKNOWN;
g_file_get_contents(bat->path_status, &data, &datalen, &error);
RETURN_ON_ERROR(error);
if (!g_strcmp0(data, "Charging\n")) {
bat->status = BATTERY_CHARGING;
} else if (!g_strcmp0(data, "Discharging\n")) {
bat->status = BATTERY_DISCHARGING;
} else if (!g_strcmp0(data, "Full\n")) {
bat->status = BATTERY_FULL;
}
g_free(data);
/* status */
bat->status = BATTERY_UNKNOWN;
g_file_get_contents(bat->path_status, &data, &datalen, &error);
RETURN_ON_ERROR(error);
if (!g_strcmp0(data, "Charging\n")) {
bat->status = BATTERY_CHARGING;
} else if (!g_strcmp0(data, "Discharging\n")) {
bat->status = BATTERY_DISCHARGING;
} else if (!g_strcmp0(data, "Full\n")) {
bat->status = BATTERY_FULL;
}
g_free(data);
/* level now */
g_file_get_contents(bat->path_level_now, &data, &datalen, &error);
RETURN_ON_ERROR(error);
bat->level_now = atoi(data);
g_free(data);
/* level now */
g_file_get_contents(bat->path_level_now, &data, &datalen, &error);
RETURN_ON_ERROR(error);
bat->level_now = atoi(data);
g_free(data);
/* level full */
g_file_get_contents(bat->path_level_full, &data, &datalen, &error);
RETURN_ON_ERROR(error);
bat->level_full = atoi(data);
g_free(data);
/* level full */
g_file_get_contents(bat->path_level_full, &data, &datalen, &error);
RETURN_ON_ERROR(error);
bat->level_full = atoi(data);
g_free(data);
/* rate now */
g_file_get_contents(bat->path_rate_now, &data, &datalen, &error);
if (g_error_matches(error, G_FILE_ERROR, G_FILE_ERROR_NODEV)) {
/* some hardware does not support reading current rate consumption */
g_error_free(error);
bat->rate_now = estimate_rate_usage(bat, old_level_now, old_timestamp);
if (bat->rate_now == 0 && bat->status != BATTERY_FULL) {
/* If the hardware updates the level slower than our sampling period,
* we need to sample more rarely */
bat->rate_now = old_rate_now;
bat->timestamp = old_timestamp;
}
} else if (error) {
g_error_free(error);
return FALSE;
} else {
bat->rate_now = atoi(data);
g_free(data);
}
/* rate now */
g_file_get_contents(bat->path_rate_now, &data, &datalen, &error);
if (g_error_matches(error, G_FILE_ERROR, G_FILE_ERROR_NODEV)) {
/* some hardware does not support reading current rate consumption */
g_error_free(error);
bat->rate_now = estimate_rate_usage(bat, old_level_now, old_timestamp);
if (bat->rate_now == 0 && bat->status != BATTERY_FULL) {
/* If the hardware updates the level slower than our sampling period,
* we need to sample more rarely */
bat->rate_now = old_rate_now;
bat->timestamp = old_timestamp;
}
} else if (error) {
g_error_free(error);
return FALSE;
} else {
bat->rate_now = atoi(data);
g_free(data);
}
return TRUE;
return TRUE;
}
static gboolean update_linux_mains(struct psy_mains *ac)
{
GError *error = NULL;
gchar *data;
gsize datalen;
ac->online = FALSE;
GError *error = NULL;
gchar *data;
gsize datalen;
ac->online = FALSE;
/* online */
g_file_get_contents(ac->path_online, &data, &datalen, &error);
RETURN_ON_ERROR(error);
ac->online = (atoi(data) == 1);
g_free(data);
/* online */
g_file_get_contents(ac->path_online, &data, &datalen, &error);
RETURN_ON_ERROR(error);
ac->online = (atoi(data) == 1);
g_free(data);
return TRUE;
return TRUE;
}
int battery_os_update(BatteryState *state)
{
GList *l;
GList *l;
gint64 total_level_now = 0;
gint64 total_level_full = 0;
gint64 total_rate_now = 0;
gint seconds = 0;
gint64 total_level_now = 0;
gint64 total_level_full = 0;
gint64 total_rate_now = 0;
gint seconds = 0;
gboolean charging = FALSE;
gboolean discharging = FALSE;
gboolean full = FALSE;
gboolean ac_connected = FALSE;
gboolean charging = FALSE;
gboolean discharging = FALSE;
gboolean full = FALSE;
gboolean ac_connected = FALSE;
for (l = batteries; l != NULL; l = l->next) {
struct psy_battery *bat = l->data;
update_linux_battery(bat);
for (l = batteries; l != NULL; l = l->next) {
struct psy_battery *bat = l->data;
update_linux_battery(bat);
total_level_now += bat->level_now;
total_level_full += bat->level_full;
total_rate_now += bat->rate_now;
total_level_now += bat->level_now;
total_level_full += bat->level_full;
total_rate_now += bat->rate_now;
charging |= (bat->status == BATTERY_CHARGING);
discharging |= (bat->status == BATTERY_DISCHARGING);
full |= (bat->status == BATTERY_FULL);
}
charging |= (bat->status == BATTERY_CHARGING);
discharging |= (bat->status == BATTERY_DISCHARGING);
full |= (bat->status == BATTERY_FULL);
}
for (l = mains; l != NULL; l = l->next) {
struct psy_mains *ac = l->data;
update_linux_mains(ac);
ac_connected |= (ac->online);
}
for (l = mains; l != NULL; l = l->next) {
struct psy_mains *ac = l->data;
update_linux_mains(ac);
ac_connected |= (ac->online);
}
/* build global state */
if (charging && !discharging)
state->state = BATTERY_CHARGING;
else if (!charging && discharging)
state->state = BATTERY_DISCHARGING;
else if (!charging && !discharging && full)
state->state = BATTERY_FULL;
/* build global state */
if (charging && !discharging)
state->state = BATTERY_CHARGING;
else if (!charging && discharging)
state->state = BATTERY_DISCHARGING;
else if (!charging && !discharging && full)
state->state = BATTERY_FULL;
/* calculate seconds */
if (total_rate_now > 0) {
if (state->state == BATTERY_CHARGING)
seconds = 3600 * (total_level_full - total_level_now) / total_rate_now;
else if (state->state == BATTERY_DISCHARGING)
seconds = 3600 * total_level_now / total_rate_now;
seconds = MAX(0, seconds);
}
battery_state_set_time(state, seconds);
/* calculate seconds */
if (total_rate_now > 0) {
if (state->state == BATTERY_CHARGING)
seconds = 3600 * (total_level_full - total_level_now) / total_rate_now;
else if (state->state == BATTERY_DISCHARGING)
seconds = 3600 * total_level_now / total_rate_now;
seconds = MAX(0, seconds);
}
battery_state_set_time(state, seconds);
/* calculate percentage */
state->percentage = level_to_percent(total_level_now, total_level_full);
/* calculate percentage */
state->percentage = level_to_percent(total_level_now, total_level_full);
/* AC state */
state->ac_connected = ac_connected;
/* AC state */
state->ac_connected = ac_connected;
return 0;
return 0;
}
static gchar *level_human_readable(struct psy_battery *bat)
{
gint now = bat->level_now;
gint full = bat->level_full;
gint now = bat->level_now;
gint full = bat->level_full;
if (full >= 1000000) {
return g_strdup_printf("%d.%d / %d.%d %ch",
now / 1000000,
(now % 1000000) / 100000,
full / 1000000,
(full % 1000000) / 100000,
bat->unit);
} else if (full >= 1000) {
return g_strdup_printf("%d.%d / %d.%d m%ch",
now / 1000,
(now % 1000) / 100,
full / 1000,
(full % 1000) / 100,
bat->unit);
} else {
return g_strdup_printf("%d / %d µ%ch", now, full, bat->unit);
}
if (full >= 1000000) {
return g_strdup_printf("%d.%d / %d.%d %ch",
now / 1000000,
(now % 1000000) / 100000,
full / 1000000,
(full % 1000000) / 100000,
bat->unit);
} else if (full >= 1000) {
return g_strdup_printf("%d.%d / %d.%d m%ch",
now / 1000,
(now % 1000) / 100,
full / 1000,
(full % 1000) / 100,
bat->unit);
} else {
return g_strdup_printf("%d / %d µ%ch", now, full, bat->unit);
}
}
static gchar *rate_human_readable(struct psy_battery *bat)
{
gint rate = bat->rate_now;
gchar unit = bat->unit;
gint rate = bat->rate_now;
gchar unit = bat->unit;
if (rate >= 1000000) {
return g_strdup_printf("%d.%d %c", rate / 1000000, (rate % 1000000) / 100000, unit);
} else if (rate >= 1000) {
return g_strdup_printf("%d.%d m%c", rate / 1000, (rate % 1000) / 100, unit);
} else if (rate > 0) {
return g_strdup_printf("%d µ%c", rate, unit);
} else {
return g_strdup_printf("0 %c", unit);
}
if (rate >= 1000000) {
return g_strdup_printf("%d.%d %c", rate / 1000000, (rate % 1000000) / 100000, unit);
} else if (rate >= 1000) {
return g_strdup_printf("%d.%d m%c", rate / 1000, (rate % 1000) / 100, unit);
} else if (rate > 0) {
return g_strdup_printf("%d µ%c", rate, unit);
} else {
return g_strdup_printf("0 %c", unit);
}
}
char *battery_os_tooltip()
{
GList *l;
GString *tooltip = g_string_new("");
gchar *result;
GList *l;
GString *tooltip = g_string_new("");
gchar *result;
for (l = batteries; l != NULL; l = l->next) {
struct psy_battery *bat = l->data;
for (l = batteries; l != NULL; l = l->next) {
struct psy_battery *bat = l->data;
if (tooltip->len)
g_string_append_c(tooltip, '\n');
if (tooltip->len)
g_string_append_c(tooltip, '\n');
g_string_append_printf(tooltip, "%s\n", bat->name);
g_string_append_printf(tooltip, "%s\n", bat->name);
if (!bat->present) {
g_string_append_printf(tooltip, "\tnot connected");
continue;
}
if (!bat->present) {
g_string_append_printf(tooltip, "\tnot connected");
continue;
}
gchar *rate = rate_human_readable(bat);
gchar *level = level_human_readable(bat);
gchar *state = (bat->status == BATTERY_UNKNOWN) ? "energy" : chargestate2str(bat->status);
gchar *rate = rate_human_readable(bat);
gchar *level = level_human_readable(bat);
gchar *state = (bat->status == BATTERY_UNKNOWN) ? "energy" : chargestate2str(bat->status);
guint8 percentage = level_to_percent(bat->level_now, bat->level_full);
guint8 percentage = level_to_percent(bat->level_now, bat->level_full);
g_string_append_printf(tooltip, "\t%s: %s (%u %%)\n\trate: %s", state, level, percentage, rate);
g_string_append_printf(tooltip, "\t%s: %s (%u %%)\n\trate: %s", state, level, percentage, rate);
g_free(rate);
g_free(level);
}
g_free(rate);
g_free(level);
}
for (l = mains; l != NULL; l = l->next) {
struct psy_mains *ac = l->data;
for (l = mains; l != NULL; l = l->next) {
struct psy_mains *ac = l->data;
if (tooltip->len)
g_string_append_c(tooltip, '\n');
if (tooltip->len)
g_string_append_c(tooltip, '\n');
g_string_append_printf(tooltip, "%s\n", ac->name);
g_string_append_printf(tooltip, ac->online ? "\tConnected" : "\tDisconnected");
}
g_string_append_printf(tooltip, "%s\n", ac->name);
g_string_append_printf(tooltip, ac->online ? "\tConnected" : "\tDisconnected");
}
result = tooltip->str;
g_string_free(tooltip, FALSE);
result = tooltip->str;
g_string_free(tooltip, FALSE);
return result;
return result;
}
#endif

94
src/battery/openbsd.c
View File

@@ -31,78 +31,78 @@ int apm_fd = -1;
gboolean battery_os_init()
{
if (apm_fd > 0)
close(apm_fd);
if (apm_fd > 0)
close(apm_fd);
apm_fd = open("/dev/apm", O_RDONLY);
apm_fd = open("/dev/apm", O_RDONLY);
if (apm_fd < 0) {
warn("ERROR: battery applet cannot open /dev/apm.");
return FALSE;
} else {
return TRUE;
}
if (apm_fd < 0) {
warn("ERROR: battery applet cannot open /dev/apm.");
return FALSE;
} else {
return TRUE;
}
}
void battery_os_free()
{
if ((apm_fd != -1) && (close(apm_fd) == -1))
warn("cannot close /dev/apm");
apm_fd = -1;
if ((apm_fd != -1) && (close(apm_fd) == -1))
warn("cannot close /dev/apm");
apm_fd = -1;
}
int battery_os_update(BatteryState *state)
{
struct apm_power_info info;
struct apm_power_info info;
if (apm_fd > 0 && ioctl(apm_fd, APM_IOC_GETPOWER, &(info)) == 0) {
// best attempt at mapping to Linux battery states
switch (info.battery_state) {
case APM_BATT_CHARGING:
state->state = BATTERY_CHARGING;
break;
default:
state->state = BATTERY_DISCHARGING;
break;
}
if (apm_fd > 0 && ioctl(apm_fd, APM_IOC_GETPOWER, &(info)) == 0) {
// best attempt at mapping to Linux battery states
switch (info.battery_state) {
case APM_BATT_CHARGING:
state->state = BATTERY_CHARGING;
break;
default:
state->state = BATTERY_DISCHARGING;
break;
}
if (info.battery_life > 100)
info.battery_life = 100;
if (info.battery_life == 100)
state->state = BATTERY_FULL;
if (info.battery_life > 100)
info.battery_life = 100;
if (info.battery_life == 100)
state->state = BATTERY_FULL;
state->percentage = info.battery_life;
if (info.minutes_left != -1)
battery_state_set_time(state, info.minutes_left * 60);
state->percentage = info.battery_life;
if (info.minutes_left != -1)
battery_state_set_time(state, info.minutes_left * 60);
state->ac_connected = info.ac_state == APM_AC_ON;
} else {
warn("power update: APM_IOC_GETPOWER");
return -1;
}
state->ac_connected = info.ac_state == APM_AC_ON;
} else {
warn("power update: APM_IOC_GETPOWER");
return -1;
}
return 0;
return 0;
}
char *battery_os_tooltip()
{
GString *tooltip = g_string_new("");
gchar *result;
GString *tooltip = g_string_new("");
gchar *result;
g_string_append_printf(tooltip, "Battery\n");
g_string_append_printf(tooltip, "Battery\n");
gchar *state = (battery_state.state == BATTERY_UNKNOWN) ? "Level" : chargestate2str(battery_state.state);
gchar *state = (battery_state.state == BATTERY_UNKNOWN) ? "Level" : chargestate2str(battery_state.state);
g_string_append_printf(tooltip, "\t%s: %d%%", state, battery_state.percentage);
g_string_append_printf(tooltip, "\t%s: %d%%", state, battery_state.percentage);
g_string_append_c(tooltip, '\n');
g_string_append_printf(tooltip, "AC\n");
g_string_append_printf(tooltip, battery_state.ac_connected ? "\tConnected" : "\tDisconnected");
g_string_append_c(tooltip, '\n');
g_string_append_printf(tooltip, "AC\n");
g_string_append_printf(tooltip, battery_state.ac_connected ? "\tConnected" : "\tDisconnected");
result = tooltip->str;
g_string_free(tooltip, FALSE);
result = tooltip->str;
g_string_free(tooltip, FALSE);
return result;
return result;
}
#endif