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

1021
src/button/button.c
View File

File diff suppressed because it is too large Load Diff

79
src/button/button.h
View File

@@ -17,55 +17,56 @@
// backend's config and state variables.
typedef struct ButtonBackend {
// Config:
char *icon_name;
char *text;
char *tooltip;
gboolean centered;
int max_icon_size;
gboolean has_font;
PangoFontDescription *font_desc;
Color font_color;
char *lclick_command;
char *mclick_command;
char *rclick_command;
char *uwheel_command;
char *dwheel_command;
// paddingxlr = horizontal padding left/right
// paddingx = horizontal padding between childs
int paddingxlr, paddingx, paddingy;
Background *bg;
// Config:
char *icon_name;
char *text;
char *tooltip;
gboolean centered;
int max_icon_size;
gboolean has_font;
PangoFontDescription *font_desc;
Color font_color;
char *lclick_command;
char *mclick_command;
char *rclick_command;
char *uwheel_command;
char *dwheel_command;
// paddingxlr = horizontal padding left/right
// paddingx = horizontal padding between childs
int paddingxlr, paddingx, paddingy;
Background *bg;
// List of Button which are frontends for this backend, one for each panel
GList *instances;
// List of Button which are frontends for this backend, one for each panel
GList *instances;
} ButtonBackend;
typedef struct ButtonFrontend {
// Frontend state:
Imlib_Image icon;
Imlib_Image icon_hover;
Imlib_Image icon_pressed;
int icon_load_size;
int iconx;
int icony;
int iconw;
int iconh;
int textx;
int texty;
int textw;
int texth;
// Frontend state:
Imlib_Image icon;
Imlib_Image icon_hover;
Imlib_Image icon_pressed;
int icon_load_size;
int iconx;
int icony;
int iconw;
int iconh;
int textx;
int texty;
int textw;
int texth;
} ButtonFrontend;
typedef struct Button {
Area area;
// All elements have the backend pointer set. However only backend elements have ownership.
ButtonBackend *backend;
// Set only for frontend Button items.
ButtonFrontend *frontend;
Area area;
// All elements have the backend pointer set. However only backend elements have ownership.
ButtonBackend *backend;
// Set only for frontend Button items.
ButtonFrontend *frontend;
} Button;
// Called before the config is read and panel_config/panels are created.
// Afterwards, the config parsing code creates the array of Button in panel_config and populates the configuration fields
// Afterwards, the config parsing code creates the array of Button in panel_config and populates the configuration
// fields
// in the backend.
// Probably does nothing.
void default_button();

538
src/clock/clock.c
View File

