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);
instantiate_area_gradients(&taskbar->bar_name.area);
}
for (l = list; l; l = l->next)
g_free(l->data);
g_slist_free(list);
for (l = list; l; l = l->next)
g_free(l->data);
g_slist_free(list);
}
void taskbarname_init_fonts()
{
if (!panel_config.taskbarname_font_desc) {
panel_config.taskbarname_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_weight(panel_config.taskbarname_font_desc, PANGO_WEIGHT_BOLD);
}
if (!panel_config.taskbarname_font_desc) {
panel_config.taskbarname_font_desc = pango_font_description_from_string(get_default_font());
pango_font_description_set_weight(panel_config.taskbarname_font_desc, PANGO_WEIGHT_BOLD);
}
}
void taskbarname_default_font_changed()
{
if (!taskbar_enabled)
return;
if (!taskbarname_enabled)
return;
if (panel_config.taskbarname_has_font)
return;
if (!taskbar_enabled)
return;
if (!taskbarname_enabled)
return;
if (panel_config.taskbarname_has_font)
return;
pango_font_description_free(panel_config.taskbarname_font_desc);
panel_config.taskbarname_font_desc = NULL;
taskbarname_init_fonts();
for (int i = 0; i < num_panels; i++) {
for (int j = 0; j < panels[i].num_desktops; j++) {
Taskbar *taskbar = &panels[i].taskbar[j];
taskbar->bar_name.area.resize_needed = TRUE;
schedule_redraw(&taskbar->bar_name.area);
}
}
schedule_panel_redraw();
pango_font_description_free(panel_config.taskbarname_font_desc);
panel_config.taskbarname_font_desc = NULL;
taskbarname_init_fonts();
for (int i = 0; i < num_panels; i++) {
for (int j = 0; j < panels[i].num_desktops; j++) {
Taskbar *taskbar = &panels[i].taskbar[j];
taskbar->bar_name.area.resize_needed = TRUE;
schedule_redraw(&taskbar->bar_name.area);
}
}
schedule_panel_redraw();
}
void cleanup_taskbarname()
{
for (int i = 0; i < num_panels; i++) {
Panel *panel = &panels[i];
for (int j = 0; j < panel->num_desktops; j++) {
Taskbar *taskbar = &panel->taskbar[j];
g_free(taskbar->bar_name.name);
taskbar->bar_name.name = NULL;
free_area(&taskbar->bar_name.area);
remove_area((Area *)&taskbar->bar_name);
}
}
for (int i = 0; i < num_panels; i++) {
Panel *panel = &panels[i];
for (int j = 0; j < panel->num_desktops; j++) {
Taskbar *taskbar = &panel->taskbar[j];
g_free(taskbar->bar_name.name);
taskbar->bar_name.name = NULL;
free_area(&taskbar->bar_name.area);
remove_area((Area *)&taskbar->bar_name);
}
}
}
int taskbarname_compute_desired_size(void *obj)
{
TaskbarName *taskbar_name = (TaskbarName *)obj;
Panel *panel = (Panel *)taskbar_name->area.panel;
int name_height, name_width, name_height_ink;
get_text_size2(panel_config.taskbarname_font_desc,
&name_height_ink,
&name_height,
&name_width,
panel->area.height,
panel->area.width,
taskbar_name->name,
strlen(taskbar_name->name),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
TaskbarName *taskbar_name = (TaskbarName *)obj;
Panel *panel = (Panel *)taskbar_name->area.panel;
int name_height, name_width, name_height_ink;
get_text_size2(panel_config.taskbarname_font_desc,
&name_height_ink,
&name_height,
&name_width,
panel->area.height,
panel->area.width,
taskbar_name->name,
strlen(taskbar_name->name),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
if (panel_horizontal) {
return name_width + 2 * taskbar_name->area.paddingxlr + left_right_border_width(&taskbar_name->area);
} else {
return name_height + 2 * taskbar_name->area.paddingxlr + top_bottom_border_width(&taskbar_name->area);
}
if (panel_horizontal) {
return name_width + 2 * taskbar_name->area.paddingxlr + left_right_border_width(&taskbar_name->area);
} else {
return name_height + 2 * taskbar_name->area.paddingxlr + top_bottom_border_width(&taskbar_name->area);
}
}
gboolean resize_taskbarname(void *obj)
{
TaskbarName *taskbar_name = (TaskbarName *)obj;
Panel *panel = (Panel *)taskbar_name->area.panel;
TaskbarName *taskbar_name = (TaskbarName *)obj;
Panel *panel = (Panel *)taskbar_name->area.panel;
schedule_redraw(&taskbar_name->area);
schedule_redraw(&taskbar_name->area);
int name_height, name_width, name_height_ink;
get_text_size2(panel_config.taskbarname_font_desc,
&name_height_ink,
&name_height,
&name_width,
panel->area.height,
panel->area.width,
taskbar_name->name,
strlen(taskbar_name->name),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
int name_height, name_width, name_height_ink;
get_text_size2(panel_config.taskbarname_font_desc,
&name_height_ink,
&name_height,
&name_width,
panel->area.height,
panel->area.width,
taskbar_name->name,
strlen(taskbar_name->name),
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_NONE,
FALSE);
gboolean result = FALSE;
int new_size = taskbarname_compute_desired_size(obj);
if (panel_horizontal) {
if (new_size != taskbar_name->area.width) {
taskbar_name->area.width = new_size;
taskbar_name->posy = (taskbar_name->area.height - name_height) / 2;
result = TRUE;
}
} else {
if (new_size != taskbar_name->area.height) {
taskbar_name->area.height = new_size;
taskbar_name->posy = (taskbar_name->area.height - name_height) / 2;
result = TRUE;
}
}
return result;
gboolean result = FALSE;
int new_size = taskbarname_compute_desired_size(obj);
if (panel_horizontal) {
if (new_size != taskbar_name->area.width) {
taskbar_name->area.width = new_size;
taskbar_name->posy = (taskbar_name->area.height - name_height) / 2;
result = TRUE;
}
} else {
if (new_size != taskbar_name->area.height) {
taskbar_name->area.height = new_size;
taskbar_name->posy = (taskbar_name->area.height - name_height) / 2;
result = TRUE;
}
}
return result;
}
void draw_taskbarname(void *obj, cairo_t *c)
{
TaskbarName *taskbar_name = obj;
Taskbar *taskbar = taskbar_name->area.parent;
Color *config_text = (taskbar->desktop == server.desktop) ? &taskbarname_active_font : &taskbarname_font;
TaskbarName *taskbar_name = obj;
Taskbar *taskbar = taskbar_name->area.parent;
Color *config_text = (taskbar->desktop == server.desktop) ? &taskbarname_active_font : &taskbarname_font;
// draw content
PangoLayout *layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, panel_config.taskbarname_font_desc);
pango_layout_set_width(layout, taskbar_name->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, taskbar_name->name, strlen(taskbar_name->name));
// draw content
PangoLayout *layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, panel_config.taskbarname_font_desc);
pango_layout_set_width(layout, taskbar_name->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, taskbar_name->name, strlen(taskbar_name->name));
cairo_set_source_rgba(c, config_text->rgb[0], config_text->rgb[1], config_text->rgb[2], config_text->alpha);
cairo_set_source_rgba(c, config_text->rgb[0], config_text->rgb[1], config_text->rgb[2], config_text->alpha);
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, taskbar_name->posy, config_text, ((Panel *)taskbar_name->area.panel)->font_shadow);
pango_cairo_update_layout(c, layout);
draw_text(layout, c, 0, taskbar_name->posy, config_text, ((Panel *)taskbar_name->area.panel)->font_shadow);
g_object_unref(layout);
g_object_unref(layout);
}

3449
src/tint.c
View File

File diff suppressed because it is too large Load Diff

1758
src/tint2conf/background_gui.c
View File

File diff suppressed because it is too large Load Diff

863
src/tint2conf/gradient_gui.c
View File

File diff suppressed because it is too large Load Diff

22
src/tint2conf/gradient_gui.h
View File

@@ -22,23 +22,23 @@ void gradient_stop_update_image(int index);
void current_gradient_stop_changed(GtkWidget *widget, gpointer data);
typedef enum GradientConfigType {
GRADIENT_CONFIG_VERTICAL = 0,
GRADIENT_CONFIG_HORIZONTAL,
GRADIENT_CONFIG_RADIAL
GRADIENT_CONFIG_VERTICAL = 0,
GRADIENT_CONFIG_HORIZONTAL,
GRADIENT_CONFIG_RADIAL
} GradientConfigType;
typedef struct GradientConfigColorStop {
Color color;
// offset in 0-1
double offset;
Color color;
// offset in 0-1
double offset;
} GradientConfigColorStop;
typedef struct GradientConfig {
GradientConfigType type;
GradientConfigColorStop start_color;
GradientConfigColorStop end_color;
// Each element is a GradientConfigColorStop
GList *extra_color_stops;
GradientConfigType type;
GradientConfigColorStop start_color;
GradientConfigColorStop end_color;
// Each element is a GradientConfigColorStop
GList *extra_color_stops;
} GradientConfig;
void gradient_create_new(GradientConfigType t);

1322
src/tint2conf/main.c
View File

File diff suppressed because it is too large Load Diff

307
src/tint2conf/md4.c
View File

@@ -40,235 +40,232 @@ typedef u_int64_t u64;
#define shash_desc md4_ctx
#define shash_desc_ctx(x) (x)
#define MD4_DIGEST_SIZE 16
#define MD4_HMAC_BLOCK_SIZE 64
#define MD4_BLOCK_WORDS 16
#define MD4_HASH_WORDS 4
#define MD4_DIGEST_SIZE 16
#define MD4_HMAC_BLOCK_SIZE 64
#define MD4_BLOCK_WORDS 16
#define MD4_HASH_WORDS 4
struct md4_ctx {
u32 hash[MD4_HASH_WORDS];
u32 block[MD4_BLOCK_WORDS];
u64 byte_count;
u32 hash[MD4_HASH_WORDS];
u32 block[MD4_BLOCK_WORDS];
u64 byte_count;
};
static inline u32 lshift(u32 x, unsigned int s)
{
x &= 0xFFFFFFFF;
return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
x &= 0xFFFFFFFF;
return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
}
static inline u32 F(u32 x, u32 y, u32 z)
{
return (x & y) | ((~x) & z);
return (x & y) | ((~x) & z);
}
static inline u32 G(u32 x, u32 y, u32 z)
{
return (x & y) | (x & z) | (y & z);
return (x & y) | (x & z) | (y & z);
}
static inline u32 H(u32 x, u32 y, u32 z)
{
return x ^ y ^ z;
return x ^ y ^ z;
}
#define ROUND1(a,b,c,d,k,s) (a = lshift(a + F(b,c,d) + k, s))
#define ROUND2(a,b,c,d,k,s) (a = lshift(a + G(b,c,d) + k + (u32)0x5A827999,s))
#define ROUND3(a,b,c,d,k,s) (a = lshift(a + H(b,c,d) + k + (u32)0x6ED9EBA1,s))
#define ROUND1(a, b, c, d, k, s) (a = lshift(a + F(b, c, d) + k, s))
#define ROUND2(a, b, c, d, k, s) (a = lshift(a + G(b, c, d) + k + (u32)0x5A827999, s))
#define ROUND3(a, b, c, d, k, s) (a = lshift(a + H(b, c, d) + k + (u32)0x6ED9EBA1, s))
/* XXX: this stuff can be optimized */
static inline void le32_to_cpu_array(u32 *buf, unsigned int words)
{
while (words--) {
*buf = ntohl(*buf);
buf++;
}
while (words--) {
*buf = ntohl(*buf);
buf++;
}
}
static inline void cpu_to_le32_array(u32 *buf, unsigned int words)
{
while (words--) {
*buf = htonl(*buf);
buf++;
}
while (words--) {
*buf = htonl(*buf);
buf++;
}
}
static void md4_transform(u32 *hash, u32 const *in)
{
u32 a, b, c, d;
u32 a, b, c, d;
a = hash[0];
b = hash[1];
c = hash[2];
d = hash[3];
a = hash[0];
b = hash[1];
c = hash[2];
d = hash[3];
ROUND1(a, b, c, d, in[0], 3);
ROUND1(d, a, b, c, in[1], 7);
ROUND1(c, d, a, b, in[2], 11);
ROUND1(b, c, d, a, in[3], 19);
ROUND1(a, b, c, d, in[4], 3);
ROUND1(d, a, b, c, in[5], 7);
ROUND1(c, d, a, b, in[6], 11);
ROUND1(b, c, d, a, in[7], 19);
ROUND1(a, b, c, d, in[8], 3);
ROUND1(d, a, b, c, in[9], 7);
ROUND1(c, d, a, b, in[10], 11);
ROUND1(b, c, d, a, in[11], 19);
ROUND1(a, b, c, d, in[12], 3);
ROUND1(d, a, b, c, in[13], 7);
ROUND1(c, d, a, b, in[14], 11);
ROUND1(b, c, d, a, in[15], 19);
ROUND1(a, b, c, d, in[0], 3);
ROUND1(d, a, b, c, in[1], 7);
ROUND1(c, d, a, b, in[2], 11);
ROUND1(b, c, d, a, in[3], 19);
ROUND1(a, b, c, d, in[4], 3);
ROUND1(d, a, b, c, in[5], 7);
ROUND1(c, d, a, b, in[6], 11);
ROUND1(b, c, d, a, in[7], 19);
ROUND1(a, b, c, d, in[8], 3);
ROUND1(d, a, b, c, in[9], 7);
ROUND1(c, d, a, b, in[10], 11);
ROUND1(b, c, d, a, in[11], 19);
ROUND1(a, b, c, d, in[12], 3);
ROUND1(d, a, b, c, in[13], 7);
ROUND1(c, d, a, b, in[14], 11);
ROUND1(b, c, d, a, in[15], 19);
ROUND2(a, b, c, d,in[ 0], 3);
ROUND2(d, a, b, c, in[4], 5);
ROUND2(c, d, a, b, in[8], 9);
ROUND2(b, c, d, a, in[12], 13);
ROUND2(a, b, c, d, in[1], 3);
ROUND2(d, a, b, c, in[5], 5);
ROUND2(c, d, a, b, in[9], 9);
ROUND2(b, c, d, a, in[13], 13);
ROUND2(a, b, c, d, in[2], 3);
ROUND2(d, a, b, c, in[6], 5);
ROUND2(c, d, a, b, in[10], 9);
ROUND2(b, c, d, a, in[14], 13);
ROUND2(a, b, c, d, in[3], 3);
ROUND2(d, a, b, c, in[7], 5);
ROUND2(c, d, a, b, in[11], 9);
ROUND2(b, c, d, a, in[15], 13);
ROUND2(a, b, c, d, in[0], 3);
ROUND2(d, a, b, c, in[4], 5);
ROUND2(c, d, a, b, in[8], 9);
ROUND2(b, c, d, a, in[12], 13);
ROUND2(a, b, c, d, in[1], 3);
ROUND2(d, a, b, c, in[5], 5);
ROUND2(c, d, a, b, in[9], 9);
ROUND2(b, c, d, a, in[13], 13);
ROUND2(a, b, c, d, in[2], 3);
ROUND2(d, a, b, c, in[6], 5);
ROUND2(c, d, a, b, in[10], 9);
ROUND2(b, c, d, a, in[14], 13);
ROUND2(a, b, c, d, in[3], 3);
ROUND2(d, a, b, c, in[7], 5);
ROUND2(c, d, a, b, in[11], 9);
ROUND2(b, c, d, a, in[15], 13);
ROUND3(a, b, c, d,in[ 0], 3);
ROUND3(d, a, b, c, in[8], 9);
ROUND3(c, d, a, b, in[4], 11);
ROUND3(b, c, d, a, in[12], 15);
ROUND3(a, b, c, d, in[2], 3);
ROUND3(d, a, b, c, in[10], 9);
ROUND3(c, d, a, b, in[6], 11);
ROUND3(b, c, d, a, in[14], 15);
ROUND3(a, b, c, d, in[1], 3);
ROUND3(d, a, b, c, in[9], 9);
ROUND3(c, d, a, b, in[5], 11);
ROUND3(b, c, d, a, in[13], 15);
ROUND3(a, b, c, d, in[3], 3);
ROUND3(d, a, b, c, in[11], 9);
ROUND3(c, d, a, b, in[7], 11);
ROUND3(b, c, d, a, in[15], 15);
ROUND3(a, b, c, d, in[0], 3);
ROUND3(d, a, b, c, in[8], 9);
ROUND3(c, d, a, b, in[4], 11);
ROUND3(b, c, d, a, in[12], 15);
ROUND3(a, b, c, d, in[2], 3);
ROUND3(d, a, b, c, in[10], 9);
ROUND3(c, d, a, b, in[6], 11);
ROUND3(b, c, d, a, in[14], 15);
ROUND3(a, b, c, d, in[1], 3);
ROUND3(d, a, b, c, in[9], 9);
ROUND3(c, d, a, b, in[5], 11);
ROUND3(b, c, d, a, in[13], 15);
ROUND3(a, b, c, d, in[3], 3);
ROUND3(d, a, b, c, in[11], 9);
ROUND3(c, d, a, b, in[7], 11);
ROUND3(b, c, d, a, in[15], 15);
hash[0] += a;
hash[1] += b;
hash[2] += c;
hash[3] += d;
hash[0] += a;
hash[1] += b;
hash[2] += c;
hash[3] += d;
}
static inline void md4_transform_helper(struct md4_ctx *ctx)
{
le32_to_cpu_array(ctx->block, ARRAY_SIZE(ctx->block));
md4_transform(ctx->hash, ctx->block);
le32_to_cpu_array(ctx->block, ARRAY_SIZE(ctx->block));
md4_transform(ctx->hash, ctx->block);
}
static int md4_init(struct shash_desc *desc)
{
struct md4_ctx *mctx = shash_desc_ctx(desc);
struct md4_ctx *mctx = shash_desc_ctx(desc);
mctx->hash[0] = 0x67452301;
mctx->hash[1] = 0xefcdab89;
mctx->hash[2] = 0x98badcfe;
mctx->hash[3] = 0x10325476;
mctx->byte_count = 0;
mctx->hash[0] = 0x67452301;
mctx->hash[1] = 0xefcdab89;
mctx->hash[2] = 0x98badcfe;
mctx->hash[3] = 0x10325476;
mctx->byte_count = 0;
return 0;
return 0;
}
static int md4_update(struct shash_desc *desc, const u8 *data, unsigned int len)
{
struct md4_ctx *mctx = shash_desc_ctx(desc);
const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
struct md4_ctx *mctx = shash_desc_ctx(desc);
const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
mctx->byte_count += len;
mctx->byte_count += len;
if (avail > len) {
memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
data, len);
return 0;
}
if (avail > len) {
memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), data, len);
return 0;
}
memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
data, avail);
memcpy((char *)mctx->block + (sizeof(mctx->block) - avail), data, avail);
md4_transform_helper(mctx);
data += avail;
len -= avail;
md4_transform_helper(mctx);
data += avail;
len -= avail;
while (len >= sizeof(mctx->block)) {
memcpy(mctx->block, data, sizeof(mctx->block));
md4_transform_helper(mctx);
data += sizeof(mctx->block);
len -= sizeof(mctx->block);
}
while (len >= sizeof(mctx->block)) {
memcpy(mctx->block, data, sizeof(mctx->block));
md4_transform_helper(mctx);
data += sizeof(mctx->block);
len -= sizeof(mctx->block);
}
memcpy(mctx->block, data, len);
memcpy(mctx->block, data, len);
return 0;
return 0;
}
static int md4_final(struct shash_desc *desc, u8 *out)
{
struct md4_ctx *mctx = shash_desc_ctx(desc);
const unsigned int offset = mctx->byte_count & 0x3f;
char *p = (char *)mctx->block + offset;
int padding = 56 - (offset + 1);
struct md4_ctx *mctx = shash_desc_ctx(desc);
const unsigned int offset = mctx->byte_count & 0x3f;
char *p = (char *)mctx->block + offset;
int padding = 56 - (offset + 1);
*p++ = 0x80;
if (padding < 0) {
memset(p, 0x00, padding + sizeof (u64));
md4_transform_helper(mctx);
p = (char *)mctx->block;
padding = 56;
}
*p++ = 0x80;
if (padding < 0) {
memset(p, 0x00, padding + sizeof(u64));
md4_transform_helper(mctx);
p = (char *)mctx->block;
padding = 56;
}
memset(p, 0, padding);
mctx->block[14] = mctx->byte_count << 3;
mctx->block[15] = mctx->byte_count >> 29;
le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
sizeof(u64)) / sizeof(u32));
md4_transform(mctx->hash, mctx->block);
cpu_to_le32_array(mctx->hash, ARRAY_SIZE(mctx->hash));
memcpy(out, mctx->hash, sizeof(mctx->hash));
memset(mctx, 0, sizeof(*mctx));
memset(p, 0, padding);
mctx->block[14] = mctx->byte_count << 3;
mctx->block[15] = mctx->byte_count >> 29;
le32_to_cpu_array(mctx->block, (sizeof(mctx->block) - sizeof(u64)) / sizeof(u32));
md4_transform(mctx->hash, mctx->block);
cpu_to_le32_array(mctx->hash, ARRAY_SIZE(mctx->hash));
memcpy(out, mctx->hash, sizeof(mctx->hash));
memset(mctx, 0, sizeof(*mctx));
return 0;
return 0;
}
static char to_hex(u8 v)
{
v = v & 0xf;
if (v < 0xa)
return '0' + v;
return 'a' + v - 0xa;
v = v & 0xf;
if (v < 0xa)
return '0' + v;
return 'a' + v - 0xa;
}
void md4hexf(const char *path, char *hash)
{
struct md4_ctx mctx;
md4_init(&mctx);
struct md4_ctx mctx;
md4_init(&mctx);
int fd = open(path, O_RDONLY);
if (fd >= 0) {
u8 buffer[MD4_HMAC_BLOCK_SIZE];
while (1) {
ssize_t count = read(fd, buffer, sizeof(buffer));
if (count <= 0)
break;
md4_update(&mctx, buffer, (unsigned)count);
}
close(fd);
}
int fd = open(path, O_RDONLY);
if (fd >= 0) {
u8 buffer[MD4_HMAC_BLOCK_SIZE];
while (1) {
ssize_t count = read(fd, buffer, sizeof(buffer));
if (count <= 0)
break;
md4_update(&mctx, buffer, (unsigned)count);
}
close(fd);
}
u8 out[MD4_DIGEST_SIZE];
md4_final(&mctx, out);
u8 out[MD4_DIGEST_SIZE];
md4_final(&mctx, out);
for (int i = 0; i < MD4_DIGEST_SIZE; i++) {
hash[2*i+0] = to_hex(out[i] >> 4);
hash[2*i+1] = to_hex(out[i] & 0xf);
}
hash[2*MD4_DIGEST_SIZE] = 0;
for (int i = 0; i < MD4_DIGEST_SIZE; i++) {
hash[2 * i + 0] = to_hex(out[i] >> 4);
hash[2 * i + 1] = to_hex(out[i] & 0xf);
}
hash[2 * MD4_DIGEST_SIZE] = 0;
}

9462
src/tint2conf/properties.c
View File

File diff suppressed because it is too large Load Diff

217
src/tint2conf/properties.h
View File