@@ -60,105 +60,105 @@ void clock_dump_geometry(void *obj, int indent);
void default_clock()
{
clock_enabled = 0;
clock_timeout = NULL;
time1_format = NULL;
time1_timezone = NULL;
time2_format = NULL;
time2_timezone = NULL;
time_tooltip_format = NULL;
time_tooltip_timezone = NULL;
clock_lclick_command = NULL;
clock_mclick_command = NULL;
clock_rclick_command = NULL;
clock_uwheel_command = NULL;
clock_dwheel_command = NULL;
time1_has_font = FALSE;
time1_font_desc = NULL;
time2_has_font = FALSE;
time2_font_desc = NULL;
clock_enabled = 0;
clock_timeout = NULL;
time1_format = NULL;
time1_timezone = NULL;
time2_format = NULL;
time2_timezone = NULL;
time_tooltip_format = NULL;
time_tooltip_timezone = NULL;
clock_lclick_command = NULL;
clock_mclick_command = NULL;
clock_rclick_command = NULL;
clock_uwheel_command = NULL;
clock_dwheel_command = NULL;
time1_has_font = FALSE;
time1_font_desc = NULL;
time2_has_font = FALSE;
time2_font_desc = NULL;
}
void cleanup_clock()
{
pango_font_description_free(time1_font_desc);
time1_font_desc = NULL;
pango_font_description_free(time2_font_desc);
time2_font_desc = NULL;
free(time1_format);
time1_format = NULL;
free(time2_format);
time2_format = NULL;
free(time_tooltip_format);
time_tooltip_format = NULL;
free(time1_timezone);
time1_timezone = NULL;
free(time2_timezone);
time2_timezone = NULL;
free(time_tooltip_timezone);
time_tooltip_timezone = NULL;
free(clock_lclick_command);
clock_lclick_command = NULL;
free(clock_mclick_command);
clock_mclick_command = NULL;
free(clock_rclick_command);
clock_rclick_command = NULL;
free(clock_uwheel_command);
clock_uwheel_command = NULL;
free(clock_dwheel_command);
clock_dwheel_command = NULL;
stop_timeout(clock_timeout);
clock_timeout = NULL;
pango_font_description_free(time1_font_desc);
time1_font_desc = NULL;
pango_font_description_free(time2_font_desc);
time2_font_desc = NULL;
free(time1_format);
time1_format = NULL;
free(time2_format);
time2_format = NULL;
free(time_tooltip_format);
time_tooltip_format = NULL;
free(time1_timezone);
time1_timezone = NULL;
free(time2_timezone);
time2_timezone = NULL;
free(time_tooltip_timezone);
time_tooltip_timezone = NULL;
free(clock_lclick_command);
clock_lclick_command = NULL;
free(clock_mclick_command);
clock_mclick_command = NULL;
free(clock_rclick_command);
clock_rclick_command = NULL;
free(clock_uwheel_command);
clock_uwheel_command = NULL;
free(clock_dwheel_command);
clock_dwheel_command = NULL;
stop_timeout(clock_timeout);
clock_timeout = NULL;
}
void update_clocks_sec(void *arg)
{
gettimeofday(&time_clock, 0);
if (time1_format) {
for (int i = 0; i < num_panels; i++)
panels[i].clock.area.resize_needed = 1;
}
schedule_panel_redraw();
gettimeofday(&time_clock, 0);
if (time1_format) {
for (int i = 0; i < num_panels; i++)
panels[i].clock.area.resize_needed = 1;
}
schedule_panel_redraw();
}
void update_clocks_min(void *arg)
{
// remember old_sec because after suspend/hibernate the clock should be updated directly, and not
// on next minute change
time_t old_sec = time_clock.tv_sec;
gettimeofday(&time_clock, 0);
if (time_clock.tv_sec % 60 == 0 || time_clock.tv_sec - old_sec > 60) {
if (time1_format) {
for (int i = 0; i < num_panels; i++)
panels[i].clock.area.resize_needed = 1;
}
schedule_panel_redraw();
}
// remember old_sec because after suspend/hibernate the clock should be updated directly, and not
// on next minute change
time_t old_sec = time_clock.tv_sec;
gettimeofday(&time_clock, 0);
if (time_clock.tv_sec % 60 == 0 || time_clock.tv_sec - old_sec > 60) {
if (time1_format) {
for (int i = 0; i < num_panels; i++)
panels[i].clock.area.resize_needed = 1;
}
schedule_panel_redraw();
}
}
struct tm *clock_gettime_for_tz(const char *timezone)
{
if (timezone) {
const char *old_tz = getenv("TZ");
setenv("TZ", timezone, 1);
struct tm *result = localtime(&time_clock.tv_sec);
if (old_tz)
setenv("TZ", old_tz, 1);
else
unsetenv("TZ");
return result;
} else {
return localtime(&time_clock.tv_sec);
}
if (timezone) {
const char *old_tz = getenv("TZ");
setenv("TZ", timezone, 1);
struct tm *result = localtime(&time_clock.tv_sec);
if (old_tz)
setenv("TZ", old_tz, 1);
else
unsetenv("TZ");
return result;
} else {
return localtime(&time_clock.tv_sec);
}
}
gboolean time_format_needs_sec_ticks(char *time_format)
{
if (!time_format)
return FALSE;
if (strchr(time_format, 'S') || strchr(time_format, 'T') || strchr(time_format, 'r'))
return TRUE;
return FALSE;
if (!time_format)
return FALSE;
if (strchr(time_format, 'S') || strchr(time_format, 'T') || strchr(time_format, 'r'))
return TRUE;
return FALSE;
}
void init_clock()
@@ -167,80 +167,80 @@ void init_clock()
void init_clock_panel(void *p)
{
Panel *panel = (Panel *)p;
Clock *clock = &panel->clock;
Panel *panel = (Panel *)p;
Clock *clock = &panel->clock;
if (!clock_timeout) {
if (time_format_needs_sec_ticks(time1_format) || time_format_needs_sec_ticks(time2_format)) {
clock_timeout = add_timeout(10, 1000, update_clocks_sec, 0, &clock_timeout);
} else {
clock_timeout = add_timeout(10, 1000, update_clocks_min, 0, &clock_timeout);
}
}
if (!clock_timeout) {
if (time_format_needs_sec_ticks(time1_format) || time_format_needs_sec_ticks(time2_format)) {
clock_timeout = add_timeout(10, 1000, update_clocks_sec, 0, &clock_timeout);
} else {
clock_timeout = add_timeout(10, 1000, update_clocks_min, 0, &clock_timeout);
}
}
if (!clock->area.bg)
clock->area.bg = &g_array_index(backgrounds, Background, 0);
clock_init_fonts();
clock->area.parent = p;
clock->area.panel = p;
snprintf(clock->area.name, sizeof(clock->area.name), "Clock");
clock->area._is_under_mouse = full_width_area_is_under_mouse;
clock->area.has_mouse_press_effect = clock->area.has_mouse_over_effect =
panel_config.mouse_effects && (clock_lclick_command || clock_mclick_command || clock_rclick_command ||
clock_uwheel_command || clock_dwheel_command);
clock->area._draw_foreground = draw_clock;
clock->area.size_mode = LAYOUT_FIXED;
clock->area._resize = resize_clock;
clock->area._compute_desired_size = clock_compute_desired_size;
clock->area._dump_geometry = clock_dump_geometry;
// check consistency
if (!time1_format)
return;
if (!clock->area.bg)
clock->area.bg = &g_array_index(backgrounds, Background, 0);
clock_init_fonts();
clock->area.parent = p;
clock->area.panel = p;
snprintf(clock->area.name, sizeof(clock->area.name), "Clock");
clock->area._is_under_mouse = full_width_area_is_under_mouse;
clock->area.has_mouse_press_effect = clock->area.has_mouse_over_effect =
panel_config.mouse_effects && (clock_lclick_command || clock_mclick_command || clock_rclick_command ||
clock_uwheel_command || clock_dwheel_command);
clock->area._draw_foreground = draw_clock;
clock->area.size_mode = LAYOUT_FIXED;
clock->area._resize = resize_clock;
clock->area._compute_desired_size = clock_compute_desired_size;
clock->area._dump_geometry = clock_dump_geometry;
// check consistency
if (!time1_format)
return;
clock->area.resize_needed = 1;
clock->area.on_screen = TRUE;
instantiate_area_gradients(&clock->area);
clock->area.resize_needed = 1;
clock->area.on_screen = TRUE;
instantiate_area_gradients(&clock->area);
if (time_tooltip_format) {
clock->area._get_tooltip_text = clock_get_tooltip;
strftime(buf_tooltip, sizeof(buf_tooltip), time_tooltip_format, clock_gettime_for_tz(time_tooltip_timezone));
}
if (time_tooltip_format) {
clock->area._get_tooltip_text = clock_get_tooltip;
strftime(buf_tooltip, sizeof(buf_tooltip), time_tooltip_format, clock_gettime_for_tz(time_tooltip_timezone));
}
}
void clock_init_fonts()
{
if (!time1_font_desc) {
time1_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_weight(time1_font_desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size(time1_font_desc, pango_font_description_get_size(time1_font_desc));
}
if (!time2_font_desc) {
time2_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_size(time2_font_desc,
pango_font_description_get_size(time2_font_desc) - PANGO_SCALE);
}
if (!time1_font_desc) {
time1_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_weight(time1_font_desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size(time1_font_desc, pango_font_description_get_size(time1_font_desc));
}
if (!time2_font_desc) {
time2_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_size(time2_font_desc,
pango_font_description_get_size(time2_font_desc) - PANGO_SCALE);
}
}
void clock_default_font_changed()
{
if (!clock_enabled)
return;
if (time1_has_font && time2_has_font)
return;
if (!time1_has_font) {
pango_font_description_free(time1_font_desc);
time1_font_desc = NULL;
}
if (!time2_has_font) {
pango_font_description_free(time2_font_desc);
time2_font_desc = NULL;
}
clock_init_fonts();
for (int i = 0; i < num_panels; i++) {
panels[i].clock.area.resize_needed = TRUE;
schedule_redraw(&panels[i].clock.area);
}
schedule_panel_redraw();
if (!clock_enabled)
return;
if (time1_has_font && time2_has_font)
return;
if (!time1_has_font) {
pango_font_description_free(time1_font_desc);
time1_font_desc = NULL;
}
if (!time2_has_font) {
pango_font_description_free(time2_font_desc);
time2_font_desc = NULL;
}
clock_init_fonts();
for (int i = 0; i < num_panels; i++) {
panels[i].clock.area.resize_needed = TRUE;
schedule_redraw(&panels[i].clock.area);
}
schedule_panel_redraw();
}
void clock_compute_text_geometry(Panel *panel,
@@ -251,167 +251,167 @@ void clock_compute_text_geometry(Panel *panel,
int *date_height,
int *date_width)
{
*date_height = *date_width = 0;
strftime(buf_time, sizeof(buf_time), time1_format, clock_gettime_for_tz(time1_timezone));
get_text_size2(time1_font_desc,
time_height_ink,
time_height,
time_width,
panel->area.height,
panel->area.width,
buf_time,
strlen(buf_time),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
if (time2_format) {
strftime(buf_date, sizeof(buf_date), time2_format, clock_gettime_for_tz(time2_timezone));
get_text_size2(time2_font_desc,
date_height_ink,
date_height,
date_width,
panel->area.height,
panel->area.width,
buf_date,
strlen(buf_date),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
}
*date_height = *date_width = 0;
strftime(buf_time, sizeof(buf_time), time1_format, clock_gettime_for_tz(time1_timezone));
get_text_size2(time1_font_desc,
time_height_ink,
time_height,
time_width,
panel->area.height,
panel->area.width,
buf_time,
strlen(buf_time),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
if (time2_format) {
strftime(buf_date, sizeof(buf_date), time2_format, clock_gettime_for_tz(time2_timezone));
get_text_size2(time2_font_desc,
date_height_ink,
date_height,
date_width,
panel->area.height,
panel->area.width,
buf_date,
strlen(buf_date),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
}
}
int clock_compute_desired_size(void *obj)
{
Clock *clock = (Clock *)obj;
Panel *panel = (Panel *)clock->area.panel;
int time_height_ink, time_height, time_width, date_height_ink, date_height, date_width;
clock_compute_text_geometry(panel,
&time_height_ink,
&time_height,
&time_width,
&date_height_ink,
&date_height,
&date_width);
Clock *clock = (Clock *)obj;
Panel *panel = (Panel *)clock->area.panel;
int time_height_ink, time_height, time_width, date_height_ink, date_height, date_width;
clock_compute_text_geometry(panel,
&time_height_ink,
&time_height,
&time_width,
&date_height_ink,
&date_height,
&date_width);
if (panel_horizontal) {
int new_size = (time_width > date_width) ? time_width : date_width;
new_size += 2 * clock->area.paddingxlr + left_right_border_width(&clock->area);
return new_size;
} else {
int new_size = time_height + date_height + 2 * clock->area.paddingxlr + top_bottom_border_width(&clock->area);
return new_size;
}
if (panel_horizontal) {
int new_size = (time_width > date_width) ? time_width : date_width;
new_size += 2 * clock->area.paddingxlr + left_right_border_width(&clock->area);
return new_size;
} else {
int new_size = time_height + date_height + 2 * clock->area.paddingxlr + top_bottom_border_width(&clock->area);
return new_size;
}
}
gboolean resize_clock(void *obj)
{
Clock *clock = (Clock *)obj;
Panel *panel = (Panel *)clock->area.panel;
gboolean result = FALSE;
Clock *clock = (Clock *)obj;
Panel *panel = (Panel *)clock->area.panel;
gboolean result = FALSE;
schedule_redraw(&clock->area);
schedule_redraw(&clock->area);
int time_height_ink, time_height, time_width, date_height_ink, date_height, date_width;
clock_compute_text_geometry(panel,
&time_height_ink,
&time_height,
&time_width,
&date_height_ink,
&date_height,
&date_width);
int time_height_ink, time_height, time_width, date_height_ink, date_height, date_width;
clock_compute_text_geometry(panel,
&time_height_ink,
&time_height,
&time_width,
&date_height_ink,
&date_height,
&date_width);
int new_size = clock_compute_desired_size(clock);
if (panel_horizontal) {
if (new_size > clock->area.width || new_size < (clock->area.width - 6)) {
// we try to limit the number of resizes
clock->area.width = new_size + 1;
clock->time1_posy = (clock->area.height - time_height) / 2;
if (time2_format) {
clock->time1_posy -= (date_height) / 2;
clock->time2_posy = clock->time1_posy + time_height;
}
result = TRUE;
}
} else {
if (new_size != clock->area.height) {
// we try to limit the number of resizes
clock->area.height = new_size;
clock->time1_posy = (clock->area.height - time_height) / 2;
if (time2_format) {
clock->time1_posy -= (date_height) / 2;
clock->time2_posy = clock->time1_posy + time_height;
}
result = TRUE;
}
}
int new_size = clock_compute_desired_size(clock);
if (panel_horizontal) {
if (new_size > clock->area.width || new_size < (clock->area.width - 6)) {
// we try to limit the number of resizes
clock->area.width = new_size + 1;
clock->time1_posy = (clock->area.height - time_height) / 2;
if (time2_format) {
clock->time1_posy -= (date_height) / 2;
clock->time2_posy = clock->time1_posy + time_height;
}
result = TRUE;
}
} else {
if (new_size != clock->area.height) {
// we try to limit the number of resizes
clock->area.height = new_size;
clock->time1_posy = (clock->area.height - time_height) / 2;
if (time2_format) {
clock->time1_posy -= (date_height) / 2;
clock->time2_posy = clock->time1_posy + time_height;
}
result = TRUE;
}
}
return result;
return result;
}
void draw_clock(void *obj, cairo_t *c)
{
Clock *clock = obj;
PangoLayout *layout = pango_cairo_create_layout(c);
Clock *clock = obj;
PangoLayout *layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, time1_font_desc);
pango_layout_set_width(layout, clock->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_time, strlen(buf_time));
pango_layout_set_font_description(layout, time1_font_desc);
pango_layout_set_width(layout, clock->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_time, strlen(buf_time));
cairo_set_source_rgba(c, clock->font.rgb[0], clock->font.rgb[1], clock->font.rgb[2], clock->font.alpha);
cairo_set_source_rgba(c, clock->font.rgb[0], clock->font.rgb[1], clock->font.rgb[2], clock->font.alpha);
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, clock->time1_posy, &clock->font, ((Panel *)clock->area.panel)->font_shadow);
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, clock->time1_posy, &clock->font, ((Panel *)clock->area.panel)->font_shadow);
if (time2_format) {
pango_layout_set_font_description(layout, time2_font_desc);
pango_layout_set_indent(layout, 0);
pango_layout_set_text(layout, buf_date, strlen(buf_date));
pango_layout_set_width(layout, clock->area.width * PANGO_SCALE);
if (time2_format) {
pango_layout_set_font_description(layout, time2_font_desc);
pango_layout_set_indent(layout, 0);
pango_layout_set_text(layout, buf_date, strlen(buf_date));
pango_layout_set_width(layout, clock->area.width * PANGO_SCALE);
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, clock->time2_posy, &clock->font, ((Panel *)clock->area.panel)->font_shadow);
}
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, clock->time2_posy, &clock->font, ((Panel *)clock->area.panel)->font_shadow);
}
g_object_unref(layout);
g_object_unref(layout);
}
void clock_dump_geometry(void *obj, int indent)
{
Clock *clock = (Clock *)obj;
fprintf(stderr, "%*sText 1: y = %d, text = %s\n", indent, "", clock->time1_posy, buf_time);
if (time2_format) {
fprintf(stderr, "%*sText 2: y = %d, text = %s\n", indent, "", clock->time2_posy, buf_date);
}
Clock *clock = (Clock *)obj;
fprintf(stderr, "%*sText 1: y = %d, text = %s\n", indent, "", clock->time1_posy, buf_time);
if (time2_format) {
fprintf(stderr, "%*sText 2: y = %d, text = %s\n", indent, "", clock->time2_posy, buf_date);
}
}
char *clock_get_tooltip(void *obj)
{
strftime(buf_tooltip, sizeof(buf_tooltip), time_tooltip_format, clock_gettime_for_tz(time_tooltip_timezone));
return strdup(buf_tooltip);
strftime(buf_tooltip, sizeof(buf_tooltip), time_tooltip_format, clock_gettime_for_tz(time_tooltip_timezone));
return strdup(buf_tooltip);
}
void clock_action(int button)
{
char *command = NULL;
switch (button) {
case 1:
command = clock_lclick_command;
break;
case 2:
command = clock_mclick_command;
break;
case 3:
command = clock_rclick_command;
break;
case 4:
command = clock_uwheel_command;
break;
case 5:
command = clock_dwheel_command;
break;
}
tint_exec(command);
char *command = NULL;
switch (button) {
case 1:
command = clock_lclick_command;
break;
case 2:
command = clock_mclick_command;
break;
case 3:
command = clock_rclick_command;
break;
case 4:
command = clock_uwheel_command;
break;
case 5:
command = clock_dwheel_command;
break;
}
tint_exec(command);
}

10
src/clock/clock.h
View File

@@ -14,12 +14,12 @@
#include "area.h"
typedef struct Clock {
// always start with area
Area area;
// always start with area
Area area;
Color font;
int time1_posy;
int time2_posy;
Color font;
int time1_posy;
int time2_posy;
} Clock;
extern char *time1_format;

2361
src/config.c
View File

File diff suppressed because it is too large Load Diff

1434
src/execplugin/execplugin.c
View File

File diff suppressed because it is too large Load Diff

122
src/execplugin/execplugin.h
View File

@@ -17,78 +17,78 @@
// backend's config and state variables.
typedef struct ExecpBackend {
// Config:
// Command to execute at a specified interval
char *command;
// Interval in seconds
int interval;
// 1 if first line of output is an icon path
gboolean has_icon;
gboolean cache_icon;
int icon_w;
int icon_h;
char *tooltip;
gboolean centered;
gboolean has_font;
PangoFontDescription *font_desc;
Color font_color;
int continuous;
gboolean has_markup;
char *lclick_command;
char *mclick_command;
char *rclick_command;
char *uwheel_command;
char *dwheel_command;
// paddingxlr = horizontal padding left/right
// paddingx = horizontal padding between childs
int paddingxlr, paddingx, paddingy;
Background *bg;
// Config:
// Command to execute at a specified interval
char *command;
// Interval in seconds
int interval;
// 1 if first line of output is an icon path
gboolean has_icon;
gboolean cache_icon;
int icon_w;
int icon_h;
char *tooltip;
gboolean centered;
gboolean has_font;
PangoFontDescription *font_desc;
Color font_color;
int continuous;
gboolean has_markup;
char *lclick_command;
char *mclick_command;
char *rclick_command;
char *uwheel_command;
char *dwheel_command;
// paddingxlr = horizontal padding left/right
// paddingx = horizontal padding between childs
int paddingxlr, paddingx, paddingy;
Background *bg;
// Backend state:
timeout *timer;
int child_pipe;
pid_t child;
// Backend state:
timeout *timer;
int child_pipe;
pid_t child;
// Command output buffer
char *buf_output;
int buf_length;
int buf_capacity;
// Command output buffer
char *buf_output;
int buf_length;
int buf_capacity;
// Text extracted from the output buffer
char *text;
// Icon path extracted from the output buffer
char *icon_path;
Imlib_Image icon;
char tooltip_text[512];
// Text extracted from the output buffer
char *text;
// Icon path extracted from the output buffer
char *icon_path;
Imlib_Image icon;
char tooltip_text[512];
// The time the last command was started
time_t last_update_start_time;
// The time the last output was obtained
time_t last_update_finish_time;
// The time it took to execute last command
time_t last_update_duration;
// The time the last command was started
time_t last_update_start_time;
// The time the last output was obtained
time_t last_update_finish_time;
// The time it took to execute last command
time_t last_update_duration;
// List of Execp which are frontends for this backend, one for each panel
GList *instances;
GTree *cmd_pids;
// List of Execp which are frontends for this backend, one for each panel
GList *instances;
GTree *cmd_pids;
} ExecpBackend;
typedef struct ExecpFrontend {
// Frontend state:
int iconx;
int icony;
int textx;
int texty;
int textw;
int texth;
// Frontend state:
int iconx;
int icony;
int textx;
int texty;
int textw;
int texth;
} ExecpFrontend;
typedef struct Execp {
Area area;
// All elements have the backend pointer set. However only backend elements have ownership.
ExecpBackend *backend;
// Set only for frontend Execp items.
ExecpFrontend *frontend;
Area area;
// All elements have the backend pointer set. However only backend elements have ownership.
ExecpBackend *backend;
// Set only for frontend Execp items.
ExecpFrontend *frontend;
} Execp;
// Called before the config is read and panel_config/panels are created.

128
src/freespace/freespace.c
View File

@@ -34,93 +34,93 @@ int freespace_area_compute_desired_size(void *obj);
void init_freespace_panel(void *p)
{
Panel *panel = (Panel *)p;
Panel *panel = (Panel *)p;
// Make sure this is only done once if there are multiple items
if (panel->freespace_list)
return;
// Make sure this is only done once if there are multiple items
if (panel->freespace_list)
return;
for (size_t k = 0; k < strlen(panel_items_order); k++) {
if (panel_items_order[k] == 'F') {
FreeSpace *freespace = (FreeSpace *) calloc(1, sizeof(FreeSpace));
panel->freespace_list = g_list_append(panel->freespace_list, freespace);
if (!freespace->area.bg)
freespace->area.bg = &g_array_index(backgrounds, Background, 0);
freespace->area.parent = p;
freespace->area.panel = p;
snprintf(freespace->area.name, sizeof(freespace->area.name), "Freespace");
freespace->area.size_mode = LAYOUT_FIXED;
freespace->area.resize_needed = 1;
freespace->area.on_screen = TRUE;
freespace->area._resize = resize_freespace;
freespace->area._compute_desired_size = freespace_area_compute_desired_size;
}
}
for (size_t k = 0; k < strlen(panel_items_order); k++) {
if (panel_items_order[k] == 'F') {
FreeSpace *freespace = (FreeSpace *)calloc(1, sizeof(FreeSpace));
panel->freespace_list = g_list_append(panel->freespace_list, freespace);
if (!freespace->area.bg)
freespace->area.bg = &g_array_index(backgrounds, Background, 0);
freespace->area.parent = p;
freespace->area.panel = p;
snprintf(freespace->area.name, sizeof(freespace->area.name), "Freespace");
freespace->area.size_mode = LAYOUT_FIXED;
freespace->area.resize_needed = 1;
freespace->area.on_screen = TRUE;
freespace->area._resize = resize_freespace;
freespace->area._compute_desired_size = freespace_area_compute_desired_size;
}
}
}
void cleanup_freespace(Panel *panel)
{
if (panel->freespace_list)
g_list_free_full(panel->freespace_list, free);
panel->freespace_list = NULL;
if (panel->freespace_list)
g_list_free_full(panel->freespace_list, free);
panel->freespace_list = NULL;
}
int freespace_get_max_size(Panel *p)
{
if (panel_shrink)
return 0;
// Get space used by every element except the freespace
int size = 0;
int spacers = 0;
for (GList *walk = p->area.children; walk; walk = g_list_next(walk)) {
Area *a = (Area *)walk->data;
if (panel_shrink)
return 0;
// Get space used by every element except the freespace
int size = 0;
int spacers = 0;
for (GList *walk = p->area.children; walk; walk = g_list_next(walk)) {
Area *a = (Area *)walk->data;
if (!a->on_screen)
continue;
if (a->_resize == resize_freespace) {
spacers++;
continue;
}
if (!a->on_screen)
continue;
if (a->_resize == resize_freespace) {
spacers++;
continue;
}
if (panel_horizontal)
size += a->width + p->area.paddingx;
else
size += a->height + p->area.paddingy;
}
if (panel_horizontal)
size += a->width + p->area.paddingx;
else
size += a->height + p->area.paddingy;
}
if (panel_horizontal)
size = p->area.width - size - left_right_border_width(&p->area) - p->area.paddingxlr;
else
size = p->area.height - size - top_bottom_border_width(&p->area) - p->area.paddingxlr;
if (panel_horizontal)
size = p->area.width - size - left_right_border_width(&p->area) - p->area.paddingxlr;
else
size = p->area.height - size - top_bottom_border_width(&p->area) - p->area.paddingxlr;
return size / spacers;
return size / spacers;
}
int freespace_area_compute_desired_size(void *obj)
{
FreeSpace *freespace = (FreeSpace *) obj;
return freespace_get_max_size((Panel *)freespace->area.panel);
FreeSpace *freespace = (FreeSpace *)obj;
return freespace_get_max_size((Panel *)freespace->area.panel);
}
gboolean resize_freespace(void *obj)
{
FreeSpace *freespace = (FreeSpace *)obj;
Panel *panel = (Panel *)freespace->area.panel;
if (!freespace->area.on_screen)
return FALSE;
FreeSpace *freespace = (FreeSpace *)obj;
Panel *panel = (Panel *)freespace->area.panel;
if (!freespace->area.on_screen)
return FALSE;
int old_size = panel_horizontal ? freespace->area.width : freespace->area.height;
int size = freespace_get_max_size(panel);
if (old_size == size)
return FALSE;
int old_size = panel_horizontal ? freespace->area.width : freespace->area.height;
int size = freespace_get_max_size(panel);
if (old_size == size)
return FALSE;
if (panel_horizontal) {
freespace->area.width = size;
} else {
freespace->area.height = size;
}
if (panel_horizontal) {
freespace->area.width = size;
} else {
freespace->area.height = size;
}
schedule_redraw(&freespace->area);
schedule_panel_redraw();
return TRUE;
schedule_redraw(&freespace->area);
schedule_panel_redraw();
return TRUE;
}

2
src/freespace/freespace.h
View File

@@ -9,7 +9,7 @@
#include "area.h"
typedef struct FreeSpace {
Area area;
Area area;
} FreeSpace;
struct Panel;

448
src/launcher/apps-common.c
View File

@@ -30,280 +30,280 @@
static gint compare_strings(gconstpointer a, gconstpointer b)
{
return strnatcasecmp((const char *)a, (const char *)b);
return strnatcasecmp((const char *)a, (const char *)b);
}
int parse_dektop_line(char *line, char **key, char **value)
{
char *p;
int found = 0;
*key = line;
for (p = line; *p; p++) {
if (*p == '=') {
*value = p + 1;
*p = 0;
found = 1;
break;
}
}
if (!found)
return 0;
if (found && (strlen(*key) == 0 || strlen(*value) == 0))
return 0;
return 1;
char *p;
int found = 0;
*key = line;
for (p = line; *p; p++) {
if (*p == '=') {
*value = p + 1;
*p = 0;
found = 1;
break;
}
}
if (!found)
return 0;
if (found && (strlen(*key) == 0 || strlen(*value) == 0))
return 0;
return 1;
}
void expand_exec(DesktopEntry *entry, const char *path)
{
// Expand % in exec
// %i -> --icon Icon
// %c -> Name
// %k -> path
if (entry->exec) {
char *exec2 = calloc(strlen(entry->exec) + (entry->name ? strlen(entry->name) : 1) +
(entry->icon ? strlen(entry->icon) : 1) + 100,
1);
char *p, *q;
// p will never point to an escaped char
for (p = entry->exec, q = exec2; *p; p++, q++) {
*q = *p; // Copy
if (*p == '\\') {
p++, q++;
// Copy the escaped char
if (*p == '%') // For % we delete the backslash, i.e. write % over it
q--;
*q = *p;
if (!*p)
break;
continue;
}
if (*p == '%') {
p++;
if (!*p)
break;
if (*p == 'i' && entry->icon != NULL) {
sprintf(q, "--icon '%s'", entry->icon);
q += strlen("--icon ''");
q += strlen(entry->icon);
q--; // To balance the q++ in the for
} else if (*p == 'c' && entry->name != NULL) {
sprintf(q, "'%s'", entry->name);
q += strlen("''");
q += strlen(entry->name);
q--; // To balance the q++ in the for
} else if (*p == 'c') {
sprintf(q, "'%s'", path);
q += strlen("''");
q += strlen(path);
q--; // To balance the q++ in the for
} else {
// We don't care about other expansions
q--; // Delete the last % from q
}
continue;
}
}
*q = '\0';
free(entry->exec);
entry->exec = exec2;
}
// Expand % in exec
// %i -> --icon Icon
// %c -> Name
// %k -> path
if (entry->exec) {
char *exec2 = calloc(strlen(entry->exec) + (entry->name ? strlen(entry->name) : 1) +
(entry->icon ? strlen(entry->icon) : 1) + 100,
1);
char *p, *q;
// p will never point to an escaped char
for (p = entry->exec, q = exec2; *p; p++, q++) {
*q = *p; // Copy
if (*p == '\\') {
p++, q++;
// Copy the escaped char
if (*p == '%') // For % we delete the backslash, i.e. write % over it
q--;
*q = *p;
if (!*p)
break;
continue;
}
if (*p == '%') {
p++;
if (!*p)
break;
if (*p == 'i' && entry->icon != NULL) {
sprintf(q, "--icon '%s'", entry->icon);
q += strlen("--icon ''");
q += strlen(entry->icon);
q--; // To balance the q++ in the for
} else if (*p == 'c' && entry->name != NULL) {
sprintf(q, "'%s'", entry->name);
q += strlen("''");
q += strlen(entry->name);
q--; // To balance the q++ in the for
} else if (*p == 'c') {
sprintf(q, "'%s'", path);
q += strlen("''");
q += strlen(path);
q--; // To balance the q++ in the for
} else {
// We don't care about other expansions
q--; // Delete the last % from q
}
continue;
}
}
*q = '\0';
free(entry->exec);
entry->exec = exec2;
}
}
gboolean read_desktop_file_full_path(const char *path, DesktopEntry *entry)
{
entry->name = entry->generic_name = entry->icon = entry->exec = entry->cwd = NULL;
entry->hidden_from_menus = FALSE;
entry->name = entry->generic_name = entry->icon = entry->exec = entry->cwd = NULL;
entry->hidden_from_menus = FALSE;
FILE *fp = fopen(path, "rt");
if (fp == NULL) {
fprintf(stderr, "Could not open file %s\n", path);
return FALSE;
}
FILE *fp = fopen(path, "rt");
if (fp == NULL) {
fprintf(stderr, "Could not open file %s\n", path);
return FALSE;
}
const gchar **languages = (const gchar **)g_get_language_names();
// lang_index is the index of the language for the best Name key in the language vector
// lang_index_default is a constant that encodes the Name key without a language
int lang_index_default = 1;
const gchar **languages = (const gchar **)g_get_language_names();
// lang_index is the index of the language for the best Name key in the language vector
// lang_index_default is a constant that encodes the Name key without a language
int lang_index_default = 1;
#define LANG_DBG 0
if (LANG_DBG)
printf("Languages:");
for (int i = 0; languages[i]; i++) {
lang_index_default = i + 1;
if (LANG_DBG)
printf(" %s", languages[i]);
}
if (LANG_DBG)
printf("\n");
// we currently do not know about any Name key at all, so use an invalid index
int lang_index_name = lang_index_default + 1;
int lang_index_generic_name = lang_index_default + 1;
if (LANG_DBG)
printf("Languages:");
for (int i = 0; languages[i]; i++) {
lang_index_default = i + 1;
if (LANG_DBG)
printf(" %s", languages[i]);
}
if (LANG_DBG)
printf("\n");
// we currently do not know about any Name key at all, so use an invalid index
int lang_index_name = lang_index_default + 1;
int lang_index_generic_name = lang_index_default + 1;
gboolean inside_desktop_entry = 0;
char *line = NULL;
size_t line_size;
while (getline(&line, &line_size, fp) >= 0) {
int len = strlen(line);
if (len == 0)
continue;
if (line[len - 1] == '\n')
line[len - 1] = '\0';
if (line[0] == '[') {
inside_desktop_entry = (strcmp(line, "[Desktop Entry]") == 0);
}
char *key, *value;
if (inside_desktop_entry && parse_dektop_line(line, &key, &value)) {
if (strstr(key, "Name") == key) {
if (strcmp(key, "Name") == 0 && lang_index_name > lang_index_default) {
entry->name = strdup(value);
lang_index_name = lang_index_default;
} else {
for (int i = 0; languages[i] && i < lang_index_name; i++) {
gchar *localized_key = g_strdup_printf("Name[%s]", languages[i]);
if (strcmp(key, localized_key) == 0) {
if (entry->name)
free(entry->name);
entry->name = strdup(value);
lang_index_name = i;
}
g_free(localized_key);
}
}
} else if (strstr(key, "GenericName") == key) {
if (strcmp(key, "GenericName") == 0 && lang_index_generic_name > lang_index_default) {
entry->generic_name = strdup(value);
lang_index_generic_name = lang_index_default;
} else {
for (int i = 0; languages[i] && i < lang_index_generic_name; i++) {
gchar *localized_key = g_strdup_printf("GenericName[%s]", languages[i]);
if (strcmp(key, localized_key) == 0) {
if (entry->generic_name)
free(entry->generic_name);
entry->generic_name = strdup(value);
lang_index_generic_name = i;
}
g_free(localized_key);
}
}
} else if (!entry->exec && strcmp(key, "Exec") == 0) {
entry->exec = strdup(value);
} else if (!entry->cwd && strcmp(key, "Path") == 0) {
entry->cwd = strdup(value);
} else if (!entry->icon && strcmp(key, "Icon") == 0) {
entry->icon = strdup(value);
} else if (strcmp(key, "NoDisplay") == 0) {
entry->hidden_from_menus = strcasecmp(value, "true") == 0;
}
}
}
fclose(fp);
// From this point:
// entry->name, entry->generic_name, entry->icon, entry->exec will never be empty strings (can be NULL though)
gboolean inside_desktop_entry = 0;
char *line = NULL;
size_t line_size;
while (getline(&line, &line_size, fp) >= 0) {
int len = strlen(line);
if (len == 0)
continue;
if (line[len - 1] == '\n')
line[len - 1] = '\0';
if (line[0] == '[') {
inside_desktop_entry = (strcmp(line, "[Desktop Entry]") == 0);
}
char *key, *value;
if (inside_desktop_entry && parse_dektop_line(line, &key, &value)) {
if (strstr(key, "Name") == key) {
if (strcmp(key, "Name") == 0 && lang_index_name > lang_index_default) {
entry->name = strdup(value);
lang_index_name = lang_index_default;
} else {
for (int i = 0; languages[i] && i < lang_index_name; i++) {
gchar *localized_key = g_strdup_printf("Name[%s]", languages[i]);
if (strcmp(key, localized_key) == 0) {
if (entry->name)
free(entry->name);
entry->name = strdup(value);
lang_index_name = i;
}
g_free(localized_key);
}
}
} else if (strstr(key, "GenericName") == key) {
if (strcmp(key, "GenericName") == 0 && lang_index_generic_name > lang_index_default) {
entry->generic_name = strdup(value);
lang_index_generic_name = lang_index_default;
} else {
for (int i = 0; languages[i] && i < lang_index_generic_name; i++) {
gchar *localized_key = g_strdup_printf("GenericName[%s]", languages[i]);
if (strcmp(key, localized_key) == 0) {
if (entry->generic_name)
free(entry->generic_name);
entry->generic_name = strdup(value);
lang_index_generic_name = i;
}
g_free(localized_key);
}
}
} else if (!entry->exec && strcmp(key, "Exec") == 0) {
entry->exec = strdup(value);
} else if (!entry->cwd && strcmp(key, "Path") == 0) {
entry->cwd = strdup(value);
} else if (!entry->icon && strcmp(key, "Icon") == 0) {
entry->icon = strdup(value);
} else if (strcmp(key, "NoDisplay") == 0) {
entry->hidden_from_menus = strcasecmp(value, "true") == 0;
}
}
}
fclose(fp);
// From this point:
// entry->name, entry->generic_name, entry->icon, entry->exec will never be empty strings (can be NULL though)
expand_exec(entry, entry->path);
expand_exec(entry, entry->path);
free(line);
return entry->exec != NULL;
free(line);
return entry->exec != NULL;
}
gboolean read_desktop_file_from_dir(const char *path, const char *file_name, DesktopEntry *entry)
{
gchar *full_path = g_build_filename(path, file_name, NULL);
if (read_desktop_file_full_path(full_path, entry)) {
g_free(full_path);
return TRUE;
}
free_and_null(entry->name);
free_and_null(entry->generic_name);
free_and_null(entry->icon);
free_and_null(entry->exec);
free_and_null(entry->cwd);
gchar *full_path = g_build_filename(path, file_name, NULL);
if (read_desktop_file_full_path(full_path, entry)) {
g_free(full_path);
return TRUE;
}
free_and_null(entry->name);
free_and_null(entry->generic_name);
free_and_null(entry->icon);
free_and_null(entry->exec);
free_and_null(entry->cwd);
GList *subdirs = NULL;
GList *subdirs = NULL;
GDir *d = g_dir_open(path, 0, NULL);
if (d) {
const gchar *name;
while ((name = g_dir_read_name(d))) {
gchar *child = g_build_filename(path, name, NULL);
if (g_file_test(child, G_FILE_TEST_IS_DIR)) {
subdirs = g_list_append(subdirs, child);
} else {
g_free(child);
}
}
g_dir_close(d);
}
GDir *d = g_dir_open(path, 0, NULL);
if (d) {
const gchar *name;
while ((name = g_dir_read_name(d))) {
gchar *child = g_build_filename(path, name, NULL);
if (g_file_test(child, G_FILE_TEST_IS_DIR)) {
subdirs = g_list_append(subdirs, child);
} else {
g_free(child);
}
}
g_dir_close(d);
}
subdirs = g_list_sort(subdirs, compare_strings);
gboolean found = FALSE;
for (GList *l = subdirs; l; l = g_list_next(l)) {
if (read_desktop_file_from_dir(l->data, file_name, entry)) {
found = TRUE;
break;
}
}
subdirs = g_list_sort(subdirs, compare_strings);
gboolean found = FALSE;
for (GList *l = subdirs; l; l = g_list_next(l)) {
if (read_desktop_file_from_dir(l->data, file_name, entry)) {
found = TRUE;
break;
}
}
for (GList *l = subdirs; l; l = g_list_next(l)) {
g_free(l->data);
}
g_list_free(subdirs);
g_free(full_path);
for (GList *l = subdirs; l; l = g_list_next(l)) {
g_free(l->data);
}
g_list_free(subdirs);
g_free(full_path);
return found;
return found;
}
gboolean read_desktop_file(const char *path, DesktopEntry *entry)
{
entry->path = strdup(path);
entry->name = entry->generic_name = entry->icon = entry->exec = entry->cwd = NULL;
entry->path = strdup(path);
entry->name = entry->generic_name = entry->icon = entry->exec = entry->cwd = NULL;
if (strchr(path, '/'))
return read_desktop_file_full_path(path, entry);
for (const GSList *location = get_apps_locations(); location; location = g_slist_next(location)) {
if (read_desktop_file_from_dir(location->data, path, entry))
return TRUE;
}
return FALSE;
if (strchr(path, '/'))
return read_desktop_file_full_path(path, entry);
for (const GSList *location = get_apps_locations(); location; location = g_slist_next(location)) {
if (read_desktop_file_from_dir(location->data, path, entry))
return TRUE;
}
return FALSE;
}
void free_desktop_entry(DesktopEntry *entry)
{
free_and_null(entry->name);
free_and_null(entry->generic_name);
free_and_null(entry->icon);
free_and_null(entry->exec);
free_and_null(entry->path);
free_and_null(entry->cwd);
free_and_null(entry->name);
free_and_null(entry->generic_name);
free_and_null(entry->icon);
free_and_null(entry->exec);
free_and_null(entry->path);
free_and_null(entry->cwd);
}
void test_read_desktop_file()
{
fprintf(stdout, "\033[1;33m");
DesktopEntry entry;
read_desktop_file("/usr/share/applications/firefox.desktop", &entry);
printf("Name:%s GenericName:%s Icon:%s Exec:%s\n", entry.name, entry.generic_name, entry.icon, entry.exec);
fprintf(stdout, "\033[0m");
fprintf(stdout, "\033[1;33m");
DesktopEntry entry;
read_desktop_file("/usr/share/applications/firefox.desktop", &entry);
printf("Name:%s GenericName:%s Icon:%s Exec:%s\n", entry.name, entry.generic_name, entry.icon, entry.exec);
fprintf(stdout, "\033[0m");
}
GSList *apps_locations = NULL;
// Do not free the result.
const GSList *get_apps_locations()
{
if (apps_locations)
return apps_locations;
if (apps_locations)
return apps_locations;
apps_locations = load_locations_from_env(apps_locations, "XDG_DATA_HOME", "applications", NULL);
apps_locations = load_locations_from_env(apps_locations, "XDG_DATA_HOME", "applications", NULL);
apps_locations =
g_slist_append(apps_locations, g_build_filename(g_get_home_dir(), ".local/share/applications", NULL));
apps_locations =
g_slist_append(apps_locations, g_build_filename(g_get_home_dir(), ".local/share/applications", NULL));
apps_locations = load_locations_from_env(apps_locations, "XDG_DATA_DIRS", "applications", NULL);
apps_locations = load_locations_from_env(apps_locations, "XDG_DATA_DIRS", "applications", NULL);
apps_locations = g_slist_append(apps_locations, g_strdup("/usr/local/share/applications"));
apps_locations = g_slist_append(apps_locations, g_strdup("/usr/share/applications"));
apps_locations = g_slist_append(apps_locations, g_strdup("/opt/share/applications"));
apps_locations = g_slist_append(apps_locations, g_strdup("/usr/local/share/applications"));
apps_locations = g_slist_append(apps_locations, g_strdup("/usr/share/applications"));
apps_locations = g_slist_append(apps_locations, g_strdup("/opt/share/applications"));
apps_locations = slist_remove_duplicates(apps_locations, g_str_equal, g_free);
apps_locations = slist_remove_duplicates(apps_locations, g_str_equal, g_free);
return apps_locations;
return apps_locations;
}

14
src/launcher/apps-common.h
View File

@@ -10,13 +10,13 @@
#include <glib.h>
typedef struct DesktopEntry {
char *name;
char *generic_name;
char *exec;
char *icon;
char *path;
char *cwd;
gboolean hidden_from_menus;
char *name;
char *generic_name;
char *exec;
char *icon;
char *path;
char *cwd;
gboolean hidden_from_menus;
} DesktopEntry;
// Parses a line of the form "key = value". Modifies the line.

1152
src/launcher/icon-theme-common.c
View File

File diff suppressed because it is too large Load Diff

36
src/launcher/icon-theme-common.h
View File

@@ -10,27 +10,27 @@
#include "cache.h"
typedef struct IconThemeWrapper {
// The icon theme name for which this wrapper was created
char *icon_theme_name;
// List of IconTheme*
GSList *themes;
// Themes are loaded lazily when needed.
gboolean _themes_loaded;
// List of IconTheme*
GSList *themes_fallback;
// Fallback themes are loaded lazily when needed.
gboolean _fallback_loaded;
Cache _cache;
// List of icon theme names that have been queued for loading.
// Used to avoid loading the same theme twice, and to avoid cycles.
GSList *_queued;
// The icon theme name for which this wrapper was created
char *icon_theme_name;
// List of IconTheme*
GSList *themes;
// Themes are loaded lazily when needed.
gboolean _themes_loaded;
// List of IconTheme*
GSList *themes_fallback;
// Fallback themes are loaded lazily when needed.
gboolean _fallback_loaded;
Cache _cache;
// List of icon theme names that have been queued for loading.
// Used to avoid loading the same theme twice, and to avoid cycles.
GSList *_queued;
} IconThemeWrapper;
typedef struct IconTheme {
char *name;
char *description;
GSList *list_inherits; // each item is a char* (theme name)
GSList *list_directories; // each item is an IconThemeDir*
char *name;
char *description;
GSList *list_inherits; // each item is a char* (theme name)
GSList *list_directories; // each item is an IconThemeDir*
} IconTheme;
// Parses a line of the form "key = value". Modifies the line.

836
src/launcher/launcher.c
View File

@@ -67,18 +67,18 @@ int launcher_compute_desired_size(void *obj);
void default_launcher()
{
launcher_enabled = 0;
launcher_max_icon_size = 0;
launcher_tooltip_enabled = 0;
launcher_alpha = 100;
launcher_saturation = 0;
launcher_brightness = 0;
icon_theme_name_config = NULL;
icon_theme_name_xsettings = NULL;
launcher_icon_theme_override = 0;
startup_notifications = 0;
launcher_icon_bg = NULL;
launcher_icon_gradients = NULL;
launcher_enabled = 0;
launcher_max_icon_size = 0;
launcher_tooltip_enabled = 0;
launcher_alpha = 100;
launcher_saturation = 0;
launcher_brightness = 0;
icon_theme_name_config = NULL;
icon_theme_name_xsettings = NULL;
launcher_icon_theme_override = 0;
startup_notifications = 0;
launcher_icon_bg = NULL;
launcher_icon_gradients = NULL;
}
void init_launcher()
@@ -87,97 +87,97 @@ void init_launcher()
void init_launcher_panel(void *p)
{
Panel *panel = (Panel *)p;
Launcher *launcher = &panel->launcher;
Panel *panel = (Panel *)p;
Launcher *launcher = &panel->launcher;
launcher->area.parent = p;
launcher->area.panel = p;
snprintf(launcher->area.name, sizeof(launcher->area.name), "Launcher");
launcher->area._draw_foreground = NULL;
launcher->area.size_mode = LAYOUT_FIXED;
launcher->area._resize = resize_launcher;
launcher->area._compute_desired_size = launcher_compute_desired_size;
launcher->area.resize_needed = 1;
schedule_redraw(&launcher->area);
if (!launcher->area.bg)
launcher->area.bg = &g_array_index(backgrounds, Background, 0);
launcher->area.parent = p;
launcher->area.panel = p;
snprintf(launcher->area.name, sizeof(launcher->area.name), "Launcher");
launcher->area._draw_foreground = NULL;
launcher->area.size_mode = LAYOUT_FIXED;
launcher->area._resize = resize_launcher;
launcher->area._compute_desired_size = launcher_compute_desired_size;
launcher->area.resize_needed = 1;
schedule_redraw(&launcher->area);
if (!launcher->area.bg)
launcher->area.bg = &g_array_index(backgrounds, Background, 0);
if (!launcher_icon_bg)
launcher_icon_bg = &g_array_index(backgrounds, Background, 0);
if (!launcher_icon_bg)
launcher_icon_bg = &g_array_index(backgrounds, Background, 0);
// check consistency
if (launcher->list_apps == NULL)
return;
// check consistency
if (launcher->list_apps == NULL)
return;
// This will be recomputed on resize, we just initialize to a non-zero value
launcher->icon_size = launcher_max_icon_size > 0 ? launcher_max_icon_size : 24;
// This will be recomputed on resize, we just initialize to a non-zero value
launcher->icon_size = launcher_max_icon_size > 0 ? launcher_max_icon_size : 24;
launcher->area.on_screen = TRUE;
schedule_panel_redraw();
instantiate_area_gradients(&launcher->area);
launcher->area.on_screen = TRUE;
schedule_panel_redraw();
instantiate_area_gradients(&launcher->area);
load_icon_themes();
launcher_load_icons(launcher);
load_icon_themes();
launcher_load_icons(launcher);
}
void free_icon_themes()
{
free_themes(icon_theme_wrapper);
icon_theme_wrapper = NULL;
free_themes(icon_theme_wrapper);
icon_theme_wrapper = NULL;
}
void cleanup_launcher()
{
for (int i = 0; i < num_panels; i++) {
Panel *panel = &panels[i];
Launcher *launcher = &panel->launcher;
cleanup_launcher_theme(launcher);
}
for (int i = 0; i < num_panels; i++) {
Panel *panel = &panels[i];
Launcher *launcher = &panel->launcher;
cleanup_launcher_theme(launcher);
}
for (GSList *l = panel_config.launcher.list_apps; l; l = l->next) {
free(l->data);
}
g_slist_free(panel_config.launcher.list_apps);
panel_config.launcher.list_apps = NULL;
for (GSList *l = panel_config.launcher.list_apps; l; l = l->next) {
free(l->data);
}
g_slist_free(panel_config.launcher.list_apps);
panel_config.launcher.list_apps = NULL;
free(icon_theme_name_config);
icon_theme_name_config = NULL;
free(icon_theme_name_config);
icon_theme_name_config = NULL;
free(icon_theme_name_xsettings);
icon_theme_name_xsettings = NULL;
free(icon_theme_name_xsettings);
icon_theme_name_xsettings = NULL;
launcher_enabled = FALSE;
launcher_enabled = FALSE;
}
void cleanup_launcher_theme(Launcher *launcher)
{
free_area(&launcher->area);
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (launcherIcon) {
free_icon(launcherIcon->image);
free_icon(launcherIcon->image_hover);
free_icon(launcherIcon->image_pressed);
free(launcherIcon->icon_name);
free(launcherIcon->icon_path);
free(launcherIcon->cmd);
g_free(launcherIcon->icon_tooltip);
free(launcherIcon->config_path);
}
free(launcherIcon);
}
g_slist_free(launcher->list_icons);
launcher->list_icons = NULL;
free_area(&launcher->area);
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (launcherIcon) {
free_icon(launcherIcon->image);
free_icon(launcherIcon->image_hover);
free_icon(launcherIcon->image_pressed);
free(launcherIcon->icon_name);
free(launcherIcon->icon_path);
free(launcherIcon->cmd);
g_free(launcherIcon->icon_tooltip);
free(launcherIcon->config_path);
}
free(launcherIcon);
}
g_slist_free(launcher->list_icons);
launcher->list_icons = NULL;
}
int launcher_compute_icon_size(Launcher *launcher)
{
int icon_size = panel_horizontal ? launcher->area.height : launcher->area.width;
icon_size = icon_size - MAX(left_right_border_width(&launcher->area), top_bottom_border_width(&launcher->area)) -
(2 * launcher->area.paddingy);
if (launcher_max_icon_size > 0 && icon_size > launcher_max_icon_size)
icon_size = launcher_max_icon_size;
return icon_size;
int icon_size = panel_horizontal ? launcher->area.height : launcher->area.width;
icon_size = icon_size - MAX(left_right_border_width(&launcher->area), top_bottom_border_width(&launcher->area)) -
(2 * launcher->area.paddingy);
if (launcher_max_icon_size > 0 && icon_size > launcher_max_icon_size)
icon_size = launcher_max_icon_size;
return icon_size;
}
void launcher_compute_geometry(Launcher *launcher,
@@ -187,438 +187,436 @@ void launcher_compute_geometry(Launcher *launcher,
int *icons_per_row,
int *margin)
{
int count = 0;
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (launcherIcon->area.on_screen)
count++;
}
int count = 0;
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (launcherIcon->area.on_screen)
count++;
}
*icon_size = launcher_compute_icon_size(launcher);
*icons_per_column = 1;
*icons_per_row = 1;
*margin = 0;
if (panel_horizontal) {
if (!count) {
*size = 0;
} else {
int height = launcher->area.height - top_bottom_border_width(&launcher->area) - 2 * launcher->area.paddingy;
// here icons_per_column always higher than 0
*icons_per_column = (height + launcher->area.paddingx) / (*icon_size + launcher->area.paddingx);
*margin = height - (*icons_per_column - 1) * (*icon_size + launcher->area.paddingx) - *icon_size;
*icons_per_row = count / *icons_per_column + (count % *icons_per_column != 0);
*size = left_right_border_width(&launcher->area) + 2 * launcher->area.paddingxlr +
(*icon_size * *icons_per_row) + ((*icons_per_row - 1) * launcher->area.paddingx);
}
} else {
if (!count) {
*size = 0;
} else {
int width = launcher->area.width - top_bottom_border_width(&launcher->area) - 2 * launcher->area.paddingy;
// here icons_per_row always higher than 0
*icons_per_row = (width + launcher->area.paddingx) / (*icon_size + launcher->area.paddingx);
*margin = width - (*icons_per_row - 1) * (*icon_size + launcher->area.paddingx) - *icon_size;
*icons_per_column = count / *icons_per_row + (count % *icons_per_row != 0);
*size = top_bottom_border_width(&launcher->area) + 2 * launcher->area.paddingxlr +
(*icon_size * *icons_per_column) + ((*icons_per_column - 1) * launcher->area.paddingx);
}
}
*icon_size = launcher_compute_icon_size(launcher);
*icons_per_column = 1;
*icons_per_row = 1;
*margin = 0;
if (panel_horizontal) {
if (!count) {
*size = 0;
} else {
int height = launcher->area.height - top_bottom_border_width(&launcher->area) - 2 * launcher->area.paddingy;
// here icons_per_column always higher than 0
*icons_per_column = (height + launcher->area.paddingx) / (*icon_size + launcher->area.paddingx);
*margin = height - (*icons_per_column - 1) * (*icon_size + launcher->area.paddingx) - *icon_size;
*icons_per_row = count / *icons_per_column + (count % *icons_per_column != 0);
*size = left_right_border_width(&launcher->area) + 2 * launcher->area.paddingxlr +
(*icon_size * *icons_per_row) + ((*icons_per_row - 1) * launcher->area.paddingx);
}
} else {
if (!count) {
*size = 0;
} else {
int width = launcher->area.width - top_bottom_border_width(&launcher->area) - 2 * launcher->area.paddingy;
// here icons_per_row always higher than 0
*icons_per_row = (width + launcher->area.paddingx) / (*icon_size + launcher->area.paddingx);
*margin = width - (*icons_per_row - 1) * (*icon_size + launcher->area.paddingx) - *icon_size;
*icons_per_column = count / *icons_per_row + (count % *icons_per_row != 0);
*size = top_bottom_border_width(&launcher->area) + 2 * launcher->area.paddingxlr +
(*icon_size * *icons_per_column) + ((*icons_per_column - 1) * launcher->area.paddingx);
}
}
}
int launcher_compute_desired_size(void *obj)
{
Launcher *launcher = (Launcher *)obj;
Launcher *launcher = (Launcher *)obj;
int size, icon_size, icons_per_column, icons_per_row, margin;
launcher_compute_geometry(launcher, &size, &icon_size, &icons_per_column, &icons_per_row, &margin);
return size;
int size, icon_size, icons_per_column, icons_per_row, margin;
launcher_compute_geometry(launcher, &size, &icon_size, &icons_per_column, &icons_per_row, &margin);
return size;
}
gboolean resize_launcher(void *obj)
{
Launcher *launcher = (Launcher *)obj;
Launcher *launcher = (Launcher *)obj;
int size, icons_per_column, icons_per_row, margin;
launcher_compute_geometry(launcher, &size, &launcher->icon_size, &icons_per_column, &icons_per_row, &margin);
int size, icons_per_column, icons_per_row, margin;
launcher_compute_geometry(launcher, &size, &launcher->icon_size, &icons_per_column, &icons_per_row, &margin);
// Resize icons if necessary
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (launcherIcon->icon_size != launcher->icon_size || !launcherIcon->image) {
launcherIcon->icon_size = launcher->icon_size;
launcherIcon->area.width = launcherIcon->icon_size;
launcherIcon->area.height = launcherIcon->icon_size;
launcher_reload_icon_image(launcher, launcherIcon);
}
}
save_icon_cache(icon_theme_wrapper);
// Resize icons if necessary
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (launcherIcon->icon_size != launcher->icon_size || !launcherIcon->image) {
launcherIcon->icon_size = launcher->icon_size;
launcherIcon->area.width = launcherIcon->icon_size;
launcherIcon->area.height = launcherIcon->icon_size;
launcher_reload_icon_image(launcher, launcherIcon);
}
}
save_icon_cache(icon_theme_wrapper);
int count = 0;
gboolean needs_repositioning = FALSE;
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (launcherIcon->area.on_screen) {
count++;
if (launcherIcon->area.posx < 0 || launcherIcon->area.posy < 0)
needs_repositioning = TRUE;
}
}
int count = 0;
gboolean needs_repositioning = FALSE;
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (launcherIcon->area.on_screen) {
count++;
if (launcherIcon->area.posx < 0 || launcherIcon->area.posy < 0)
needs_repositioning = TRUE;
}
}
if (!needs_repositioning) {
if (panel_horizontal) {
if (launcher->area.width == size)
return FALSE;
launcher->area.width = size;
} else {
if (launcher->area.height == size)
return FALSE;
launcher->area.height = size;
}
}
if (!needs_repositioning) {
if (panel_horizontal) {
if (launcher->area.width == size)
return FALSE;
launcher->area.width = size;
} else {
if (launcher->area.height == size)
return FALSE;
launcher->area.height = size;
}
}
int posx, posy;
int start;
if (panel_horizontal) {
posy = start = top_border_width(&launcher->area) + launcher->area.paddingy + margin / 2;
posx = left_border_width(&launcher->area) + launcher->area.paddingxlr;
} else {
posx = start = left_border_width(&launcher->area) + launcher->area.paddingy + margin / 2;
posy = top_border_width(&launcher->area) + launcher->area.paddingxlr;
}
int posx, posy;
int start;
if (panel_horizontal) {
posy = start = top_border_width(&launcher->area) + launcher->area.paddingy + margin / 2;
posx = left_border_width(&launcher->area) + launcher->area.paddingxlr;
} else {
posx = start = left_border_width(&launcher->area) + launcher->area.paddingy + margin / 2;
posy = top_border_width(&launcher->area) + launcher->area.paddingxlr;
}
int i = 0;
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (!launcherIcon->area.on_screen)
continue;
i++;
launcherIcon->y = posy;
launcherIcon->x = posx;
launcher_icon_on_change_layout(launcherIcon);
// printf("launcher %d : %d,%d\n", i, posx, posy);
if (panel_horizontal) {
if (i % icons_per_column) {
posy += launcher->icon_size + launcher->area.paddingx;
} else {
posy = start;
posx += (launcher->icon_size + launcher->area.paddingx);
}
} else {
if (i % icons_per_row) {
posx += launcher->icon_size + launcher->area.paddingx;
} else {
posx = start;
posy += (launcher->icon_size + launcher->area.paddingx);
}
}
}
int i = 0;
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (!launcherIcon->area.on_screen)
continue;
i++;
launcherIcon->y = posy;
launcherIcon->x = posx;
launcher_icon_on_change_layout(launcherIcon);
// printf("launcher %d : %d,%d\n", i, posx, posy);
if (panel_horizontal) {
if (i % icons_per_column) {
posy += launcher->icon_size + launcher->area.paddingx;
} else {
posy = start;
posx += (launcher->icon_size + launcher->area.paddingx);
}
} else {
if (i % icons_per_row) {
posx += launcher->icon_size + launcher->area.paddingx;
} else {
posx = start;
posy += (launcher->icon_size + launcher->area.paddingx);
}
}
}
if ((panel_horizontal && icons_per_column == 1) || (!panel_horizontal && icons_per_row == 1)) {
launcher->area._is_under_mouse = full_width_area_is_under_mouse;
for (GSList *l = launcher->list_icons; l; l = l->next)
((LauncherIcon *)l->data)->area._is_under_mouse = full_width_area_is_under_mouse;
} else {
launcher->area._is_under_mouse = NULL;
for (GSList *l = launcher->list_icons; l; l = l->next)
((LauncherIcon *)l->data)->area._is_under_mouse = NULL;
}
if ((panel_horizontal && icons_per_column == 1) || (!panel_horizontal && icons_per_row == 1)) {
launcher->area._is_under_mouse = full_width_area_is_under_mouse;
for (GSList *l = launcher->list_icons; l; l = l->next)
((LauncherIcon *)l->data)->area._is_under_mouse = full_width_area_is_under_mouse;
} else {
launcher->area._is_under_mouse = NULL;
for (GSList *l = launcher->list_icons; l; l = l->next)
((LauncherIcon *)l->data)->area._is_under_mouse = NULL;
}
return TRUE;
return TRUE;
}
// Here we override the default layout of the icons; normally Area layouts its children
// in a stack; we need to layout them in a kind of table
void launcher_icon_on_change_layout(void *obj)
{
LauncherIcon *launcherIcon = (LauncherIcon *)obj;
launcherIcon->area.posy = ((Area *)launcherIcon->area.parent)->posy + launcherIcon->y;
launcherIcon->area.posx = ((Area *)launcherIcon->area.parent)->posx + launcherIcon->x;
launcherIcon->area.width = launcherIcon->icon_size;
launcherIcon->area.height = launcherIcon->icon_size;
LauncherIcon *launcherIcon = (LauncherIcon *)obj;
launcherIcon->area.posy = ((Area *)launcherIcon->area.parent)->posy + launcherIcon->y;
launcherIcon->area.posx = ((Area *)launcherIcon->area.parent)->posx + launcherIcon->x;
launcherIcon->area.width = launcherIcon->icon_size;
launcherIcon->area.height = launcherIcon->icon_size;
}
int launcher_icon_compute_desired_size(void *obj)
{
LauncherIcon *icon = (LauncherIcon *)obj;
return icon->icon_size;
LauncherIcon *icon = (LauncherIcon *)obj;
return icon->icon_size;
}
char *launcher_icon_get_tooltip_text(void *obj)
{
LauncherIcon *launcherIcon = (LauncherIcon *)obj;
return strdup(launcherIcon->icon_tooltip);
LauncherIcon *launcherIcon = (LauncherIcon *)obj;
return strdup(launcherIcon->icon_tooltip);
}
void draw_launcher_icon(void *obj, cairo_t *c)
{
LauncherIcon *launcherIcon = (LauncherIcon *)obj;
LauncherIcon *launcherIcon = (LauncherIcon *)obj;
Imlib_Image image;
// Render
if (panel_config.mouse_effects) {
if (launcherIcon->area.mouse_state == MOUSE_OVER)
image = launcherIcon->image_hover ? launcherIcon->image_hover : launcherIcon->image;
else if (launcherIcon->area.mouse_state == MOUSE_DOWN)
image = launcherIcon->image_pressed ? launcherIcon->image_pressed : launcherIcon->image;
else
image = launcherIcon->image;
} else {
image = launcherIcon->image;
}
imlib_context_set_image(image);
render_image(launcherIcon->area.pix, 0, 0);
Imlib_Image image;
// Render
if (panel_config.mouse_effects) {
if (launcherIcon->area.mouse_state == MOUSE_OVER)
image = launcherIcon->image_hover ? launcherIcon->image_hover : launcherIcon->image;
else if (launcherIcon->area.mouse_state == MOUSE_DOWN)
image = launcherIcon->image_pressed ? launcherIcon->image_pressed : launcherIcon->image;
else
image = launcherIcon->image;
} else {
image = launcherIcon->image;
}
imlib_context_set_image(image);
render_image(launcherIcon->area.pix, 0, 0);
}
void launcher_icon_dump_geometry(void *obj, int indent)
{
LauncherIcon *launcherIcon = (LauncherIcon *)obj;
fprintf(stderr, "%*sIcon: w = h = %d, name = %s\n", indent, "", launcherIcon->icon_size, launcherIcon->icon_name);
LauncherIcon *launcherIcon = (LauncherIcon *)obj;
fprintf(stderr, "%*sIcon: w = h = %d, name = %s\n", indent, "", launcherIcon->icon_size, launcherIcon->icon_name);
}
Imlib_Image scale_icon(Imlib_Image original, int icon_size)
{
Imlib_Image icon_scaled;
if (original) {
imlib_context_set_image(original);
icon_scaled = imlib_create_cropped_scaled_image(0,
0,
imlib_image_get_width(),
imlib_image_get_height(),
icon_size,
icon_size);
Imlib_Image icon_scaled;
if (original) {
imlib_context_set_image(original);
icon_scaled = imlib_create_cropped_scaled_image(0,
0,
imlib_image_get_width(),
imlib_image_get_height(),
icon_size,
icon_size);
imlib_context_set_image(icon_scaled);
imlib_image_set_has_alpha(1);
DATA32 *data = imlib_image_get_data();
adjust_asb(data,
icon_size,
icon_size,
launcher_alpha / 100.0,
launcher_saturation / 100.0,
launcher_brightness / 100.0);
imlib_image_put_back_data(data);
imlib_context_set_image(icon_scaled);
imlib_image_set_has_alpha(1);
DATA32 *data = imlib_image_get_data();
adjust_asb(data,
icon_size,
icon_size,
launcher_alpha / 100.0,
launcher_saturation / 100.0,
launcher_brightness / 100.0);
imlib_image_put_back_data(data);
imlib_context_set_image(icon_scaled);
} else {
icon_scaled = imlib_create_image(icon_size, icon_size);
imlib_context_set_image(icon_scaled);
imlib_context_set_color(255, 255, 255, 255);
imlib_image_fill_rectangle(0, 0, icon_size, icon_size);
}
return icon_scaled;
imlib_context_set_image(icon_scaled);
} else {
icon_scaled = imlib_create_image(icon_size, icon_size);
imlib_context_set_image(icon_scaled);
imlib_context_set_color(255, 255, 255, 255);
imlib_image_fill_rectangle(0, 0, icon_size, icon_size);
}
return icon_scaled;
}
void free_icon(Imlib_Image icon)
{
if (icon) {
imlib_context_set_image(icon);
imlib_free_image();
}
if (icon) {
imlib_context_set_image(icon);
imlib_free_image();
}
}
void launcher_action(LauncherIcon *icon, XEvent *evt)
{
launcher_reload_icon((Launcher *)icon->area.parent, icon);
launcher_reload_hidden_icons((Launcher *)icon->area.parent);
char *cmd = calloc(strlen(icon->cmd) + 10, 1);
sprintf(cmd, "(%s&)", icon->cmd);
launcher_reload_icon((Launcher *)icon->area.parent, icon);
launcher_reload_hidden_icons((Launcher *)icon->area.parent);
char *cmd = calloc(strlen(icon->cmd) + 10, 1);
sprintf(cmd, "(%s&)", icon->cmd);
#if HAVE_SN
SnLauncherContext *ctx = 0;
Time time;
if (startup_notifications) {
ctx = sn_launcher_context_new(server.sn_display, server.screen);
sn_launcher_context_set_name(ctx, icon->icon_tooltip);
sn_launcher_context_set_description(ctx, "Application launched from tint2");
sn_launcher_context_set_binary_name(ctx, icon->cmd);
// Get a timestamp from the X event
if (evt->type == ButtonPress || evt->type == ButtonRelease) {
time = evt->xbutton.time;
} else {
fprintf(stderr, "Unknown X event: %d\n", evt->type);
free(cmd);
return;
}
sn_launcher_context_initiate(ctx, "tint2", icon->cmd, time);
}
SnLauncherContext *ctx = 0;
Time time;
if (startup_notifications) {
ctx = sn_launcher_context_new(server.sn_display, server.screen);
sn_launcher_context_set_name(ctx, icon->icon_tooltip);
sn_launcher_context_set_description(ctx, "Application launched from tint2");
sn_launcher_context_set_binary_name(ctx, icon->cmd);
// Get a timestamp from the X event
if (evt->type == ButtonPress || evt->type == ButtonRelease) {
time = evt->xbutton.time;
} else {
fprintf(stderr, "Unknown X event: %d\n", evt->type);
free(cmd);
return;
}
sn_launcher_context_initiate(ctx, "tint2", icon->cmd, time);
}
#endif /* HAVE_SN */
pid_t pid;
pid = fork();
if (pid < 0) {
fprintf(stderr, "Could not fork\n");
} else if (pid == 0) {
pid_t pid;
pid = fork();
if (pid < 0) {
fprintf(stderr, "Could not fork\n");
} else if (pid == 0) {
// Child process
#if HAVE_SN
if (startup_notifications) {
sn_launcher_context_setup_child_process(ctx);
}
if (startup_notifications) {
sn_launcher_context_setup_child_process(ctx);
}
#endif // HAVE_SN
// Allow children to exist after parent destruction
setsid();
// Run the command
if (icon->cwd)
chdir(icon->cwd);
execl("/bin/sh", "/bin/sh", "-c", icon->cmd, NULL);
fprintf(stderr, "Failed to execlp %s\n", icon->cmd);
// Allow children to exist after parent destruction
setsid();
// Run the command
if (icon->cwd)
chdir(icon->cwd);
execl("/bin/sh", "/bin/sh", "-c", icon->cmd, NULL);
fprintf(stderr, "Failed to execlp %s\n", icon->cmd);
#if HAVE_SN
if (startup_notifications) {
sn_launcher_context_unref(ctx);
}
if (startup_notifications) {
sn_launcher_context_unref(ctx);
}
#endif // HAVE_SN
exit(1);
} else {
exit(1);
} else {
// Parent process
#if HAVE_SN
if (startup_notifications) {
g_tree_insert(server.pids, GINT_TO_POINTER(pid), ctx);
}
if (startup_notifications) {
g_tree_insert(server.pids, GINT_TO_POINTER(pid), ctx);
}
#endif // HAVE_SN
}
free(cmd);
}
free(cmd);
}
// Populates the list_icons list from the list_apps list
void launcher_load_icons(Launcher *launcher)
{
// Load apps (.desktop style launcher items)
GSList *app = launcher->list_apps;
int index = 0;
while (app != NULL) {
index++;
LauncherIcon *launcherIcon = (LauncherIcon *)calloc(1, sizeof(LauncherIcon));
launcherIcon->area.panel = launcher->area.panel;
launcherIcon->area._draw_foreground = draw_launcher_icon;
launcherIcon->area.size_mode = LAYOUT_FIXED;
launcherIcon->area._resize = NULL;
launcherIcon->area._compute_desired_size = launcher_icon_compute_desired_size;
sprintf(launcherIcon->area.name, "LauncherIcon %d", index);
launcherIcon->area.resize_needed = 0;
launcherIcon->area.has_mouse_over_effect = panel_config.mouse_effects;
launcherIcon->area.has_mouse_press_effect = launcherIcon->area.has_mouse_over_effect;
launcherIcon->area.bg = launcher_icon_bg;
launcherIcon->area.on_screen = TRUE;
launcherIcon->area.posx = -1;
launcherIcon->area._on_change_layout = launcher_icon_on_change_layout;
launcherIcon->area._dump_geometry = launcher_icon_dump_geometry;
if (launcher_tooltip_enabled) {
launcherIcon->area._get_tooltip_text = launcher_icon_get_tooltip_text;
} else {
launcherIcon->area._get_tooltip_text = NULL;
}
launcherIcon->config_path = strdup(app->data);
add_area(&launcherIcon->area, (Area *)launcher);
launcher->list_icons = g_slist_append(launcher->list_icons, launcherIcon);
launcherIcon->icon_size = launcher->icon_size;
launcher_reload_icon(launcher, launcherIcon);
instantiate_area_gradients(&launcherIcon->area);
app = g_slist_next(app);
}
// Load apps (.desktop style launcher items)
GSList *app = launcher->list_apps;
int index = 0;
while (app != NULL) {
index++;
LauncherIcon *launcherIcon = (LauncherIcon *)calloc(1, sizeof(LauncherIcon));
launcherIcon->area.panel = launcher->area.panel;
launcherIcon->area._draw_foreground = draw_launcher_icon;
launcherIcon->area.size_mode = LAYOUT_FIXED;
launcherIcon->area._resize = NULL;
launcherIcon->area._compute_desired_size = launcher_icon_compute_desired_size;
sprintf(launcherIcon->area.name, "LauncherIcon %d", index);
launcherIcon->area.resize_needed = 0;
launcherIcon->area.has_mouse_over_effect = panel_config.mouse_effects;
launcherIcon->area.has_mouse_press_effect = launcherIcon->area.has_mouse_over_effect;
launcherIcon->area.bg = launcher_icon_bg;
launcherIcon->area.on_screen = TRUE;
launcherIcon->area.posx = -1;
launcherIcon->area._on_change_layout = launcher_icon_on_change_layout;
launcherIcon->area._dump_geometry = launcher_icon_dump_geometry;
if (launcher_tooltip_enabled) {
launcherIcon->area._get_tooltip_text = launcher_icon_get_tooltip_text;
} else {
launcherIcon->area._get_tooltip_text = NULL;
}
launcherIcon->config_path = strdup(app->data);
add_area(&launcherIcon->area, (Area *)launcher);
launcher->list_icons = g_slist_append(launcher->list_icons, launcherIcon);
launcherIcon->icon_size = launcher->icon_size;
launcher_reload_icon(launcher, launcherIcon);
instantiate_area_gradients(&launcherIcon->area);
app = g_slist_next(app);
}
}
void launcher_reload_icon(Launcher *launcher, LauncherIcon *launcherIcon)
{
DesktopEntry entry;
if (read_desktop_file(launcherIcon->config_path, &entry) && entry.exec) {
schedule_redraw(&launcherIcon->area);
if (launcherIcon->cmd)
free(launcherIcon->cmd);
launcherIcon->cmd = strdup(entry.exec);
if (launcherIcon->cwd)
free(launcherIcon->cwd);
if (entry.cwd)
launcherIcon->cwd = strdup(entry.cwd);
else
launcherIcon->cwd = NULL;
if (launcherIcon->icon_name)
free(launcherIcon->icon_name);
launcherIcon->icon_name = entry.icon ? strdup(entry.icon) : strdup(DEFAULT_ICON);
if (entry.name) {
if (entry.generic_name) {
launcherIcon->icon_tooltip = g_strdup_printf("%s (%s)", entry.name, entry.generic_name);
} else {
launcherIcon->icon_tooltip = g_strdup_printf("%s", entry.name);
}
} else {
if (entry.generic_name) {
launcherIcon->icon_tooltip = g_strdup_printf("%s", entry.generic_name);
} else if (entry.exec) {
launcherIcon->icon_tooltip = g_strdup_printf("%s", entry.exec);
}
}
launcher_reload_icon_image(launcher, launcherIcon);
show(&launcherIcon->area);
} else {
hide(&launcherIcon->area);
}
free_desktop_entry(&entry);
DesktopEntry entry;
if (read_desktop_file(launcherIcon->config_path, &entry) && entry.exec) {
schedule_redraw(&launcherIcon->area);
if (launcherIcon->cmd)
free(launcherIcon->cmd);
launcherIcon->cmd = strdup(entry.exec);
if (launcherIcon->cwd)
free(launcherIcon->cwd);
if (entry.cwd)
launcherIcon->cwd = strdup(entry.cwd);
else
launcherIcon->cwd = NULL;
if (launcherIcon->icon_name)
free(launcherIcon->icon_name);
launcherIcon->icon_name = entry.icon ? strdup(entry.icon) : strdup(DEFAULT_ICON);
if (entry.name) {
if (entry.generic_name) {
launcherIcon->icon_tooltip = g_strdup_printf("%s (%s)", entry.name, entry.generic_name);
} else {
launcherIcon->icon_tooltip = g_strdup_printf("%s", entry.name);
}
} else {
if (entry.generic_name) {
launcherIcon->icon_tooltip = g_strdup_printf("%s", entry.generic_name);
} else if (entry.exec) {
launcherIcon->icon_tooltip = g_strdup_printf("%s", entry.exec);
}
}
launcher_reload_icon_image(launcher, launcherIcon);
show(&launcherIcon->area);
} else {
hide(&launcherIcon->area);
}
free_desktop_entry(&entry);
}
void launcher_reload_hidden_icons(Launcher *launcher)
{
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (!launcherIcon->area.on_screen)
launcher_reload_icon(launcher, launcherIcon);
}
for (GSList *l = launcher->list_icons; l; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon *)l->data;
if (!launcherIcon->area.on_screen)
launcher_reload_icon(launcher, launcherIcon);
}
}
void launcher_reload_icon_image(Launcher *launcher, LauncherIcon *launcherIcon)
{
free_icon(launcherIcon->image);
free_icon(launcherIcon->image_hover);
free_icon(launcherIcon->image_pressed);
launcherIcon->image = NULL;
free_icon(launcherIcon->image);
free_icon(launcherIcon->image_hover);
free_icon(launcherIcon->image_pressed);
launcherIcon->image = NULL;
char *new_icon_path = get_icon_path(icon_theme_wrapper, launcherIcon->icon_name, launcherIcon->icon_size, TRUE);
if (new_icon_path)
launcherIcon->image = load_image(new_icon_path, TRUE);
// On loading error, fallback to default
if (!launcherIcon->image) {
free(new_icon_path);
new_icon_path = get_icon_path(icon_theme_wrapper, DEFAULT_ICON, launcherIcon->icon_size, TRUE);
if (new_icon_path)
launcherIcon->image = load_image(new_icon_path, TRUE);
}
Imlib_Image original = launcherIcon->image;
launcherIcon->image = scale_icon(launcherIcon->image, launcherIcon->icon_size);
free_icon(original);
free(launcherIcon->icon_path);
launcherIcon->icon_path = new_icon_path;
// fprintf(stderr, "launcher.c %d: Using icon %s\n", __LINE__, launcherIcon->icon_path);
char *new_icon_path = get_icon_path(icon_theme_wrapper, launcherIcon->icon_name, launcherIcon->icon_size, TRUE);
if (new_icon_path)
launcherIcon->image = load_image(new_icon_path, TRUE);
// On loading error, fallback to default
if (!launcherIcon->image) {
free(new_icon_path);
new_icon_path = get_icon_path(icon_theme_wrapper, DEFAULT_ICON, launcherIcon->icon_size, TRUE);
if (new_icon_path)
launcherIcon->image = load_image(new_icon_path, TRUE);
}
Imlib_Image original = launcherIcon->image;
launcherIcon->image = scale_icon(launcherIcon->image, launcherIcon->icon_size);
free_icon(original);
free(launcherIcon->icon_path);
launcherIcon->icon_path = new_icon_path;
// fprintf(stderr, "launcher.c %d: Using icon %s\n", __LINE__, launcherIcon->icon_path);
if (panel_config.mouse_effects) {
launcherIcon->image_hover = adjust_icon(launcherIcon->image,
panel_config.mouse_over_alpha,
panel_config.mouse_over_saturation,
panel_config.mouse_over_brightness);
launcherIcon->image_pressed = adjust_icon(launcherIcon->image,
panel_config.mouse_pressed_alpha,
panel_config.mouse_pressed_saturation,
panel_config.mouse_pressed_brightness);
}
schedule_redraw(&launcherIcon->area);
if (panel_config.mouse_effects) {
launcherIcon->image_hover = adjust_icon(launcherIcon->image,
panel_config.mouse_over_alpha,
panel_config.mouse_over_saturation,
panel_config.mouse_over_brightness);
launcherIcon->image_pressed = adjust_icon(launcherIcon->image,
panel_config.mouse_pressed_alpha,
panel_config.mouse_pressed_saturation,
panel_config.mouse_pressed_brightness);
}
schedule_redraw(&launcherIcon->area);
}
void load_icon_themes()
{
if (icon_theme_wrapper)
return;
icon_theme_wrapper =
load_themes(launcher_icon_theme_override
? (icon_theme_name_config ? icon_theme_name_config
: icon_theme_name_xsettings ? icon_theme_name_xsettings : "hicolor")
: (icon_theme_name_xsettings ? icon_theme_name_xsettings
: icon_theme_name_config ? icon_theme_name_config : "hicolor"));
if (icon_theme_wrapper)
return;
icon_theme_wrapper =
load_themes(launcher_icon_theme_override
? (icon_theme_name_config ? icon_theme_name_config
: icon_theme_name_xsettings ? icon_theme_name_xsettings : "hicolor")
: (icon_theme_name_xsettings ? icon_theme_name_xsettings
: icon_theme_name_config ? icon_theme_name_config : "hicolor"));
}
void launcher_default_icon_theme_changed()
{
for (int i = 0; i < num_panels; i++) {
Launcher *launcher = &panels[i].launcher;
cleanup_launcher_theme(launcher);
launcher_load_icons(launcher);
launcher->area.resize_needed = 1;
}
schedule_panel_redraw();
for (int i = 0; i < num_panels; i++) {
Launcher *launcher = &panels[i].launcher;
cleanup_launcher_theme(launcher);
launcher_load_icons(launcher);
launcher->area.resize_needed = 1;
}
schedule_panel_redraw();
}

36
src/launcher/launcher.h
View File

@@ -17,27 +17,27 @@ void load_icon_themes();
void free_icon_themes();
typedef struct Launcher {
// always start with area
Area area;
GSList *list_apps; // List of char*, each is a path to a app.desktop file
GSList *list_icons; // List of LauncherIcon*
int icon_size;
// always start with area
Area area;
GSList *list_apps; // List of char*, each is a path to a app.desktop file
GSList *list_icons; // List of LauncherIcon*
int icon_size;
} Launcher;
typedef struct LauncherIcon {
// always start with area
Area area;
char *config_path;
Imlib_Image image;
Imlib_Image image_hover;
Imlib_Image image_pressed;
char *cmd;
char *cwd;
char *icon_name;
char *icon_path;
char *icon_tooltip;
int icon_size;
int x, y;
// always start with area
Area area;
char *config_path;
Imlib_Image image;
Imlib_Image image_hover;
Imlib_Image image_pressed;
char *cmd;
char *cwd;
char *icon_name;
char *icon_path;
char *icon_tooltip;
int icon_size;
int x, y;
} LauncherIcon;
extern gboolean launcher_enabled;

630
src/launcher/xsettings-client.c
View File

@@ -34,78 +34,78 @@
#include "launcher.h"
struct _XSettingsClient {
Display *display;
int screen;
XSettingsNotifyFunc notify;
XSettingsWatchFunc watch;
void *cb_data;
Display *display;
int screen;
XSettingsNotifyFunc notify;
XSettingsWatchFunc watch;
void *cb_data;
Window manager_window;
XSettingsList *settings;
Window manager_window;
XSettingsList *settings;
};
void xsettings_notify_cb(const char *name, XSettingsAction action, XSettingsSetting *setting, void *data)
{
if ((action == XSETTINGS_ACTION_NEW || action == XSETTINGS_ACTION_CHANGED) && name != NULL && setting != NULL) {
if (strcmp(name, "Net/IconThemeName") == 0 && setting->type == XSETTINGS_TYPE_STRING) {
fprintf(stderr, "xsettings: %s = %s\n", name, setting->data.v_string);
if (icon_theme_name_xsettings) {
if (strcmp(icon_theme_name_xsettings, setting->data.v_string) == 0)
return;
free(icon_theme_name_xsettings);
}
icon_theme_name_xsettings = strdup(setting->data.v_string);
default_icon_theme_changed();
} else if (strcmp(name, "Gtk/FontName") == 0 && setting->type == XSETTINGS_TYPE_STRING) {
fprintf(stderr, "xsettings: %s = %s\n", name, setting->data.v_string);
if (default_font) {
if (strcmp(default_font, setting->data.v_string) == 0)
return;
free(default_font);
}
default_font = strdup(setting->data.v_string);
default_font_changed();
}
}
if ((action == XSETTINGS_ACTION_NEW || action == XSETTINGS_ACTION_CHANGED) && name != NULL && setting != NULL) {
if (strcmp(name, "Net/IconThemeName") == 0 && setting->type == XSETTINGS_TYPE_STRING) {
fprintf(stderr, "xsettings: %s = %s\n", name, setting->data.v_string);
if (icon_theme_name_xsettings) {
if (strcmp(icon_theme_name_xsettings, setting->data.v_string) == 0)
return;
free(icon_theme_name_xsettings);
}
icon_theme_name_xsettings = strdup(setting->data.v_string);
default_icon_theme_changed();
} else if (strcmp(name, "Gtk/FontName") == 0 && setting->type == XSETTINGS_TYPE_STRING) {
fprintf(stderr, "xsettings: %s = %s\n", name, setting->data.v_string);
if (default_font) {
if (strcmp(default_font, setting->data.v_string) == 0)
return;
free(default_font);
}
default_font = strdup(setting->data.v_string);
default_font_changed();
}
}
}
static void notify_changes(XSettingsClient *client, XSettingsList *old_list)
{
XSettingsList *old_iter = old_list;
XSettingsList *new_iter = client->settings;
XSettingsList *old_iter = old_list;
XSettingsList *new_iter = client->settings;
if (!client->notify)
return;
if (!client->notify)
return;
while (old_iter || new_iter) {
int cmp;
while (old_iter || new_iter) {
int cmp;
if (old_iter && new_iter)
cmp = strcmp(old_iter->setting->name, new_iter->setting->name);
else if (old_iter)
cmp = -1;
else
cmp = 1;
if (old_iter && new_iter)
cmp = strcmp(old_iter->setting->name, new_iter->setting->name);
else if (old_iter)
cmp = -1;
else
cmp = 1;
if (cmp < 0) {
client->notify(old_iter->setting->name, XSETTINGS_ACTION_DELETED, NULL, client->cb_data);
} else if (cmp == 0) {
if (!xsettings_setting_equal(old_iter->setting, new_iter->setting))
client->notify(old_iter->setting->name, XSETTINGS_ACTION_CHANGED, new_iter->setting, client->cb_data);
} else {
client->notify(new_iter->setting->name, XSETTINGS_ACTION_NEW, new_iter->setting, client->cb_data);
}
if (cmp < 0) {
client->notify(old_iter->setting->name, XSETTINGS_ACTION_DELETED, NULL, client->cb_data);
} else if (cmp == 0) {
if (!xsettings_setting_equal(old_iter->setting, new_iter->setting))
client->notify(old_iter->setting->name, XSETTINGS_ACTION_CHANGED, new_iter->setting, client->cb_data);
} else {
client->notify(new_iter->setting->name, XSETTINGS_ACTION_NEW, new_iter->setting, client->cb_data);
}
if (old_iter)
old_iter = old_iter->next;
if (new_iter)
new_iter = new_iter->next;
}
if (old_iter)
old_iter = old_iter->next;
if (new_iter)
new_iter = new_iter->next;
}
}
static int ignore_errors(Display *display, XErrorEvent *event)
{
return True;
return True;
}
static char local_byte_order = '\0';
@@ -114,364 +114,364 @@ static char local_byte_order = '\0';
static XSettingsResult fetch_card16(XSettingsBuffer *buffer, CARD16 *result)
{
CARD16 x;
CARD16 x;
if (BYTES_LEFT(buffer) < 2)
return XSETTINGS_ACCESS;
if (BYTES_LEFT(buffer) < 2)
return XSETTINGS_ACCESS;
x = *(CARD16 *)buffer->pos;
buffer->pos += 2;
x = *(CARD16 *)buffer->pos;
buffer->pos += 2;
if (buffer->byte_order == local_byte_order)
*result = x;
else
*result = (x << 8) | (x >> 8);
if (buffer->byte_order == local_byte_order)
*result = x;
else
*result = (x << 8) | (x >> 8);
return XSETTINGS_SUCCESS;
return XSETTINGS_SUCCESS;
}
static XSettingsResult fetch_ushort(XSettingsBuffer *buffer, unsigned short *result)
{
CARD16 x;
XSettingsResult r;
CARD16 x;
XSettingsResult r;
r = fetch_card16(buffer, &x);
if (r == XSETTINGS_SUCCESS)
*result = x;
r = fetch_card16(buffer, &x);
if (r == XSETTINGS_SUCCESS)
*result = x;
return r;
return r;
}
static XSettingsResult fetch_card32(XSettingsBuffer *buffer, CARD32 *result)
{
CARD32 x;
CARD32 x;
if (BYTES_LEFT(buffer) < 4)
return XSETTINGS_ACCESS;
if (BYTES_LEFT(buffer) < 4)
return XSETTINGS_ACCESS;
x = *(CARD32 *)buffer->pos;
buffer->pos += 4;
x = *(CARD32 *)buffer->pos;
buffer->pos += 4;
if (buffer->byte_order == local_byte_order)
*result = x;
else
*result = (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24);
if (buffer->byte_order == local_byte_order)
*result = x;
else
*result = (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24);
return XSETTINGS_SUCCESS;
return XSETTINGS_SUCCESS;
}
static XSettingsResult fetch_card8(XSettingsBuffer *buffer, CARD8 *result)
{
if (BYTES_LEFT(buffer) < 1)
return XSETTINGS_ACCESS;
if (BYTES_LEFT(buffer) < 1)
return XSETTINGS_ACCESS;
*result = *(CARD8 *)buffer->pos;
buffer->pos += 1;
*result = *(CARD8 *)buffer->pos;
buffer->pos += 1;
return XSETTINGS_SUCCESS;
return XSETTINGS_SUCCESS;
}
#define XSETTINGS_PAD(n, m) ((n + m - 1) & (~(m - 1)))
static XSettingsList *parse_settings(unsigned char *data, size_t len)
{
XSettingsBuffer buffer;
XSettingsResult result = XSETTINGS_SUCCESS;
XSettingsList *settings = NULL;
CARD32 serial;
CARD32 n_entries;
CARD32 i;
XSettingsSetting *setting = NULL;
XSettingsBuffer buffer;
XSettingsResult result = XSETTINGS_SUCCESS;
XSettingsList *settings = NULL;
CARD32 serial;
CARD32 n_entries;
CARD32 i;
XSettingsSetting *setting = NULL;
local_byte_order = xsettings_byte_order();
local_byte_order = xsettings_byte_order();
buffer.byte_order = local_byte_order;
buffer.pos = buffer.data = data;
buffer.len = len;
buffer.byte_order = local_byte_order;
buffer.pos = buffer.data = data;
buffer.len = len;
result = fetch_card8(&buffer, (CARD8 *)&buffer.byte_order);
if (buffer.byte_order != MSBFirst && buffer.byte_order != LSBFirst) {
fprintf(stderr, "Invalid byte order %x in XSETTINGS property\n", buffer.byte_order);
result = XSETTINGS_FAILED;
goto out;
}
result = fetch_card8(&buffer, (CARD8 *)&buffer.byte_order);
if (buffer.byte_order != MSBFirst && buffer.byte_order != LSBFirst) {
fprintf(stderr, "Invalid byte order %x in XSETTINGS property\n", buffer.byte_order);
result = XSETTINGS_FAILED;
goto out;
}
buffer.pos += 3;
buffer.pos += 3;
result = fetch_card32(&buffer, &serial);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_card32(&buffer, &serial);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_card32(&buffer, &n_entries);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_card32(&buffer, &n_entries);
if (result != XSETTINGS_SUCCESS)
goto out;
for (i = 0; i < n_entries; i++) {
CARD8 type;
CARD16 name_len;
CARD32 v_int;
size_t pad_len;
for (i = 0; i < n_entries; i++) {
CARD8 type;
CARD16 name_len;
CARD32 v_int;
size_t pad_len;
result = fetch_card8(&buffer, &type);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_card8(&buffer, &type);
if (result != XSETTINGS_SUCCESS)
goto out;
buffer.pos += 1;
buffer.pos += 1;
result = fetch_card16(&buffer, &name_len);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_card16(&buffer, &name_len);
if (result != XSETTINGS_SUCCESS)
goto out;
pad_len = XSETTINGS_PAD(name_len, 4);
if (BYTES_LEFT(&buffer) < pad_len) {
result = XSETTINGS_ACCESS;
goto out;
}
pad_len = XSETTINGS_PAD(name_len, 4);
if (BYTES_LEFT(&buffer) < pad_len) {
result = XSETTINGS_ACCESS;
goto out;
}
setting = calloc(1, sizeof *setting);
if (!setting) {
result = XSETTINGS_NO_MEM;
goto out;
}
setting->type = XSETTINGS_TYPE_INT; /* No allocated memory */
setting = calloc(1, sizeof *setting);
if (!setting) {
result = XSETTINGS_NO_MEM;
goto out;
}
setting->type = XSETTINGS_TYPE_INT; /* No allocated memory */
setting->name = calloc(name_len + 1, 1);
if (!setting->name) {
result = XSETTINGS_NO_MEM;
goto out;
}
setting->name = calloc(name_len + 1, 1);
if (!setting->name) {
result = XSETTINGS_NO_MEM;
goto out;
}
memcpy(setting->name, buffer.pos, name_len);
setting->name[name_len] = '\0';
buffer.pos += pad_len;
memcpy(setting->name, buffer.pos, name_len);
setting->name[name_len] = '\0';
buffer.pos += pad_len;
result = fetch_card32(&buffer, &v_int);
if (result != XSETTINGS_SUCCESS)
goto out;
setting->last_change_serial = v_int;
result = fetch_card32(&buffer, &v_int);
if (result != XSETTINGS_SUCCESS)
goto out;
setting->last_change_serial = v_int;
switch (type) {
case XSETTINGS_TYPE_INT:
result = fetch_card32(&buffer, &v_int);
if (result != XSETTINGS_SUCCESS)
goto out;
setting->data.v_int = (INT32)v_int;
break;
case XSETTINGS_TYPE_STRING:
result = fetch_card32(&buffer, &v_int);
if (result != XSETTINGS_SUCCESS)
goto out;
switch (type) {
case XSETTINGS_TYPE_INT:
result = fetch_card32(&buffer, &v_int);
if (result != XSETTINGS_SUCCESS)
goto out;
setting->data.v_int = (INT32)v_int;
break;
case XSETTINGS_TYPE_STRING:
result = fetch_card32(&buffer, &v_int);
if (result != XSETTINGS_SUCCESS)
goto out;
pad_len = XSETTINGS_PAD(v_int, 4);
if (v_int + 1 == 0 || /* Guard against wrap-around */
BYTES_LEFT(&buffer) < pad_len) {
result = XSETTINGS_ACCESS;
goto out;
}
pad_len = XSETTINGS_PAD(v_int, 4);
if (v_int + 1 == 0 || /* Guard against wrap-around */
BYTES_LEFT(&buffer) < pad_len) {
result = XSETTINGS_ACCESS;
goto out;
}
setting->data.v_string = calloc(v_int + 1, 1);
if (!setting->data.v_string) {
result = XSETTINGS_NO_MEM;
goto out;
}
setting->data.v_string = calloc(v_int + 1, 1);
if (!setting->data.v_string) {
result = XSETTINGS_NO_MEM;
goto out;
}
memcpy(setting->data.v_string, buffer.pos, v_int);
setting->data.v_string[v_int] = '\0';
buffer.pos += pad_len;
break;
case XSETTINGS_TYPE_COLOR:
result = fetch_ushort(&buffer, &setting->data.v_color.red);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_ushort(&buffer, &setting->data.v_color.green);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_ushort(&buffer, &setting->data.v_color.blue);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_ushort(&buffer, &setting->data.v_color.alpha);
if (result != XSETTINGS_SUCCESS)
goto out;
break;
default:
/* Quietly ignore unknown types */
break;
}
memcpy(setting->data.v_string, buffer.pos, v_int);
setting->data.v_string[v_int] = '\0';
buffer.pos += pad_len;
break;
case XSETTINGS_TYPE_COLOR:
result = fetch_ushort(&buffer, &setting->data.v_color.red);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_ushort(&buffer, &setting->data.v_color.green);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_ushort(&buffer, &setting->data.v_color.blue);
if (result != XSETTINGS_SUCCESS)
goto out;
result = fetch_ushort(&buffer, &setting->data.v_color.alpha);
if (result != XSETTINGS_SUCCESS)
goto out;
break;
default:
/* Quietly ignore unknown types */
break;
}
setting->type = type;
setting->type = type;
result = xsettings_list_insert(&settings, setting);
if (result != XSETTINGS_SUCCESS)
goto out;
result = xsettings_list_insert(&settings, setting);
if (result != XSETTINGS_SUCCESS)
goto out;
setting = NULL;
}
setting = NULL;
}
out:
if (result != XSETTINGS_SUCCESS) {
switch (result) {
case XSETTINGS_NO_MEM:
fprintf(stderr, "Out of memory reading XSETTINGS property\n");
break;
case XSETTINGS_ACCESS:
fprintf(stderr, "Invalid XSETTINGS property (read off end)\n");
break;
case XSETTINGS_DUPLICATE_ENTRY:
fprintf(stderr, "Duplicate XSETTINGS entry for '%s'\n", setting->name);
case XSETTINGS_FAILED:
case XSETTINGS_SUCCESS:
case XSETTINGS_NO_ENTRY:
break;
}
if (result != XSETTINGS_SUCCESS) {
switch (result) {
case XSETTINGS_NO_MEM:
fprintf(stderr, "Out of memory reading XSETTINGS property\n");
break;
case XSETTINGS_ACCESS:
fprintf(stderr, "Invalid XSETTINGS property (read off end)\n");
break;
case XSETTINGS_DUPLICATE_ENTRY:
fprintf(stderr, "Duplicate XSETTINGS entry for '%s'\n", setting->name);
case XSETTINGS_FAILED:
case XSETTINGS_SUCCESS:
case XSETTINGS_NO_ENTRY:
break;
}
if (setting)
xsettings_setting_free(setting);
if (setting)
xsettings_setting_free(setting);
xsettings_list_free(settings);
settings = NULL;
}
xsettings_list_free(settings);
settings = NULL;
}
return settings;
return settings;
}
static void read_settings(XSettingsClient *client)
{
Atom type;
int format;
unsigned long n_items;
unsigned long bytes_after;
unsigned char *data;
Atom type;
int format;
unsigned long n_items;
unsigned long bytes_after;
unsigned char *data;
int (*old_handler)(Display *, XErrorEvent *);
int (*old_handler)(Display *, XErrorEvent *);
XSettingsList *old_list = client->settings;
client->settings = NULL;
XSettingsList *old_list = client->settings;
client->settings = NULL;
old_handler = XSetErrorHandler(ignore_errors);
int result = XGetWindowProperty(client->display,
client->manager_window,
server.atom._XSETTINGS_SETTINGS,
0,
LONG_MAX,
False,
server.atom._XSETTINGS_SETTINGS,
&type,
&format,
&n_items,
&bytes_after,
&data);
XSetErrorHandler(old_handler);
old_handler = XSetErrorHandler(ignore_errors);
int result = XGetWindowProperty(client->display,
client->manager_window,
server.atom._XSETTINGS_SETTINGS,
0,
LONG_MAX,
False,
server.atom._XSETTINGS_SETTINGS,
&type,
&format,
&n_items,
&bytes_after,
&data);
XSetErrorHandler(old_handler);
if (result == Success && type == server.atom._XSETTINGS_SETTINGS) {
if (format != 8) {
fprintf(stderr, "Invalid format for XSETTINGS property %d", format);
} else
client->settings = parse_settings(data, n_items);
XFree(data);
}
if (result == Success && type == server.atom._XSETTINGS_SETTINGS) {
if (format != 8) {
fprintf(stderr, "Invalid format for XSETTINGS property %d", format);
} else
client->settings = parse_settings(data, n_items);
XFree(data);
}
notify_changes(client, old_list);
xsettings_list_free(old_list);
notify_changes(client, old_list);
xsettings_list_free(old_list);
}
static void check_manager_window(XSettingsClient *client)
{
if (client->manager_window && client->watch)
client->watch(client->manager_window, False, 0, client->cb_data);
if (client->manager_window && client->watch)
client->watch(client->manager_window, False, 0, client->cb_data);
XGrabServer(client->display);
XGrabServer(client->display);
client->manager_window = XGetSelectionOwner(server.display, server.atom._XSETTINGS_SCREEN);
if (client->manager_window)
XSelectInput(server.display, client->manager_window, PropertyChangeMask | StructureNotifyMask);
client->manager_window = XGetSelectionOwner(server.display, server.atom._XSETTINGS_SCREEN);
if (client->manager_window)
XSelectInput(server.display, client->manager_window, PropertyChangeMask | StructureNotifyMask);
XUngrabServer(client->display);
XFlush(client->display);
XUngrabServer(client->display);
XFlush(client->display);
if (client->manager_window && client->watch)
client->watch(client->manager_window, True, PropertyChangeMask | StructureNotifyMask, client->cb_data);
if (client->manager_window && client->watch)
client->watch(client->manager_window, True, PropertyChangeMask | StructureNotifyMask, client->cb_data);
read_settings(client);
read_settings(client);
}
XSettingsClient *xsettings_client_new(Display *display,
int screen,
XSettingsNotifyFunc notify,
XSettingsWatchFunc watch,
void *cb_data)
int screen,
XSettingsNotifyFunc notify,
XSettingsWatchFunc watch,
void *cb_data)
{
XSettingsClient *client = calloc(1, sizeof *client);
if (!client)
return NULL;
XSettingsClient *client = calloc(1, sizeof *client);
if (!client)
return NULL;
client->display = display;
client->screen = screen;
client->notify = notify;
client->watch = watch;
client->cb_data = cb_data;
client->display = display;
client->screen = screen;
client->notify = notify;
client->watch = watch;
client->cb_data = cb_data;
client->manager_window = None;
client->settings = NULL;
client->manager_window = None;
client->settings = NULL;
if (client->watch)
client->watch(RootWindow(display, screen), True, StructureNotifyMask, client->cb_data);
if (client->watch)
client->watch(RootWindow(display, screen), True, StructureNotifyMask, client->cb_data);
check_manager_window(client);
check_manager_window(client);
if (client->manager_window == None) {
printf("No XSETTINGS manager, tint2 uses config option 'launcher_icon_theme'.\n");
free(client);
return NULL;
} else {
return client;
}
if (client->manager_window == None) {
printf("No XSETTINGS manager, tint2 uses config option 'launcher_icon_theme'.\n");
free(client);
return NULL;
} else {
return client;
}
}
void xsettings_client_destroy(XSettingsClient *client)
{
if (!client)
return;
if (client->watch)
client->watch(RootWindow(client->display, client->screen), False, 0, client->cb_data);
if (client->manager_window && client->watch)
client->watch(client->manager_window, False, 0, client->cb_data);
if (!client)
return;
if (client->watch)
client->watch(RootWindow(client->display, client->screen), False, 0, client->cb_data);
if (client->manager_window && client->watch)
client->watch(client->manager_window, False, 0, client->cb_data);
xsettings_list_free(client->settings);
free(client);
xsettings_list_free(client->settings);
free(client);
}
XSettingsResult xsettings_client_get_setting(XSettingsClient *client, const char *name, XSettingsSetting **setting)
{
XSettingsSetting *search = xsettings_list_lookup(client->settings, name);
if (search) {
*setting = xsettings_setting_copy(search);
return *setting ? XSETTINGS_SUCCESS : XSETTINGS_NO_MEM;
} else
return XSETTINGS_NO_ENTRY;
XSettingsSetting *search = xsettings_list_lookup(client->settings, name);
if (search) {
*setting = xsettings_setting_copy(search);
return *setting ? XSETTINGS_SUCCESS : XSETTINGS_NO_MEM;
} else
return XSETTINGS_NO_ENTRY;
}
Bool xsettings_client_process_event(XSettingsClient *client, XEvent *xev)
{
/* The checks here will not unlikely cause us to reread
* the properties from the manager window a number of
* times when the manager changes from A->B. But manager changes
* are going to be pretty rare.
*/
if (xev->xany.window == RootWindow(server.display, server.screen)) {
if (xev->xany.type == ClientMessage && xev->xclient.message_type == server.atom.MANAGER) {
check_manager_window(client);
return True;
}
} else if (xev->xany.window == client->manager_window) {
if (xev->xany.type == DestroyNotify) {
check_manager_window(client);
return True;
} else if (xev->xany.type == PropertyNotify) {
read_settings(client);
return True;
}
}
/* The checks here will not unlikely cause us to reread
* the properties from the manager window a number of
* times when the manager changes from A->B. But manager changes
* are going to be pretty rare.
*/
if (xev->xany.window == RootWindow(server.display, server.screen)) {
if (xev->xany.type == ClientMessage && xev->xclient.message_type == server.atom.MANAGER) {
check_manager_window(client);
return True;
}
} else if (xev->xany.window == client->manager_window) {
if (xev->xany.type == DestroyNotify) {
check_manager_window(client);
return True;
} else if (xev->xany.type == PropertyNotify) {
read_settings(client);
return True;
}
}
return False;
return False;
}