@@ -8,22 +8,20 @@
#include "../launcher/icon-theme-common.h"
// panel
extern GtkWidget *panel_width, *panel_height, *panel_margin_x, *panel_margin_y, *panel_padding_x, *panel_padding_y, *panel_spacing;
extern GtkWidget *panel_wm_menu, *panel_dock, *panel_autohide, *panel_autohide_show_time, *panel_autohide_hide_time, *panel_autohide_size;
extern GtkWidget *panel_combo_strut_policy, *panel_combo_layer, *panel_combo_width_type, *panel_combo_height_type, *panel_combo_monitor;
extern GtkWidget *panel_width, *panel_height, *panel_margin_x, *panel_margin_y, *panel_padding_x, *panel_padding_y,
*panel_spacing;
extern GtkWidget *panel_wm_menu, *panel_dock, *panel_autohide, *panel_autohide_show_time, *panel_autohide_hide_time,
*panel_autohide_size;
extern GtkWidget *panel_combo_strut_policy, *panel_combo_layer, *panel_combo_width_type, *panel_combo_height_type,
*panel_combo_monitor;
extern GtkWidget *panel_window_name, *disable_transparency;
extern GtkWidget *panel_mouse_effects;
extern GtkWidget *mouse_hover_icon_opacity, *mouse_hover_icon_saturation, *mouse_hover_icon_brightness;
extern GtkWidget *mouse_pressed_icon_opacity, *mouse_pressed_icon_saturation, *mouse_pressed_icon_brightness;
extern GtkWidget *panel_primary_monitor_first, *panel_shrink;
enum {
itemsColName = 0,
itemsColValue,
itemsNumCols
};
enum { itemsColName = 0, itemsColValue, itemsNumCols };
extern GtkListStore *panel_items, *all_items;
extern GtkWidget *panel_items_view, *all_items_view;
char *get_panel_items();
@@ -52,44 +50,34 @@ extern GtkWidget *panel_background;
// taskbar
extern GtkWidget *taskbar_show_desktop, *taskbar_show_name, *taskbar_padding_x, *taskbar_padding_y, *taskbar_spacing;
extern GtkWidget *taskbar_hide_inactive_tasks, *taskbar_hide_diff_monitor;
extern GtkWidget *taskbar_name_padding_x, *taskbar_name_padding_y, *taskbar_name_inactive_color, *taskbar_name_active_color;
extern GtkWidget *taskbar_name_padding_x, *taskbar_name_padding_y, *taskbar_name_inactive_color,
*taskbar_name_active_color;
extern GtkWidget *taskbar_name_font, *taskbar_name_font_set;
extern GtkWidget *taskbar_active_background, *taskbar_inactive_background;
extern GtkWidget *taskbar_name_active_background, *taskbar_name_inactive_background;
extern GtkWidget *taskbar_distribute_size, *taskbar_sort_order, *taskbar_alignment, *taskbar_always_show_all_desktop_tasks;
extern GtkWidget *taskbar_distribute_size, *taskbar_sort_order, *taskbar_alignment,
*taskbar_always_show_all_desktop_tasks;
extern GtkWidget *taskbar_hide_empty;
// task
extern GtkWidget *task_mouse_left, *task_mouse_middle, *task_mouse_right, *task_mouse_scroll_up, *task_mouse_scroll_down;
extern GtkWidget *task_mouse_left, *task_mouse_middle, *task_mouse_right, *task_mouse_scroll_up,
*task_mouse_scroll_down;
extern GtkWidget *task_show_icon, *task_show_text, *task_align_center, *font_shadow;
extern GtkWidget *task_maximum_width, *task_maximum_height, *task_padding_x, *task_padding_y, *task_spacing;
extern GtkWidget *task_font, *task_font_set;
extern GtkWidget *task_default_color, *task_default_color_set,
*task_default_icon_opacity, *task_default_icon_osb_set,
*task_default_icon_saturation,
*task_default_icon_brightness,
*task_default_background, *task_default_background_set;
extern GtkWidget *task_normal_color, *task_normal_color_set,
*task_normal_icon_opacity, *task_normal_icon_osb_set,
*task_normal_icon_saturation,
*task_normal_icon_brightness,
*task_normal_background, *task_normal_background_set;
extern GtkWidget *task_active_color, *task_active_color_set,
*task_active_icon_opacity, *task_active_icon_osb_set,
*task_active_icon_saturation,
*task_active_icon_brightness,
*task_active_background, *task_active_background_set;
extern GtkWidget *task_urgent_color, *task_urgent_color_set,
*task_urgent_icon_opacity, *task_urgent_icon_osb_set,
*task_urgent_icon_saturation,
*task_urgent_icon_brightness,
*task_urgent_background, *task_urgent_background_set;
extern GtkWidget *task_default_color, *task_default_color_set, *task_default_icon_opacity, *task_default_icon_osb_set,
*task_default_icon_saturation, *task_default_icon_brightness, *task_default_background,
*task_default_background_set;
extern GtkWidget *task_normal_color, *task_normal_color_set, *task_normal_icon_opacity, *task_normal_icon_osb_set,
*task_normal_icon_saturation, *task_normal_icon_brightness, *task_normal_background, *task_normal_background_set;
extern GtkWidget *task_active_color, *task_active_color_set, *task_active_icon_opacity, *task_active_icon_osb_set,
*task_active_icon_saturation, *task_active_icon_brightness, *task_active_background, *task_active_background_set;
extern GtkWidget *task_urgent_color, *task_urgent_color_set, *task_urgent_icon_opacity, *task_urgent_icon_osb_set,
*task_urgent_icon_saturation, *task_urgent_icon_brightness, *task_urgent_background, *task_urgent_background_set;
extern GtkWidget *task_urgent_blinks;
extern GtkWidget *task_iconified_color, *task_iconified_color_set,
*task_iconified_icon_opacity, *task_iconified_icon_osb_set,
*task_iconified_icon_saturation,
*task_iconified_icon_brightness,
*task_iconified_background, *task_iconified_background_set;
extern GtkWidget *task_iconified_color, *task_iconified_color_set, *task_iconified_icon_opacity,
*task_iconified_icon_osb_set, *task_iconified_icon_saturation, *task_iconified_icon_brightness,
*task_iconified_background, *task_iconified_background_set;
// clock
extern GtkWidget *clock_format_line1, *clock_format_line2, *clock_tmz_line1, *clock_tmz_line2;
@@ -102,10 +90,12 @@ extern GtkWidget *clock_background;
// battery
extern GtkWidget *battery_hide_if_higher, *battery_alert_if_lower, *battery_alert_cmd;
extern GtkWidget *battery_padding_x, *battery_padding_y;
extern GtkWidget *battery_font_line1, *battery_font_line1_set, *battery_font_line2, *battery_font_line2_set, *battery_font_color;
extern GtkWidget *battery_font_line1, *battery_font_line1_set, *battery_font_line2, *battery_font_line2_set,
*battery_font_color;
extern GtkWidget *battery_background;
extern GtkWidget *battery_tooltip;
extern GtkWidget *battery_left_command, *battery_mclick_command, *battery_right_command, *battery_uwheel_command, *battery_dwheel_command;
extern GtkWidget *battery_left_command, *battery_mclick_command, *battery_right_command, *battery_uwheel_command,
*battery_dwheel_command;
extern GtkWidget *ac_connected_cmd, *ac_disconnected_cmd;
// systray
@@ -121,60 +111,55 @@ extern GtkWidget *tooltip_background;
// Separator
typedef struct Separator {
char name[256];
GtkWidget *container;
GtkWidget *page_separator;
GtkWidget *page_label;
GtkWidget *separator_background;
GtkWidget *separator_color;
GtkWidget *separator_style;
GtkWidget *separator_size;
GtkWidget *separator_padding_x;
GtkWidget *separator_padding_y;
char name[256];
GtkWidget *container;
GtkWidget *page_separator;
GtkWidget *page_label;
GtkWidget *separator_background;
GtkWidget *separator_color;
GtkWidget *separator_style;
GtkWidget *separator_size;
GtkWidget *separator_padding_x;
GtkWidget *separator_padding_y;
} Separator;
extern GArray *separators;
// Executor
typedef struct Executor {
char name[256];
GtkWidget *container;
GtkWidget *page_execp;
GtkWidget *page_label;
GtkWidget *execp_command, *execp_interval, *execp_has_icon, *execp_cache_icon, *execp_show_tooltip;
GtkWidget *execp_continuous, *execp_markup, *execp_tooltip;
GtkWidget *execp_left_command, *execp_right_command;
GtkWidget *execp_mclick_command, *execp_rclick_command, *execp_uwheel_command, *execp_dwheel_command;
GtkWidget *execp_font, *execp_font_set, *execp_font_color, *execp_padding_x, *execp_padding_y, *execp_centered;
GtkWidget *execp_background, *execp_icon_w, *execp_icon_h;
char name[256];
GtkWidget *container;
GtkWidget *page_execp;
GtkWidget *page_label;
GtkWidget *execp_command, *execp_interval, *execp_has_icon, *execp_cache_icon, *execp_show_tooltip;
GtkWidget *execp_continuous, *execp_markup, *execp_tooltip;
GtkWidget *execp_left_command, *execp_right_command;
GtkWidget *execp_mclick_command, *execp_rclick_command, *execp_uwheel_command, *execp_dwheel_command;
GtkWidget *execp_font, *execp_font_set, *execp_font_color, *execp_padding_x, *execp_padding_y, *execp_centered;
GtkWidget *execp_background, *execp_icon_w, *execp_icon_h;
} Executor;
extern GArray *executors;
// Button
typedef struct Button {
char name[256];
GtkWidget *container;
GtkWidget *page_button;
GtkWidget *page_label;
GtkWidget *button_icon, *button_text, *button_tooltip;
GtkWidget *button_left_command, *button_right_command;
GtkWidget *button_mclick_command, *button_rclick_command, *button_uwheel_command, *button_dwheel_command;
GtkWidget *button_font, *button_font_set, *button_font_color, *button_padding_x, *button_padding_y, *button_centered;
GtkWidget *button_background, *button_max_icon_size;
char name[256];
GtkWidget *container;
GtkWidget *page_button;
GtkWidget *page_label;
GtkWidget *button_icon, *button_text, *button_tooltip;
GtkWidget *button_left_command, *button_right_command;
GtkWidget *button_mclick_command, *button_rclick_command, *button_uwheel_command, *button_dwheel_command;
GtkWidget *button_font, *button_font_set, *button_font_color, *button_padding_x, *button_padding_y,
*button_centered;
GtkWidget *button_background, *button_max_icon_size;
} Button;
extern GArray *buttons;
// launcher
enum {
appsColIcon = 0,
appsColIconName,
appsColText,
appsColPath,
appsNumCols
};
enum { appsColIcon = 0, appsColIconName, appsColText, appsColPath, appsNumCols };
extern GtkListStore *launcher_apps, *all_apps;
extern GtkWidget *launcher_apps_view, *all_apps_view;
@@ -195,73 +180,49 @@ gchar *get_current_icon_theme();
// background
enum {
bgColPixbuf = 0,
bgColFillColor,
bgColFillOpacity,
bgColBorderColor,
bgColBorderOpacity,
bgColGradientId,
bgColBorderWidth,
bgColCornerRadius,
bgColText,
bgColFillColorOver,
bgColFillOpacityOver,
bgColBorderColorOver,
bgColBorderOpacityOver,
bgColGradientIdOver,
bgColFillColorPress,
bgColFillOpacityPress,
bgColBorderColorPress,
bgColBorderOpacityPress,
bgColGradientIdPress,
bgColPixbuf = 0,
bgColFillColor,
bgColFillOpacity,
bgColBorderColor,
bgColBorderOpacity,
bgColGradientId,
bgColBorderWidth,
bgColCornerRadius,
bgColText,
bgColFillColorOver,
bgColFillOpacityOver,
bgColBorderColorOver,
bgColBorderOpacityOver,
bgColGradientIdOver,
bgColFillColorPress,
bgColFillOpacityPress,
bgColBorderColorPress,
bgColBorderOpacityPress,
bgColGradientIdPress,
bgColBorderSidesTop,
bgColBorderSidesBottom,
bgColBorderSidesLeft,
bgColBorderSidesRight,
bgNumCols
bgNumCols
};
extern GtkListStore *backgrounds;
extern GtkWidget *current_background,
*background_fill_color,
*background_border_color,
*background_gradient,
*background_fill_color_over,
*background_border_color_over,
*background_gradient_over,
*background_fill_color_press,
*background_border_color_press,
*background_gradient_press,
*background_border_width,
*background_border_sides_top,
*background_border_sides_bottom,
*background_border_sides_left,
*background_border_sides_right,
*background_corner_radius;
extern GtkWidget *current_background, *background_fill_color, *background_border_color, *background_gradient,
*background_fill_color_over, *background_border_color_over, *background_gradient_over, *background_fill_color_press,
*background_border_color_press, *background_gradient_press, *background_border_width, *background_border_sides_top,
*background_border_sides_bottom, *background_border_sides_left, *background_border_sides_right,
*background_corner_radius;
// gradients
enum {
grColPixbuf = 0,
grColId,
grColText,
grNumCols
};
enum { grColPixbuf = 0, grColId, grColText, grNumCols };
// gradient color stops
enum {
grStopColPixbuf = 0,
grStopNumCols
};
enum { grStopColPixbuf = 0, grStopNumCols };
extern GtkListStore *gradient_ids, *gradient_stop_ids;
extern GList *gradients;
extern GtkWidget *current_gradient,
*gradient_combo_type,
*gradient_start_color,
*gradient_end_color,
*current_gradient_stop,
*gradient_stop_color,
*gradient_stop_offset;
extern GtkWidget *current_gradient, *gradient_combo_type, *gradient_start_color, *gradient_end_color,
*current_gradient_stop, *gradient_stop_color, *gradient_stop_offset;
void background_create_new();
void background_force_update();

3599
src/tint2conf/properties_rw.c
View File

File diff suppressed because it is too large Load Diff

2
src/tint2conf/properties_rw.h
View File

@@ -5,7 +5,7 @@
char *get_current_theme_path();
gboolean config_is_manual(const char *path);
void config_read_file (const char *path);
void config_read_file(const char *path);
void config_save_file(const char *path);
#endif

321
src/tint2conf/theme_view.c
View File

@@ -34,203 +34,216 @@ gint theme_name_compare(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpo
GtkWidget *create_view()
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
theme_list_store =
gtk_list_store_new(NB_COL, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_INT, G_TYPE_INT, G_TYPE_BOOLEAN);
theme_list_store = gtk_list_store_new(NB_COL,
G_TYPE_STRING,
G_TYPE_STRING,
GDK_TYPE_PIXBUF,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_BOOLEAN);
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(theme_list_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(theme_list_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
g_object_unref(theme_list_store); // destroy store automatically with view
g_object_unref(theme_list_store); // destroy store automatically with view
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_FILE);
gtk_tree_view_column_set_visible(col, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_FILE);
gtk_tree_view_column_set_visible(col, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", COL_THEME_NAME);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
g_renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(g_renderer, "xalign", 0.0, NULL);
gtk_cell_renderer_set_fixed_size(g_renderer, 200, 30);
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, g_renderer, TRUE);
gtk_tree_view_column_add_attribute(col, g_renderer, "pixbuf", COL_SNAPSHOT);
gtk_tree_view_column_add_attribute(col, g_renderer, "width", COL_WIDTH);
gtk_tree_view_column_add_attribute(col, g_renderer, "height", COL_HEIGHT);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
g_renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(g_renderer, "xalign", 0.0, NULL);
gtk_cell_renderer_set_fixed_size(g_renderer, 200, 30);
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, g_renderer, TRUE);
gtk_tree_view_column_add_attribute(col, g_renderer, "pixbuf", COL_SNAPSHOT);
gtk_tree_view_column_add_attribute(col, g_renderer, "width", COL_WIDTH);
gtk_tree_view_column_add_attribute(col, g_renderer, "height", COL_HEIGHT);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
GtkTreeSortable *sortable = GTK_TREE_SORTABLE(theme_list_store);
gtk_tree_sortable_set_sort_column_id(sortable, COL_THEME_FILE, GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func(sortable, COL_THEME_FILE, theme_name_compare, NULL, NULL);
return view;
GtkTreeSortable *sortable = GTK_TREE_SORTABLE(theme_list_store);
gtk_tree_sortable_set_sort_column_id(sortable, COL_THEME_FILE, GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func(sortable, COL_THEME_FILE, theme_name_compare, NULL, NULL);
return view;
}
gint theme_name_compare(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer user_data)
{
gchar *path_a, *path_b;
gtk_tree_model_get(model, a, COL_THEME_FILE, &path_a, -1);
gtk_tree_model_get(model, b, COL_THEME_FILE, &path_b, -1);
gchar *path_a, *path_b;
gtk_tree_model_get(model, a, COL_THEME_FILE, &path_a, -1);
gtk_tree_model_get(model, b, COL_THEME_FILE, &path_b, -1);
gboolean home_a = strstr(path_a, g_get_user_config_dir()) == path_a;
gboolean home_b = strstr(path_b, g_get_user_config_dir()) == path_b;
gboolean home_a = strstr(path_a, g_get_user_config_dir()) == path_a;
gboolean home_b = strstr(path_b, g_get_user_config_dir()) == path_b;
if (home_a && !home_b)
return -1;
if (!home_a && home_b)
return 1;
if (home_a && !home_b)
return -1;
if (!home_a && home_b)
return 1;
gchar *name_a = path_a;
gchar *p;
for (p = name_a; *p; p++) {
if (*p == '/')
name_a = p + 1;
}
gchar *name_b = path_b;
for (p = name_b; *p; p++) {
if (*p == '/')
name_b = p + 1;
}
if (g_str_equal(name_a, name_b))
return 0;
if (g_str_equal(name_a, "tint2rc"))
return -1;
if (g_str_equal(name_b, "tint2rc"))
return 1;
gint result = strnatcasecmp(name_a, name_b);
g_free(path_a);
g_free(path_b);
return result;
gchar *name_a = path_a;
gchar *p;
for (p = name_a; *p; p++) {
if (*p == '/')
name_a = p + 1;
}
gchar *name_b = path_b;
for (p = name_b; *p; p++) {
if (*p == '/')
name_b = p + 1;
}
if (g_str_equal(name_a, name_b))
return 0;
if (g_str_equal(name_a, "tint2rc"))
return -1;
if (g_str_equal(name_b, "tint2rc"))
return 1;
gint result = strnatcasecmp(name_a, name_b);
g_free(path_a);
g_free(path_b);
return result;
}
gboolean theme_list_contains(const char *given_path)
{
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(g_theme_view));
GtkTreeIter iter;
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(g_theme_view));
GtkTreeIter iter;
gboolean have_iter = gtk_tree_model_get_iter_first(model, &iter);
while (have_iter) {
gchar *filepath;
gtk_tree_model_get(model, &iter, COL_THEME_FILE, &filepath, -1);
if (g_str_equal(filepath, given_path)) {
gtk_list_store_set(theme_list_store, &iter, COL_SNAPSHOT, NULL, -1);
g_free(filepath);
return TRUE;
}
g_free(filepath);
have_iter = gtk_tree_model_iter_next(model, &iter);
}
return FALSE;
gboolean have_iter = gtk_tree_model_get_iter_first(model, &iter);
while (have_iter) {
gchar *filepath;
gtk_tree_model_get(model, &iter, COL_THEME_FILE, &filepath, -1);
if (g_str_equal(filepath, given_path)) {
gtk_list_store_set(theme_list_store, &iter, COL_SNAPSHOT, NULL, -1);
g_free(filepath);
return TRUE;
}
g_free(filepath);
have_iter = gtk_tree_model_iter_next(model, &iter);
}
return FALSE;
}
void theme_list_append(const gchar *path)
{
if (theme_list_contains(path))
return;
if (theme_list_contains(path))
return;
GtkTreeIter iter;
gtk_list_store_append(theme_list_store, &iter);
GtkTreeIter iter;
gtk_list_store_append(theme_list_store, &iter);
gchar *name = strrchr(path, '/') + 1;
gchar *name = strrchr(path, '/') + 1;
gchar *dir = g_strdup(path);
strrchr(dir, '/')[0] = 0;
char *suffix = contract_tilde(dir);
g_free(dir);
gchar *dir = g_strdup(path);
strrchr(dir, '/')[0] = 0;
char *suffix = contract_tilde(dir);
g_free(dir);
gchar *display_name = g_strdup_printf("%s\n(%s)", name, suffix);
gtk_list_store_set(theme_list_store, &iter, COL_THEME_FILE, path, COL_THEME_NAME, display_name, COL_FORCE_REFRESH, FALSE, -1);
g_free(display_name);
g_free(suffix);
gchar *display_name = g_strdup_printf("%s\n(%s)", name, suffix);
gtk_list_store_set(theme_list_store,
&iter,
COL_THEME_FILE,
path,
COL_THEME_NAME,
display_name,
COL_FORCE_REFRESH,
FALSE,
-1);
g_free(display_name);
g_free(suffix);
}
gboolean update_snapshot(gpointer ignored)
{
{
gchar *tint2_cache_dir = g_build_filename(g_get_user_cache_dir(), "tint2", NULL);
if (!g_file_test(tint2_cache_dir, G_FILE_TEST_IS_DIR))
g_mkdir(tint2_cache_dir, 0700);
g_free(tint2_cache_dir);
}
{
gchar *tint2_cache_dir = g_build_filename(g_get_user_cache_dir(), "tint2", NULL);
if (!g_file_test(tint2_cache_dir, G_FILE_TEST_IS_DIR))
g_mkdir(tint2_cache_dir, 0700);
g_free(tint2_cache_dir);
}
const gint PADDING = 20;
const gint PADDING = 20;
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(g_theme_view));
GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(g_theme_view));
GtkTreeIter iter;
gboolean have_iter;
GtkTreeIter iter;
gboolean have_iter;
int num_updates = 0;
gboolean need_pls_wait = FALSE;
int num_updates = 0;
gboolean need_pls_wait = FALSE;
have_iter = gtk_tree_model_get_iter_first(model, &iter);
while (have_iter) {
GdkPixbuf *pixbuf;
gtk_tree_model_get(model, &iter, COL_SNAPSHOT, &pixbuf, -1);
if (pixbuf) {
g_object_unref(pixbuf);
have_iter = gtk_tree_model_iter_next(model, &iter);
continue;
}
have_iter = gtk_tree_model_get_iter_first(model, &iter);
while (have_iter) {
GdkPixbuf *pixbuf;
gtk_tree_model_get(model, &iter, COL_SNAPSHOT, &pixbuf, -1);
if (pixbuf) {
g_object_unref(pixbuf);
have_iter = gtk_tree_model_iter_next(model, &iter);
continue;
}
gchar *path;
gboolean force_refresh;
gtk_tree_model_get(model, &iter, COL_THEME_FILE, &path, COL_FORCE_REFRESH, &force_refresh, -1);
gchar *path;
gboolean force_refresh;
gtk_tree_model_get(model, &iter, COL_THEME_FILE, &path, COL_FORCE_REFRESH, &force_refresh, -1);
char hash[MD4_HEX_SIZE + 4];
md4hexf(path, hash);
strcat(hash, ".png");
char hash[MD4_HEX_SIZE + 4];
md4hexf(path, hash);
strcat(hash, ".png");
gchar *snap = g_build_filename(g_get_user_cache_dir(), "tint2", hash, NULL);
pixbuf = force_refresh ? NULL : gdk_pixbuf_new_from_file(snap, NULL);
if (!pixbuf) {
gchar *cmd = g_strdup_printf("tint2 -c \'%s\' -s \'%s\' 1>/dev/null 2>/dev/null", path, snap);
num_updates++;
if (num_updates > 3 && !need_pls_wait) {
need_pls_wait = TRUE;
create_please_wait(GTK_WINDOW(g_window));
}
if (system(cmd) == 0) {
// load
pixbuf = gdk_pixbuf_new_from_file(snap, NULL);
}
g_free(cmd);
}
gchar *snap = g_build_filename(g_get_user_cache_dir(), "tint2", hash, NULL);
pixbuf = force_refresh ? NULL : gdk_pixbuf_new_from_file(snap, NULL);
if (!pixbuf) {
gchar *cmd = g_strdup_printf("tint2 -c \'%s\' -s \'%s\' 1>/dev/null 2>/dev/null", path, snap);
num_updates++;
if (num_updates > 3 && !need_pls_wait) {
need_pls_wait = TRUE;
create_please_wait(GTK_WINDOW(g_window));
}
if (system(cmd) == 0) {
// load
pixbuf = gdk_pixbuf_new_from_file(snap, NULL);
}
g_free(cmd);
}
g_free(snap);
g_free(path);
g_free(snap);
g_free(path);
gtk_list_store_set(theme_list_store,
&iter,
COL_SNAPSHOT,
pixbuf,
COL_WIDTH,
gdk_pixbuf_get_width(pixbuf) + PADDING,
COL_HEIGHT,
gdk_pixbuf_get_height(pixbuf) + PADDING,
COL_FORCE_REFRESH,
FALSE,
-1);
if (pixbuf)
g_object_unref(pixbuf);
gtk_list_store_set(theme_list_store,
&iter,
COL_SNAPSHOT,
pixbuf,
COL_WIDTH,
gdk_pixbuf_get_width(pixbuf) + PADDING,
COL_HEIGHT,
gdk_pixbuf_get_height(pixbuf) + PADDING,
COL_FORCE_REFRESH,
FALSE,
-1);
if (pixbuf)
g_object_unref(pixbuf);
if (need_pls_wait)
process_events();
if (need_pls_wait)
process_events();
have_iter = gtk_tree_model_iter_next(model, &iter);
}
have_iter = gtk_tree_model_iter_next(model, &iter);
}
if (need_pls_wait)
destroy_please_wait();
if (need_pls_wait)
destroy_please_wait();
return FALSE;
return FALSE;
}