8
src/launcher/xsettings-client.h
View File

@@ -38,10 +38,10 @@ typedef void (*XSettingsNotifyFunc)(const char *name, XSettingsAction action, XS
typedef void (*XSettingsWatchFunc)(Window window, Bool is_start, long mask, void *cb_data);
XSettingsClient *xsettings_client_new(Display *display,
int screen,
XSettingsNotifyFunc notify,
XSettingsWatchFunc watch,
void *cb_data);
int screen,
XSettingsNotifyFunc notify,
XSettingsWatchFunc watch,
void *cb_data);
void xsettings_client_destroy(XSettingsClient *client);
Bool xsettings_client_process_event(XSettingsClient *client, XEvent *xev);

276
src/launcher/xsettings-common.c
View File

@@ -30,216 +30,216 @@
XSettingsSetting *xsettings_setting_copy(XSettingsSetting *setting)
{
XSettingsSetting *result;
size_t str_len;
XSettingsSetting *result;
size_t str_len;
result = calloc(1, sizeof *result);
if (!result)
return NULL;
result = calloc(1, sizeof *result);
if (!result)
return NULL;
str_len = strlen(setting->name);
result->name = calloc(str_len + 1, 1);
if (!result->name)
goto err;
str_len = strlen(setting->name);
result->name = calloc(str_len + 1, 1);
if (!result->name)
goto err;
memcpy(result->name, setting->name, str_len + 1);
memcpy(result->name, setting->name, str_len + 1);
result->type = setting->type;
result->type = setting->type;
switch (setting->type) {
case XSETTINGS_TYPE_INT:
result->data.v_int = setting->data.v_int;
break;
case XSETTINGS_TYPE_COLOR:
result->data.v_color = setting->data.v_color;
break;
case XSETTINGS_TYPE_STRING:
str_len = strlen(setting->data.v_string);
result->data.v_string = calloc(str_len + 1, 1);
if (!result->data.v_string)
goto err;
switch (setting->type) {
case XSETTINGS_TYPE_INT:
result->data.v_int = setting->data.v_int;
break;
case XSETTINGS_TYPE_COLOR:
result->data.v_color = setting->data.v_color;
break;
case XSETTINGS_TYPE_STRING:
str_len = strlen(setting->data.v_string);
result->data.v_string = calloc(str_len + 1, 1);
if (!result->data.v_string)
goto err;
memcpy(result->data.v_string, setting->data.v_string, str_len + 1);
break;
default:
break;
}
memcpy(result->data.v_string, setting->data.v_string, str_len + 1);
break;
default:
break;
}
result->last_change_serial = setting->last_change_serial;
result->last_change_serial = setting->last_change_serial;
return result;
return result;
err:
if (result->name)
free(result->name);
free(result);
if (result->name)
free(result->name);
free(result);
return NULL;
return NULL;
}
XSettingsList *xsettings_list_copy(XSettingsList *list)
{
XSettingsList *new = NULL;
XSettingsList *old_iter = list;
XSettingsList *new_iter = NULL;
XSettingsList *new = NULL;
XSettingsList *old_iter = list;
XSettingsList *new_iter = NULL;
while (old_iter) {
XSettingsList *new_node;
while (old_iter) {
XSettingsList *new_node;
new_node = calloc(1, sizeof *new_node);
if (!new_node)
goto error;
new_node = calloc(1, sizeof *new_node);
if (!new_node)
goto error;
new_node->setting = xsettings_setting_copy(old_iter->setting);
if (!new_node->setting) {
free(new_node);
goto error;
}
new_node->setting = xsettings_setting_copy(old_iter->setting);
if (!new_node->setting) {
free(new_node);
goto error;
}
if (new_iter)
new_iter->next = new_node;
else
new = new_node;
if (new_iter)
new_iter->next = new_node;
else
new = new_node;
new_iter = new_node;
new_iter = new_node;
old_iter = old_iter->next;
}
old_iter = old_iter->next;
}
return new;
return new;
error:
xsettings_list_free(new);
return NULL;
xsettings_list_free(new);
return NULL;
}
int xsettings_setting_equal(XSettingsSetting *setting_a, XSettingsSetting *setting_b)
{
if (setting_a->type != setting_b->type)
return 0;
if (setting_a->type != setting_b->type)
return 0;
if (strcmp(setting_a->name, setting_b->name) != 0)
return 0;
if (strcmp(setting_a->name, setting_b->name) != 0)
return 0;
switch (setting_a->type) {
case XSETTINGS_TYPE_INT:
return setting_a->data.v_int == setting_b->data.v_int;
case XSETTINGS_TYPE_COLOR:
return (setting_a->data.v_color.red == setting_b->data.v_color.red &&
setting_a->data.v_color.green == setting_b->data.v_color.green &&
setting_a->data.v_color.blue == setting_b->data.v_color.blue &&
setting_a->data.v_color.alpha == setting_b->data.v_color.alpha);
case XSETTINGS_TYPE_STRING:
return strcmp(setting_a->data.v_string, setting_b->data.v_string) == 0;
default:
break;
}
switch (setting_a->type) {
case XSETTINGS_TYPE_INT:
return setting_a->data.v_int == setting_b->data.v_int;
case XSETTINGS_TYPE_COLOR:
return (setting_a->data.v_color.red == setting_b->data.v_color.red &&
setting_a->data.v_color.green == setting_b->data.v_color.green &&
setting_a->data.v_color.blue == setting_b->data.v_color.blue &&
setting_a->data.v_color.alpha == setting_b->data.v_color.alpha);
case XSETTINGS_TYPE_STRING:
return strcmp(setting_a->data.v_string, setting_b->data.v_string) == 0;
default:
break;
}
return 0;
return 0;
}
void xsettings_setting_free(XSettingsSetting *setting)
{
if (setting->type == XSETTINGS_TYPE_STRING)
free(setting->data.v_string);
if (setting->type == XSETTINGS_TYPE_STRING)
free(setting->data.v_string);
if (setting->name)
free(setting->name);
if (setting->name)
free(setting->name);
free(setting);
free(setting);
}
void xsettings_list_free(XSettingsList *list)
{
while (list) {
XSettingsList *next = list->next;
while (list) {
XSettingsList *next = list->next;
xsettings_setting_free(list->setting);
free(list);
xsettings_setting_free(list->setting);
free(list);
list = next;
}
list = next;
}
}
XSettingsResult xsettings_list_insert(XSettingsList **list, XSettingsSetting *setting)
{
XSettingsList *node;
XSettingsList *iter;
XSettingsList *last = NULL;
XSettingsList *node;
XSettingsList *iter;
XSettingsList *last = NULL;
node = calloc(1, sizeof *node);
if (!node)
return XSETTINGS_NO_MEM;
node->setting = setting;
node = calloc(1, sizeof *node);
if (!node)
return XSETTINGS_NO_MEM;
node->setting = setting;
iter = *list;
while (iter) {
int cmp = strcmp(setting->name, iter->setting->name);
iter = *list;
while (iter) {
int cmp = strcmp(setting->name, iter->setting->name);
if (cmp < 0)
break;
else if (cmp == 0) {
free(node);
return XSETTINGS_DUPLICATE_ENTRY;
}
if (cmp < 0)
break;
else if (cmp == 0) {
free(node);
return XSETTINGS_DUPLICATE_ENTRY;
}
last = iter;
iter = iter->next;
}
last = iter;
iter = iter->next;
}
if (last)
last->next = node;
else
*list = node;
if (last)
last->next = node;
else
*list = node;
node->next = iter;
node->next = iter;
return XSETTINGS_SUCCESS;
return XSETTINGS_SUCCESS;
}
XSettingsResult xsettings_list_delete(XSettingsList **list, const char *name)
{
XSettingsList *iter;
XSettingsList *last = NULL;
XSettingsList *iter;
XSettingsList *last = NULL;
iter = *list;
while (iter) {
if (strcmp(name, iter->setting->name) == 0) {
if (last)
last->next = iter->next;
else
*list = iter->next;
iter = *list;
while (iter) {
if (strcmp(name, iter->setting->name) == 0) {
if (last)
last->next = iter->next;
else
*list = iter->next;
xsettings_setting_free(iter->setting);
free(iter);
xsettings_setting_free(iter->setting);
free(iter);
return XSETTINGS_SUCCESS;
}
return XSETTINGS_SUCCESS;
}
last = iter;
iter = iter->next;
}
last = iter;
iter = iter->next;
}
return XSETTINGS_FAILED;
return XSETTINGS_FAILED;
}
XSettingsSetting *xsettings_list_lookup(XSettingsList *list, const char *name)
{
XSettingsList *iter;
XSettingsList *iter;
iter = list;
while (iter) {
if (strcmp(name, iter->setting->name) == 0)
return iter->setting;
iter = list;
while (iter) {
if (strcmp(name, iter->setting->name) == 0)
return iter->setting;
iter = iter->next;
}
iter = iter->next;
}
return NULL;
return NULL;
}
char xsettings_byte_order(void)
{
CARD32 myint = 0x01020304;
return (*(char *)&myint == 1) ? MSBFirst : LSBFirst;
CARD32 myint = 0x01020304;
return (*(char *)&myint == 1) ? MSBFirst : LSBFirst;
}

50
src/launcher/xsettings-common.h
View File

@@ -36,48 +36,48 @@ typedef struct _XSettingsSetting XSettingsSetting;
* protocol values.
*/
typedef enum {
XSETTINGS_TYPE_INT = 0,
XSETTINGS_TYPE_STRING = 1,
XSETTINGS_TYPE_COLOR = 2,
XSETTINGS_TYPE_NONE = 0xff
XSETTINGS_TYPE_INT = 0,
XSETTINGS_TYPE_STRING = 1,
XSETTINGS_TYPE_COLOR = 2,
XSETTINGS_TYPE_NONE = 0xff
} XSettingsType;
typedef enum {
XSETTINGS_SUCCESS,
XSETTINGS_NO_MEM,
XSETTINGS_ACCESS,
XSETTINGS_FAILED,
XSETTINGS_NO_ENTRY,
XSETTINGS_DUPLICATE_ENTRY
XSETTINGS_SUCCESS,
XSETTINGS_NO_MEM,
XSETTINGS_ACCESS,
XSETTINGS_FAILED,
XSETTINGS_NO_ENTRY,
XSETTINGS_DUPLICATE_ENTRY
} XSettingsResult;
struct _XSettingsBuffer {
char byte_order;
size_t len;
unsigned char *data;
unsigned char *pos;
char byte_order;
size_t len;
unsigned char *data;
unsigned char *pos;
};
struct _XSettingsColor {
unsigned short red, green, blue, alpha;
unsigned short red, green, blue, alpha;
};
struct _XSettingsList {
XSettingsSetting *setting;
XSettingsList *next;
XSettingsSetting *setting;
XSettingsList *next;
};
struct _XSettingsSetting {
char *name;
XSettingsType type;
char *name;
XSettingsType type;
union {
int v_int;
char *v_string;
XSettingsColor v_color;
} data;
union {
int v_int;
char *v_string;
XSettingsColor v_color;
} data;
unsigned long last_change_serial;
unsigned long last_change_serial;
};
XSettingsSetting *xsettings_setting_copy(XSettingsSetting *setting);