16
src/tint2conf/theme_view.h
View File

@@ -5,13 +5,15 @@
extern GtkWidget *g_theme_view;
extern GtkListStore *theme_list_store;
enum { COL_THEME_FILE = 0,
COL_THEME_NAME,
COL_SNAPSHOT,
COL_WIDTH,
COL_HEIGHT,
COL_FORCE_REFRESH,
NB_COL, };
enum {
COL_THEME_FILE = 0,
COL_THEME_NAME,
COL_SNAPSHOT,
COL_WIDTH,
COL_HEIGHT,
COL_FORCE_REFRESH,
NB_COL,
};
GtkWidget *create_view();

666
src/tint2rc.c
View File

@@ -1,411 +1,261 @@
#include "tint2rc.h"
unsigned char themes_tint2rc[] = {
0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61,
0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20, 0x74, 0x69, 0x6e, 0x74, 0x32,
0x63, 0x6f, 0x6e, 0x66, 0x20, 0x32, 0x36, 0x34, 0x31, 0x20, 0x2d, 0x2d,
0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x53, 0x65, 0x65, 0x20, 0x68, 0x74, 0x74,
0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x6c, 0x61, 0x62, 0x2e,
0x63, 0x6f, 0x6d, 0x2f, 0x6f, 0x39, 0x30, 0x30, 0x30, 0x2f, 0x74, 0x69,
0x6e, 0x74, 0x32, 0x2f, 0x77, 0x69, 0x6b, 0x69, 0x73, 0x2f, 0x43, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20,
0x0a, 0x23, 0x20, 0x66, 0x75, 0x6c, 0x6c, 0x20, 0x64, 0x6f, 0x63, 0x75,
0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66,
0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75,
0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x2e, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x42, 0x61, 0x63,
0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x0a, 0x23, 0x20, 0x42,
0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x31, 0x3a,
0x20, 0x50, 0x61, 0x6e, 0x65, 0x6c, 0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64,
0x65, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65,
0x72, 0x5f, 0x77, 0x69, 0x64, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x30, 0x0a,
0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63,
0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x20, 0x36, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72,
0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x20, 0x33, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b,
0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x20, 0x36, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64,
0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76,
0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x20, 0x33, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75,
0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65,
0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x20, 0x36, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72,
0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73,
0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x20, 0x33, 0x30, 0x0a, 0x0a, 0x23, 0x20, 0x42, 0x61, 0x63, 0x6b, 0x67,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x32, 0x3a, 0x20, 0x44, 0x65, 0x66,
0x61, 0x75, 0x6c, 0x74, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x2c, 0x20, 0x49,
0x63, 0x6f, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x74, 0x61, 0x73,
0x6b, 0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x3d, 0x20,
0x34, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x77, 0x69, 0x64,
0x74, 0x68, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20,
0x3d, 0x20, 0x23, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x20, 0x32, 0x30,
0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f,
0x72, 0x20, 0x3d, 0x20, 0x23, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x20,
0x33, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e,
0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65,
0x72, 0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x20,
0x32, 0x32, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f,
0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20,
0x23, 0x65, 0x61, 0x65, 0x61, 0x65, 0x61, 0x20, 0x34, 0x34, 0x0a, 0x62,
0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f,
0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20,
0x3d, 0x20, 0x23, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x20, 0x34, 0x0a,
0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23,
0x65, 0x61, 0x65, 0x61, 0x65, 0x61, 0x20, 0x34, 0x34, 0x0a, 0x0a, 0x23,
0x20, 0x42, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20,
0x33, 0x3a, 0x20, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x20, 0x74, 0x61,
0x73, 0x6b, 0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x3d,
0x20, 0x34, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x77, 0x69,
0x64, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62, 0x61, 0x63, 0x6b,
0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
0x20, 0x3d, 0x20, 0x23, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x20, 0x32,
0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c,
0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
0x20, 0x34, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75,
0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76,
0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61,
0x20, 0x32, 0x32, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63,
0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d,
0x20, 0x23, 0x65, 0x61, 0x65, 0x61, 0x65, 0x61, 0x20, 0x34, 0x34, 0x0a,
0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63,
0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64,
0x20, 0x3d, 0x20, 0x23, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x20, 0x34,
0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f,
0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20,
0x23, 0x65, 0x61, 0x65, 0x61, 0x65, 0x61, 0x20, 0x34, 0x34, 0x0a, 0x0a,
0x23, 0x20, 0x42, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64,
0x20, 0x34, 0x3a, 0x20, 0x55, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x20, 0x74,
0x61, 0x73, 0x6b, 0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x20,
0x3d, 0x20, 0x34, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x77,
0x69, 0x64, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62, 0x61, 0x63,
0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f,
0x72, 0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x34, 0x34, 0x30, 0x30, 0x20,
0x31, 0x30, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63,
0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x37, 0x37,
0x33, 0x33, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f,
0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x63, 0x63, 0x37,
0x37, 0x30, 0x30, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64,
0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76,
0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x37, 0x37, 0x33, 0x33,
0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f,
0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72,
0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x35, 0x35, 0x35,
0x35, 0x35, 0x35, 0x20, 0x34, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72,
0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73,
0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x37, 0x37, 0x33, 0x33,
0x20, 0x31, 0x30, 0x30, 0x0a, 0x0a, 0x23, 0x20, 0x42, 0x61, 0x63, 0x6b,
0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x35, 0x3a, 0x20, 0x54, 0x6f,
0x6f, 0x6c, 0x74, 0x69, 0x70, 0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65,
0x64, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72,
0x5f, 0x77, 0x69, 0x64, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62,
0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f,
0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x61,
0x61, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72,
0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x61, 0x63,
0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f,
0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66,
0x66, 0x66, 0x66, 0x61, 0x61, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x6f,
0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68,
0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f,
0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x66,
0x66, 0x66, 0x66, 0x61, 0x61, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x6f,
0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70,
0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x0a, 0x23, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x0a, 0x23, 0x20, 0x50, 0x61, 0x6e, 0x65, 0x6c, 0x0a, 0x70, 0x61, 0x6e,
0x65, 0x6c, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x73, 0x20, 0x3d, 0x20, 0x4c,
0x54, 0x53, 0x43, 0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f, 0x73, 0x69,
0x7a, 0x65, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x30, 0x25, 0x20, 0x33, 0x30,
0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69,
0x6e, 0x20, 0x3d, 0x20, 0x30, 0x20, 0x30, 0x0a, 0x70, 0x61, 0x6e, 0x65,
0x6c, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20,
0x32, 0x20, 0x30, 0x20, 0x32, 0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f,
0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69,
0x64, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x77, 0x6d, 0x5f, 0x6d, 0x65, 0x6e,
0x75, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f,
0x64, 0x6f, 0x63, 0x6b, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x70, 0x61, 0x6e,
0x65, 0x6c, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20,
0x3d, 0x20, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x20, 0x63, 0x65, 0x6e,
0x74, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x74,
0x61, 0x6c, 0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f, 0x6c, 0x61, 0x79,
0x65, 0x72, 0x20, 0x3d, 0x20, 0x74, 0x6f, 0x70, 0x0a, 0x70, 0x61, 0x6e,
0x65, 0x6c, 0x5f, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x20, 0x3d,
0x20, 0x61, 0x6c, 0x6c, 0x0a, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79,
0x5f, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x5f, 0x66, 0x69, 0x72,
0x73, 0x74, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x68,
0x69, 0x64, 0x65, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x61, 0x75, 0x74, 0x6f,
0x68, 0x69, 0x64, 0x65, 0x5f, 0x73, 0x68, 0x6f, 0x77, 0x5f, 0x74, 0x69,
0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x61, 0x75,
0x74, 0x6f, 0x68, 0x69, 0x64, 0x65, 0x5f, 0x68, 0x69, 0x64, 0x65, 0x5f,
0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x30, 0x2e,
0x35, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x68, 0x69, 0x64, 0x65, 0x5f, 0x68,
0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x3d, 0x20, 0x32, 0x0a, 0x73, 0x74,
0x72, 0x75, 0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x20, 0x3d,
0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x69, 0x7a, 0x65,
0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f,
0x77, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x3d, 0x20, 0x74, 0x69, 0x6e,
0x74, 0x32, 0x0a, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x74,
0x72, 0x61, 0x6e, 0x73, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x20,
0x3d, 0x20, 0x31, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x65, 0x66,
0x66, 0x65, 0x63, 0x74, 0x73, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x66, 0x6f,
0x6e, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, 0x20, 0x3d, 0x20,
0x30, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x68, 0x6f, 0x76, 0x65,
0x72, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x61, 0x73, 0x62, 0x20, 0x3d,
0x20, 0x31, 0x30, 0x30, 0x20, 0x30, 0x20, 0x31, 0x30, 0x0a, 0x6d, 0x6f,
0x75, 0x73, 0x65, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x5f,
0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x61, 0x73, 0x62, 0x20, 0x3d, 0x20, 0x31,
0x30, 0x30, 0x20, 0x30, 0x20, 0x30, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23,
0x20, 0x54, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x0a, 0x74, 0x61, 0x73,
0x6b, 0x62, 0x61, 0x72, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x3d, 0x20,
0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x73, 0x6b, 0x74,
0x6f, 0x70, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x70,
0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x30, 0x20, 0x30,
0x20, 0x32, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x62,
0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64,
0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72,
0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x61, 0x63, 0x6b,
0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20,
0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x6e, 0x61,
0x6d, 0x65, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62,
0x61, 0x72, 0x5f, 0x68, 0x69, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x61, 0x63,
0x74, 0x69, 0x76, 0x65, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x73, 0x20, 0x3d,
0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x68,
0x69, 0x64, 0x65, 0x5f, 0x64, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e,
0x74, 0x5f, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20,
0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x61, 0x6c,
0x77, 0x61, 0x79, 0x73, 0x5f, 0x73, 0x68, 0x6f, 0x77, 0x5f, 0x61, 0x6c,
0x6c, 0x5f, 0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x61,
0x73, 0x6b, 0x73, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b,
0x62, 0x61, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x70, 0x61, 0x64,
0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x34, 0x20, 0x32, 0x0a, 0x74,
0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f,
0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69,
0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61,
0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76,
0x65, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64,
0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b,
0x62, 0x61, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x66, 0x6f, 0x6e,
0x74, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x65,
0x33, 0x65, 0x33, 0x65, 0x33, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x74, 0x61,
0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x61,
0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x66, 0x6f, 0x6e, 0x74, 0x5f, 0x63,
0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66,
0x66, 0x66, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62,
0x61, 0x72, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74,
0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74,
0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x73, 0x6f, 0x72, 0x74, 0x5f,
0x6f, 0x72, 0x64, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x6e, 0x6f, 0x6e, 0x65,
0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x61, 0x6c, 0x69, 0x67, 0x6e, 0x20,
0x3d, 0x20, 0x6c, 0x65, 0x66, 0x74, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23,
0x20, 0x54, 0x61, 0x73, 0x6b, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x74,
0x65, 0x78, 0x74, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x74, 0x61, 0x73, 0x6b,
0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x74, 0x61,
0x73, 0x6b, 0x5f, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x65, 0x64, 0x20,
0x3d, 0x20, 0x31, 0x0a, 0x75, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x6e,
0x62, 0x5f, 0x6f, 0x66, 0x5f, 0x62, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x3d,
0x20, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b,
0x5f, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x73, 0x69, 0x7a,
0x65, 0x20, 0x3d, 0x20, 0x31, 0x35, 0x30, 0x20, 0x33, 0x35, 0x0a, 0x74,
0x61, 0x73, 0x6b, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20,
0x3d, 0x20, 0x32, 0x20, 0x32, 0x20, 0x34, 0x0a, 0x74, 0x61, 0x73, 0x6b,
0x5f, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x20, 0x3d, 0x20, 0x31,
0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x66, 0x6f, 0x6e, 0x74, 0x5f, 0x63,
0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66,
0x66, 0x66, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f,
0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69,
0x64, 0x20, 0x3d, 0x20, 0x32, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x61,
0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72,
0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x33, 0x0a,
0x74, 0x61, 0x73, 0x6b, 0x5f, 0x75, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x5f,
0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69,
0x64, 0x20, 0x3d, 0x20, 0x34, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69,
0x63, 0x6f, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x62, 0x61, 0x63,
0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d,
0x20, 0x32, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x6c, 0x65, 0x66,
0x74, 0x20, 0x3d, 0x20, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x5f, 0x69,
0x63, 0x6f, 0x6e, 0x69, 0x66, 0x79, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65,
0x5f, 0x6d, 0x69, 0x64, 0x64, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0x6e, 0x6f,
0x6e, 0x65, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x72, 0x69, 0x67,
0x68, 0x74, 0x20, 0x3d, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x0a, 0x6d,
0x6f, 0x75, 0x73, 0x65, 0x5f, 0x73, 0x63, 0x72, 0x6f, 0x6c, 0x6c, 0x5f,
0x75, 0x70, 0x20, 0x3d, 0x20, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x0a,
0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x73, 0x63, 0x72, 0x6f, 0x6c, 0x6c,
0x5f, 0x64, 0x6f, 0x77, 0x6e, 0x20, 0x3d, 0x20, 0x69, 0x63, 0x6f, 0x6e,
0x69, 0x66, 0x79, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x53, 0x79,
0x73, 0x74, 0x65, 0x6d, 0x20, 0x74, 0x72, 0x61, 0x79, 0x20, 0x28, 0x6e,
0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20,
0x61, 0x72, 0x65, 0x61, 0x29, 0x0a, 0x73, 0x79, 0x73, 0x74, 0x72, 0x61,
0x79, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20,
0x30, 0x20, 0x34, 0x20, 0x32, 0x0a, 0x73, 0x79, 0x73, 0x74, 0x72, 0x61,
0x79, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64,
0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x73, 0x79, 0x73, 0x74,
0x72, 0x61, 0x79, 0x5f, 0x73, 0x6f, 0x72, 0x74, 0x20, 0x3d, 0x20, 0x61,
0x73, 0x63, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x0a, 0x73, 0x79, 0x73,
0x74, 0x72, 0x61, 0x79, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x73, 0x69,
0x7a, 0x65, 0x20, 0x3d, 0x20, 0x32, 0x34, 0x0a, 0x73, 0x79, 0x73, 0x74,
0x72, 0x61, 0x79, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x61, 0x73, 0x62,
0x20, 0x3d, 0x20, 0x31, 0x30, 0x30, 0x20, 0x30, 0x20, 0x30, 0x0a, 0x73,
0x79, 0x73, 0x74, 0x72, 0x61, 0x79, 0x5f, 0x6d, 0x6f, 0x6e, 0x69, 0x74,
0x6f, 0x72, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23,
0x20, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x0a, 0x6c, 0x61,
0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69,
0x6e, 0x67, 0x20, 0x3d, 0x20, 0x32, 0x20, 0x34, 0x20, 0x32, 0x0a, 0x6c,
0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x62, 0x61, 0x63, 0x6b,
0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20,
0x30, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69,
0x63, 0x6f, 0x6e, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75,
0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x6c, 0x61,
0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f,
0x73, 0x69, 0x7a, 0x65, 0x20, 0x3d, 0x20, 0x32, 0x34, 0x0a, 0x6c, 0x61,
0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f,
0x61, 0x73, 0x62, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x30, 0x20, 0x30, 0x20,
0x30, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69,
0x63, 0x6f, 0x6e, 0x5f, 0x74, 0x68, 0x65, 0x6d, 0x65, 0x5f, 0x6f, 0x76,
0x65, 0x72, 0x72, 0x69, 0x64, 0x65, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x73,
0x74, 0x61, 0x72, 0x74, 0x75, 0x70, 0x5f, 0x6e, 0x6f, 0x74, 0x69, 0x66,
0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x3d, 0x20, 0x31,
0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x74, 0x6f,
0x6f, 0x6c, 0x74, 0x69, 0x70, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x6c, 0x61,
0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f,
0x61, 0x70, 0x70, 0x20, 0x3d, 0x20, 0x2f, 0x75, 0x73, 0x72, 0x2f, 0x73,
0x68, 0x61, 0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x74, 0x69, 0x6e, 0x74, 0x32, 0x63,
0x6f, 0x6e, 0x66, 0x2e, 0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a,
0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65,
0x6d, 0x5f, 0x61, 0x70, 0x70, 0x20, 0x3d, 0x20, 0x2f, 0x75, 0x73, 0x72,
0x2f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x2f, 0x73, 0x68, 0x61, 0x72, 0x65,
0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x2f, 0x74, 0x69, 0x6e, 0x74, 0x32, 0x63, 0x6f, 0x6e, 0x66, 0x2e,
0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a, 0x6c, 0x61, 0x75, 0x6e,
0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x61, 0x70,
0x70, 0x20, 0x3d, 0x20, 0x2f, 0x75, 0x73, 0x72, 0x2f, 0x73, 0x68, 0x61,
0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x2f, 0x66, 0x69, 0x72, 0x65, 0x66, 0x6f, 0x78, 0x2e,
0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a, 0x6c, 0x61, 0x75, 0x6e,
0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x61, 0x70,
0x70, 0x20, 0x3d, 0x20, 0x2f, 0x75, 0x73, 0x72, 0x2f, 0x73, 0x68, 0x61,
0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69,
0x6f, 0x6e, 0x73, 0x2f, 0x69, 0x63, 0x65, 0x77, 0x65, 0x61, 0x73, 0x65,
0x6c, 0x2e, 0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a, 0x6c, 0x61,
0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f,
0x61, 0x70, 0x70, 0x20, 0x3d, 0x20, 0x2f, 0x75, 0x73, 0x72, 0x2f, 0x73,
0x68, 0x61, 0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61,
0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x63, 0x68, 0x72, 0x6f, 0x6d, 0x69,
0x75, 0x6d, 0x2d, 0x62, 0x72, 0x6f, 0x77, 0x73, 0x65, 0x72, 0x2e, 0x64,
0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63,
0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x61, 0x70, 0x70,
0x20, 0x3d, 0x20, 0x2f, 0x75, 0x73, 0x72, 0x2f, 0x73, 0x68, 0x61, 0x72,
0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2d, 0x63, 0x68,
0x72, 0x6f, 0x6d, 0x65, 0x2e, 0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70,
0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x43, 0x6c, 0x6f, 0x63, 0x6b,
0x0a, 0x74, 0x69, 0x6d, 0x65, 0x31, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61,
0x74, 0x20, 0x3d, 0x20, 0x25, 0x48, 0x3a, 0x25, 0x4d, 0x0a, 0x74, 0x69,
0x6d, 0x65, 0x32, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d,
0x20, 0x25, 0x41, 0x20, 0x25, 0x64, 0x20, 0x25, 0x42, 0x0a, 0x74, 0x69,
0x6d, 0x65, 0x31, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x7a, 0x6f, 0x6e, 0x65,
0x20, 0x3d, 0x20, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x32, 0x5f, 0x74, 0x69,
0x6d, 0x65, 0x7a, 0x6f, 0x6e, 0x65, 0x20, 0x3d, 0x20, 0x0a, 0x63, 0x6c,
0x6f, 0x63, 0x6b, 0x5f, 0x66, 0x6f, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6c,
0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
0x20, 0x31, 0x30, 0x30, 0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x70,
0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x32, 0x20, 0x30,
0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30,
0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x6f, 0x6f, 0x6c, 0x74,
0x69, 0x70, 0x20, 0x3d, 0x20, 0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f,
0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65,
0x7a, 0x6f, 0x6e, 0x65, 0x20, 0x3d, 0x20, 0x0a, 0x63, 0x6c, 0x6f, 0x63,
0x6b, 0x5f, 0x6c, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x5f, 0x63, 0x6f, 0x6d,
0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x63, 0x6c, 0x6f, 0x63,
0x6b, 0x5f, 0x72, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x5f, 0x63, 0x6f, 0x6d,
0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x6f, 0x72, 0x61, 0x67, 0x65,
0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6d, 0x63, 0x6c, 0x69, 0x63,
0x6b, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20,
0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x75, 0x77, 0x68, 0x65, 0x65,
0x6c, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20,
0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x64, 0x77, 0x68, 0x65, 0x65,
0x6c, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20,
0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x42, 0x61, 0x74, 0x74, 0x65,
0x72, 0x79, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x74,
0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62,
0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x6c, 0x6f, 0x77, 0x5f, 0x73,
0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x0a, 0x62,
0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x6c, 0x6f, 0x77, 0x5f, 0x63,
0x6d, 0x64, 0x20, 0x3d, 0x20, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x79, 0x2d,
0x73, 0x65, 0x6e, 0x64, 0x20, 0x22, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72,
0x79, 0x20, 0x6c, 0x6f, 0x77, 0x22, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65,
0x72, 0x79, 0x5f, 0x66, 0x6f, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6c, 0x6f,
0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x20,
0x31, 0x30, 0x30, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f,
0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x31, 0x20,
0x30, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x62, 0x61,
0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20,
0x3d, 0x20, 0x30, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f,
0x68, 0x69, 0x64, 0x65, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x31, 0x0a, 0x62,
0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x6c, 0x63, 0x6c, 0x69, 0x63,
0x6b, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20,
0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x72, 0x63, 0x6c,
0x69, 0x63, 0x6b, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20,
0x3d, 0x20, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x6d,
0x63, 0x6c, 0x69, 0x63, 0x6b, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e,
0x64, 0x20, 0x3d, 0x20, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79,
0x5f, 0x75, 0x77, 0x68, 0x65, 0x65, 0x6c, 0x5f, 0x63, 0x6f, 0x6d, 0x6d,
0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65,
0x72, 0x79, 0x5f, 0x64, 0x77, 0x68, 0x65, 0x65, 0x6c, 0x5f, 0x63, 0x6f,
0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x61, 0x63, 0x5f,
0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6d,
0x64, 0x20, 0x3d, 0x20, 0x0a, 0x61, 0x63, 0x5f, 0x64, 0x69, 0x73, 0x63,
0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6d, 0x64,
0x20, 0x3d, 0x20, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x54, 0x6f,
0x6f, 0x6c, 0x74, 0x69, 0x70, 0x0a, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69,
0x70, 0x5f, 0x73, 0x68, 0x6f, 0x77, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f,
0x75, 0x74, 0x20, 0x3d, 0x20, 0x30, 0x2e, 0x35, 0x0a, 0x74, 0x6f, 0x6f,
0x6c, 0x74, 0x69, 0x70, 0x5f, 0x68, 0x69, 0x64, 0x65, 0x5f, 0x74, 0x69,
0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x30, 0x2e, 0x31, 0x0a,
0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f, 0x70, 0x61, 0x64, 0x64,
0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x32, 0x20, 0x32, 0x0a, 0x74, 0x6f,
0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72,
0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x35, 0x0a,
0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f, 0x66, 0x6f, 0x6e, 0x74,
0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x32, 0x32,
0x32, 0x32, 0x32, 0x32, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x0a
};
unsigned char themes_tint2rc[] =
{0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x20, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x74, 0x65, 0x64, 0x20, 0x62, 0x79, 0x20,
0x74, 0x69, 0x6e, 0x74, 0x32, 0x63, 0x6f, 0x6e, 0x66, 0x20, 0x32, 0x36, 0x34, 0x31, 0x20, 0x2d, 0x2d, 0x2d, 0x2d,
0x0a, 0x23, 0x20, 0x53, 0x65, 0x65, 0x20, 0x68, 0x74, 0x74, 0x70, 0x73, 0x3a, 0x2f, 0x2f, 0x67, 0x69, 0x74, 0x6c,
0x61, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6f, 0x39, 0x30, 0x30, 0x30, 0x2f, 0x74, 0x69, 0x6e, 0x74, 0x32, 0x2f,
0x77, 0x69, 0x6b, 0x69, 0x73, 0x2f, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x20, 0x66, 0x6f, 0x72,
0x20, 0x0a, 0x23, 0x20, 0x66, 0x75, 0x6c, 0x6c, 0x20, 0x64, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x66, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72,
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x0a, 0x23, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x42,
0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x0a, 0x23, 0x20, 0x42, 0x61, 0x63, 0x6b, 0x67, 0x72,
0x6f, 0x75, 0x6e, 0x64, 0x20, 0x31, 0x3a, 0x20, 0x50, 0x61, 0x6e, 0x65, 0x6c, 0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64,
0x65, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x77, 0x69, 0x64, 0x74, 0x68,
0x20, 0x3d, 0x20, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c,
0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x36, 0x30, 0x0a, 0x62, 0x6f, 0x72,
0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x20, 0x33, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f,
0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x36,
0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65,
0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x33, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b,
0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65,
0x64, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x36, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64,
0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20,
0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x33, 0x30, 0x0a, 0x0a, 0x23, 0x20, 0x42, 0x61, 0x63, 0x6b, 0x67,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x32, 0x3a, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x74, 0x61,
0x73, 0x6b, 0x2c, 0x20, 0x49, 0x63, 0x6f, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x0a,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x34, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f,
0x77, 0x69, 0x64, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e,
0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x20, 0x32,
0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x37,
0x37, 0x37, 0x37, 0x37, 0x37, 0x20, 0x33, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64,
0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x61,
0x61, 0x61, 0x61, 0x20, 0x32, 0x32, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x65, 0x61, 0x65, 0x61, 0x65, 0x61, 0x20, 0x34, 0x34,
0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70,
0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x20, 0x34, 0x0a,
0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65,
0x64, 0x20, 0x3d, 0x20, 0x23, 0x65, 0x61, 0x65, 0x61, 0x65, 0x61, 0x20, 0x34, 0x34, 0x0a, 0x0a, 0x23, 0x20, 0x42,
0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x33, 0x3a, 0x20, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65,
0x20, 0x74, 0x61, 0x73, 0x6b, 0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x34, 0x0a, 0x62,
0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x77, 0x69, 0x64, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62, 0x61, 0x63,
0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x37, 0x37,
0x37, 0x37, 0x37, 0x37, 0x20, 0x32, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f,
0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x20, 0x34, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b,
0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20,
0x3d, 0x20, 0x23, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x20, 0x32, 0x32, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72,
0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x65, 0x61, 0x65,
0x61, 0x65, 0x61, 0x20, 0x34, 0x34, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63,
0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x35, 0x35, 0x35,
0x35, 0x35, 0x35, 0x20, 0x34, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f,
0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x65, 0x61, 0x65, 0x61, 0x65, 0x61, 0x20, 0x34,
0x34, 0x0a, 0x0a, 0x23, 0x20, 0x42, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x34, 0x3a, 0x20,
0x55, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x20, 0x74, 0x61, 0x73, 0x6b, 0x0a, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64,
0x20, 0x3d, 0x20, 0x34, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x77, 0x69, 0x64, 0x74, 0x68, 0x20, 0x3d,
0x20, 0x31, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72,
0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x34, 0x34, 0x30, 0x30, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64,
0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x37, 0x37, 0x33, 0x33, 0x20,
0x31, 0x30, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f,
0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x63, 0x63, 0x37, 0x37, 0x30, 0x30, 0x20, 0x31,
0x30, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76,
0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x61, 0x61, 0x37, 0x37, 0x33, 0x33, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x61,
0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73,
0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x20, 0x34, 0x0a, 0x62, 0x6f, 0x72,
0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d,
0x20, 0x23, 0x61, 0x61, 0x37, 0x37, 0x33, 0x33, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x0a, 0x23, 0x20, 0x42, 0x61, 0x63,
0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x35, 0x3a, 0x20, 0x54, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x0a,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f,
0x77, 0x69, 0x64, 0x74, 0x68, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e,
0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x61, 0x61, 0x20, 0x31,
0x30, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23,
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75,
0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66,
0x66, 0x66, 0x66, 0x61, 0x61, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f,
0x6c, 0x6f, 0x72, 0x5f, 0x68, 0x6f, 0x76, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x63, 0x6f, 0x6c,
0x6f, 0x72, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x61,
0x61, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x6f, 0x72, 0x64, 0x65, 0x72, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x5f,
0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x23, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x31,
0x30, 0x30, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x50, 0x61, 0x6e, 0x65, 0x6c, 0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f,
0x69, 0x74, 0x65, 0x6d, 0x73, 0x20, 0x3d, 0x20, 0x4c, 0x54, 0x53, 0x43, 0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f,
0x73, 0x69, 0x7a, 0x65, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x30, 0x25, 0x20, 0x33, 0x30, 0x0a, 0x70, 0x61, 0x6e, 0x65,
0x6c, 0x5f, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x20, 0x3d, 0x20, 0x30, 0x20, 0x30, 0x0a, 0x70, 0x61, 0x6e, 0x65,
0x6c, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x32, 0x20, 0x30, 0x20, 0x32, 0x0a, 0x70,
0x61, 0x6e, 0x65, 0x6c, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20,
0x3d, 0x20, 0x31, 0x0a, 0x77, 0x6d, 0x5f, 0x6d, 0x65, 0x6e, 0x75, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x70, 0x61, 0x6e,
0x65, 0x6c, 0x5f, 0x64, 0x6f, 0x63, 0x6b, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f, 0x70,
0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x62, 0x6f, 0x74, 0x74, 0x6f, 0x6d, 0x20, 0x63, 0x65,
0x6e, 0x74, 0x65, 0x72, 0x20, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x6f, 0x6e, 0x74, 0x61, 0x6c, 0x0a, 0x70, 0x61, 0x6e,
0x65, 0x6c, 0x5f, 0x6c, 0x61, 0x79, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x74, 0x6f, 0x70, 0x0a, 0x70, 0x61, 0x6e, 0x65,
0x6c, 0x5f, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x61, 0x6c, 0x6c, 0x0a, 0x70, 0x72, 0x69,
0x6d, 0x61, 0x72, 0x79, 0x5f, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x5f, 0x66, 0x69, 0x72, 0x73, 0x74, 0x20,
0x3d, 0x20, 0x30, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x68, 0x69, 0x64, 0x65, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x61, 0x75,
0x74, 0x6f, 0x68, 0x69, 0x64, 0x65, 0x5f, 0x73, 0x68, 0x6f, 0x77, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74,
0x20, 0x3d, 0x20, 0x30, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x68, 0x69, 0x64, 0x65, 0x5f, 0x68, 0x69, 0x64, 0x65, 0x5f,
0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x30, 0x2e, 0x35, 0x0a, 0x61, 0x75, 0x74, 0x6f, 0x68,
0x69, 0x64, 0x65, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x20, 0x3d, 0x20, 0x32, 0x0a, 0x73, 0x74, 0x72, 0x75,
0x74, 0x5f, 0x70, 0x6f, 0x6c, 0x69, 0x63, 0x79, 0x20, 0x3d, 0x20, 0x66, 0x6f, 0x6c, 0x6c, 0x6f, 0x77, 0x5f, 0x73,
0x69, 0x7a, 0x65, 0x0a, 0x70, 0x61, 0x6e, 0x65, 0x6c, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x5f, 0x6e, 0x61,
0x6d, 0x65, 0x20, 0x3d, 0x20, 0x74, 0x69, 0x6e, 0x74, 0x32, 0x0a, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x5f,
0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x63, 0x79, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x6d, 0x6f,
0x75, 0x73, 0x65, 0x5f, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x73, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x66, 0x6f, 0x6e,
0x74, 0x5f, 0x73, 0x68, 0x61, 0x64, 0x6f, 0x77, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f,
0x68, 0x6f, 0x76, 0x65, 0x72, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x61, 0x73, 0x62, 0x20, 0x3d, 0x20, 0x31, 0x30,
0x30, 0x20, 0x30, 0x20, 0x31, 0x30, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65,
0x64, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x61, 0x73, 0x62, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x30, 0x20, 0x30, 0x20,
0x30, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62,
0x61, 0x72, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x20, 0x3d, 0x20, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x5f, 0x64, 0x65,
0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69,
0x6e, 0x67, 0x20, 0x3d, 0x20, 0x30, 0x20, 0x30, 0x20, 0x32, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f,
0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74,
0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61,
0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f,
0x68, 0x69, 0x64, 0x65, 0x5f, 0x69, 0x6e, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x74, 0x61, 0x73, 0x6b, 0x73,
0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x68, 0x69, 0x64, 0x65, 0x5f, 0x64,
0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20,
0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x5f, 0x73, 0x68,
0x6f, 0x77, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x61, 0x73, 0x6b,
0x73, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f,
0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x34, 0x20, 0x32, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62,
0x61, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f,
0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f,
0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
0x5f, 0x66, 0x6f, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x65, 0x33, 0x65, 0x33,
0x65, 0x33, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65,
0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x66, 0x6f, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20,
0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62,
0x61, 0x72, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x20,
0x3d, 0x20, 0x30, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x62, 0x61, 0x72, 0x5f, 0x73, 0x6f, 0x72, 0x74, 0x5f, 0x6f, 0x72,
0x64, 0x65, 0x72, 0x20, 0x3d, 0x20, 0x6e, 0x6f, 0x6e, 0x65, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x61, 0x6c, 0x69,
0x67, 0x6e, 0x20, 0x3d, 0x20, 0x6c, 0x65, 0x66, 0x74, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x54, 0x61, 0x73, 0x6b, 0x0a,
0x74, 0x61, 0x73, 0x6b, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f,
0x69, 0x63, 0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x63, 0x65, 0x6e, 0x74, 0x65,
0x72, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x75, 0x72, 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x6e, 0x62, 0x5f, 0x6f,
0x66, 0x5f, 0x62, 0x6c, 0x69, 0x6e, 0x6b, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x0a, 0x74, 0x61,
0x73, 0x6b, 0x5f, 0x6d, 0x61, 0x78, 0x69, 0x6d, 0x75, 0x6d, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x20, 0x3d, 0x20, 0x31,
0x35, 0x30, 0x20, 0x33, 0x35, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20,
0x3d, 0x20, 0x32, 0x20, 0x32, 0x20, 0x34, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69,
0x70, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x66, 0x6f, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6c,
0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x74, 0x61,
0x73, 0x6b, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20,
0x32, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67,
0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x33, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x75,
0x72, 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64,
0x20, 0x3d, 0x20, 0x34, 0x0a, 0x74, 0x61, 0x73, 0x6b, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x69, 0x66, 0x69, 0x65, 0x64,
0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x32, 0x0a,
0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x6c, 0x65, 0x66, 0x74, 0x20, 0x3d, 0x20, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0x65,
0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x69, 0x66, 0x79, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x6d, 0x69, 0x64, 0x64,
0x6c, 0x65, 0x20, 0x3d, 0x20, 0x6e, 0x6f, 0x6e, 0x65, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x72, 0x69, 0x67,
0x68, 0x74, 0x20, 0x3d, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x0a, 0x6d, 0x6f, 0x75, 0x73, 0x65, 0x5f, 0x73, 0x63,
0x72, 0x6f, 0x6c, 0x6c, 0x5f, 0x75, 0x70, 0x20, 0x3d, 0x20, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x0a, 0x6d, 0x6f,
0x75, 0x73, 0x65, 0x5f, 0x73, 0x63, 0x72, 0x6f, 0x6c, 0x6c, 0x5f, 0x64, 0x6f, 0x77, 0x6e, 0x20, 0x3d, 0x20, 0x69,
0x63, 0x6f, 0x6e, 0x69, 0x66, 0x79, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x53, 0x79, 0x73, 0x74, 0x65, 0x6d, 0x20, 0x74,
0x72, 0x61, 0x79, 0x20, 0x28, 0x6e, 0x6f, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x61,
0x72, 0x65, 0x61, 0x29, 0x0a, 0x73, 0x79, 0x73, 0x74, 0x72, 0x61, 0x79, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e,
0x67, 0x20, 0x3d, 0x20, 0x30, 0x20, 0x34, 0x20, 0x32, 0x0a, 0x73, 0x79, 0x73, 0x74, 0x72, 0x61, 0x79, 0x5f, 0x62,
0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x73, 0x79,
0x73, 0x74, 0x72, 0x61, 0x79, 0x5f, 0x73, 0x6f, 0x72, 0x74, 0x20, 0x3d, 0x20, 0x61, 0x73, 0x63, 0x65, 0x6e, 0x64,
0x69, 0x6e, 0x67, 0x0a, 0x73, 0x79, 0x73, 0x74, 0x72, 0x61, 0x79, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x73, 0x69,
0x7a, 0x65, 0x20, 0x3d, 0x20, 0x32, 0x34, 0x0a, 0x73, 0x79, 0x73, 0x74, 0x72, 0x61, 0x79, 0x5f, 0x69, 0x63, 0x6f,
0x6e, 0x5f, 0x61, 0x73, 0x62, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x30, 0x20, 0x30, 0x20, 0x30, 0x0a, 0x73, 0x79, 0x73,
0x74, 0x72, 0x61, 0x79, 0x5f, 0x6d, 0x6f, 0x6e, 0x69, 0x74, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x0a, 0x23,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a,
0x23, 0x20, 0x4c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72,
0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x32, 0x20, 0x34, 0x20, 0x32, 0x0a, 0x6c, 0x61,
0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69,
0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x63, 0x6f, 0x6e,
0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a,
0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x20,
0x3d, 0x20, 0x32, 0x34, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f,
0x61, 0x73, 0x62, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x30, 0x20, 0x30, 0x20, 0x30, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63,
0x68, 0x65, 0x72, 0x5f, 0x69, 0x63, 0x6f, 0x6e, 0x5f, 0x74, 0x68, 0x65, 0x6d, 0x65, 0x5f, 0x6f, 0x76, 0x65, 0x72,
0x72, 0x69, 0x64, 0x65, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x75, 0x70, 0x5f, 0x6e, 0x6f,
0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x6c, 0x61, 0x75,
0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x6c,
0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x61, 0x70, 0x70, 0x20, 0x3d, 0x20,
0x2f, 0x75, 0x73, 0x72, 0x2f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x74, 0x69, 0x6e, 0x74, 0x32, 0x63, 0x6f, 0x6e, 0x66, 0x2e, 0x64, 0x65, 0x73, 0x6b,
0x74, 0x6f, 0x70, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x61,
0x70, 0x70, 0x20, 0x3d, 0x20, 0x2f, 0x75, 0x73, 0x72, 0x2f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x2f, 0x73, 0x68, 0x61,
0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x74, 0x69, 0x6e,
0x74, 0x32, 0x63, 0x6f, 0x6e, 0x66, 0x2e, 0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a, 0x6c, 0x61, 0x75, 0x6e,
0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x61, 0x70, 0x70, 0x20, 0x3d, 0x20, 0x2f, 0x75, 0x73,
0x72, 0x2f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e,
0x73, 0x2f, 0x66, 0x69, 0x72, 0x65, 0x66, 0x6f, 0x78, 0x2e, 0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a, 0x6c,
0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x61, 0x70, 0x70, 0x20, 0x3d, 0x20,
0x2f, 0x75, 0x73, 0x72, 0x2f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74,
0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x69, 0x63, 0x65, 0x77, 0x65, 0x61, 0x73, 0x65, 0x6c, 0x2e, 0x64, 0x65, 0x73, 0x6b,
0x74, 0x6f, 0x70, 0x0a, 0x6c, 0x61, 0x75, 0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x61,
0x70, 0x70, 0x20, 0x3d, 0x20, 0x2f, 0x75, 0x73, 0x72, 0x2f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2f, 0x61, 0x70, 0x70,
0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x63, 0x68, 0x72, 0x6f, 0x6d, 0x69, 0x75, 0x6d, 0x2d,
0x62, 0x72, 0x6f, 0x77, 0x73, 0x65, 0x72, 0x2e, 0x64, 0x65, 0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a, 0x6c, 0x61, 0x75,
0x6e, 0x63, 0x68, 0x65, 0x72, 0x5f, 0x69, 0x74, 0x65, 0x6d, 0x5f, 0x61, 0x70, 0x70, 0x20, 0x3d, 0x20, 0x2f, 0x75,
0x73, 0x72, 0x2f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x2f, 0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f,
0x6e, 0x73, 0x2f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2d, 0x63, 0x68, 0x72, 0x6f, 0x6d, 0x65, 0x2e, 0x64, 0x65,
0x73, 0x6b, 0x74, 0x6f, 0x70, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x0a, 0x74, 0x69, 0x6d,
0x65, 0x31, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d, 0x20, 0x25, 0x48, 0x3a, 0x25, 0x4d, 0x0a, 0x74,
0x69, 0x6d, 0x65, 0x32, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d, 0x20, 0x25, 0x41, 0x20, 0x25, 0x64,
0x20, 0x25, 0x42, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x31, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x7a, 0x6f, 0x6e, 0x65, 0x20,
0x3d, 0x20, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x32, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x7a, 0x6f, 0x6e, 0x65, 0x20, 0x3d,
0x20, 0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x66, 0x6f, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20,
0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b,
0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x32, 0x20, 0x30, 0x0a, 0x63, 0x6c, 0x6f, 0x63,
0x6b, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30,
0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x20, 0x3d, 0x20, 0x0a, 0x63,
0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x7a, 0x6f,
0x6e, 0x65, 0x20, 0x3d, 0x20, 0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6c, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x5f,
0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x72, 0x63,
0x6c, 0x69, 0x63, 0x6b, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x6f, 0x72, 0x61, 0x67,
0x65, 0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x6d, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x5f, 0x63, 0x6f, 0x6d, 0x6d,
0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x75, 0x77, 0x68, 0x65, 0x65, 0x6c,
0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x64,
0x77, 0x68, 0x65, 0x65, 0x6c, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x0a, 0x23,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a,
0x23, 0x20, 0x42, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x74,
0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x20, 0x3d, 0x20, 0x31, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f,
0x6c, 0x6f, 0x77, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x0a, 0x62, 0x61, 0x74,
0x74, 0x65, 0x72, 0x79, 0x5f, 0x6c, 0x6f, 0x77, 0x5f, 0x63, 0x6d, 0x64, 0x20, 0x3d, 0x20, 0x6e, 0x6f, 0x74, 0x69,
0x66, 0x79, 0x2d, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x22, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x20, 0x6c, 0x6f,
0x77, 0x22, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x66, 0x6f, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6c,
0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x20, 0x31, 0x30, 0x30, 0x0a, 0x62, 0x61,
0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x31, 0x20, 0x30,
0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64,
0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x30, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x68, 0x69, 0x64,
0x65, 0x20, 0x3d, 0x20, 0x31, 0x30, 0x31, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x6c, 0x63, 0x6c,
0x69, 0x63, 0x6b, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x62, 0x61, 0x74, 0x74,
0x65, 0x72, 0x79, 0x5f, 0x72, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20,
0x3d, 0x20, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x6d, 0x63, 0x6c, 0x69, 0x63, 0x6b, 0x5f, 0x63,
0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x62, 0x61, 0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x75,
0x77, 0x68, 0x65, 0x65, 0x6c, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x62, 0x61,
0x74, 0x74, 0x65, 0x72, 0x79, 0x5f, 0x64, 0x77, 0x68, 0x65, 0x65, 0x6c, 0x5f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e,
0x64, 0x20, 0x3d, 0x20, 0x0a, 0x61, 0x63, 0x5f, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x63,
0x6d, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x61, 0x63, 0x5f, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74,
0x65, 0x64, 0x5f, 0x63, 0x6d, 0x64, 0x20, 0x3d, 0x20, 0x0a, 0x0a, 0x23, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x0a, 0x23, 0x20, 0x54, 0x6f, 0x6f, 0x6c, 0x74,
0x69, 0x70, 0x0a, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f, 0x73, 0x68, 0x6f, 0x77, 0x5f, 0x74, 0x69, 0x6d,
0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x30, 0x2e, 0x35, 0x0a, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f,
0x68, 0x69, 0x64, 0x65, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x20, 0x3d, 0x20, 0x30, 0x2e, 0x31, 0x0a,
0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f, 0x70, 0x61, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x32,
0x20, 0x32, 0x0a, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f, 0x62, 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75,
0x6e, 0x64, 0x5f, 0x69, 0x64, 0x20, 0x3d, 0x20, 0x35, 0x0a, 0x74, 0x6f, 0x6f, 0x6c, 0x74, 0x69, 0x70, 0x5f, 0x66,
0x6f, 0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x23, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
0x20, 0x31, 0x30, 0x30, 0x0a, 0x0a};
unsigned int themes_tint2rc_len = 4870;