1706
src/panel.c
View File

File diff suppressed because it is too large Load Diff

102
src/panel.h
View File

@@ -42,29 +42,29 @@ extern MouseAction mouse_tilt_right;
// panel mode
typedef enum TaskbarMode {
SINGLE_DESKTOP = 0,
MULTI_DESKTOP,
SINGLE_DESKTOP = 0,
MULTI_DESKTOP,
} TaskbarMode;
typedef enum Layer {
BOTTOM_LAYER,
NORMAL_LAYER,
TOP_LAYER,
BOTTOM_LAYER,
NORMAL_LAYER,
TOP_LAYER,
} Layer;
// panel position
typedef enum PanelPosition {
LEFT = 0x01,
RIGHT = 0x02,
CENTER = 0X04,
TOP = 0X08,
BOTTOM = 0x10,
LEFT = 0x01,
RIGHT = 0x02,
CENTER = 0X04,
TOP = 0X08,
BOTTOM = 0x10,
} PanelPosition;
typedef enum Strut {
STRUT_MINIMUM,
STRUT_FOLLOW_SIZE,
STRUT_NONE,
STRUT_MINIMUM,
STRUT_FOLLOW_SIZE,
STRUT_NONE,
} Strut;
extern TaskbarMode taskbar_mode;
@@ -95,54 +95,54 @@ extern gboolean debug_fps;
extern gboolean debug_frames;
typedef struct Panel {
Area area;
Area area;
Window main_win;
Pixmap temp_pmap;
Window main_win;
Pixmap temp_pmap;
// position relative to root window
int posx, posy;
int marginx, marginy;
gboolean fractional_width, fractional_height;
int max_size;
int monitor;
int font_shadow;
gboolean mouse_effects;
// Mouse effects for icons
int mouse_over_alpha;
int mouse_over_saturation;
int mouse_over_brightness;
int mouse_pressed_alpha;
int mouse_pressed_saturation;
int mouse_pressed_brightness;
// position relative to root window
int posx, posy;
int marginx, marginy;
gboolean fractional_width, fractional_height;
int max_size;
int monitor;
int font_shadow;
gboolean mouse_effects;
// Mouse effects for icons
int mouse_over_alpha;
int mouse_over_saturation;
int mouse_over_brightness;
int mouse_pressed_alpha;
int mouse_pressed_saturation;
int mouse_pressed_brightness;
// Per-panel parameters and states for Taskbar and Task
GlobalTaskbar g_taskbar;
GlobalTask g_task;
// Per-panel parameters and states for Taskbar and Task
GlobalTaskbar g_taskbar;
GlobalTask g_task;
// Array of Taskbar, with num_desktops items
Taskbar *taskbar;
int num_desktops;
gboolean taskbarname_has_font;
PangoFontDescription *taskbarname_font_desc;
// Array of Taskbar, with num_desktops items
Taskbar *taskbar;
int num_desktops;
gboolean taskbarname_has_font;
PangoFontDescription *taskbarname_font_desc;
Clock clock;
Clock clock;
#ifdef ENABLE_BATTERY
Battery battery;
Battery battery;
#endif
Launcher launcher;
GList *freespace_list;
GList *separator_list;
GList *execp_list;
GList *button_list;
Launcher launcher;
GList *freespace_list;
GList *separator_list;
GList *execp_list;
GList *button_list;
// Autohide
gboolean is_hidden;
int hidden_width, hidden_height;
Pixmap hidden_pixmap;
timeout *autohide_timeout;
// Autohide
gboolean is_hidden;
int hidden_width, hidden_height;
Pixmap hidden_pixmap;
timeout *autohide_timeout;
} Panel;
extern Panel panel_config;