422
src/tooltip/tooltip.c
View File

@@ -41,290 +41,290 @@ Tooltip g_tooltip;
void default_tooltip()
{
// give the tooltip some reasonable default values
memset(&g_tooltip, 0, sizeof(Tooltip));
// give the tooltip some reasonable default values
memset(&g_tooltip, 0, sizeof(Tooltip));
g_tooltip.font_color.rgb[0] = 1;
g_tooltip.font_color.rgb[1] = 1;
g_tooltip.font_color.rgb[2] = 1;
g_tooltip.font_color.alpha = 1;
just_shown = FALSE;
g_tooltip.font_color.rgb[0] = 1;
g_tooltip.font_color.rgb[1] = 1;
g_tooltip.font_color.rgb[2] = 1;
g_tooltip.font_color.alpha = 1;
just_shown = FALSE;
}
void cleanup_tooltip()
{
stop_tooltip_timeout();
tooltip_hide(NULL);
tooltip_copy_text(NULL);
if (g_tooltip.window)
XDestroyWindow(server.display, g_tooltip.window);
g_tooltip.window = 0;
pango_font_description_free(g_tooltip.font_desc);
g_tooltip.font_desc = NULL;
stop_tooltip_timeout();
tooltip_hide(NULL);
tooltip_copy_text(NULL);
if (g_tooltip.window)
XDestroyWindow(server.display, g_tooltip.window);
g_tooltip.window = 0;
pango_font_description_free(g_tooltip.font_desc);
g_tooltip.font_desc = NULL;
}
void init_tooltip()
{
if (!g_tooltip.bg)
g_tooltip.bg = &g_array_index(backgrounds, Background, 0);
tooltip_init_fonts();
if (!g_tooltip.bg)
g_tooltip.bg = &g_array_index(backgrounds, Background, 0);
tooltip_init_fonts();
XSetWindowAttributes attr;
attr.override_redirect = True;
attr.event_mask = StructureNotifyMask;
attr.colormap = server.colormap;
attr.background_pixel = 0;
attr.border_pixel = 0;
unsigned long mask = CWEventMask | CWColormap | CWBorderPixel | CWBackPixel | CWOverrideRedirect;
if (g_tooltip.window)
XDestroyWindow(server.display, g_tooltip.window);
g_tooltip.window = XCreateWindow(server.display,
server.root_win,
0,
0,
100,
20,
0,
server.depth,
InputOutput,
server.visual,
mask,
&attr);
XSetWindowAttributes attr;
attr.override_redirect = True;
attr.event_mask = StructureNotifyMask;
attr.colormap = server.colormap;
attr.background_pixel = 0;
attr.border_pixel = 0;
unsigned long mask = CWEventMask | CWColormap | CWBorderPixel | CWBackPixel | CWOverrideRedirect;
if (g_tooltip.window)
XDestroyWindow(server.display, g_tooltip.window);
g_tooltip.window = XCreateWindow(server.display,
server.root_win,
0,
0,
100,
20,
0,
server.depth,
InputOutput,
server.visual,
mask,
&attr);
}
void tooltip_init_fonts()
{
if (!g_tooltip.font_desc)
g_tooltip.font_desc = pango_font_description_from_string(get_default_font());
if (!g_tooltip.font_desc)
g_tooltip.font_desc = pango_font_description_from_string(get_default_font());
}
void tooltip_default_font_changed()
{
if (g_tooltip.has_font)
return;
if (!g_tooltip.has_font) {
pango_font_description_free(g_tooltip.font_desc);
g_tooltip.font_desc = NULL;
}
tooltip_init_fonts();
tooltip_update();
if (g_tooltip.has_font)
return;
if (!g_tooltip.has_font) {
pango_font_description_free(g_tooltip.font_desc);
g_tooltip.font_desc = NULL;
}
tooltip_init_fonts();
tooltip_update();
}
void tooltip_trigger_show(Area *area, Panel *p, XEvent *e)
{
// Position the tooltip in the center of the area
x = area->posx + MIN(area->width / 3, 22) + e->xmotion.x_root - e->xmotion.x;
y = area->posy + area->height / 2 + e->xmotion.y_root - e->xmotion.y;
just_shown = TRUE;
g_tooltip.panel = p;
if (g_tooltip.mapped && g_tooltip.area != area) {
tooltip_copy_text(area);
tooltip_update();
stop_tooltip_timeout();
} else if (!g_tooltip.mapped) {
start_show_timeout();
}
// Position the tooltip in the center of the area
x = area->posx + MIN(area->width / 3, 22) + e->xmotion.x_root - e->xmotion.x;
y = area->posy + area->height / 2 + e->xmotion.y_root - e->xmotion.y;
just_shown = TRUE;
g_tooltip.panel = p;
if (g_tooltip.mapped && g_tooltip.area != area) {
tooltip_copy_text(area);
tooltip_update();
stop_tooltip_timeout();
} else if (!g_tooltip.mapped) {
start_show_timeout();
}
}
void tooltip_show(void *arg)
{
int mx, my;
Window w;
XTranslateCoordinates(server.display, server.root_win, g_tooltip.panel->main_win, x, y, &mx, &my, &w);
Area *area = find_area_under_mouse(g_tooltip.panel, mx, my);
if (!g_tooltip.mapped && area->_get_tooltip_text) {
tooltip_copy_text(area);
g_tooltip.mapped = True;
XMapWindow(server.display, g_tooltip.window);
tooltip_update();
XFlush(server.display);
}
int mx, my;
Window w;
XTranslateCoordinates(server.display, server.root_win, g_tooltip.panel->main_win, x, y, &mx, &my, &w);
Area *area = find_area_under_mouse(g_tooltip.panel, mx, my);
if (!g_tooltip.mapped && area->_get_tooltip_text) {
tooltip_copy_text(area);
g_tooltip.mapped = True;
XMapWindow(server.display, g_tooltip.window);
tooltip_update();
XFlush(server.display);
}
}
void tooltip_update_geometry()
{
Panel *panel = g_tooltip.panel;
int screen_width = server.monitors[panel->monitor].x + server.monitors[panel->monitor].width;
Panel *panel = g_tooltip.panel;
int screen_width = server.monitors[panel->monitor].x + server.monitors[panel->monitor].width;
cairo_surface_t *cs = cairo_xlib_surface_create(server.display, g_tooltip.window, server.visual, width, height);
cairo_t *c = cairo_create(cs);
PangoLayout *layout = pango_cairo_create_layout(c);
cairo_surface_t *cs = cairo_xlib_surface_create(server.display, g_tooltip.window, server.visual, width, height);
cairo_t *c = cairo_create(cs);
PangoLayout *layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, g_tooltip.font_desc);
PangoRectangle r1, r2;
pango_layout_set_text(layout, "1234567890", -1);
pango_layout_get_pixel_extents(layout, &r1, &r2);
int max_width = MIN(r2.width * 7, screen_width * 2 / 3);
pango_layout_set_width(layout, max_width * PANGO_SCALE);
pango_layout_set_font_description(layout, g_tooltip.font_desc);
PangoRectangle r1, r2;
pango_layout_set_text(layout, "1234567890", -1);
pango_layout_get_pixel_extents(layout, &r1, &r2);
int max_width = MIN(r2.width * 7, screen_width * 2 / 3);
pango_layout_set_width(layout, max_width * PANGO_SCALE);
pango_layout_set_text(layout, g_tooltip.tooltip_text, -1);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
pango_layout_get_pixel_extents(layout, &r1, &r2);
width = left_right_bg_border_width(g_tooltip.bg) + 2 * g_tooltip.paddingx + r2.width;
height = top_bottom_bg_border_width(g_tooltip.bg) + 2 * g_tooltip.paddingy + r2.height;
pango_layout_set_text(layout, g_tooltip.tooltip_text, -1);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
pango_layout_get_pixel_extents(layout, &r1, &r2);
width = left_right_bg_border_width(g_tooltip.bg) + 2 * g_tooltip.paddingx + r2.width;
height = top_bottom_bg_border_width(g_tooltip.bg) + 2 * g_tooltip.paddingy + r2.height;
if (panel_horizontal && panel_position & BOTTOM)
y = panel->posy - height;
else if (panel_horizontal && panel_position & TOP)
y = panel->posy + panel->area.height;
else if (panel_position & LEFT)
x = panel->posx + panel->area.width;
else
x = panel->posx - width;
if (panel_horizontal && panel_position & BOTTOM)
y = panel->posy - height;
else if (panel_horizontal && panel_position & TOP)
y = panel->posy + panel->area.height;
else if (panel_position & LEFT)
x = panel->posx + panel->area.width;
else
x = panel->posx - width;
g_object_unref(layout);
cairo_destroy(c);
cairo_surface_destroy(cs);
g_object_unref(layout);
cairo_destroy(c);
cairo_surface_destroy(cs);
}
void tooltip_adjust_geometry()
{
// adjust coordinates and size to not go offscreen
// it seems quite impossible that the height needs to be adjusted, but we do it anyway.
// adjust coordinates and size to not go offscreen
// it seems quite impossible that the height needs to be adjusted, but we do it anyway.
Panel *panel = g_tooltip.panel;
int screen_width = server.monitors[panel->monitor].x + server.monitors[panel->monitor].width;
int screen_height = server.monitors[panel->monitor].y + server.monitors[panel->monitor].height;
if (x + width <= screen_width && y + height <= screen_height && x >= server.monitors[panel->monitor].x &&
y >= server.monitors[panel->monitor].y)
return; // no adjustment needed
Panel *panel = g_tooltip.panel;
int screen_width = server.monitors[panel->monitor].x + server.monitors[panel->monitor].width;
int screen_height = server.monitors[panel->monitor].y + server.monitors[panel->monitor].height;
if (x + width <= screen_width && y + height <= screen_height && x >= server.monitors[panel->monitor].x &&
y >= server.monitors[panel->monitor].y)
return; // no adjustment needed
int min_x, min_y, max_width, max_height;
if (panel_horizontal) {
min_x = 0;
max_width = server.monitors[panel->monitor].width;
max_height = server.monitors[panel->monitor].height - panel->area.height;
if (panel_position & BOTTOM)
min_y = 0;
else
min_y = panel->area.height;
} else {
max_width = server.monitors[panel->monitor].width - panel->area.width;
min_y = 0;
max_height = server.monitors[panel->monitor].height;
if (panel_position & LEFT)
min_x = panel->area.width;
else
min_x = 0;
}
int min_x, min_y, max_width, max_height;
if (panel_horizontal) {
min_x = 0;
max_width = server.monitors[panel->monitor].width;
max_height = server.monitors[panel->monitor].height - panel->area.height;
if (panel_position & BOTTOM)
min_y = 0;
else
min_y = panel->area.height;
} else {
max_width = server.monitors[panel->monitor].width - panel->area.width;
min_y = 0;
max_height = server.monitors[panel->monitor].height;
if (panel_position & LEFT)
min_x = panel->area.width;
else
min_x = 0;
}
if (x + width > server.monitors[panel->monitor].x + server.monitors[panel->monitor].width)
x = server.monitors[panel->monitor].x + server.monitors[panel->monitor].width - width;
if (y + height > server.monitors[panel->monitor].y + server.monitors[panel->monitor].height)
y = server.monitors[panel->monitor].y + server.monitors[panel->monitor].height - height;
if (x + width > server.monitors[panel->monitor].x + server.monitors[panel->monitor].width)
x = server.monitors[panel->monitor].x + server.monitors[panel->monitor].width - width;
if (y + height > server.monitors[panel->monitor].y + server.monitors[panel->monitor].height)
y = server.monitors[panel->monitor].y + server.monitors[panel->monitor].height - height;
if (x < min_x)
x = min_x;
if (width > max_width)
width = max_width;
if (y < min_y)
y = min_y;
if (height > max_height)
height = max_height;
if (x < min_x)
x = min_x;
if (width > max_width)
width = max_width;
if (y < min_y)
y = min_y;
if (height > max_height)
height = max_height;
}
void tooltip_update()
{
if (!g_tooltip.tooltip_text) {
tooltip_hide(0);
return;
}
if (!g_tooltip.tooltip_text) {
tooltip_hide(0);
return;
}
tooltip_update_geometry();
if (just_shown) {
if (!panel_horizontal)
y -= height / 2; // center vertically
just_shown = FALSE;
}
tooltip_adjust_geometry();
XMoveResizeWindow(server.display, g_tooltip.window, x, y, width, height);
tooltip_update_geometry();
if (just_shown) {
if (!panel_horizontal)
y -= height / 2; // center vertically
just_shown = FALSE;
}
tooltip_adjust_geometry();
XMoveResizeWindow(server.display, g_tooltip.window, x, y, width, height);
// Stuff for drawing the tooltip
cairo_surface_t *cs = cairo_xlib_surface_create(server.display, g_tooltip.window, server.visual, width, height);
cairo_t *c = cairo_create(cs);
Color bc = g_tooltip.bg->fill_color;
Border b = g_tooltip.bg->border;
if (server.real_transparency) {
clear_pixmap(g_tooltip.window, 0, 0, width, height);
draw_rect(c, b.width, b.width, width - 2 * b.width, height - 2 * b.width, b.radius - b.width / 1.571);
cairo_set_source_rgba(c, bc.rgb[0], bc.rgb[1], bc.rgb[2], bc.alpha);
} else {
cairo_rectangle(c, 0., 0, width, height);
cairo_set_source_rgb(c, bc.rgb[0], bc.rgb[1], bc.rgb[2]);
}
cairo_fill(c);
cairo_set_line_width(c, b.width);
if (server.real_transparency)
draw_rect(c, b.width / 2.0, b.width / 2.0, width - b.width, height - b.width, b.radius);
else
cairo_rectangle(c, b.width / 2.0, b.width / 2.0, width - b.width, height - b.width);
cairo_set_source_rgba(c, b.color.rgb[0], b.color.rgb[1], b.color.rgb[2], b.color.alpha);
cairo_stroke(c);
// Stuff for drawing the tooltip
cairo_surface_t *cs = cairo_xlib_surface_create(server.display, g_tooltip.window, server.visual, width, height);
cairo_t *c = cairo_create(cs);
Color bc = g_tooltip.bg->fill_color;
Border b = g_tooltip.bg->border;
if (server.real_transparency) {
clear_pixmap(g_tooltip.window, 0, 0, width, height);
draw_rect(c, b.width, b.width, width - 2 * b.width, height - 2 * b.width, b.radius - b.width / 1.571);
cairo_set_source_rgba(c, bc.rgb[0], bc.rgb[1], bc.rgb[2], bc.alpha);
} else {
cairo_rectangle(c, 0., 0, width, height);
cairo_set_source_rgb(c, bc.rgb[0], bc.rgb[1], bc.rgb[2]);
}
cairo_fill(c);
cairo_set_line_width(c, b.width);
if (server.real_transparency)
draw_rect(c, b.width / 2.0, b.width / 2.0, width - b.width, height - b.width, b.radius);
else
cairo_rectangle(c, b.width / 2.0, b.width / 2.0, width - b.width, height - b.width);
cairo_set_source_rgba(c, b.color.rgb[0], b.color.rgb[1], b.color.rgb[2], b.color.alpha);
cairo_stroke(c);
Color fc = g_tooltip.font_color;
cairo_set_source_rgba(c, fc.rgb[0], fc.rgb[1], fc.rgb[2], fc.alpha);
PangoLayout *layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, g_tooltip.font_desc);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
pango_layout_set_text(layout, g_tooltip.tooltip_text, -1);
PangoRectangle r1, r2;
pango_layout_get_pixel_extents(layout, &r1, &r2);
pango_layout_set_width(layout, width * PANGO_SCALE);
pango_layout_set_height(layout, height * PANGO_SCALE);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
// I do not know why this is the right way, but with the below cairo_move_to it seems to be centered (horiz. and
// vert.)
cairo_move_to(c,
-r1.x / 2 + left_bg_border_width(g_tooltip.bg) + g_tooltip.paddingx,
-r1.y / 2 + 1 + top_bg_border_width(g_tooltip.bg) + g_tooltip.paddingy);
pango_cairo_show_layout(c, layout);
Color fc = g_tooltip.font_color;
cairo_set_source_rgba(c, fc.rgb[0], fc.rgb[1], fc.rgb[2], fc.alpha);
PangoLayout *layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, g_tooltip.font_desc);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
pango_layout_set_text(layout, g_tooltip.tooltip_text, -1);
PangoRectangle r1, r2;
pango_layout_get_pixel_extents(layout, &r1, &r2);
pango_layout_set_width(layout, width * PANGO_SCALE);
pango_layout_set_height(layout, height * PANGO_SCALE);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
// I do not know why this is the right way, but with the below cairo_move_to it seems to be centered (horiz. and
// vert.)
cairo_move_to(c,
-r1.x / 2 + left_bg_border_width(g_tooltip.bg) + g_tooltip.paddingx,
-r1.y / 2 + 1 + top_bg_border_width(g_tooltip.bg) + g_tooltip.paddingy);
pango_cairo_show_layout(c, layout);
g_object_unref(layout);
cairo_destroy(c);
cairo_surface_destroy(cs);
g_object_unref(layout);
cairo_destroy(c);
cairo_surface_destroy(cs);
}
void tooltip_trigger_hide()
{
if (g_tooltip.mapped) {
tooltip_copy_text(0);
start_hide_timeout();
} else {
// tooltip not visible yet, but maybe a timeout is still pending
stop_tooltip_timeout();
}
if (g_tooltip.mapped) {
tooltip_copy_text(0);
start_hide_timeout();
} else {
// tooltip not visible yet, but maybe a timeout is still pending
stop_tooltip_timeout();
}
}
void tooltip_hide(void *arg)
{
if (g_tooltip.mapped) {
g_tooltip.mapped = False;
XUnmapWindow(server.display, g_tooltip.window);
XFlush(server.display);
}
if (g_tooltip.mapped) {
g_tooltip.mapped = False;
XUnmapWindow(server.display, g_tooltip.window);
XFlush(server.display);
}
}
void start_show_timeout()
{
change_timeout(&g_tooltip.timeout, g_tooltip.show_timeout_msec, 0, tooltip_show, 0);
change_timeout(&g_tooltip.timeout, g_tooltip.show_timeout_msec, 0, tooltip_show, 0);
}
void start_hide_timeout()
{
change_timeout(&g_tooltip.timeout, g_tooltip.hide_timeout_msec, 0, tooltip_hide, 0);
change_timeout(&g_tooltip.timeout, g_tooltip.hide_timeout_msec, 0, tooltip_hide, 0);
}
void stop_tooltip_timeout()
{
stop_timeout(g_tooltip.timeout);
stop_timeout(g_tooltip.timeout);
}
void tooltip_copy_text(Area *area)
{
free(g_tooltip.tooltip_text);
if (area && area->_get_tooltip_text)
g_tooltip.tooltip_text = area->_get_tooltip_text(area);
else
g_tooltip.tooltip_text = NULL;
g_tooltip.area = area;
free(g_tooltip.tooltip_text);
if (area && area->_get_tooltip_text)
g_tooltip.tooltip_text = area->_get_tooltip_text(area);
else
g_tooltip.tooltip_text = NULL;
g_tooltip.area = area;
}