306
src/separator/separator.c
View File

@@ -19,132 +19,132 @@ int separator_compute_desired_size(void *obj);
Separator *create_separator()
{
Separator *separator = (Separator *)calloc(1, sizeof(Separator));
separator->color.rgb[0] = 0.5;
separator->color.rgb[1] = 0.5;
separator->color.rgb[2] = 0.5;
separator->color.alpha = 0.9;
separator->style = SEPARATOR_DOTS;
separator->thickness = 3;
separator->area.paddingxlr = 1;
return separator;
Separator *separator = (Separator *)calloc(1, sizeof(Separator));
separator->color.rgb[0] = 0.5;
separator->color.rgb[1] = 0.5;
separator->color.rgb[2] = 0.5;
separator->color.alpha = 0.9;
separator->style = SEPARATOR_DOTS;
separator->thickness = 3;
separator->area.paddingxlr = 1;
return separator;
}
void destroy_separator(void *obj)
{
Separator *separator = (Separator *)obj;
remove_area(&separator->area);
free_area(&separator->area);
free_and_null(separator);
Separator *separator = (Separator *)obj;
remove_area(&separator->area);
free_area(&separator->area);
free_and_null(separator);
}
gpointer copy_separator(gconstpointer arg, gpointer data)
{
Separator *old = (Separator *)arg;
Separator *copy = (Separator *)calloc(1, sizeof(Separator));
memcpy(copy, old, sizeof(Separator));
return copy;
Separator *old = (Separator *)arg;
Separator *copy = (Separator *)calloc(1, sizeof(Separator));
memcpy(copy, old, sizeof(Separator));
return copy;
}
void init_separator()
{
GList *to_remove = panel_config.separator_list;
for (int k = 0; k < strlen(panel_items_order) && to_remove; k++) {
if (panel_items_order[k] == ':') {
to_remove = to_remove->next;
}
}
GList *to_remove = panel_config.separator_list;
for (int k = 0; k < strlen(panel_items_order) && to_remove; k++) {
if (panel_items_order[k] == ':') {
to_remove = to_remove->next;
}
}
if (to_remove) {
if (to_remove == panel_config.separator_list) {
g_list_free_full(to_remove, destroy_separator);
panel_config.separator_list = NULL;
} else {
// Cut panel_config.separator_list
if (to_remove->prev)
to_remove->prev->next = NULL;
to_remove->prev = NULL;
// Remove all elements of to_remove and to_remove itself
g_list_free_full(to_remove, destroy_separator);
}
}
if (to_remove) {
if (to_remove == panel_config.separator_list) {
g_list_free_full(to_remove, destroy_separator);
panel_config.separator_list = NULL;
} else {
// Cut panel_config.separator_list
if (to_remove->prev)
to_remove->prev->next = NULL;
to_remove->prev = NULL;
// Remove all elements of to_remove and to_remove itself
g_list_free_full(to_remove, destroy_separator);
}
}
}
void init_separator_panel(void *p)
{
Panel *panel = (Panel *)p;
Panel *panel = (Panel *)p;
// Make sure this is only done once if there are multiple items
if (panel->separator_list)
return;
// Make sure this is only done once if there are multiple items
if (panel->separator_list)
return;
// panel->separator_list is now a copy of the pointer panel_config.separator_list
// We make it a deep copy
panel->separator_list = g_list_copy_deep(panel_config.separator_list, copy_separator, NULL);
// panel->separator_list is now a copy of the pointer panel_config.separator_list
// We make it a deep copy
panel->separator_list = g_list_copy_deep(panel_config.separator_list, copy_separator, NULL);
for (GList *l = panel->separator_list; l; l = l->next) {
Separator *separator = (Separator *)l->data;
if (!separator->area.bg)
separator->area.bg = &g_array_index(backgrounds, Background, 0);
separator->area.parent = p;
separator->area.panel = p;
snprintf(separator->area.name, sizeof(separator->area.name), "separator");
separator->area.size_mode = LAYOUT_FIXED;
separator->area.resize_needed = 1;
separator->area.on_screen = TRUE;
separator->area._resize = resize_separator;
separator->area._compute_desired_size = separator_compute_desired_size;
separator->area._draw_foreground = draw_separator;
instantiate_area_gradients(&separator->area);
}
for (GList *l = panel->separator_list; l; l = l->next) {
Separator *separator = (Separator *)l->data;
if (!separator->area.bg)
separator->area.bg = &g_array_index(backgrounds, Background, 0);
separator->area.parent = p;
separator->area.panel = p;
snprintf(separator->area.name, sizeof(separator->area.name), "separator");
separator->area.size_mode = LAYOUT_FIXED;
separator->area.resize_needed = 1;
separator->area.on_screen = TRUE;
separator->area._resize = resize_separator;
separator->area._compute_desired_size = separator_compute_desired_size;
separator->area._draw_foreground = draw_separator;
instantiate_area_gradients(&separator->area);
}
}
void cleanup_separator()
{
// Cleanup frontends
for (int i = 0; i < num_panels; i++) {
g_list_free_full(panels[i].separator_list, destroy_separator);
panels[i].separator_list = NULL;
}
// Cleanup frontends
for (int i = 0; i < num_panels; i++) {
g_list_free_full(panels[i].separator_list, destroy_separator);
panels[i].separator_list = NULL;
}
// Cleanup backends
g_list_free_full(panel_config.separator_list, destroy_separator);
panel_config.separator_list = NULL;
// Cleanup backends
g_list_free_full(panel_config.separator_list, destroy_separator);
panel_config.separator_list = NULL;
}
int separator_compute_desired_size(void *obj)
{
Separator *separator = (Separator *)obj;
if (!separator->area.on_screen)
return 0;
Separator *separator = (Separator *)obj;
if (!separator->area.on_screen)
return 0;
if (panel_horizontal)
return separator->thickness + 2 * separator->area.paddingxlr + left_right_border_width(&separator->area);
else
return separator->thickness + 2 * separator->area.paddingxlr + top_bottom_border_width(&separator->area);
if (panel_horizontal)
return separator->thickness + 2 * separator->area.paddingxlr + left_right_border_width(&separator->area);
else
return separator->thickness + 2 * separator->area.paddingxlr + top_bottom_border_width(&separator->area);
}
gboolean resize_separator(void *obj)
{
Separator *separator = (Separator *)obj;
if (!separator->area.on_screen)
return FALSE;
Separator *separator = (Separator *)obj;
if (!separator->area.on_screen)
return FALSE;
if (panel_horizontal) {
separator->area.width =
separator->thickness + 2 * separator->area.paddingxlr + left_right_border_width(&separator->area);
separator->length =
separator->area.height - 2 * separator->area.paddingy - top_bottom_border_width(&separator->area);
} else {
separator->area.height =
separator->thickness + 2 * separator->area.paddingxlr + top_bottom_border_width(&separator->area);
separator->length =
separator->area.width - 2 * separator->area.paddingy - left_right_border_width(&separator->area);
}
if (panel_horizontal) {
separator->area.width =
separator->thickness + 2 * separator->area.paddingxlr + left_right_border_width(&separator->area);
separator->length =
separator->area.height - 2 * separator->area.paddingy - top_bottom_border_width(&separator->area);
} else {
separator->area.height =
separator->thickness + 2 * separator->area.paddingxlr + top_bottom_border_width(&separator->area);
separator->length =
separator->area.width - 2 * separator->area.paddingy - left_right_border_width(&separator->area);
}
schedule_redraw(&separator->area);
schedule_panel_redraw();
return TRUE;
schedule_redraw(&separator->area);
schedule_panel_redraw();
return TRUE;
}
void draw_separator_line(void *obj, cairo_t *c);
@@ -152,80 +152,80 @@ void draw_separator_dots(void *obj, cairo_t *c);
void draw_separator(void *obj, cairo_t *c)
{
Separator *separator = (Separator *)obj;
Separator *separator = (Separator *)obj;
if (separator->style == SEPARATOR_EMPTY)
return;
else if (separator->style == SEPARATOR_LINE)
draw_separator_line(separator, c);
else if (separator->style == SEPARATOR_DOTS)
draw_separator_dots(separator, c);
if (separator->style == SEPARATOR_EMPTY)
return;
else if (separator->style == SEPARATOR_LINE)
draw_separator_line(separator, c);
else if (separator->style == SEPARATOR_DOTS)
draw_separator_dots(separator, c);
}
void draw_separator_line(void *obj, cairo_t *c)
{
Separator *separator = (Separator *)obj;
Separator *separator = (Separator *)obj;
if (separator->thickness <= 0)
return;
if (separator->thickness <= 0)
return;
cairo_set_source_rgba(c,
separator->color.rgb[0],
separator->color.rgb[1],
separator->color.rgb[2],
separator->color.alpha);
cairo_set_line_width(c, separator->thickness);
cairo_set_line_cap(c, CAIRO_LINE_CAP_ROUND);
if (panel_horizontal) {
cairo_move_to(c, separator->area.width / 2.0, separator->area.height / 2.0 - separator->length / 2.0);
cairo_line_to(c, separator->area.width / 2.0, separator->area.height / 2.0 + separator->length / 2.0);
} else {
cairo_move_to(c, separator->area.width / 2.0 - separator->length / 2.0, separator->area.height / 2.0);
cairo_line_to(c, separator->area.width / 2.0 + separator->length / 2.0, separator->area.height / 2.0);
}
cairo_stroke(c);
cairo_set_source_rgba(c,
separator->color.rgb[0],
separator->color.rgb[1],
separator->color.rgb[2],
separator->color.alpha);
cairo_set_line_width(c, separator->thickness);
cairo_set_line_cap(c, CAIRO_LINE_CAP_ROUND);
if (panel_horizontal) {
cairo_move_to(c, separator->area.width / 2.0, separator->area.height / 2.0 - separator->length / 2.0);
cairo_line_to(c, separator->area.width / 2.0, separator->area.height / 2.0 + separator->length / 2.0);
} else {
cairo_move_to(c, separator->area.width / 2.0 - separator->length / 2.0, separator->area.height / 2.0);
cairo_line_to(c, separator->area.width / 2.0 + separator->length / 2.0, separator->area.height / 2.0);
}
cairo_stroke(c);
}
void draw_separator_dots(void *obj, cairo_t *c)
{
const double PI = 3.14159265359;
Separator *separator = (Separator *)obj;
if (separator->thickness <= 0)
return;
const double PI = 3.14159265359;
Separator *separator = (Separator *)obj;
if (separator->thickness <= 0)
return;
cairo_set_source_rgba(c,
separator->color.rgb[0],
separator->color.rgb[1],
separator->color.rgb[2],
separator->color.alpha);
cairo_set_line_width(c, 0);
cairo_set_source_rgba(c,
separator->color.rgb[0],
separator->color.rgb[1],
separator->color.rgb[2],
separator->color.alpha);
cairo_set_line_width(c, 0);
int num_circles = separator->length / (1.618 * separator->thickness - 1);
double spacing = (separator->length - num_circles * separator->thickness) / MAX(1.0, num_circles - 1.0);
if (spacing > separator->thickness)
num_circles++;
spacing = (separator->length - num_circles * separator->thickness) / MAX(1.0, num_circles - 1.0);
double offset = (panel_horizontal ? separator->area.height : separator->area.width) / 2.0 - separator->length / 2.0;
if (num_circles == 1)
offset += spacing / 2.0;
for (int i = 0; i < num_circles; i++) {
if (panel_horizontal) {
cairo_arc(c,
separator->area.width / 2.0,
offset + separator->thickness / 2.0,
separator->thickness / 2.0,
0,
2 * PI);
} else {
cairo_arc(c,
offset + separator->thickness / 2.0,
separator->area.height / 2.0,
separator->thickness / 2.0,
0,
2 * PI);
}
cairo_stroke_preserve(c);
cairo_fill(c);
offset += separator->thickness + spacing;
}
int num_circles = separator->length / (1.618 * separator->thickness - 1);
double spacing = (separator->length - num_circles * separator->thickness) / MAX(1.0, num_circles - 1.0);
if (spacing > separator->thickness)
num_circles++;
spacing = (separator->length - num_circles * separator->thickness) / MAX(1.0, num_circles - 1.0);
double offset = (panel_horizontal ? separator->area.height : separator->area.width) / 2.0 - separator->length / 2.0;
if (num_circles == 1)
offset += spacing / 2.0;
for (int i = 0; i < num_circles; i++) {
if (panel_horizontal) {
cairo_arc(c,
separator->area.width / 2.0,
offset + separator->thickness / 2.0,
separator->thickness / 2.0,
0,
2 * PI);
} else {
cairo_arc(c,
offset + separator->thickness / 2.0,
separator->area.height / 2.0,
separator->thickness / 2.0,
0,
2 * PI);
}
cairo_stroke_preserve(c);
cairo_fill(c);
offset += separator->thickness + spacing;
}
}

16
src/separator/separator.h
View File