28
src/tooltip/tooltip.h
View File

@@ -23,20 +23,20 @@
#include "timer.h"
typedef struct {
Area *area; // never ever use the area attribut if you are not 100% sure that this area was not freed
char *tooltip_text;
Panel *panel;
Window window;
int show_timeout_msec;
int hide_timeout_msec;
Bool mapped;
int paddingx;
int paddingy;
gboolean has_font;
PangoFontDescription *font_desc;
Color font_color;
Background *bg;
timeout *timeout;
Area *area; // never ever use the area attribut if you are not 100% sure that this area was not freed
char *tooltip_text;
Panel *panel;
Window window;
int show_timeout_msec;
int hide_timeout_msec;
Bool mapped;
int paddingx;
int paddingy;
gboolean has_font;
PangoFontDescription *font_desc;
Color font_color;
Background *bg;
timeout *timeout;
} Tooltip;
extern Tooltip g_tooltip;

1636
src/util/area.c
View File

File diff suppressed because it is too large Load Diff

178
src/util/area.h
View File

@@ -121,125 +121,125 @@
// The Area's _get_tooltip_text member must point to this function.
typedef enum BorderMask {
BORDER_TOP = 1 << 0,
BORDER_BOTTOM = 1 << 1,
BORDER_LEFT = 1 << 2,
BORDER_RIGHT = 1 << 3
BORDER_TOP = 1 << 0,
BORDER_BOTTOM = 1 << 1,
BORDER_LEFT = 1 << 2,
BORDER_RIGHT = 1 << 3
} BorderMask;
#define BORDER_ALL (BORDER_TOP | BORDER_BOTTOM | BORDER_LEFT | BORDER_RIGHT)
typedef struct Border {
// It's essential that the first member is color
Color color;
// Width in pixels
int width;
// Corner radius
int radius;
// Mask: bitwise OR of BorderMask
int mask;
// It's essential that the first member is color
Color color;
// Width in pixels
int width;
// Corner radius
int radius;
// Mask: bitwise OR of BorderMask
int mask;
} Border;
typedef enum MouseState { MOUSE_NORMAL = 0, MOUSE_OVER = 1, MOUSE_DOWN = 2, MOUSE_STATE_COUNT } MouseState;
typedef struct Background {
// Normal state
Color fill_color;
Border border;
// On mouse hover
Color fill_color_hover;
Color border_color_hover;
// On mouse press
Color fill_color_pressed;
Color border_color_pressed;
// Pointer to a GradientClass or NULL, no ownership
GradientClass *gradients[MOUSE_STATE_COUNT];
// Normal state
Color fill_color;
Border border;
// On mouse hover
Color fill_color_hover;
Color border_color_hover;
// On mouse press
Color fill_color_pressed;
Color border_color_pressed;
// Pointer to a GradientClass or NULL, no ownership
GradientClass *gradients[MOUSE_STATE_COUNT];
} Background;
typedef enum Layout {
LAYOUT_DYNAMIC,
LAYOUT_FIXED,
LAYOUT_DYNAMIC,
LAYOUT_FIXED,
} Layout;
typedef enum Alignment {
ALIGN_LEFT = 0,
ALIGN_CENTER = 1,
ALIGN_RIGHT = 2,
ALIGN_LEFT = 0,
ALIGN_CENTER = 1,
ALIGN_RIGHT = 2,
} Alignment;
struct Panel;
typedef struct Area {
// Position relative to the panel window
int posx, posy;
// Size, including borders
int width, height;
int old_width, old_height;
Background *bg;
// Each element is a GradientInstance attached to this Area (list can be empty)
GList *gradient_instances_by_state[MOUSE_STATE_COUNT];
// Each element is a GradientInstance that depends on this Area's geometry (position or size)
GList *dependent_gradients;
// List of children, each one a pointer to Area
GList *children;
// Pointer to the parent Area or NULL
void *parent;
// Pointer to the Panel that contains this Area
void *panel;
Layout size_mode;
Alignment alignment;
gboolean has_mouse_over_effect;
gboolean has_mouse_press_effect;
// TODO padding/spacing is a clusterfuck
// paddingxlr = padding
// paddingy = vertical padding, sometimes
// paddingx = spacing
int paddingxlr, paddingx, paddingy;
MouseState mouse_state;
// Set to non-zero if the Area is visible. An object may exist but stay hidden.
gboolean on_screen;
// Set to non-zero if the size of the Area has to be recalculated.
gboolean resize_needed;
// Set to non-zero if the Area has to be redrawn.
// Do not set this directly; use schedule_redraw() instead.
gboolean _redraw_needed;
// Set to non-zero if the position/size has changed, thus _on_change_layout needs to be called
gboolean _changed;
// This is the pixmap on which the Area is rendered. Render to it directly if needed.
Pixmap pix;
Pixmap pix_by_state[MOUSE_STATE_COUNT];
char name[32];
// Position relative to the panel window
int posx, posy;
// Size, including borders
int width, height;
int old_width, old_height;
Background *bg;
// Each element is a GradientInstance attached to this Area (list can be empty)
GList *gradient_instances_by_state[MOUSE_STATE_COUNT];
// Each element is a GradientInstance that depends on this Area's geometry (position or size)
GList *dependent_gradients;
// List of children, each one a pointer to Area
GList *children;
// Pointer to the parent Area or NULL
void *parent;
// Pointer to the Panel that contains this Area
void *panel;
Layout size_mode;
Alignment alignment;
gboolean has_mouse_over_effect;
gboolean has_mouse_press_effect;
// TODO padding/spacing is a clusterfuck
// paddingxlr = padding
// paddingy = vertical padding, sometimes
// paddingx = spacing
int paddingxlr, paddingx, paddingy;
MouseState mouse_state;
// Set to non-zero if the Area is visible. An object may exist but stay hidden.
gboolean on_screen;
// Set to non-zero if the size of the Area has to be recalculated.
gboolean resize_needed;
// Set to non-zero if the Area has to be redrawn.
// Do not set this directly; use schedule_redraw() instead.
gboolean _redraw_needed;
// Set to non-zero if the position/size has changed, thus _on_change_layout needs to be called
gboolean _changed;
// This is the pixmap on which the Area is rendered. Render to it directly if needed.
Pixmap pix;
Pixmap pix_by_state[MOUSE_STATE_COUNT];
char name[32];
// Callbacks
// Callbacks
// Called on draw before any drawing takes place, obj = pointer to the Area
void (*_clear)(void *obj);
// Called on draw before any drawing takes place, obj = pointer to the Area
void (*_clear)(void *obj);
// Called on draw, obj = pointer to the Area
void (*_draw_foreground)(void *obj, cairo_t *c);
// Called on draw, obj = pointer to the Area
void (*_draw_foreground)(void *obj, cairo_t *c);
// Called on resize, obj = pointer to the Area
// Returns 1 if the new size is different than the previous size.
gboolean (*_resize)(void *obj);
// Called on resize, obj = pointer to the Area
// Returns 1 if the new size is different than the previous size.
gboolean (*_resize)(void *obj);
// Called before resize, obj = pointer to the Area
// Returns the desired size of the Area
int (*_compute_desired_size)(void *obj);
// Called before resize, obj = pointer to the Area
// Returns the desired size of the Area
int (*_compute_desired_size)(void *obj);
// Implemented only to override the default layout algorithm for this widget.
// For example, if this widget is a cell in a table, its position and size should be computed here.
void (*_on_change_layout)(void *obj);
// Implemented only to override the default layout algorithm for this widget.
// For example, if this widget is a cell in a table, its position and size should be computed here.
void (*_on_change_layout)(void *obj);
// Returns a copy of the tooltip to be displayed for this widget.
// The caller takes ownership of the pointer.
char *(*_get_tooltip_text)(void *obj);
// Returns a copy of the tooltip to be displayed for this widget.
// The caller takes ownership of the pointer.
char *(*_get_tooltip_text)(void *obj);
// Returns true if the Area handles a mouse event at the given x, y coordinates relative to the window.
// Leave this to NULL to use a default implementation.
gboolean (*_is_under_mouse)(void *obj, int x, int y);
// Returns true if the Area handles a mouse event at the given x, y coordinates relative to the window.
// Leave this to NULL to use a default implementation.
gboolean (*_is_under_mouse)(void *obj, int x, int y);
// Prints the geometry of the object on stderr, with left indentation of indent spaces.
void (*_dump_geometry)(void *obj, int indent);
// Prints the geometry of the object on stderr, with left indentation of indent spaces.
void (*_dump_geometry)(void *obj, int indent);
} Area;
// Initializes the Background member to default values.

168
src/util/cache.c
View File