@@ -7,18 +7,14 @@
#include "common.h"
#include "area.h"
typedef enum SeparatorStyle {
SEPARATOR_EMPTY = 0,
SEPARATOR_LINE,
SEPARATOR_DOTS
} SeparatorStyle;
typedef enum SeparatorStyle { SEPARATOR_EMPTY = 0, SEPARATOR_LINE, SEPARATOR_DOTS } SeparatorStyle;
typedef struct Separator {
Area area;
SeparatorStyle style;
Color color;
int thickness;
int length;
Area area;
SeparatorStyle style;
Color color;
int thickness;
int length;
} Separator;
Separator *create_separator();

916
src/server.c
View File

File diff suppressed because it is too large Load Diff

214
src/server.h
View File

@@ -21,123 +21,123 @@
extern gboolean primary_monitor_first;
typedef struct Global_atom {
Atom _XROOTPMAP_ID;
Atom _XROOTMAP_ID;
Atom _NET_CURRENT_DESKTOP;
Atom _NET_NUMBER_OF_DESKTOPS;
Atom _NET_DESKTOP_NAMES;
Atom _NET_DESKTOP_GEOMETRY;
Atom _NET_DESKTOP_VIEWPORT;
Atom _NET_WORKAREA;
Atom _NET_ACTIVE_WINDOW;
Atom _NET_WM_WINDOW_TYPE;
Atom _NET_WM_STATE_SKIP_PAGER;
Atom _NET_WM_STATE_SKIP_TASKBAR;
Atom _NET_WM_STATE_STICKY;
Atom _NET_WM_STATE_DEMANDS_ATTENTION;
Atom _NET_WM_WINDOW_TYPE_DOCK;
Atom _NET_WM_WINDOW_TYPE_DESKTOP;
Atom _NET_WM_WINDOW_TYPE_TOOLBAR;
Atom _NET_WM_WINDOW_TYPE_MENU;
Atom _NET_WM_WINDOW_TYPE_SPLASH;
Atom _NET_WM_WINDOW_TYPE_DIALOG;
Atom _NET_WM_WINDOW_TYPE_NORMAL;
Atom _NET_WM_DESKTOP;
Atom WM_STATE;
Atom _NET_WM_STATE;
Atom _NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_SHADED;
Atom _NET_WM_STATE_HIDDEN;
Atom _NET_WM_STATE_BELOW;
Atom _NET_WM_STATE_ABOVE;
Atom _NET_WM_STATE_MODAL;
Atom _NET_CLIENT_LIST;
Atom _NET_WM_NAME;
Atom _NET_WM_VISIBLE_NAME;
Atom _NET_WM_STRUT;
Atom _NET_WM_ICON;
Atom _NET_WM_ICON_GEOMETRY;
Atom _NET_WM_ICON_NAME;
Atom _NET_CLOSE_WINDOW;
Atom UTF8_STRING;
Atom _NET_SUPPORTING_WM_CHECK;
Atom _NET_WM_CM_S0;
Atom _NET_WM_STRUT_PARTIAL;
Atom WM_NAME;
Atom __SWM_VROOT;
Atom _MOTIF_WM_HINTS;
Atom WM_HINTS;
Atom _NET_SYSTEM_TRAY_SCREEN;
Atom _NET_SYSTEM_TRAY_OPCODE;
Atom MANAGER;
Atom _NET_SYSTEM_TRAY_MESSAGE_DATA;
Atom _NET_SYSTEM_TRAY_ORIENTATION;
Atom _NET_SYSTEM_TRAY_ICON_SIZE;
Atom _NET_SYSTEM_TRAY_PADDING;
Atom _XEMBED;
Atom _XEMBED_INFO;
Atom _NET_WM_PID;
Atom _XSETTINGS_SCREEN;
Atom _XSETTINGS_SETTINGS;
Atom XdndAware;
Atom XdndEnter;
Atom XdndPosition;
Atom XdndStatus;
Atom XdndDrop;
Atom XdndLeave;
Atom XdndSelection;
Atom XdndTypeList;
Atom XdndActionCopy;
Atom XdndFinished;
Atom TARGETS;
Atom _XROOTPMAP_ID;
Atom _XROOTMAP_ID;
Atom _NET_CURRENT_DESKTOP;
Atom _NET_NUMBER_OF_DESKTOPS;
Atom _NET_DESKTOP_NAMES;
Atom _NET_DESKTOP_GEOMETRY;
Atom _NET_DESKTOP_VIEWPORT;
Atom _NET_WORKAREA;
Atom _NET_ACTIVE_WINDOW;
Atom _NET_WM_WINDOW_TYPE;
Atom _NET_WM_STATE_SKIP_PAGER;
Atom _NET_WM_STATE_SKIP_TASKBAR;
Atom _NET_WM_STATE_STICKY;
Atom _NET_WM_STATE_DEMANDS_ATTENTION;
Atom _NET_WM_WINDOW_TYPE_DOCK;
Atom _NET_WM_WINDOW_TYPE_DESKTOP;
Atom _NET_WM_WINDOW_TYPE_TOOLBAR;
Atom _NET_WM_WINDOW_TYPE_MENU;
Atom _NET_WM_WINDOW_TYPE_SPLASH;
Atom _NET_WM_WINDOW_TYPE_DIALOG;
Atom _NET_WM_WINDOW_TYPE_NORMAL;
Atom _NET_WM_DESKTOP;
Atom WM_STATE;
Atom _NET_WM_STATE;
Atom _NET_WM_STATE_MAXIMIZED_VERT;
Atom _NET_WM_STATE_MAXIMIZED_HORZ;
Atom _NET_WM_STATE_SHADED;
Atom _NET_WM_STATE_HIDDEN;
Atom _NET_WM_STATE_BELOW;
Atom _NET_WM_STATE_ABOVE;
Atom _NET_WM_STATE_MODAL;
Atom _NET_CLIENT_LIST;
Atom _NET_WM_NAME;
Atom _NET_WM_VISIBLE_NAME;
Atom _NET_WM_STRUT;
Atom _NET_WM_ICON;
Atom _NET_WM_ICON_GEOMETRY;
Atom _NET_WM_ICON_NAME;
Atom _NET_CLOSE_WINDOW;
Atom UTF8_STRING;
Atom _NET_SUPPORTING_WM_CHECK;
Atom _NET_WM_CM_S0;
Atom _NET_WM_STRUT_PARTIAL;
Atom WM_NAME;
Atom __SWM_VROOT;
Atom _MOTIF_WM_HINTS;
Atom WM_HINTS;
Atom _NET_SYSTEM_TRAY_SCREEN;
Atom _NET_SYSTEM_TRAY_OPCODE;
Atom MANAGER;
Atom _NET_SYSTEM_TRAY_MESSAGE_DATA;
Atom _NET_SYSTEM_TRAY_ORIENTATION;
Atom _NET_SYSTEM_TRAY_ICON_SIZE;
Atom _NET_SYSTEM_TRAY_PADDING;
Atom _XEMBED;
Atom _XEMBED_INFO;
Atom _NET_WM_PID;
Atom _XSETTINGS_SCREEN;
Atom _XSETTINGS_SETTINGS;
Atom XdndAware;
Atom XdndEnter;
Atom XdndPosition;
Atom XdndStatus;
Atom XdndDrop;
Atom XdndLeave;
Atom XdndSelection;
Atom XdndTypeList;
Atom XdndActionCopy;
Atom XdndFinished;
Atom TARGETS;
} Global_atom;
typedef struct Monitor {
int x;
int y;
int width;
int height;
gboolean primary;
gchar **names;
int x;
int y;
int width;
int height;
gboolean primary;
gchar **names;
} Monitor;
typedef struct Viewport {
int x;
int y;
int width;
int height;
int x;
int y;
int width;
int height;
} Viewport;
typedef struct Server {
Display *display;
Window root_win;
Window composite_manager;
gboolean real_transparency;
gboolean disable_transparency;
// current desktop
int desktop;
int screen;
int depth;
int num_desktops;
// number of monitor (without monitor included into another one)
int num_monitors;
// Non-null only if WM uses viewports (compiz) and number of viewports > 1.
// In that case there are num_desktops viewports.
Viewport *viewports;
Monitor *monitors;
gboolean got_root_win;
Visual *visual;
Visual *visual32;
// root background
Pixmap root_pmap;
GC gc;
Colormap colormap;
Colormap colormap32;
Global_atom atom;
Display *display;
Window root_win;
Window composite_manager;
gboolean real_transparency;
gboolean disable_transparency;
// current desktop
int desktop;
int screen;
int depth;
int num_desktops;
// number of monitor (without monitor included into another one)
int num_monitors;
// Non-null only if WM uses viewports (compiz) and number of viewports > 1.
// In that case there are num_desktops viewports.
Viewport *viewports;
Monitor *monitors;
gboolean got_root_win;
Visual *visual;
Visual *visual32;
// root background
Pixmap root_pmap;
GC gc;
Colormap colormap;
Colormap colormap32;
Global_atom atom;
#ifdef HAVE_SN
SnDisplay *sn_display;
GTree *pids;
SnDisplay *sn_display;
GTree *pids;
#endif // HAVE_SN
} Server;

2519
src/systray/systraybar.c
View File

File diff suppressed because it is too large Load Diff

74
src/systray/systraybar.h
View File

@@ -21,50 +21,50 @@
#define XEMBED_MAPPED (1 << 0)
typedef enum SystraySortMethod {
SYSTRAY_SORT_ASCENDING = 0,
SYSTRAY_SORT_DESCENDING,
SYSTRAY_SORT_LEFT2RIGHT,
SYSTRAY_SORT_RIGHT2LEFT,
SYSTRAY_SORT_ASCENDING = 0,
SYSTRAY_SORT_DESCENDING,
SYSTRAY_SORT_LEFT2RIGHT,
SYSTRAY_SORT_RIGHT2LEFT,
} SystraySortMethod;
typedef struct {
// always start with area
Area area;
// always start with area
Area area;
GSList *list_icons;
SystraySortMethod sort;
int alpha, saturation, brightness;
int icon_size, icons_per_column, icons_per_row, margin;
GSList *list_icons;
SystraySortMethod sort;
int alpha, saturation, brightness;
int icon_size, icons_per_column, icons_per_row, margin;
} Systray;
typedef struct {
// The actual tray icon window (created by the application)
Window win;
// The parent window created by tint2 to embed the icon
Window parent;
int x, y;
int width, height;
int depth;
gboolean reparented;
gboolean embedded;
// Process PID or zero.
int pid;
// A number that is incremented for each new icon, used to sort them by the order in which they were created.
int chrono;
// Name of the tray icon window.
char *name;
// Members used for rendering
struct timespec time_last_render;
int num_fast_renders;
timeout *render_timeout;
// Members used for resizing
int bad_size_counter;
struct timespec time_last_resize;
timeout *resize_timeout;
// Icon contents if we are compositing the icon, otherwise null
Imlib_Image image;
// XDamage
Damage damage;
// The actual tray icon window (created by the application)
Window win;
// The parent window created by tint2 to embed the icon
Window parent;
int x, y;
int width, height;
int depth;
gboolean reparented;
gboolean embedded;
// Process PID or zero.
int pid;
// A number that is incremented for each new icon, used to sort them by the order in which they were created.
int chrono;
// Name of the tray icon window.
char *name;
// Members used for rendering
struct timespec time_last_render;
int num_fast_renders;
timeout *render_timeout;
// Members used for resizing
int bad_size_counter;
struct timespec time_last_resize;
timeout *resize_timeout;
// Icon contents if we are compositing the icon, otherwise null
Imlib_Image image;
// XDamage
Damage damage;
} TrayWindow;
// net_sel_win != None when protocol started

1068
src/taskbar/task.c
View File

File diff suppressed because it is too large Load Diff

100
src/taskbar/task.h
View File

@@ -14,65 +14,65 @@
#include "timer.h"
typedef enum TaskState {
TASK_NORMAL = 0,
TASK_ACTIVE,
TASK_ICONIFIED,
TASK_URGENT,
TASK_UNDEFINED,
TASK_STATE_COUNT,
TASK_NORMAL = 0,
TASK_ACTIVE,
TASK_ICONIFIED,
TASK_URGENT,
TASK_UNDEFINED,
TASK_STATE_COUNT,
} TaskState;
typedef struct GlobalTask {
Area area;
gboolean has_text;
gboolean has_icon;
gboolean centered;
int icon_posy;
int icon_size1;
int maximum_width;
int maximum_height;
int alpha[TASK_STATE_COUNT];
int saturation[TASK_STATE_COUNT];
int brightness[TASK_STATE_COUNT];
int config_asb_mask;
Background *background[TASK_STATE_COUNT];
GList *gradient[TASK_STATE_COUNT];
int config_background_mask;
// starting position for text ~ task_padding + task_border + icon_size
double text_posx, text_height;
gboolean has_font;
PangoFontDescription *font_desc;
Color font[TASK_STATE_COUNT];
int config_font_mask;
gboolean tooltip_enabled;
Area area;
gboolean has_text;
gboolean has_icon;
gboolean centered;
int icon_posy;
int icon_size1;
int maximum_width;
int maximum_height;
int alpha[TASK_STATE_COUNT];
int saturation[TASK_STATE_COUNT];
int brightness[TASK_STATE_COUNT];
int config_asb_mask;
Background *background[TASK_STATE_COUNT];
GList *gradient[TASK_STATE_COUNT];
int config_background_mask;
// starting position for text ~ task_padding + task_border + icon_size
double text_posx, text_height;
gboolean has_font;
PangoFontDescription *font_desc;
Color font[TASK_STATE_COUNT];
int config_font_mask;
gboolean tooltip_enabled;
} GlobalTask;
// Stores information about a task.
// Warning: any dynamically allocated members are shared between the Task instances created for the same window
// (if the task appears on all desktops, there will be a different instance on each desktop's taskbar).
typedef struct Task {
Area area;
Window win;
int desktop;
TaskState current_state;
Imlib_Image icon[TASK_STATE_COUNT];
Imlib_Image icon_hover[TASK_STATE_COUNT];
Imlib_Image icon_press[TASK_STATE_COUNT];
unsigned int icon_width;
unsigned int icon_height;
char *title;
int urgent_tick;
// These may not be up-to-date
int win_x;
int win_y;
int win_w;
int win_h;
struct timespec last_activation_time;
int _text_width;
int _text_height;
double _text_posy;
int _icon_x;
int _icon_y;
Area area;
Window win;
int desktop;
TaskState current_state;
Imlib_Image icon[TASK_STATE_COUNT];
Imlib_Image icon_hover[TASK_STATE_COUNT];
Imlib_Image icon_press[TASK_STATE_COUNT];
unsigned int icon_width;
unsigned int icon_height;
char *title;
int urgent_tick;
// These may not be up-to-date
int win_x;
int win_y;
int win_w;
int win_h;
struct timespec last_activation_time;
int _text_width;
int _text_height;
double _text_posy;
int _icon_x;
int _icon_y;
} Task;
extern timeout *urgent_timeout;

977
src/taskbar/taskbar.c
View File

File diff suppressed because it is too large Load Diff

42
src/taskbar/taskbar.h
View File

@@ -12,39 +12,39 @@
#include "taskbarname.h"
typedef enum TaskbarState {
TASKBAR_NORMAL = 0,
TASKBAR_ACTIVE,
TASKBAR_STATE_COUNT,
TASKBAR_NORMAL = 0,
TASKBAR_ACTIVE,
TASKBAR_STATE_COUNT,
} TaskbarState;
typedef enum TaskbarSortMethod {
TASKBAR_NOSORT = 0,
TASKBAR_SORT_CENTER,
TASKBAR_SORT_TITLE,
TASKBAR_SORT_LRU,
TASKBAR_SORT_MRU,
TASKBAR_NOSORT = 0,
TASKBAR_SORT_CENTER,
TASKBAR_SORT_TITLE,
TASKBAR_SORT_LRU,
TASKBAR_SORT_MRU,
} TaskbarSortMethod;
typedef struct {
Area area;
gchar *name;
int posy;
Area area;
gchar *name;
int posy;
} TaskbarName;
typedef struct {
Area area;
int desktop;
TaskbarName bar_name;
int text_width;
Area area;
int desktop;
TaskbarName bar_name;
int text_width;
} Taskbar;
typedef struct GlobalTaskbar {
Area area;
Area area_name;
Background *background[TASKBAR_STATE_COUNT];
Background *background_name[TASKBAR_STATE_COUNT];
GList *gradient[TASKBAR_STATE_COUNT];
GList *gradient_name[TASKBAR_STATE_COUNT];
Area area;
Area area_name;
Background *background[TASKBAR_STATE_COUNT];
Background *background_name[TASKBAR_STATE_COUNT];
GList *gradient[TASKBAR_STATE_COUNT];
GList *gradient_name[TASKBAR_STATE_COUNT];
} GlobalTaskbar;
extern gboolean taskbar_enabled;

258
src/taskbar/taskbarname.c
View File

@@ -41,176 +41,176 @@ int taskbarname_compute_desired_size(void *obj);
void default_taskbarname()
{
taskbarname_enabled = FALSE;
taskbarname_enabled = FALSE;
}
void init_taskbarname_panel(void *p)
{
if (!taskbarname_enabled)
return;
if (!taskbarname_enabled)
return;
Panel *panel = (Panel *)p;
Panel *panel = (Panel *)p;
taskbarname_init_fonts();
taskbarname_init_fonts();
GSList *list = get_desktop_names();
GSList *l = list;
for (int j = 0; j < panel->num_desktops; j++) {
Taskbar *taskbar = &panel->taskbar[j];
memcpy(&taskbar->bar_name.area, &panel->g_taskbar.area_name, sizeof(Area));
taskbar->bar_name.area.parent = taskbar;
taskbar->bar_name.area.has_mouse_over_effect = panel_config.mouse_effects;
taskbar->bar_name.area.has_mouse_press_effect = panel_config.mouse_effects;
taskbar->bar_name.area._compute_desired_size = taskbarname_compute_desired_size;
if (j == server.desktop) {
taskbar->bar_name.area.bg = panel->g_taskbar.background_name[TASKBAR_ACTIVE];
} else {
taskbar->bar_name.area.bg = panel->g_taskbar.background_name[TASKBAR_NORMAL];
}
GSList *list = get_desktop_names();
GSList *l = list;
for (int j = 0; j < panel->num_desktops; j++) {
Taskbar *taskbar = &panel->taskbar[j];
memcpy(&taskbar->bar_name.area, &panel->g_taskbar.area_name, sizeof(Area));
taskbar->bar_name.area.parent = taskbar;
taskbar->bar_name.area.has_mouse_over_effect = panel_config.mouse_effects;
taskbar->bar_name.area.has_mouse_press_effect = panel_config.mouse_effects;
taskbar->bar_name.area._compute_desired_size = taskbarname_compute_desired_size;
if (j == server.desktop) {
taskbar->bar_name.area.bg = panel->g_taskbar.background_name[TASKBAR_ACTIVE];
} else {
taskbar->bar_name.area.bg = panel->g_taskbar.background_name[TASKBAR_NORMAL];
}
// use desktop number if name is missing
if (l) {
taskbar->bar_name.name = g_strdup(l->data);
l = l->next;
} else {
taskbar->bar_name.name = g_strdup_printf("%d", j + 1);
}
// use desktop number if name is missing
if (l) {
taskbar->bar_name.name = g_strdup(l->data);
l = l->next;
} else {
taskbar->bar_name.name = g_strdup_printf("%d", j + 1);
}
// append the name at the beginning of taskbar
taskbar->area.children = g_list_append(taskbar->area.children, &taskbar->bar_name);
instantiate_area_gradients(&taskbar->bar_name.area);
}
// append the name at the beginning of taskbar
taskbar->area.children = g_list_append(taskbar->area.children, &taskbar->bar_name);