@@ -32,129 +32,129 @@
void init_cache(Cache *cache)
{
if (cache->_table)
free_cache(cache);
cache->_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
cache->dirty = FALSE;
cache->loaded = FALSE;
if (cache->_table)
free_cache(cache);
cache->_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
cache->dirty = FALSE;
cache->loaded = FALSE;
}
void free_cache(Cache *cache)
{
if (cache->_table)
g_hash_table_destroy(cache->_table);
cache->_table = NULL;
cache->dirty = FALSE;
cache->loaded = FALSE;
if (cache->_table)
g_hash_table_destroy(cache->_table);
cache->_table = NULL;
cache->dirty = FALSE;
cache->loaded = FALSE;
}
void load_cache(Cache *cache, const gchar *cache_path)
{
init_cache(cache);
init_cache(cache);
cache->loaded = TRUE;
cache->loaded = TRUE;
int fd = open(cache_path, O_RDONLY);
if (fd == -1)
return;
flock(fd, LOCK_SH);
int fd = open(cache_path, O_RDONLY);
if (fd == -1)
return;
flock(fd, LOCK_SH);
FILE *f = fopen(cache_path, "rt");
if (!f)
goto unlock;
FILE *f = fopen(cache_path, "rt");
if (!f)
goto unlock;
char *line = NULL;
size_t line_size;
char *line = NULL;
size_t line_size;
while (getline(&line, &line_size, f) >= 0) {
char *key, *value;
while (getline(&line, &line_size, f) >= 0) {
char *key, *value;
size_t line_len = strlen(line);
gboolean has_newline = FALSE;
if (line_len >= 1) {
if (line[line_len - 1] == '\n') {
line[line_len - 1] = '\0';
line_len--;
has_newline = TRUE;
}
}
if (!has_newline)
break;
size_t line_len = strlen(line);
gboolean has_newline = FALSE;
if (line_len >= 1) {
if (line[line_len - 1] == '\n') {
line[line_len - 1] = '\0';
line_len--;
has_newline = TRUE;
}
}
if (!has_newline)
break;
if (line_len == 0)
continue;
if (line_len == 0)
continue;
if (parse_line(line, &key, &value)) {
g_hash_table_insert(cache->_table, g_strdup(key), g_strdup(value));
free(key);
free(value);
}
}
free(line);
fclose(f);
if (parse_line(line, &key, &value)) {
g_hash_table_insert(cache->_table, g_strdup(key), g_strdup(value));
free(key);
free(value);
}
}
free(line);
fclose(f);
unlock:
flock(fd, LOCK_UN);
close(fd);
flock(fd, LOCK_UN);
close(fd);
}
void write_cache_line(gpointer key, gpointer value, gpointer user_data)
{
gchar *k = key;
gchar *v = value;
FILE *f = user_data;
gchar *k = key;
gchar *v = value;
FILE *f = user_data;
fprintf(f, "%s=%s\n", k, v);
fprintf(f, "%s=%s\n", k, v);
}
void save_cache(Cache *cache, const gchar *cache_path)
{
int fd = open(cache_path, O_RDONLY | O_CREAT, 0600);
if (fd == -1) {
gchar *dir_path = g_path_get_dirname(cache_path);
g_mkdir_with_parents(dir_path, 0700);
g_free(dir_path);
fd = open(cache_path, O_RDONLY | O_CREAT, 0600);
}
if (fd == -1) {
fprintf(stderr, RED "Could not save icon theme cache!" RESET "\n");
return;
}
flock(fd, LOCK_EX);
int fd = open(cache_path, O_RDONLY | O_CREAT, 0600);
if (fd == -1) {
gchar *dir_path = g_path_get_dirname(cache_path);
g_mkdir_with_parents(dir_path, 0700);
g_free(dir_path);
fd = open(cache_path, O_RDONLY | O_CREAT, 0600);
}
if (fd == -1) {
fprintf(stderr, RED "Could not save icon theme cache!" RESET "\n");
return;
}
flock(fd, LOCK_EX);
FILE *f = fopen(cache_path, "w");
if (!f) {
fprintf(stderr, RED "Could not save icon theme cache!" RESET "\n");
goto unlock;
}
g_hash_table_foreach(cache->_table, write_cache_line, f);
fclose(f);
cache->dirty = FALSE;
FILE *f = fopen(cache_path, "w");
if (!f) {
fprintf(stderr, RED "Could not save icon theme cache!" RESET "\n");
goto unlock;
}
g_hash_table_foreach(cache->_table, write_cache_line, f);
fclose(f);
cache->dirty = FALSE;
unlock:
flock(fd, LOCK_UN);
close(fd);
flock(fd, LOCK_UN);
close(fd);
}
const gchar *get_from_cache(Cache *cache, const gchar *key)
{
if (!cache->_table)
return NULL;
return g_hash_table_lookup(cache->_table, key);
if (!cache->_table)
return NULL;
return g_hash_table_lookup(cache->_table, key);
}
void add_to_cache(Cache *cache, const gchar *key, const gchar *value)
{
if (!cache->_table)
init_cache(cache);
if (!cache->_table)
init_cache(cache);
if (!key || !value)
return;
if (!key || !value)
return;
gchar *old_value = g_hash_table_lookup(cache->_table, key);
if (old_value && g_str_equal(old_value, value))
return;
gchar *old_value = g_hash_table_lookup(cache->_table, key);
if (old_value && g_str_equal(old_value, value))
return;
g_hash_table_insert(cache->_table, g_strdup(key), g_strdup(value));
cache->dirty = TRUE;
g_hash_table_insert(cache->_table, g_strdup(key), g_strdup(value));
cache->dirty = TRUE;
}

6
src/util/cache.h
View File

@@ -6,9 +6,9 @@
// A cache with string keys and values, backed by a file.
// The strings must not be NULL and are stripped of any whitespace at start and end.
typedef struct Cache {
gboolean dirty;
gboolean loaded;
GHashTable *_table;
gboolean dirty;
gboolean loaded;
GHashTable *_table;
} Cache;
// Initializes the cache. You can also call load_cache directly if you set the memory contents to zero first.

1
src/util/color.c
View File

@@ -1,2 +1 @@
#include "color.h"

8
src/util/color.h
View File

@@ -2,10 +2,10 @@
#define COLOR_H
typedef struct Color {
// Values are in [0, 1], with 0 meaning no intensity.
double rgb[3];
// Values are in [0, 1], with 0 meaning fully transparent, 1 meaning fully opaque.
double alpha;
// Values are in [0, 1], with 0 meaning no intensity.
double rgb[3];
// Values are in [0, 1], with 0 meaning fully transparent, 1 meaning fully opaque.
double alpha;
} Color;
#endif // COLOR_H

998
src/util/common.c
View File

File diff suppressed because it is too large Load Diff

54
src/util/common.h
View File

@@ -24,19 +24,19 @@
// mouse actions
typedef enum MouseAction {
NONE = 0,
CLOSE,
TOGGLE,
ICONIFY,
SHADE,
TOGGLE_ICONIFY,
MAXIMIZE_RESTORE,
MAXIMIZE,
RESTORE,
DESKTOP_LEFT,
DESKTOP_RIGHT,
NEXT_TASK,
PREV_TASK
NONE = 0,
CLOSE,
TOGGLE,
ICONIFY,
SHADE,
TOGGLE_ICONIFY,
MAXIMIZE_RESTORE,
MAXIMIZE,
RESTORE,
DESKTOP_LEFT,
DESKTOP_RIGHT,
NEXT_TASK,
PREV_TASK
} MouseAction;
#define ALL_DESKTOPS 0xFFFFFFFF
@@ -94,16 +94,16 @@ void create_heuristic_mask(DATA32 *data, int w, int h);
void render_image(Drawable d, int x, int y);
void get_text_size2(PangoFontDescription *font,
int *height_ink,
int *height,
int *width,
int panel_height,
int panel_with,
char *text,
int len,
PangoWrapMode wrap,
PangoEllipsizeMode ellipsis,
gboolean markup);
int *height_ink,
int *height,
int *width,
int panel_height,
int panel_with,
char *text,
int len,
PangoWrapMode wrap,
PangoEllipsizeMode ellipsis,
gboolean markup);
void draw_text(PangoLayout *layout, cairo_t *c, int posx, int posy, Color *color, int font_shadow);
@@ -125,10 +125,10 @@ GSList *slist_remove_duplicates(GSList *list, GCompareFunc eq, GDestroyNotify fr
gint cmp_ptr(gconstpointer a, gconstpointer b);
#define free_and_null(p) \
{ \
free(p); \
p = NULL; \
}
{ \
free(p); \
p = NULL; \
}
#if !GLIB_CHECK_VERSION(2, 33, 4)
GList *g_list_copy_deep(GList *list, GCopyFunc func, gpointer user_data);

192
src/util/gradient.c
View File

@@ -8,116 +8,116 @@
gboolean read_double(const char *str, double *value)
{
if (!str[0])
return FALSE;
char *end;
*value = strtod(str, &end);
if (end[0])
return FALSE;
return TRUE;
if (!str[0])
return FALSE;
char *end;
*value = strtod(str, &end);
if (end[0])
return FALSE;
return TRUE;
}
gboolean read_double_with_percent(const char *str, double *value)
{
if (!str[0])
return FALSE;
char *end;
*value = strtod(str, &end);
if (end[0] == '%' && !end[1]) {
*value *= 0.01;
return TRUE;
}
if (end[0])
return FALSE;
return TRUE;
if (!str[0])
return FALSE;
char *end;
*value = strtod(str, &end);
if (end[0] == '%' && !end[1]) {
*value *= 0.01;
return TRUE;
}
if (end[0])
return FALSE;
return TRUE;
}
GradientType gradient_type_from_string(const char *str)
{
if (g_str_equal(str, "horizontal"))
return GRADIENT_HORIZONTAL;
if (g_str_equal(str, "vertical"))
return GRADIENT_VERTICAL;
if (g_str_equal(str, "radial"))
return GRADIENT_CENTERED;
fprintf(stderr, RED "Invalid gradient type: %s" RESET "\n", str);
return GRADIENT_VERTICAL;
if (g_str_equal(str, "horizontal"))
return GRADIENT_HORIZONTAL;
if (g_str_equal(str, "vertical"))
return GRADIENT_VERTICAL;
if (g_str_equal(str, "radial"))
return GRADIENT_CENTERED;
fprintf(stderr, RED "Invalid gradient type: %s" RESET "\n", str);
return GRADIENT_VERTICAL;
}
void init_gradient(GradientClass *g, GradientType type)
{
memset(g, 0, sizeof(*g));
g->type = type;
if (g->type == GRADIENT_VERTICAL) {
Offset *offset_top = (Offset *)calloc(1, sizeof(Offset));
offset_top->constant = TRUE;
offset_top->constant_value = 0;
g->from.offsets_y = g_list_append(g->from.offsets_y, offset_top);
Offset *offset_bottom = (Offset *)calloc(1, sizeof(Offset));
offset_bottom->constant = FALSE;
offset_bottom->element = ELEMENT_SELF;
offset_bottom->variable = SIZE_HEIGHT;
offset_bottom->multiplier = 1.0;
g->to.offsets_y = g_list_append(g->to.offsets_y, offset_bottom);
} else if (g->type == GRADIENT_HORIZONTAL) {
Offset *offset_left = (Offset *)calloc(1, sizeof(Offset));
offset_left->constant = TRUE;
offset_left->constant_value = 0;
g->from.offsets_x = g_list_append(g->from.offsets_x, offset_left);
Offset *offset_right = (Offset *)calloc(1, sizeof(Offset));
offset_right->constant = FALSE;
offset_right->element = ELEMENT_SELF;
offset_right->variable = SIZE_WIDTH;
offset_right->multiplier = 1.0;
g->to.offsets_x = g_list_append(g->to.offsets_x, offset_right);
} else if (g->type == GRADIENT_CENTERED) {
// from
Offset *offset_center_x = (Offset *)calloc(1, sizeof(Offset));
offset_center_x->constant = FALSE;
offset_center_x->element = ELEMENT_SELF;
offset_center_x->variable = SIZE_CENTERX;
offset_center_x->multiplier = 1.0;
g->from.offsets_x = g_list_append(g->from.offsets_x, offset_center_x);
Offset *offset_center_y = (Offset *)calloc(1, sizeof(Offset));
offset_center_y->constant = FALSE;
offset_center_y->element = ELEMENT_SELF;
offset_center_y->variable = SIZE_CENTERY;
offset_center_y->multiplier = 1.0;
g->from.offsets_y = g_list_append(g->from.offsets_y, offset_center_y);
Offset *offset_center_r = (Offset *)calloc(1, sizeof(Offset));
offset_center_r->constant = TRUE;
offset_center_r->constant_value = 0;
g->from.offsets_r = g_list_append(g->from.offsets_r, offset_center_r);
// to
offset_center_x = (Offset *)calloc(1, sizeof(Offset));
offset_center_x->constant = FALSE;
offset_center_x->element = ELEMENT_SELF;
offset_center_x->variable = SIZE_CENTERX;
offset_center_x->multiplier = 1.0;
g->to.offsets_x = g_list_append(g->to.offsets_x, offset_center_x);
offset_center_y = (Offset *)calloc(1, sizeof(Offset));
offset_center_y->constant = FALSE;
offset_center_y->element = ELEMENT_SELF;
offset_center_y->variable = SIZE_CENTERY;
offset_center_y->multiplier = 1.0;
g->to.offsets_y = g_list_append(g->to.offsets_y, offset_center_y);
offset_center_r = (Offset *)calloc(1, sizeof(Offset));
offset_center_r->constant = FALSE;
offset_center_r->element = ELEMENT_SELF;
offset_center_r->variable = SIZE_RADIUS;
offset_center_r->multiplier = 1.0;
g->to.offsets_r = g_list_append(g->to.offsets_r, offset_center_r);
}
memset(g, 0, sizeof(*g));
g->type = type;
if (g->type == GRADIENT_VERTICAL) {
Offset *offset_top = (Offset *)calloc(1, sizeof(Offset));
offset_top->constant = TRUE;
offset_top->constant_value = 0;
g->from.offsets_y = g_list_append(g->from.offsets_y, offset_top);
Offset *offset_bottom = (Offset *)calloc(1, sizeof(Offset));
offset_bottom->constant = FALSE;
offset_bottom->element = ELEMENT_SELF;
offset_bottom->variable = SIZE_HEIGHT;
offset_bottom->multiplier = 1.0;
g->to.offsets_y = g_list_append(g->to.offsets_y, offset_bottom);
} else if (g->type == GRADIENT_HORIZONTAL) {
Offset *offset_left = (Offset *)calloc(1, sizeof(Offset));
offset_left->constant = TRUE;
offset_left->constant_value = 0;
g->from.offsets_x = g_list_append(g->from.offsets_x, offset_left);
Offset *offset_right = (Offset *)calloc(1, sizeof(Offset));
offset_right->constant = FALSE;
offset_right->element = ELEMENT_SELF;
offset_right->variable = SIZE_WIDTH;
offset_right->multiplier = 1.0;
g->to.offsets_x = g_list_append(g->to.offsets_x, offset_right);
} else if (g->type == GRADIENT_CENTERED) {
// from
Offset *offset_center_x = (Offset *)calloc(1, sizeof(Offset));
offset_center_x->constant = FALSE;
offset_center_x->element = ELEMENT_SELF;
offset_center_x->variable = SIZE_CENTERX;
offset_center_x->multiplier = 1.0;
g->from.offsets_x = g_list_append(g->from.offsets_x, offset_center_x);
Offset *offset_center_y = (Offset *)calloc(1, sizeof(Offset));
offset_center_y->constant = FALSE;
offset_center_y->element = ELEMENT_SELF;
offset_center_y->variable = SIZE_CENTERY;
offset_center_y->multiplier = 1.0;
g->from.offsets_y = g_list_append(g->from.offsets_y, offset_center_y);
Offset *offset_center_r = (Offset *)calloc(1, sizeof(Offset));
offset_center_r->constant = TRUE;
offset_center_r->constant_value = 0;
g->from.offsets_r = g_list_append(g->from.offsets_r, offset_center_r);
// to
offset_center_x = (Offset *)calloc(1, sizeof(Offset));
offset_center_x->constant = FALSE;
offset_center_x->element = ELEMENT_SELF;
offset_center_x->variable = SIZE_CENTERX;
offset_center_x->multiplier = 1.0;
g->to.offsets_x = g_list_append(g->to.offsets_x, offset_center_x);
offset_center_y = (Offset *)calloc(1, sizeof(Offset));
offset_center_y->constant = FALSE;
offset_center_y->element = ELEMENT_SELF;
offset_center_y->variable = SIZE_CENTERY;
offset_center_y->multiplier = 1.0;
g->to.offsets_y = g_list_append(g->to.offsets_y, offset_center_y);
offset_center_r = (Offset *)calloc(1, sizeof(Offset));
offset_center_r->constant = FALSE;
offset_center_r->element = ELEMENT_SELF;
offset_center_r->variable = SIZE_RADIUS;
offset_center_r->multiplier = 1.0;
g->to.offsets_r = g_list_append(g->to.offsets_r, offset_center_r);
}
}
void cleanup_gradient(GradientClass *g)
{
g_list_free_full(g->extra_color_stops, free);
g_list_free_full(g->from.offsets_x, free);
g_list_free_full(g->from.offsets_y, free);
g_list_free_full(g->from.offsets_r, free);
g_list_free_full(g->to.offsets_x, free);
g_list_free_full(g->to.offsets_y, free);
g_list_free_full(g->to.offsets_r, free);
bzero(g, sizeof(*g));
g_list_free_full(g->extra_color_stops, free);
g_list_free_full(g->from.offsets_x, free);
g_list_free_full(g->from.offsets_y, free);
g_list_free_full(g->from.offsets_r, free);
g_list_free_full(g->to.offsets_x, free);
g_list_free_full(g->to.offsets_y, free);
g_list_free_full(g->to.offsets_r, free);
bzero(g, sizeof(*g));
}

80
src/util/gradient.h
View File

@@ -9,62 +9,54 @@
//////////////////////////////////////////////////////////////////////
// Gradient types read from config options, not associated to any area
typedef enum GradientType {
GRADIENT_VERTICAL = 0,
GRADIENT_HORIZONTAL,
GRADIENT_CENTERED
} GradientType;
typedef enum GradientType { GRADIENT_VERTICAL = 0, GRADIENT_HORIZONTAL, GRADIENT_CENTERED } GradientType;
typedef struct ColorStop {
Color color;
// offset in 0-1
double offset;
Color color;
// offset in 0-1
double offset;
} ColorStop;
typedef enum Element {
ELEMENT_SELF = 0,
ELEMENT_PARENT,
ELEMENT_PANEL
} Element;
typedef enum Element { ELEMENT_SELF = 0, ELEMENT_PARENT, ELEMENT_PANEL } Element;
typedef enum SizeVariable {
SIZE_WIDTH = 0,
SIZE_HEIGHT,
SIZE_RADIUS,
SIZE_LEFT,
SIZE_RIGHT,
SIZE_TOP,
SIZE_BOTTOM,
SIZE_CENTERX,
SIZE_CENTERY
SIZE_WIDTH = 0,
SIZE_HEIGHT,
SIZE_RADIUS,
SIZE_LEFT,
SIZE_RIGHT,
SIZE_TOP,
SIZE_BOTTOM,
SIZE_CENTERX,
SIZE_CENTERY
} SizeVariable;
typedef struct Offset {
gboolean constant;
// if constant == true
double constant_value;
// else
Element element;
SizeVariable variable;
double multiplier;
gboolean constant;
// if constant == true
double constant_value;
// else
Element element;
SizeVariable variable;
double multiplier;
} Offset;
typedef struct ControlPoint {
// Each element is an Offset
GList *offsets_x;
GList *offsets_y;
// Defined only for radial gradients
GList *offsets_r;
// Each element is an Offset
GList *offsets_x;
GList *offsets_y;
// Defined only for radial gradients
GList *offsets_r;
} ControlPoint;
typedef struct GradientClass {
GradientType type;
Color start_color;
Color end_color;
// Each element is a ColorStop
GList *extra_color_stops;
ControlPoint from;
ControlPoint to;
GradientType type;
Color start_color;
Color end_color;
// Each element is a ColorStop
GList *extra_color_stops;
ControlPoint from;
ControlPoint to;
} GradientClass;
GradientType gradient_type_from_string(const char *str);
@@ -78,9 +70,9 @@ struct Area;
typedef struct Area Area;
typedef struct GradientInstance {
GradientClass *gradient_class;
Area *area;
cairo_pattern_t *pattern;
GradientClass *gradient_class;
Area *area;
cairo_pattern_t *pattern;
} GradientInstance;
extern gboolean debug_gradients;

152
src/util/strnatcmp.c
View File

@@ -43,110 +43,110 @@
// remember it in BIAS.
static int compare_right(char const *a, char const *b)
{
int bias = 0;
int bias = 0;
for (;; a++, b++) {
if (!isdigit(*a) && !isdigit(*b))
return bias;
else if (!isdigit(*a))
return -1;
else if (!isdigit(*b))
return +1;
else if (*a < *b) {
if (!bias)
bias = -1;
} else if (*a > *b) {
if (!bias)
bias = +1;
} else if (!*a && !*b)
return bias;
}
for (;; a++, b++) {
if (!isdigit(*a) && !isdigit(*b))
return bias;
else if (!isdigit(*a))
return -1;
else if (!isdigit(*b))
return +1;
else if (*a < *b) {
if (!bias)
bias = -1;
} else if (*a > *b) {
if (!bias)
bias = +1;
} else if (!*a && !*b)
return bias;
}
return 0;
return 0;
}
// Compare two left-aligned numbers:
// The first to have a different value wins.
static int compare_left(char const *a, char const *b)
{
for (;; a++, b++) {
if (!isdigit(*a) && !isdigit(*b))
return 0;
else if (!isdigit(*a))
return -1;
else if (!isdigit(*b))
return +1;
else if (*a < *b)
return -1;
else if (*a > *b)
return +1;
}
for (;; a++, b++) {
if (!isdigit(*a) && !isdigit(*b))
return 0;
else if (!isdigit(*a))
return -1;
else if (!isdigit(*b))
return +1;
else if (*a < *b)
return -1;
else if (*a > *b)
return +1;
}
return 0;
return 0;
}
static int strnatcmp0(char const *a, char const *b, int ignore_case)
{
assert(a && b);
assert(a && b);
int ai, bi;
ai = bi = 0;
while (1) {
char ca = a[ai];
char cb = b[bi];
int ai, bi;
ai = bi = 0;
while (1) {
char ca = a[ai];
char cb = b[bi];
// Skip over leading spaces
while (isspace(ca)) {
ai++;
ca = a[ai];
}
// Skip over leading spaces
while (isspace(ca)) {
ai++;
ca = a[ai];
}
while (isspace(cb)) {
bi++;
cb = b[bi];
}
while (isspace(cb)) {
bi++;
cb = b[bi];
}
// Process run of digits
if (isdigit(ca) && isdigit(cb)) {
int fractional = (ca == '0' || cb == '0');
// Process run of digits
if (isdigit(ca) && isdigit(cb)) {
int fractional = (ca == '0' || cb == '0');
if (fractional) {
int result = compare_left(a + ai, b + bi);
if (result)
return result;
} else {
int result = compare_right(a + ai, b + bi);
if (result)
return result;
}
}
if (fractional) {
int result = compare_left(a + ai, b + bi);
if (result)
return result;
} else {
int result = compare_right(a + ai, b + bi);
if (result)
return result;
}
}
if (!ca && !cb) {
// The strings compare the same. Perhaps the caller will want to call strcmp to break the tie.
return 0;
}
if (!ca && !cb) {
// The strings compare the same. Perhaps the caller will want to call strcmp to break the tie.
return 0;
}
if (ignore_case) {
ca = toupper(ca);
cb = toupper(cb);
}
if (ignore_case) {
ca = toupper(ca);
cb = toupper(cb);
}
if (ca < cb)
return -1;
else if (ca > cb)
return +1;
if (ca < cb)
return -1;
else if (ca > cb)
return +1;
ai++;
bi++;
}
ai++;
bi++;
}
}
int strnatcmp(char const *a, char const *b)
{
return strnatcmp0(a, b, 0);
return strnatcmp0(a, b, 0);
}
int strnatcasecmp(char const *a, char const *b)
{
return strnatcmp0(a, b, 1);
return strnatcmp0(a, b, 1);
}

566
src/util/timer.c
View File

@@ -28,22 +28,22 @@ GHashTable *multi_timeouts;
// functions and structs for multi timeouts
typedef struct {
int current_count;
int count_to_expiration;
int current_count;
int count_to_expiration;
} multi_timeout;
typedef struct {
GSList *timeout_list;
timeout *parent_timeout;
GSList *timeout_list;
timeout *parent_timeout;
} multi_timeout_handler;
struct _timeout {
int interval_msec;
struct timespec timeout_expires;
void (*_callback)(void *);
void *arg;
multi_timeout *multi_timeout;
timeout **self;
int interval_msec;
struct timespec timeout_expires;
void (*_callback)(void *);
void *arg;
multi_timeout *multi_timeout;
timeout **self;
};
void add_timeout_intern(int value_msec, int interval_msec, void (*_callback)(void *), void *arg, timeout *t);
@@ -61,25 +61,25 @@ void stop_multi_timeout(timeout *t);
void default_timeout()
{
timeout_list = NULL;
multi_timeouts = NULL;
timeout_list = NULL;
multi_timeouts = NULL;
}
void cleanup_timeout()
{
while (timeout_list) {
timeout *t = timeout_list->data;
if (t->multi_timeout)
stop_multi_timeout(t);
if (t->self)
*t->self = NULL;
free(t);
timeout_list = g_slist_remove(timeout_list, t);
}
if (multi_timeouts) {
g_hash_table_destroy(multi_timeouts);
multi_timeouts = NULL;
}
while (timeout_list) {
timeout *t = timeout_list->data;
if (t->multi_timeout)
stop_multi_timeout(t);
if (t->self)
*t->self = NULL;
free(t);
timeout_list = g_slist_remove(timeout_list, t);
}
if (multi_timeouts) {
g_hash_table_destroy(multi_timeouts);
multi_timeouts = NULL;
}
}
// Implementation notes for timeouts
@@ -96,358 +96,358 @@ void cleanup_timeout()
timeout *add_timeout(int value_msec, int interval_msec, void (*_callback)(void *), void *arg, timeout **self)
{
if (self && *self)
return *self;
timeout *t = calloc(1, sizeof(timeout));
t->self = self;
add_timeout_intern(value_msec, interval_msec, _callback, arg, t);
return t;
if (self && *self)
return *self;
timeout *t = calloc(1, sizeof(timeout));
t->self = self;
add_timeout_intern(value_msec, interval_msec, _callback, arg, t);
return t;
}
void change_timeout(timeout **t, int value_msec, int interval_msec, void (*_callback)(), void *arg)
{
if (!((timeout_list && g_slist_find(timeout_list, *t)) ||
(multi_timeouts && g_hash_table_lookup(multi_timeouts, *t))))
*t = add_timeout(value_msec, interval_msec, _callback, arg, t);
else {
if ((*t)->multi_timeout)
remove_from_multi_timeout(*t);
else
timeout_list = g_slist_remove(timeout_list, *t);
add_timeout_intern(value_msec, interval_msec, _callback, arg, *t);
}
if (!((timeout_list && g_slist_find(timeout_list, *t)) ||
(multi_timeouts && g_hash_table_lookup(multi_timeouts, *t))))
*t = add_timeout(value_msec, interval_msec, _callback, arg, t);
else {
if ((*t)->multi_timeout)
remove_from_multi_timeout(*t);
else
timeout_list = g_slist_remove(timeout_list, *t);
add_timeout_intern(value_msec, interval_msec, _callback, arg, *t);
}
}
void update_next_timeout()
{
if (timeout_list) {
timeout *t = timeout_list->data;
struct timespec cur_time;
struct timespec next_timeout2 = {.tv_sec = next_timeout.tv_sec, .tv_nsec = next_timeout.tv_usec * 1000};
clock_gettime(CLOCK_MONOTONIC, &cur_time);
if (timespec_subtract(&next_timeout2, &t->timeout_expires, &cur_time)) {
next_timeout.tv_sec = 0;
next_timeout.tv_usec = 0;
} else {
next_timeout.tv_sec = next_timeout2.tv_sec;
next_timeout.tv_usec = next_timeout2.tv_nsec / 1000;
}
} else
next_timeout.tv_sec = -1;
if (timeout_list) {
timeout *t = timeout_list->data;
struct timespec cur_time;
struct timespec next_timeout2 = {.tv_sec = next_timeout.tv_sec, .tv_nsec = next_timeout.tv_usec * 1000};
clock_gettime(CLOCK_MONOTONIC, &cur_time);
if (timespec_subtract(&next_timeout2, &t->timeout_expires, &cur_time)) {
next_timeout.tv_sec = 0;
next_timeout.tv_usec = 0;
} else {
next_timeout.tv_sec = next_timeout2.tv_sec;
next_timeout.tv_usec = next_timeout2.tv_nsec / 1000;
}
} else
next_timeout.tv_sec = -1;
}
void callback_timeout_expired()
{
struct timespec cur_time;
timeout *t;
while (timeout_list) {
clock_gettime(CLOCK_MONOTONIC, &cur_time);
t = timeout_list->data;
if (compare_timespecs(&t->timeout_expires, &cur_time) <= 0) {
// it's time for the callback function
t->_callback(t->arg);
// If _callback() calls stop_timeout(t) the timer 't' was freed and is not in the timeout_list
if (g_slist_find(timeout_list, t)) {
// Timer still exists
timeout_list = g_slist_remove(timeout_list, t);
if (t->interval_msec > 0) {
add_timeout_intern(t->interval_msec, t->interval_msec, t->_callback, t->arg, t);
} else {
// Destroy single-shot timer
if (t->self)
*t->self = NULL;
free(t);
}
}
} else {
return;
}
}
struct timespec cur_time;
timeout *t;
while (timeout_list) {
clock_gettime(CLOCK_MONOTONIC, &cur_time);
t = timeout_list->data;
if (compare_timespecs(&t->timeout_expires, &cur_time) <= 0) {
// it's time for the callback function
t->_callback(t->arg);
// If _callback() calls stop_timeout(t) the timer 't' was freed and is not in the timeout_list
if (g_slist_find(timeout_list, t)) {
// Timer still exists
timeout_list = g_slist_remove(timeout_list, t);
if (t->interval_msec > 0) {
add_timeout_intern(t->interval_msec, t->interval_msec, t->_callback, t->arg, t);
} else {
// Destroy single-shot timer
if (t->self)
*t->self = NULL;
free(t);
}
}
} else {
return;
}
}
}
void stop_timeout(timeout *t)
{
if (!t)
return;
// if not in the list, it was deleted in callback_timeout_expired
if ((timeout_list && g_slist_find(timeout_list, t)) || (multi_timeouts && g_hash_table_lookup(multi_timeouts, t))) {
if (multi_timeouts && t->multi_timeout)
remove_from_multi_timeout(t);
if (timeout_list)
timeout_list = g_slist_remove(timeout_list, t);
if (t->self)
*t->self = NULL;
free(t);
}
if (!t)
return;
// if not in the list, it was deleted in callback_timeout_expired
if ((timeout_list && g_slist_find(timeout_list, t)) || (multi_timeouts && g_hash_table_lookup(multi_timeouts, t))) {
if (multi_timeouts && t->multi_timeout)
remove_from_multi_timeout(t);
if (timeout_list)
timeout_list = g_slist_remove(timeout_list, t);
if (t->self)
*t->self = NULL;
free(t);
}
}
void add_timeout_intern(int value_msec, int interval_msec, void (*_callback)(), void *arg, timeout *t)
{
t->interval_msec = interval_msec;
t->_callback = _callback;
t->arg = arg;
struct timespec cur_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
t->timeout_expires = add_msec_to_timespec(cur_time, value_msec);
t->interval_msec = interval_msec;
t->_callback = _callback;
t->arg = arg;
struct timespec cur_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
t->timeout_expires = add_msec_to_timespec(cur_time, value_msec);
int can_align = 0;
if (interval_msec > 0 && !t->multi_timeout)
can_align = align_with_existing_timeouts(t);
if (!can_align)
timeout_list = g_slist_insert_sorted(timeout_list, t, compare_timeouts);
int can_align = 0;
if (interval_msec > 0 && !t->multi_timeout)
can_align = align_with_existing_timeouts(t);
if (!can_align)
timeout_list = g_slist_insert_sorted(timeout_list, t, compare_timeouts);
}
gint compare_timeouts(gconstpointer t1, gconstpointer t2)
{
return compare_timespecs(&((const timeout *)t1)->timeout_expires, &((const timeout *)t2)->timeout_expires);
return compare_timespecs(&((const timeout *)t1)->timeout_expires, &((const timeout *)t2)->timeout_expires);
}
gint compare_timespecs(const struct timespec *t1, const struct timespec *t2)
{
if (t1->tv_sec < t2->tv_sec)
return -1;
else if (t1->tv_sec == t2->tv_sec) {
if (t1->tv_nsec < t2->tv_nsec)
return -1;
else if (t1->tv_nsec == t2->tv_nsec)
return 0;
else
return 1;
} else
return 1;
if (t1->tv_sec < t2->tv_sec)
return -1;
else if (t1->tv_sec == t2->tv_sec) {
if (t1->tv_nsec < t2->tv_nsec)
return -1;
else if (t1->tv_nsec == t2->tv_nsec)
return 0;
else
return 1;
} else
return 1;
}
int timespec_subtract(struct timespec *result, struct timespec *x, struct timespec *y)
{
/* Perform the carry for the later subtraction by updating y. */
if (x->tv_nsec < y->tv_nsec) {
int nsec = (y->tv_nsec - x->tv_nsec) / 1000000000 + 1;
y->tv_nsec -= 1000000000 * nsec;
y->tv_sec += nsec;
}
if (x->tv_nsec - y->tv_nsec > 1000000000) {
int nsec = (x->tv_nsec - y->tv_nsec) / 1000000000;
y->tv_nsec += 1000000000 * nsec;
y->tv_sec -= nsec;
}
/* Perform the carry for the later subtraction by updating y. */
if (x->tv_nsec < y->tv_nsec) {
int nsec = (y->tv_nsec - x->tv_nsec) / 1000000000 + 1;
y->tv_nsec -= 1000000000 * nsec;
y->tv_sec += nsec;
}
if (x->tv_nsec - y->tv_nsec > 1000000000) {
int nsec = (x->tv_nsec - y->tv_nsec) / 1000000000;
y->tv_nsec += 1000000000 * nsec;
y->tv_sec -= nsec;
}
/* Compute the time remaining to wait. tv_nsec is certainly positive. */
result->tv_sec = x->tv_sec - y->tv_sec;
result->tv_nsec = x->tv_nsec - y->tv_nsec;
/* Compute the time remaining to wait. tv_nsec is certainly positive. */
result->tv_sec = x->tv_sec - y->tv_sec;
result->tv_nsec = x->tv_nsec - y->tv_nsec;
/* Return 1 if result is negative. */
return x->tv_sec < y->tv_sec;
/* Return 1 if result is negative. */
return x->tv_sec < y->tv_sec;
}
struct timespec add_msec_to_timespec(struct timespec ts, int msec)
{
ts.tv_sec += msec / 1000;
ts.tv_nsec += (msec % 1000) * 1000000;
if (ts.tv_nsec >= 1000000000) { // 10^9
ts.tv_sec++;
ts.tv_nsec -= 1000000000;
}
return ts;
ts.tv_sec += msec / 1000;
ts.tv_nsec += (msec % 1000) * 1000000;
if (ts.tv_nsec >= 1000000000) { // 10^9
ts.tv_sec++;
ts.tv_nsec -= 1000000000;
}
return ts;
}
int align_with_existing_timeouts(timeout *t)
{
GSList *it = timeout_list;
while (it) {
timeout *t2 = it->data;
if (t2->interval_msec > 0) {
if (t->interval_msec % t2->interval_msec == 0 || t2->interval_msec % t->interval_msec == 0) {
if (!multi_timeouts)
multi_timeouts = g_hash_table_new(0, 0);
if (!t->multi_timeout && !t2->multi_timeout) {
// both timeouts can be aligned, but there is no multi timeout for them
create_multi_timeout(t, t2);
} else {
// there is already a multi timeout, so we append the new timeout to the multi timeout
append_multi_timeout(t, t2);
}
return 1;
}
}
it = it->next;
}
return 0;
GSList *it = timeout_list;
while (it) {
timeout *t2 = it->data;
if (t2->interval_msec > 0) {
if (t->interval_msec % t2->interval_msec == 0 || t2->interval_msec % t->interval_msec == 0) {
if (!multi_timeouts)
multi_timeouts = g_hash_table_new(0, 0);
if (!t->multi_timeout && !t2->multi_timeout) {
// both timeouts can be aligned, but there is no multi timeout for them
create_multi_timeout(t, t2);
} else {
// there is already a multi timeout, so we append the new timeout to the multi timeout
append_multi_timeout(t, t2);
}
return 1;
}
}
it = it->next;
}
return 0;
}
int calc_multi_timeout_interval(multi_timeout_handler *mth)
{
GSList *it = mth->timeout_list;
timeout *t = it->data;
int min_interval = t->interval_msec;
it = it->next;
while (it) {
t = it->data;
if (t->interval_msec < min_interval)
min_interval = t->interval_msec;
it = it->next;
}
return min_interval;
GSList *it = mth->timeout_list;
timeout *t = it->data;
int min_interval = t->interval_msec;
it = it->next;
while (it) {
t = it->data;
if (t->interval_msec < min_interval)
min_interval = t->interval_msec;
it = it->next;
}
return min_interval;
}
void create_multi_timeout(timeout *t1, timeout *t2)
{
multi_timeout *mt1 = calloc(1, sizeof(multi_timeout));
multi_timeout *mt2 = calloc(1, sizeof(multi_timeout));
multi_timeout_handler *mth = calloc(1, sizeof(multi_timeout_handler));
timeout *real_timeout = calloc(1, sizeof(timeout));
multi_timeout *mt1 = calloc(1, sizeof(multi_timeout));
multi_timeout *mt2 = calloc(1, sizeof(multi_timeout));
multi_timeout_handler *mth = calloc(1, sizeof(multi_timeout_handler));
timeout *real_timeout = calloc(1, sizeof(timeout));
mth->timeout_list = 0;
mth->timeout_list = g_slist_prepend(mth->timeout_list, t1);
mth->timeout_list = g_slist_prepend(mth->timeout_list, t2);
mth->parent_timeout = real_timeout;
mth->timeout_list = 0;
mth->timeout_list = g_slist_prepend(mth->timeout_list, t1);
mth->timeout_list = g_slist_prepend(mth->timeout_list, t2);
mth->parent_timeout = real_timeout;
g_hash_table_insert(multi_timeouts, t1, mth);
g_hash_table_insert(multi_timeouts, t2, mth);
g_hash_table_insert(multi_timeouts, real_timeout, mth);
g_hash_table_insert(multi_timeouts, t1, mth);
g_hash_table_insert(multi_timeouts, t2, mth);
g_hash_table_insert(multi_timeouts, real_timeout, mth);
t1->multi_timeout = mt1;
t2->multi_timeout = mt2;
// set real_timeout->multi_timeout to something, such that we see in add_timeout_intern that
// it is already a multi_timeout (we never use it, except of checking for 0 ptr)
real_timeout->multi_timeout = (void *)real_timeout;
t1->multi_timeout = mt1;
t2->multi_timeout = mt2;
// set real_timeout->multi_timeout to something, such that we see in add_timeout_intern that
// it is already a multi_timeout (we never use it, except of checking for 0 ptr)
real_timeout->multi_timeout = (void *)real_timeout;
timeout_list = g_slist_remove(timeout_list, t1);
timeout_list = g_slist_remove(timeout_list, t2);
timeout_list = g_slist_remove(timeout_list, t1);
timeout_list = g_slist_remove(timeout_list, t2);
update_multi_timeout_values(mth);
update_multi_timeout_values(mth);
}
void append_multi_timeout(timeout *t1, timeout *t2)
{
if (t2->multi_timeout) {
// swap t1 and t2 such that t1 is the multi timeout
timeout *tmp = t2;
t2 = t1;
t1 = tmp;
}
if (t2->multi_timeout) {
// swap t1 and t2 such that t1 is the multi timeout
timeout *tmp = t2;
t2 = t1;
t1 = tmp;
}
multi_timeout *mt = calloc(1, sizeof(multi_timeout));
multi_timeout_handler *mth = g_hash_table_lookup(multi_timeouts, t1);
multi_timeout *mt = calloc(1, sizeof(multi_timeout));
multi_timeout_handler *mth = g_hash_table_lookup(multi_timeouts, t1);
mth->timeout_list = g_slist_prepend(mth->timeout_list, t2);
g_hash_table_insert(multi_timeouts, t2, mth);
mth->timeout_list = g_slist_prepend(mth->timeout_list, t2);
g_hash_table_insert(multi_timeouts, t2, mth);
t2->multi_timeout = mt;
t2->multi_timeout = mt;
update_multi_timeout_values(mth);
update_multi_timeout_values(mth);
}
void update_multi_timeout_values(multi_timeout_handler *mth)
{
int interval = calc_multi_timeout_interval(mth);
int next_timeout_msec = interval;
int interval = calc_multi_timeout_interval(mth);
int next_timeout_msec = interval;
struct timespec cur_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
struct timespec cur_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
GSList *it = mth->timeout_list;
struct timespec diff_time;
while (it) {
timeout *t = it->data;
t->multi_timeout->count_to_expiration = t->interval_msec / interval;
timespec_subtract(&diff_time, &t->timeout_expires, &cur_time);
int msec_to_expiration = diff_time.tv_sec * 1000 + diff_time.tv_nsec / 1000000;
int count_left = msec_to_expiration / interval + (msec_to_expiration % interval != 0);
t->multi_timeout->current_count = t->multi_timeout->count_to_expiration - count_left;
if (msec_to_expiration < next_timeout_msec)
next_timeout_msec = msec_to_expiration;
it = it->next;
}
GSList *it = mth->timeout_list;
struct timespec diff_time;
while (it) {
timeout *t = it->data;
t->multi_timeout->count_to_expiration = t->interval_msec / interval;
timespec_subtract(&diff_time, &t->timeout_expires, &cur_time);
int msec_to_expiration = diff_time.tv_sec * 1000 + diff_time.tv_nsec / 1000000;
int count_left = msec_to_expiration / interval + (msec_to_expiration % interval != 0);
t->multi_timeout->current_count = t->multi_timeout->count_to_expiration - count_left;
if (msec_to_expiration < next_timeout_msec)
next_timeout_msec = msec_to_expiration;
it = it->next;
}
mth->parent_timeout->interval_msec = interval;
timeout_list = g_slist_remove(timeout_list, mth->parent_timeout);
add_timeout_intern(next_timeout_msec, interval, callback_multi_timeout, mth, mth->parent_timeout);
mth->parent_timeout->interval_msec = interval;
timeout_list = g_slist_remove(timeout_list, mth->parent_timeout);
add_timeout_intern(next_timeout_msec, interval, callback_multi_timeout, mth, mth->parent_timeout);
}
void callback_multi_timeout(void *arg)
{
multi_timeout_handler *mth = arg;
struct timespec cur_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
GSList *it = mth->timeout_list;
while (it) {
timeout *t = it->data;
if (++t->multi_timeout->current_count >= t->multi_timeout->count_to_expiration) {
t->_callback(t->arg);
if (multi_timeouts && g_hash_table_lookup(multi_timeouts, t)) {
// Timer still exists
t->multi_timeout->current_count = 0;
t->timeout_expires = add_msec_to_timespec(cur_time, t->interval_msec);
} else {
return;
}
}
it = it->next;
}
multi_timeout_handler *mth = arg;
struct timespec cur_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
GSList *it = mth->timeout_list;
while (it) {
timeout *t = it->data;
if (++t->multi_timeout->current_count >= t->multi_timeout->count_to_expiration) {
t->_callback(t->arg);
if (multi_timeouts && g_hash_table_lookup(multi_timeouts, t)) {
// Timer still exists
t->multi_timeout->current_count = 0;
t->timeout_expires = add_msec_to_timespec(cur_time, t->interval_msec);
} else {
return;
}
}
it = it->next;
}
}
void remove_from_multi_timeout(timeout *t)
{
multi_timeout_handler *mth = g_hash_table_lookup(multi_timeouts, t);
g_hash_table_remove(multi_timeouts, t);
multi_timeout_handler *mth = g_hash_table_lookup(multi_timeouts, t);
g_hash_table_remove(multi_timeouts, t);
mth->timeout_list = g_slist_remove(mth->timeout_list, t);
free(t->multi_timeout);
t->multi_timeout = 0;
mth->timeout_list = g_slist_remove(mth->timeout_list, t);
free(t->multi_timeout);
t->multi_timeout = 0;
if (g_slist_length(mth->timeout_list) == 1) {
timeout *last_timeout = mth->timeout_list->data;
mth->timeout_list = g_slist_remove(mth->timeout_list, last_timeout);
free(last_timeout->multi_timeout);
last_timeout->multi_timeout = 0;
g_hash_table_remove(multi_timeouts, last_timeout);
g_hash_table_remove(multi_timeouts, mth->parent_timeout);
mth->parent_timeout->multi_timeout = 0;
stop_timeout(mth->parent_timeout);
free(mth);
if (g_slist_length(mth->timeout_list) == 1) {
timeout *last_timeout = mth->timeout_list->data;
mth->timeout_list = g_slist_remove(mth->timeout_list, last_timeout);
free(last_timeout->multi_timeout);
last_timeout->multi_timeout = 0;
g_hash_table_remove(multi_timeouts, last_timeout);
g_hash_table_remove(multi_timeouts, mth->parent_timeout);
mth->parent_timeout->multi_timeout = 0;
stop_timeout(mth->parent_timeout);
free(mth);
struct timespec cur_time, diff_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
timespec_subtract(&diff_time, &t->timeout_expires, &cur_time);
int msec_to_expiration = diff_time.tv_sec * 1000 + diff_time.tv_nsec / 1000000;
add_timeout_intern(msec_to_expiration,
last_timeout->interval_msec,
last_timeout->_callback,
last_timeout->arg,
last_timeout);
} else
update_multi_timeout_values(mth);
struct timespec cur_time, diff_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
timespec_subtract(&diff_time, &t->timeout_expires, &cur_time);
int msec_to_expiration = diff_time.tv_sec * 1000 + diff_time.tv_nsec / 1000000;
add_timeout_intern(msec_to_expiration,
last_timeout->interval_msec,
last_timeout->_callback,
last_timeout->arg,
last_timeout);
} else
update_multi_timeout_values(mth);
}
void stop_multi_timeout(timeout *t)
{
multi_timeout_handler *mth = g_hash_table_lookup(multi_timeouts, t);
g_hash_table_remove(multi_timeouts, mth->parent_timeout);
while (mth->timeout_list) {
timeout *t1 = mth->timeout_list->data;
mth->timeout_list = g_slist_remove(mth->timeout_list, t1);
g_hash_table_remove(multi_timeouts, t1);
free(t1->multi_timeout);
free(t1);
}
free(mth);
multi_timeout_handler *mth = g_hash_table_lookup(multi_timeouts, t);
g_hash_table_remove(multi_timeouts, mth->parent_timeout);
while (mth->timeout_list) {
timeout *t1 = mth->timeout_list->data;
mth->timeout_list = g_slist_remove(mth->timeout_list, t1);
g_hash_table_remove(multi_timeouts, t1);
free(t1->multi_timeout);
free(t1);
}
free(mth);
}
double profiling_get_time_old_time = 0;
double get_time()
{
struct timespec cur_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
return cur_time.tv_sec + cur_time.tv_nsec * 1.0e-9;
struct timespec cur_time;
clock_gettime(CLOCK_MONOTONIC, &cur_time);
return cur_time.tv_sec + cur_time.tv_nsec * 1.0e-9;
}
double profiling_get_time()
{
double t = get_time();
if (profiling_get_time_old_time == 0)
profiling_get_time_old_time = t;
double delta = t - profiling_get_time_old_time;
profiling_get_time_old_time = t;
return delta;
double t = get_time();
if (profiling_get_time_old_time == 0)
profiling_get_time_old_time = t;
double delta = t - profiling_get_time_old_time;
profiling_get_time_old_time = t;
return delta;
}

220
src/util/uevent.c
View File

@@ -38,170 +38,170 @@ static GList *notifiers = NULL;
static const char *has_prefix(const char *str, const char *end, const char *prefix, size_t prefixlen)
{
if ((end - str) < prefixlen)
return NULL;
if ((end - str) < prefixlen)
return NULL;
if (!memcmp(str, prefix, prefixlen))
return str + prefixlen;
if (!memcmp(str, prefix, prefixlen))
return str + prefixlen;
return NULL;
return NULL;
}
#define HAS_CONST_PREFIX(str, end, prefix) has_prefix((str), end, prefix, sizeof(prefix) - 1)
static void uevent_param_free(gpointer data)
{
struct uevent_parameter *param = data;
free(param->key);
free(param->val);
free(param);
struct uevent_parameter *param = data;
free(param->key);
free(param->val);
free(param);
}
static void uevent_free(struct uevent *ev)
{
free(ev->path);
free(ev->subsystem);
g_list_free_full(ev->params, uevent_param_free);
free(ev);
free(ev->path);
free(ev->subsystem);
g_list_free_full(ev->params, uevent_param_free);
free(ev);
}
static struct uevent *uevent_new(char *buffer, int size)
{
gboolean first = TRUE;
gboolean first = TRUE;
if (size == 0)
return NULL;
if (size == 0)
return NULL;
struct uevent *ev = calloc(1, sizeof(*ev));
if (!ev)
return NULL;
struct uevent *ev = calloc(1, sizeof(*ev));
if (!ev)
return NULL;
/* ensure nul termination required by strlen() */
buffer[size - 1] = '\0';
/* ensure nul termination required by strlen() */
buffer[size - 1] = '\0';
const char *s = buffer;
const char *end = s + size;
for (; s < end; s += strlen(s) + 1) {
if (first) {
const char *p = strchr(s, '@');
if (!p) {
/* error: kernel events contain @ */
/* triggered by udev events, though */
free(ev);
return NULL;
}
ev->path = strdup(p + 1);
first = FALSE;
} else {
const char *val;
if ((val = HAS_CONST_PREFIX(s, end, "ACTION=")) != NULL) {
if (!strcmp(val, "add"))
ev->action = UEVENT_ADD;
else if (!strcmp(val, "remove"))
ev->action = UEVENT_REMOVE;
else if (!strcmp(val, "change"))
ev->action = UEVENT_CHANGE;
else
ev->action = UEVENT_UNKNOWN;
} else if ((val = HAS_CONST_PREFIX(s, end, "SEQNUM=")) != NULL) {
ev->sequence = atoi(val);
} else if ((val = HAS_CONST_PREFIX(s, end, "SUBSYSTEM=")) != NULL) {
ev->subsystem = strdup(val);
} else {
val = strchr(s, '=');
if (val) {
struct uevent_parameter *param = malloc(sizeof(*param));
if (param) {
param->key = strndup(s, val - s);
param->val = strdup(val + 1);
ev->params = g_list_append(ev->params, param);
}
}
}
}
}
const char *s = buffer;
const char *end = s + size;
for (; s < end; s += strlen(s) + 1) {
if (first) {
const char *p = strchr(s, '@');
if (!p) {
/* error: kernel events contain @ */
/* triggered by udev events, though */
free(ev);
return NULL;
}
ev->path = strdup(p + 1);
first = FALSE;
} else {
const char *val;
if ((val = HAS_CONST_PREFIX(s, end, "ACTION=")) != NULL) {
if (!strcmp(val, "add"))
ev->action = UEVENT_ADD;
else if (!strcmp(val, "remove"))
ev->action = UEVENT_REMOVE;
else if (!strcmp(val, "change"))
ev->action = UEVENT_CHANGE;
else
ev->action = UEVENT_UNKNOWN;
} else if ((val = HAS_CONST_PREFIX(s, end, "SEQNUM=")) != NULL) {
ev->sequence = atoi(val);
} else if ((val = HAS_CONST_PREFIX(s, end, "SUBSYSTEM=")) != NULL) {
ev->subsystem = strdup(val);
} else {
val = strchr(s, '=');
if (val) {
struct uevent_parameter *param = malloc(sizeof(*param));
if (param) {
param->key = strndup(s, val - s);
param->val = strdup(val + 1);
ev->params = g_list_append(ev->params, param);
}
}
}
}
}
return ev;
return ev;
}
void uevent_register_notifier(struct uevent_notify *nb)
{
notifiers = g_list_append(notifiers, nb);
notifiers = g_list_append(notifiers, nb);
}
void uevent_unregister_notifier(struct uevent_notify *nb)
{
GList *l = notifiers;
GList *l = notifiers;
while (l != NULL) {
GList *next = l->next;
struct uevent_notify *lnb = l->data;
while (l != NULL) {
GList *next = l->next;
struct uevent_notify *lnb = l->data;
if (memcmp(nb, lnb, sizeof(struct uevent_notify)) == 0)
notifiers = g_list_delete_link(notifiers, l);
if (memcmp(nb, lnb, sizeof(struct uevent_notify)) == 0)
notifiers = g_list_delete_link(notifiers, l);
l = next;
}
l = next;
}
}
void uevent_handler()
{
if (ueventfd < 0)
return;
if (ueventfd < 0)
return;
char buf[512];
int len = recv(ueventfd, buf, sizeof(buf), MSG_DONTWAIT);
if (len < 0)
return;
char buf[512];
int len = recv(ueventfd, buf, sizeof(buf), MSG_DONTWAIT);
if (len < 0)
return;
struct uevent *ev = uevent_new(buf, len);
if (ev) {
for (GList *l = notifiers; l; l = l->next) {
struct uevent_notify *nb = l->data;
struct uevent *ev = uevent_new(buf, len);
if (ev) {
for (GList *l = notifiers; l; l = l->next) {
struct uevent_notify *nb = l->data;
if (!(ev->action & nb->action))
continue;
if (!(ev->action & nb->action))
continue;
if (nb->subsystem && strcmp(ev->subsystem, nb->subsystem))
continue;
if (nb->subsystem && strcmp(ev->subsystem, nb->subsystem))
continue;
nb->cb(ev, nb->userdata);
}
nb->cb(ev, nb->userdata);
}
uevent_free(ev);
}
uevent_free(ev);
}
}
int uevent_init()
{
/* Open hotplug event netlink socket */
memset(&nls, 0, sizeof(struct sockaddr_nl));
nls.nl_family = AF_NETLINK;
nls.nl_pid = getpid();
nls.nl_groups = -1;
/* Open hotplug event netlink socket */
memset(&nls, 0, sizeof(struct sockaddr_nl));
nls.nl_family = AF_NETLINK;
nls.nl_pid = getpid();
nls.nl_groups = -1;
/* open socket */
ueventfd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
if (ueventfd < 0) {
fprintf(stderr, "Error: socket open failed\n");
return -1;
}
/* open socket */
ueventfd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
if (ueventfd < 0) {
fprintf(stderr, "Error: socket open failed\n");
return -1;
}
/* Listen to netlink socket */
if (bind(ueventfd, (void *)&nls, sizeof(struct sockaddr_nl))) {
fprintf(stderr, "Bind failed\n");
return -1;
}
/* Listen to netlink socket */
if (bind(ueventfd, (void *)&nls, sizeof(struct sockaddr_nl))) {
fprintf(stderr, "Bind failed\n");
return -1;
}
printf("Kernel uevent interface initialized...\n");
printf("Kernel uevent interface initialized...\n");
return ueventfd;
return ueventfd;
}
void uevent_cleanup()
{
if (ueventfd >= 0)
close(ueventfd);
if (ueventfd >= 0)
close(ueventfd);
}
#endif

32
src/util/uevent.h
View File

@@ -21,31 +21,31 @@
#define UEVENT_H
enum uevent_action {
UEVENT_UNKNOWN = 0x01,
UEVENT_ADD = 0x02,
UEVENT_REMOVE = 0x04,
UEVENT_CHANGE = 0x08,
UEVENT_UNKNOWN = 0x01,
UEVENT_ADD = 0x02,
UEVENT_REMOVE = 0x04,
UEVENT_CHANGE = 0x08,
};
struct uevent_parameter {
char *key;
char *val;
char *key;
char *val;
};
struct uevent {
char *path;
enum uevent_action action;
int sequence;
char *subsystem;
GList *params;
char *path;
enum uevent_action action;
int sequence;
char *subsystem;
GList *params;
};
struct uevent_notify {
int action; /* bitfield */
char *subsystem; /* NULL => any */
void *userdata;
int action; /* bitfield */
char *subsystem; /* NULL => any */
void *userdata;
void (*cb)(struct uevent *e, void *userdata);
void (*cb)(struct uevent *e, void *userdata);
};
#if ENABLE_UEVENT
@@ -58,7 +58,7 @@ void uevent_unregister_notifier(struct uevent_notify *nb);
#else
static inline int uevent_init()
{
return -1;
return -1;
}
static inline void uevent_cleanup()

400
src/util/window.c
View File

@@ -37,288 +37,288 @@
void activate_window(Window win)
{
send_event32(win, server.atom._NET_ACTIVE_WINDOW, 2, CurrentTime, 0);
send_event32(win, server.atom._NET_ACTIVE_WINDOW, 2, CurrentTime, 0);
}
void change_window_desktop(Window win, int desktop)
{
send_event32(win, server.atom._NET_WM_DESKTOP, desktop, 2, 0);
send_event32(win, server.atom._NET_WM_DESKTOP, desktop, 2, 0);
}
void close_window(Window win)
{
send_event32(win, server.atom._NET_CLOSE_WINDOW, 0, 2, 0);
send_event32(win, server.atom._NET_CLOSE_WINDOW, 0, 2, 0);
}
void toggle_window_shade(Window win)
{
send_event32(win, server.atom._NET_WM_STATE, 2, server.atom._NET_WM_STATE_SHADED, 0);
send_event32(win, server.atom._NET_WM_STATE, 2, server.atom._NET_WM_STATE_SHADED, 0);
}
void toggle_window_maximized(Window win)
{
send_event32(win, server.atom._NET_WM_STATE, 2, server.atom._NET_WM_STATE_MAXIMIZED_VERT, 0);
send_event32(win, server.atom._NET_WM_STATE, 2, server.atom._NET_WM_STATE_MAXIMIZED_HORZ, 0);
send_event32(win, server.atom._NET_WM_STATE, 2, server.atom._NET_WM_STATE_MAXIMIZED_VERT, 0);
send_event32(win, server.atom._NET_WM_STATE, 2, server.atom._NET_WM_STATE_MAXIMIZED_HORZ, 0);
}
gboolean window_is_hidden(Window win)
{
Window window;
int count;
Window window;
int count;
Atom *at = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_STATE_SKIP_TASKBAR) {
XFree(at);
return TRUE;
}
// do not add transient_for windows if the transient window is already in the taskbar
window = win;
while (XGetTransientForHint(server.display, window, &window)) {
if (get_task_buttons(window)) {
XFree(at);
return TRUE;
}
}
}
XFree(at);
Atom *at = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_STATE_SKIP_TASKBAR) {
XFree(at);
return TRUE;
}
// do not add transient_for windows if the transient window is already in the taskbar
window = win;
while (XGetTransientForHint(server.display, window, &window)) {
if (get_task_buttons(window)) {
XFree(at);
return TRUE;
}
}
}
XFree(at);
at = server_get_property(win, server.atom._NET_WM_WINDOW_TYPE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_WINDOW_TYPE_DOCK || at[i] == server.atom._NET_WM_WINDOW_TYPE_DESKTOP ||
at[i] == server.atom._NET_WM_WINDOW_TYPE_TOOLBAR || at[i] == server.atom._NET_WM_WINDOW_TYPE_MENU ||
at[i] == server.atom._NET_WM_WINDOW_TYPE_SPLASH) {
XFree(at);
return TRUE;
}
}
XFree(at);
at = server_get_property(win, server.atom._NET_WM_WINDOW_TYPE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_WINDOW_TYPE_DOCK || at[i] == server.atom._NET_WM_WINDOW_TYPE_DESKTOP ||
at[i] == server.atom._NET_WM_WINDOW_TYPE_TOOLBAR || at[i] == server.atom._NET_WM_WINDOW_TYPE_MENU ||
at[i] == server.atom._NET_WM_WINDOW_TYPE_SPLASH) {
XFree(at);
return TRUE;
}
}
XFree(at);
for (int i = 0; i < num_panels; i++) {
if (panels[i].main_win == win) {
return TRUE;
}
}
for (int i = 0; i < num_panels; i++) {
if (panels[i].main_win == win) {
return TRUE;
}
}
// specification
// Windows with neither _NET_WM_WINDOW_TYPE nor WM_TRANSIENT_FOR set
// MUST be taken as top-level window.
return FALSE;
// specification
// Windows with neither _NET_WM_WINDOW_TYPE nor WM_TRANSIENT_FOR set
// MUST be taken as top-level window.
return FALSE;
}
int get_window_desktop(Window win)
{
int desktop = get_property32(win, server.atom._NET_WM_DESKTOP, XA_CARDINAL);
if (desktop == ALL_DESKTOPS)
return desktop;
if (!server.viewports)
return CLAMP(desktop, 0, server.num_desktops - 1);
int desktop = get_property32(win, server.atom._NET_WM_DESKTOP, XA_CARDINAL);
if (desktop == ALL_DESKTOPS)
return desktop;
if (!server.viewports)
return CLAMP(desktop, 0, server.num_desktops - 1);
int x, y, w, h;
get_window_coordinates(win, &x, &y, &w, &h);
int x, y, w, h;
get_window_coordinates(win, &x, &y, &w, &h);
desktop = get_current_desktop();
// Window coordinates are relative to the current viewport, make them absolute
x += server.viewports[desktop].x;
y += server.viewports[desktop].y;
desktop = get_current_desktop();
// Window coordinates are relative to the current viewport, make them absolute
x += server.viewports[desktop].x;
y += server.viewports[desktop].y;
if (x < 0 || y < 0) {
int num_results;
long *x_screen_size =
server_get_property(server.root_win, server.atom._NET_DESKTOP_GEOMETRY, XA_CARDINAL, &num_results);
if (!x_screen_size)
return 0;
int x_screen_width = x_screen_size[0];
int x_screen_height = x_screen_size[1];
XFree(x_screen_size);
if (x < 0 || y < 0) {
int num_results;
long *x_screen_size =
server_get_property(server.root_win, server.atom._NET_DESKTOP_GEOMETRY, XA_CARDINAL, &num_results);
if (!x_screen_size)
return 0;
int x_screen_width = x_screen_size[0];
int x_screen_height = x_screen_size[1];
XFree(x_screen_size);
// Wrap
if (x < 0)
x += x_screen_width;
if (y < 0)
y += x_screen_height;
}
// Wrap
if (x < 0)
x += x_screen_width;
if (y < 0)
y += x_screen_height;
}
int best_match = -1;
int match_right = 0;
int match_bottom = 0;
// There is an ambiguity when a window is right on the edge between viewports.
// In that case, prefer the viewports which is on the right and bottom of the window's top-left corner.
for (int i = 0; i < server.num_desktops; i++) {
if (x >= server.viewports[i].x && x <= (server.viewports[i].x + server.viewports[i].width) &&
y >= server.viewports[i].y && y <= (server.viewports[i].y + server.viewports[i].height)) {
int current_right = x < (server.viewports[i].x + server.viewports[i].width);
int current_bottom = y < (server.viewports[i].y + server.viewports[i].height);
if (best_match < 0 || (!match_right && current_right) || (!match_bottom && current_bottom)) {
best_match = i;
}
}
}
int best_match = -1;
int match_right = 0;
int match_bottom = 0;
// There is an ambiguity when a window is right on the edge between viewports.
// In that case, prefer the viewports which is on the right and bottom of the window's top-left corner.
for (int i = 0; i < server.num_desktops; i++) {
if (x >= server.viewports[i].x && x <= (server.viewports[i].x + server.viewports[i].width) &&
y >= server.viewports[i].y && y <= (server.viewports[i].y + server.viewports[i].height)) {
int current_right = x < (server.viewports[i].x + server.viewports[i].width);
int current_bottom = y < (server.viewports[i].y + server.viewports[i].height);
if (best_match < 0 || (!match_right && current_right) || (!match_bottom && current_bottom)) {
best_match = i;
}
}
}
if (best_match < 0)
best_match = 0;
// fprintf(stderr, "window %lx %s : viewport %d, (%d, %d)\n", win, get_task(win) ? get_task(win)->title : "??",
// best_match+1, x, y);
return best_match;
if (best_match < 0)
best_match = 0;
// fprintf(stderr, "window %lx %s : viewport %d, (%d, %d)\n", win, get_task(win) ? get_task(win)->title : "??",
// best_match+1, x, y);
return best_match;
}
int get_window_monitor(Window win)
{
int x, y, w, h;
get_window_coordinates(win, &x, &y, &w, &h);
int x, y, w, h;
get_window_coordinates(win, &x, &y, &w, &h);
int best_match = -1;
int match_right = 0;
int match_bottom = 0;
// There is an ambiguity when a window is right on the edge between screens.
// In that case, prefer the monitor which is on the right and bottom of the window's top-left corner.
for (int i = 0; i < server.num_monitors; i++) {
if (x >= server.monitors[i].x && x <= (server.monitors[i].x + server.monitors[i].width) &&
y >= server.monitors[i].y && y <= (server.monitors[i].y + server.monitors[i].height)) {
int current_right = x < (server.monitors[i].x + server.monitors[i].width);
int current_bottom = y < (server.monitors[i].y + server.monitors[i].height);
if (best_match < 0 || (!match_right && current_right) || (!match_bottom && current_bottom)) {
best_match = i;
}
}
}
int best_match = -1;
int match_right = 0;
int match_bottom = 0;
// There is an ambiguity when a window is right on the edge between screens.
// In that case, prefer the monitor which is on the right and bottom of the window's top-left corner.
for (int i = 0; i < server.num_monitors; i++) {
if (x >= server.monitors[i].x && x <= (server.monitors[i].x + server.monitors[i].width) &&
y >= server.monitors[i].y && y <= (server.monitors[i].y + server.monitors[i].height)) {
int current_right = x < (server.monitors[i].x + server.monitors[i].width);
int current_bottom = y < (server.monitors[i].y + server.monitors[i].height);
if (best_match < 0 || (!match_right && current_right) || (!match_bottom && current_bottom)) {
best_match = i;
}
}
}
if (best_match < 0)
best_match = 0;
// fprintf(stderr, "desktop %d, window %lx %s : monitor %d, (%d, %d)\n", 1 + get_current_desktop(), win,
// get_task(win) ? get_task(win)->title : "??", best_match+1, x, y);
return best_match;
if (best_match < 0)
best_match = 0;
// fprintf(stderr, "desktop %d, window %lx %s : monitor %d, (%d, %d)\n", 1 + get_current_desktop(), win,
// get_task(win) ? get_task(win)->title : "??", best_match+1, x, y);
return best_match;
}
void get_window_coordinates(Window win, int *x, int *y, int *w, int *h)
{
int dummy_int;
unsigned ww, wh, bw, bh;
Window src;
XTranslateCoordinates(server.display, win, server.root_win, 0, 0, x, y, &src);
XGetGeometry(server.display, win, &src, &dummy_int, &dummy_int, &ww, &wh, &bw, &bh);
*w = ww + bw;
*h = wh + bh;
int dummy_int;
unsigned ww, wh, bw, bh;
Window src;
XTranslateCoordinates(server.display, win, server.root_win, 0, 0, x, y, &src);
XGetGeometry(server.display, win, &src, &dummy_int, &dummy_int, &ww, &wh, &bw, &bh);
*w = ww + bw;
*h = wh + bh;
}
gboolean window_is_iconified(Window win)
{
// EWMH specification : minimization of windows use _NET_WM_STATE_HIDDEN.
// WM_STATE is not accurate for shaded window and in multi_desktop mode.
int count;
Atom *at = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_STATE_HIDDEN) {
XFree(at);
return TRUE;
}
}
XFree(at);
return FALSE;
// EWMH specification : minimization of windows use _NET_WM_STATE_HIDDEN.
// WM_STATE is not accurate for shaded window and in multi_desktop mode.
int count;
Atom *at = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_STATE_HIDDEN) {
XFree(at);
return TRUE;
}
}
XFree(at);
return FALSE;
}
gboolean window_is_urgent(Window win)
{
int count;
int count;
Atom *at = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_STATE_DEMANDS_ATTENTION) {
XFree(at);
return TRUE;
}
}
XFree(at);
return FALSE;
Atom *at = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_STATE_DEMANDS_ATTENTION) {
XFree(at);
return TRUE;
}
}
XFree(at);
return FALSE;
}
gboolean window_is_skip_taskbar(Window win)
{
int count;
int count;
Atom *at = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_STATE_SKIP_TASKBAR) {
XFree(at);
return 1;
}
}
XFree(at);
return FALSE;
Atom *at = server_get_property(win, server.atom._NET_WM_STATE, XA_ATOM, &count);
for (int i = 0; i < count; i++) {
if (at[i] == server.atom._NET_WM_STATE_SKIP_TASKBAR) {
XFree(at);
return 1;
}
}
XFree(at);
return FALSE;
}
Window get_active_window()
{
return get_property32(server.root_win, server.atom._NET_ACTIVE_WINDOW, XA_WINDOW);
return get_property32(server.root_win, server.atom._NET_ACTIVE_WINDOW, XA_WINDOW);
}
gboolean window_is_active(Window win)
{
return (win == get_property32(server.root_win, server.atom._NET_ACTIVE_WINDOW, XA_WINDOW));
return (win == get_property32(server.root_win, server.atom._NET_ACTIVE_WINDOW, XA_WINDOW));
}
int get_icon_count(gulong *data, int num)
{
int count, pos, w, h;
int count, pos, w, h;
count = 0;
pos = 0;
while (pos + 2 < num) {
w = data[pos++];
h = data[pos++];
pos += w * h;
if (pos > num || w <= 0 || h <= 0)
break;
count++;
}
count = 0;
pos = 0;
while (pos + 2 < num) {
w = data[pos++];
h = data[pos++];
pos += w * h;
if (pos > num || w <= 0 || h <= 0)
break;
count++;
}
return count;
return count;
}
gulong *get_best_icon(gulong *data, int icon_count, int num, int *iw, int *ih, int best_icon_size)
{
int width[icon_count], height[icon_count], pos, i, w, h;
gulong *icon_data[icon_count];
int width[icon_count], height[icon_count], pos, i, w, h;
gulong *icon_data[icon_count];
/* List up icons */
pos = 0;
i = icon_count;
while (i--) {
w = data[pos++];
h = data[pos++];
if (pos + w * h > num)
break;
/* List up icons */
pos = 0;
i = icon_count;
while (i--) {
w = data[pos++];
h = data[pos++];
if (pos + w * h > num)
break;
width[i] = w;
height[i] = h;
icon_data[i] = &data[pos];
width[i] = w;
height[i] = h;
icon_data[i] = &data[pos];
pos += w * h;
}
pos += w * h;
}
/* Try to find exact size */
int icon_num = -1;
for (i = 0; i < icon_count; i++) {
if (width[i] == best_icon_size) {
icon_num = i;
break;
}
}
/* Try to find exact size */
int icon_num = -1;
for (i = 0; i < icon_count; i++) {
if (width[i] == best_icon_size) {
icon_num = i;
break;
}
}
/* Take the biggest or whatever */
if (icon_num < 0) {
int highest = 0;
for (i = 0; i < icon_count; i++) {
if (width[i] > highest) {
icon_num = i;
highest = width[i];
}
}
}
/* Take the biggest or whatever */
if (icon_num < 0) {
int highest = 0;
for (i = 0; i < icon_count; i++) {
if (width[i] > highest) {
icon_num = i;
highest = width[i];
}
}
}
*iw = width[icon_num];
*ih = height[icon_num];
return icon_data[icon_num];
*iw = width[icon_num];
*ih = height[icon_num];
return icon_data[icon_num];
}
// Thanks zcodes!