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

Cleanup indentation with clang-format and changed a few variable names

Browse Source
This commit is contained in:
o9000
2015-11-20 23:28:37 +01:00
parent c0e62e2e79
commit 4a6937826c
51 changed files with 4145 additions and 3789 deletions
Download Patch File Download Diff File Expand all files Collapse all files

590
src/taskbar/task.c
View File

@@ -35,180 +35,184 @@
#include "tooltip.h"
#include "timer.h"
timeout* urgent_timeout;
GSList* urgent_list;
timeout *urgent_timeout;
GSList *urgent_list;
char* task_get_tooltip(void* obj)
char *task_get_tooltip(void *obj)
{
Task* t = obj;
Task *t = (Task *)obj;
return strdup(t->title);
}
Task *add_task (Window win)
Task *add_task(Window win)
{
if (!win) return 0;
if (window_is_hidden(win)) return 0;
if (!win)
return 0;
if (window_is_hidden(win))
return 0;
XSelectInput(server.dsp, win, PropertyChangeMask|StructureNotifyMask);
XSelectInput(server.dsp, win, PropertyChangeMask | StructureNotifyMask);
XFlush(server.dsp);
int monitor;
if (nb_panel > 1) {
monitor = window_get_monitor (win);
if (monitor >= nb_panel) monitor = 0;
}
else monitor = 0;
if (num_panels > 1) {
monitor = get_window_monitor(win);
if (monitor >= num_panels)
monitor = 0;
} else
monitor = 0;
Task new_tsk;
memset(&new_tsk, 0, sizeof(new_tsk));
new_tsk.area.has_mouse_over_effect = 1;
new_tsk.area.has_mouse_press_effect = 1;
new_tsk.win = win;
new_tsk.desktop = window_get_desktop (win);
new_tsk.area.panel = &panel1[monitor];
new_tsk.current_state = window_is_iconified(win) ? TASK_ICONIFIED : TASK_NORMAL;
window_get_coordinates(win, &new_tsk.win_x, &new_tsk.win_y, &new_tsk.win_w, &new_tsk.win_h);
Task new_task;
memset(&new_task, 0, sizeof(new_task));
new_task.area.has_mouse_over_effect = 1;
new_task.area.has_mouse_press_effect = 1;
new_task.win = win;
new_task.desktop = get_window_desktop(win);
new_task.area.panel = &panels[monitor];
new_task.current_state = window_is_iconified(win) ? TASK_ICONIFIED : TASK_NORMAL;
get_window_coordinates(win, &new_task.win_x, &new_task.win_y, &new_task.win_w, &new_task.win_h);
// allocate only one title and one icon
// even with task_on_all_desktop and with task_on_all_panel
new_tsk.title = 0;
new_task.title = 0;
int k;
for (k=0; k<TASK_STATE_COUNT; ++k) {
new_tsk.icon[k] = 0;
new_tsk.state_pix[k] = 0;
for (k = 0; k < TASK_STATE_COUNT; ++k) {
new_task.icon[k] = 0;
new_task.state_pix[k] = 0;
}
get_title(&new_tsk);
get_icon(&new_tsk);
get_title(&new_task);
get_icon(&new_task);
//printf("new task %s win %u: desktop %d, monitor %d\n", new_tsk.title, win, new_tsk.desktop, monitor);
// printf("new task %s win %u: desktop %d, monitor %d\n", new_task.title, win, new_task.desktop, monitor);
GPtrArray* task_group = g_ptr_array_new();
Taskbar *tskbar;
Task *new_tsk2=0;
GPtrArray *task_group = g_ptr_array_new();
Taskbar *taskbar;
Task *new_task2 = 0;
int j;
for (j=0 ; j < panel1[monitor].nb_desktop ; j++) {
if (new_tsk.desktop != ALLDESKTOP && new_tsk.desktop != j) continue;
for (j = 0; j < panels[monitor].num_desktops; j++) {
if (new_task.desktop != ALLDESKTOP && new_task.desktop != j)
continue;
tskbar = &panel1[monitor].taskbar[j];
new_tsk2 = calloc(1, sizeof(Task));
memcpy(&new_tsk2->area, &panel1[monitor].g_task.area, sizeof(Area));
new_tsk2->area.parent = tskbar;
new_tsk2->area.has_mouse_over_effect = 1;
new_tsk2->area.has_mouse_press_effect = 1;
new_tsk2->win = new_tsk.win;
new_tsk2->desktop = new_tsk.desktop;
new_tsk2->win_x = new_tsk.win_x;
new_tsk2->win_y = new_tsk.win_y;
new_tsk2->win_w = new_tsk.win_w;
new_tsk2->win_h = new_tsk.win_h;
new_tsk2->current_state = -1; // to update the current state later in set_task_state...
if (new_tsk2->desktop == ALLDESKTOP && server.desktop != j) {
taskbar = &panels[monitor].taskbar[j];
new_task2 = calloc(1, sizeof(Task));
memcpy(&new_task2->area, &panels[monitor].g_task.area, sizeof(Area));
new_task2->area.parent = taskbar;
new_task2->area.has_mouse_over_effect = 1;
new_task2->area.has_mouse_press_effect = 1;
new_task2->win = new_task.win;
new_task2->desktop = new_task.desktop;
new_task2->win_x = new_task.win_x;
new_task2->win_y = new_task.win_y;
new_task2->win_w = new_task.win_w;
new_task2->win_h = new_task.win_h;
new_task2->current_state = -1; // to update the current state later in set_task_state...
if (new_task2->desktop == ALLDESKTOP && server.desktop != j) {
// hide ALLDESKTOP task on non-current desktop
new_tsk2->area.on_screen = 0;
new_task2->area.on_screen = FALSE;
}
new_tsk2->title = new_tsk.title;
if (panel1[monitor].g_task.tooltip_enabled)
new_tsk2->area._get_tooltip_text = task_get_tooltip;
for (k=0; k<TASK_STATE_COUNT; ++k) {
new_tsk2->icon[k] = new_tsk.icon[k];
new_tsk2->icon_hover[k] = new_tsk.icon_hover[k];
new_tsk2->icon_press[k] = new_tsk.icon_press[k];
new_tsk2->state_pix[k] = 0;
new_task2->title = new_task.title;
if (panels[monitor].g_task.tooltip_enabled)
new_task2->area._get_tooltip_text = task_get_tooltip;
for (k = 0; k < TASK_STATE_COUNT; ++k) {
new_task2->icon[k] = new_task.icon[k];
new_task2->icon_hover[k] = new_task.icon_hover[k];
new_task2->icon_press[k] = new_task.icon_press[k];
new_task2->state_pix[k] = 0;
}
new_tsk2->icon_width = new_tsk.icon_width;
new_tsk2->icon_height = new_tsk.icon_height;
tskbar->area.children = g_list_append(tskbar->area.children, new_tsk2);
tskbar->area.resize_needed = 1;
g_ptr_array_add(task_group, new_tsk2);
//printf("add_task panel %d, desktop %d, task %s\n", i, j, new_tsk2->title);
new_task2->icon_width = new_task.icon_width;
new_task2->icon_height = new_task.icon_height;
taskbar->area.children = g_list_append(taskbar->area.children, new_task2);
taskbar->area.resize_needed = 1;
g_ptr_array_add(task_group, new_task2);
// printf("add_task panel %d, desktop %d, task %s\n", i, j, new_task2->title);
}
Window* key = calloc(1, sizeof(Window));
*key = new_tsk.win;
Window *key = calloc(1, sizeof(Window));
*key = new_task.win;
g_hash_table_insert(win_to_task_table, key, task_group);
set_task_state(new_tsk2, new_tsk.current_state);
set_task_state(new_task2, new_task.current_state);
sort_taskbar_for_win(win);
if (panel_mode == MULTI_DESKTOP) {
Panel *panel = new_tsk2->area.panel;
if (taskbar_mode == MULTI_DESKTOP) {
Panel *panel = new_task2->area.panel;
panel->area.resize_needed = 1;
}
if (window_is_urgent(win)) {
add_urgent(new_tsk2);
add_urgent(new_task2);
}
return new_tsk2;
return new_task2;
}
void remove_task (Task *tsk)
void remove_task(Task *task)
{
if (!tsk) return;
if (!task)
return;
if (panel_mode == MULTI_DESKTOP) {
Panel *panel = tsk->area.panel;
if (taskbar_mode == MULTI_DESKTOP) {
Panel *panel = task->area.panel;
panel->area.resize_needed = 1;
}
Window win = tsk->win;
Window win = task->win;
// free title and icon just for the first task
// even with task_on_all_desktop and with task_on_all_panel
//printf("remove_task %s %d\n", tsk->title, tsk->desktop);
if (tsk->title)
free (tsk->title);
// printf("remove_task %s %d\n", task->title, task->desktop);
if (task->title)
free(task->title);
int k;
for (k=0; k<TASK_STATE_COUNT; ++k) {
if (tsk->icon[k]) {
imlib_context_set_image(tsk->icon[k]);
for (k = 0; k < TASK_STATE_COUNT; ++k) {
if (task->icon[k]) {
imlib_context_set_image(task->icon[k]);
imlib_free_image();
tsk->icon[k] = 0;
task->icon[k] = 0;
}
if (tsk->icon_hover[k]) {
imlib_context_set_image(tsk->icon_hover[k]);
if (task->icon_hover[k]) {
imlib_context_set_image(task->icon_hover[k]);
imlib_free_image();
tsk->icon_hover[k] = 0;
task->icon_hover[k] = 0;
}
if (tsk->icon_press[k]) {
imlib_context_set_image(tsk->icon_press[k]);
if (task->icon_press[k]) {
imlib_context_set_image(task->icon_press[k]);
imlib_free_image();
tsk->icon_press[k] = 0;
task->icon_press[k] = 0;
}
if (tsk->state_pix[k]) XFreePixmap(server.dsp, tsk->state_pix[k]);
if (task->state_pix[k])
XFreePixmap(server.dsp, task->state_pix[k]);
}
int i;
Task *tsk2;
GPtrArray* task_group = g_hash_table_lookup(win_to_task_table, &win);
for (i=0; i<task_group->len; ++i) {
tsk2 = g_ptr_array_index(task_group, i);
if (tsk2 == task_active) task_active = 0;
if (tsk2 == task_drag) task_drag = 0;
if (g_slist_find(urgent_list, tsk2)) del_urgent(tsk2);
remove_area((Area*)tsk2);
free(tsk2);
Task *task2;
GPtrArray *task_group = g_hash_table_lookup(win_to_task_table, &win);
for (i = 0; i < task_group->len; ++i) {
task2 = g_ptr_array_index(task_group, i);
if (task2 == task_active)
task_active = 0;
if (task2 == task_drag)
task_drag = 0;
if (g_slist_find(urgent_list, task2))
del_urgent(task2);
remove_area((Area *)task2);
free(task2);
}
g_hash_table_remove(win_to_task_table, &win);
}
int get_title(Task *tsk)
gboolean get_title(Task *task)
{
Panel *panel = tsk->area.panel;
Panel *panel = task->area.panel;
char *title, *name;
if (!panel->g_task.text &&
!panel->g_task.tooltip_enabled &&
taskbar_sort_method != TASKBAR_SORT_TITLE)
if (!panel->g_task.text && !panel->g_task.tooltip_enabled && taskbar_sort_method != TASKBAR_SORT_TITLE)
return 0;
name = server_get_property (tsk->win, server.atom._NET_WM_VISIBLE_NAME, server.atom.UTF8_STRING, 0);
name = server_get_property(task->win, server.atom._NET_WM_VISIBLE_NAME, server.atom.UTF8_STRING, 0);
if (!name || !strlen(name)) {
name = server_get_property (tsk->win, server.atom._NET_WM_NAME, server.atom.UTF8_STRING, 0);
name = server_get_property(task->win, server.atom._NET_WM_NAME, server.atom.UTF8_STRING, 0);
if (!name || !strlen(name)) {
name = server_get_property (tsk->win, server.atom.WM_NAME, XA_STRING, 0);
name = server_get_property(task->win, server.atom.WM_NAME, XA_STRING, 0);
}
}
@@ -217,70 +221,68 @@ int get_title(Task *tsk)
} else {
title = strdup("Untitled");
}
if (name) XFree (name);
if (tsk->title) {
if (name)
XFree(name);
if (task->title) {
// check unecessary title change
if (strcmp(tsk->title, title) == 0) {
if (strcmp(task->title, title) == 0) {
free(title);
return 0;
}
else
free(tsk->title);
}
} else
free(task->title);
}
tsk->title = title;
GPtrArray* task_group = task_get_tasks(tsk->win);
task->title = title;
GPtrArray *task_group = task_get_tasks(task->win);
if (task_group) {
int i;
for (i=0; i<task_group->len; ++i) {
Task* tsk2 = g_ptr_array_index(task_group, i);
tsk2->title = tsk->title;
set_task_redraw(tsk2);
for (i = 0; i < task_group->len; ++i) {
Task *task2 = g_ptr_array_index(task_group, i);
task2->title = task->title;
set_task_redraw(task2);
}
}
return 1;
}
void get_icon (Task *tsk)
void get_icon(Task *task)
{
Panel *panel = tsk->area.panel;
if (!panel->g_task.icon) return;
Panel *panel = task->area.panel;
if (!panel->g_task.icon)
return;
int i;
Imlib_Image img = NULL;
XWMHints *hints = 0;
gulong *data = 0;
int k;
for (k=0; k<TASK_STATE_COUNT; ++k) {
if (tsk->icon[k]) {
imlib_context_set_image(tsk->icon[k]);
for (int k = 0; k < TASK_STATE_COUNT; ++k) {
if (task->icon[k]) {
imlib_context_set_image(task->icon[k]);
imlib_free_image();
tsk->icon[k] = 0;
task->icon[k] = 0;
}
}
data = server_get_property (tsk->win, server.atom._NET_WM_ICON, XA_CARDINAL, &i);
data = server_get_property(task->win, server.atom._NET_WM_ICON, XA_CARDINAL, &i);
if (data) {
// get ARGB icon
int w, h;
gulong *tmp_data;
tmp_data = get_best_icon (data, get_icon_count (data, i), i, &w, &h, panel->g_task.icon_size1);
tmp_data = get_best_icon(data, get_icon_count(data, i), i, &w, &h, panel->g_task.icon_size1);
#ifdef __x86_64__
DATA32 icon_data[w * h];
int length = w * h;
for (i = 0; i < length; ++i)
icon_data[i] = tmp_data[i];
img = imlib_create_image_using_copied_data (w, h, icon_data);
img = imlib_create_image_using_copied_data(w, h, icon_data);
#else
img = imlib_create_image_using_data (w, h, (DATA32*)tmp_data);
img = imlib_create_image_using_data(w, h, (DATA32 *)tmp_data);
#endif
}
else {
} else {
// get Pixmap icon
hints = XGetWMHints(server.dsp, tsk->win);
hints = XGetWMHints(server.dsp, task->win);
if (hints) {
if (hints->flags & IconPixmapHint && hints->icon_pixmap != 0) {
// get width, height and depth for the pixmap
@@ -289,7 +291,7 @@ void get_icon (Task *tsk)
uint border_width, bpp;
uint w, h;
//printf(" get pixmap\n");
// printf(" get pixmap\n");
XGetGeometry(server.dsp, hints->icon_pixmap, &root, &icon_x, &icon_y, &w, &h, &border_width, &bpp);
imlib_context_set_drawable(hints->icon_pixmap);
img = imlib_create_image_from_drawable(hints->icon_mask, 0, 0, w, h, 0);
@@ -307,25 +309,37 @@ void get_icon (Task *tsk)
int w, h;
w = imlib_image_get_width();
h = imlib_image_get_height();
Imlib_Image orig_image = imlib_create_cropped_scaled_image(0, 0, w, h, panel->g_task.icon_size1, panel->g_task.icon_size1);
Imlib_Image orig_image =
imlib_create_cropped_scaled_image(0, 0, w, h, panel->g_task.icon_size1, panel->g_task.icon_size1);
imlib_free_image();
imlib_context_set_image(orig_image);
tsk->icon_width = imlib_image_get_width();
tsk->icon_height = imlib_image_get_height();
for (k=0; k<TASK_STATE_COUNT; ++k) {
task->icon_width = imlib_image_get_width();
task->icon_height = imlib_image_get_height();
for (int k = 0; k < TASK_STATE_COUNT; ++k) {
imlib_context_set_image(orig_image);
tsk->icon[k] = imlib_clone_image();
imlib_context_set_image(tsk->icon[k]);
task->icon[k] = imlib_clone_image();
imlib_context_set_image(task->icon[k]);
DATA32 *data32;
if (panel->g_task.alpha[k] != 100 || panel->g_task.saturation[k] != 0 || panel->g_task.brightness[k] != 0) {
data32 = imlib_image_get_data();
adjust_asb(data32, tsk->icon_width, tsk->icon_height, panel->g_task.alpha[k], (float)panel->g_task.saturation[k]/100, (float)panel->g_task.brightness[k]/100);
adjust_asb(data32,
task->icon_width,
task->icon_height,
panel->g_task.alpha[k],
(float)panel->g_task.saturation[k] / 100,
(float)panel->g_task.brightness[k] / 100);
imlib_image_put_back_data(data32);
}
if (panel_config.mouse_effects) {
tsk->icon_hover[k] = adjust_icon(tsk->icon[k], panel_config.mouse_over_alpha, panel_config.mouse_over_saturation, panel_config.mouse_over_brightness);
tsk->icon_press[k] = adjust_icon(tsk->icon[k], panel_config.mouse_pressed_alpha, panel_config.mouse_pressed_saturation, panel_config.mouse_pressed_brightness);
task->icon_hover[k] = adjust_icon(task->icon[k],
panel_config.mouse_over_alpha,
panel_config.mouse_over_saturation,
panel_config.mouse_over_brightness);
task->icon_press[k] = adjust_icon(task->icon[k],
panel_config.mouse_pressed_alpha,
panel_config.mouse_pressed_saturation,
panel_config.mouse_pressed_brightness);
}
}
imlib_context_set_image(orig_image);
@@ -334,116 +348,123 @@ void get_icon (Task *tsk)
if (hints)
XFree(hints);
if (data)
XFree (data);
XFree(data);
GPtrArray* task_group = task_get_tasks(tsk->win);
GPtrArray *task_group = task_get_tasks(task->win);
if (task_group) {
for (i=0; i<task_group->len; ++i) {
Task* tsk2 = g_ptr_array_index(task_group, i);
tsk2->icon_width = tsk->icon_width;
tsk2->icon_height = tsk->icon_height;
int k;
for (k=0; k<TASK_STATE_COUNT; ++k) {
tsk2->icon[k] = tsk->icon[k];
tsk2->icon_hover[k] = tsk->icon_hover[k];
tsk2->icon_press[k] = tsk->icon_press[k];
for (i = 0; i < task_group->len; ++i) {
Task *task2 = g_ptr_array_index(task_group, i);
task2->icon_width = task->icon_width;
task2->icon_height = task->icon_height;
for (int k = 0; k < TASK_STATE_COUNT; ++k) {
task2->icon[k] = task->icon[k];
task2->icon_hover[k] = task->icon_hover[k];
task2->icon_press[k] = task->icon_press[k];
}
set_task_redraw(tsk2);
set_task_redraw(task2);
}
}
}
// TODO icons look too large when the panel is large
void draw_task_icon (Task *tsk, int text_width)
void draw_task_icon(Task *task, int text_width)
{
if (tsk->icon[tsk->current_state] == 0) return;
if (!task->icon[task->current_state])
return;
// Find pos
int pos_x;
Panel *panel = (Panel*)tsk->area.panel;
Panel *panel = (Panel *)task->area.panel;
if (panel->g_task.centered) {
if (panel->g_task.text)
pos_x = (tsk->area.width - text_width - panel->g_task.icon_size1) / 2;
pos_x = (task->area.width - text_width - panel->g_task.icon_size1) / 2;
else
pos_x = (tsk->area.width - panel->g_task.icon_size1) / 2;
}
else pos_x = panel->g_task.area.paddingxlr + tsk->area.bg->border.width;
pos_x = (task->area.width - panel->g_task.icon_size1) / 2;
} else
pos_x = panel->g_task.area.paddingxlr + task->area.bg->border.width;
// Render
Imlib_Image image;
// Render
if (panel_config.mouse_effects) {
if (tsk->area.mouse_state == MOUSE_OVER)
image = tsk->icon_hover[tsk->current_state];
else if (tsk->area.mouse_state == MOUSE_DOWN)
image = tsk->icon_press[tsk->current_state];
if (task->area.mouse_state == MOUSE_OVER)
image = task->icon_hover[task->current_state];
else if (task->area.mouse_state == MOUSE_DOWN)
image = task->icon_press[task->current_state];
else
image = tsk->icon[tsk->current_state];
image = task->icon[task->current_state];
} else {
image = tsk->icon[tsk->current_state];
image = task->icon[task->current_state];
}
imlib_context_set_image(image);
render_image(tsk->area.pix, pos_x, panel->g_task.icon_posy);
render_image(task->area.pix, pos_x, panel->g_task.icon_posy);
}
void draw_task (void *obj, cairo_t *c)
void draw_task(void *obj, cairo_t *c)
{
Task *tsk = obj;
Task *task = obj;
if (!panel_config.mouse_effects)
tsk->state_pix[tsk->current_state] = tsk->area.pix;
task->state_pix[task->current_state] = task->area.pix;
PangoLayout *layout;
Color *config_text;
int width=0, height;
Panel *panel = (Panel*)tsk->area.panel;
//printf("draw_task %d %d\n", tsk->area.posx, tsk->area.posy);
int width = 0, height;
Panel *panel = (Panel *)task->area.panel;
// printf("draw_task %d %d\n", task->area.posx, task->area.posy);
if (panel->g_task.text) {
/* Layout */
layout = pango_cairo_create_layout (c);
pango_layout_set_font_description (layout, panel->g_task.font_desc);
pango_layout_set_text(layout, tsk->title, -1);
layout = pango_cairo_create_layout(c);
pango_layout_set_font_description(layout, panel->g_task.font_desc);
pango_layout_set_text(layout, task->title, -1);
/* Drawing width and Cut text */
// pango use U+22EF or U+2026
pango_layout_set_width(layout, ((Taskbar*)tsk->area.parent)->text_width * PANGO_SCALE);
pango_layout_set_width(layout, ((Taskbar *)task->area.parent)->text_width * PANGO_SCALE);
pango_layout_set_height(layout, panel->g_task.text_height * PANGO_SCALE);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_END);
pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END);
/* Center text */
if (panel->g_task.centered) pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
else pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);
if (panel->g_task.centered)
pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
else
pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
pango_layout_get_pixel_size (layout, &width, &height);
pango_layout_get_pixel_size(layout, &width, &height);
config_text = &panel->g_task.font[tsk->current_state];
config_text = &panel->g_task.font[task->current_state];
double text_posy = (panel->g_task.area.height - height) / 2.0;
draw_text(layout, c, panel->g_task.text_posx, text_posy, config_text, panel->font_shadow);
g_object_unref (layout);
g_object_unref(layout);
}
if (panel->g_task.icon) {
draw_task_icon (tsk, width);
draw_task_icon(task, width);
}
}
void on_change_task (void *obj)
void on_change_task(void *obj)
{
Task *tsk = obj;
Panel *panel = (Panel*)tsk->area.panel;
Task *task = obj;
Panel *panel = (Panel *)task->area.panel;
long value[] = {panel->posx + task->area.posx, panel->posy + task->area.posy, task->area.width, task->area.height};
XChangeProperty(server.dsp,
task->win,
server.atom._NET_WM_ICON_GEOMETRY,
XA_CARDINAL,
32,
PropModeReplace,
(unsigned char *)value,
4);
long value[] = { panel->posx+tsk->area.posx, panel->posy+tsk->area.posy, tsk->area.width, tsk->area.height };
XChangeProperty (server.dsp, tsk->win, server.atom._NET_WM_ICON_GEOMETRY, XA_CARDINAL, 32, PropModeReplace, (unsigned char*)value, 4);
// reset Pixmap when position/size changed
set_task_redraw(tsk);
set_task_redraw(task);
}
// Given a pointer to the active task (active_task) and a pointer
@@ -454,35 +475,35 @@ Task *find_active_task(Task *current_task, Task *active_task)
if (active_task == NULL)
return current_task;
Taskbar* tskbar = current_task->area.parent;
Taskbar *taskbar = current_task->area.parent;
GList *l0 = tskbar->area.children;
GList *l0 = taskbar->area.children;
if (taskbarname_enabled)
l0 = l0->next;
for (; l0 ; l0 = l0->next) {
Task *tsk = l0->data;
if (tsk->win == active_task->win)
return tsk;
for (; l0; l0 = l0->next) {
Task *task = l0->data;
if (task->win == active_task->win)
return task;
}
return current_task;
}
Task *next_task(Task *tsk)
Task *next_task(Task *task)
{
if (tsk == 0)
if (!task)
return 0;
Taskbar* tskbar = tsk->area.parent;
Taskbar *taskbar = task->area.parent;
GList *l0 = tskbar->area.children;
if (taskbarname_enabled) l0 = l0->next;
GList *lfirst_tsk = l0;
for (; l0 ; l0 = l0->next) {
Task *tsk1 = l0->data;
if (tsk1 == tsk) {
if (l0->next == 0) l0 = lfirst_tsk;
else l0 = l0->next;
GList *l0 = taskbar->area.children;
if (taskbarname_enabled)
l0 = l0->next;
GList *lfirst_task = l0;
for (; l0; l0 = l0->next) {
Task *task1 = l0->data;
if (task1 == task) {
l0 = l0->next ? l0->next : lfirst_task;
return l0->data;
}
}
@@ -490,34 +511,33 @@ Task *next_task(Task *tsk)
return 0;
}
Task *prev_task(Task *tsk)
Task *prev_task(Task *task)
{
if (tsk == 0)
if (!task)
return 0;
Task *tsk1, *tsk2;
Taskbar* tskbar = tsk->area.parent;
Taskbar *taskbar = task->area.parent;
tsk2 = 0;
GList *l0 = tskbar->area.children;
if (taskbarname_enabled) l0 = l0->next;
GList *lfirst_tsk = l0;
for (; l0 ; l0 = l0->next) {
tsk1 = l0->data;
if (tsk1 == tsk) {
if (l0 == lfirst_tsk) {
l0 = g_list_last ( l0 );
tsk2 = l0->data;
Task *task2 = NULL;
GList *l0 = taskbar->area.children;
if (taskbarname_enabled)
l0 = l0->next;
GList *lfirst_task = l0;
for (; l0; l0 = l0->next) {
Task *task1 = l0->data;
if (task1 == task) {
if (l0 == lfirst_task) {
l0 = g_list_last(l0);
task2 = l0->data;
}
return tsk2;
return task2;
}
tsk2 = tsk1;
task2 = task1;
}
return 0;
}
void active_task()
{
if (task_active) {
@@ -525,8 +545,8 @@ void active_task()
task_active = 0;
}
Window w1 = window_get_active();
//printf("Change active task %ld\n", w1);
Window w1 = get_active_window();
// printf("Change active task %ld\n", w1);
if (w1) {
if (!task_get_tasks(w1)) {
@@ -538,32 +558,31 @@ void active_task()
}
}
void set_task_state(Task *tsk, int state)
void set_task_state(Task *task, TaskState state)
{
if (tsk == 0 || state < 0 || state >= TASK_STATE_COUNT)
if (!task || state < 0 || state >= TASK_STATE_COUNT)
return;
if (tsk->current_state != state || hide_task_diff_monitor) {
GPtrArray* task_group = task_get_tasks(tsk->win);
if (task->current_state != state || hide_task_diff_monitor) {
GPtrArray *task_group = task_get_tasks(task->win);
if (task_group) {
int i;
for (i=0; i<task_group->len; ++i) {
Task* tsk1 = g_ptr_array_index(task_group, i);
tsk1->current_state = state;
tsk1->area.bg = panel1[0].g_task.background[state];
for (i = 0; i < task_group->len; ++i) {
Task *task1 = g_ptr_array_index(task_group, i);
task1->current_state = state;
task1->area.bg = panels[0].g_task.background[state];
if (!panel_config.mouse_effects) {
tsk1->area.pix = tsk1->state_pix[state];
if (!tsk1->area.pix)
tsk1->area.redraw_needed = 1;
task1->area.pix = task1->state_pix[state];
if (!task1->area.pix)
task1->area.redraw_needed = TRUE;
} else {
tsk1->area.redraw_needed = 1;
task1->area.redraw_needed = TRUE;
}
if (state == TASK_ACTIVE && g_slist_find(urgent_list, tsk1))
del_urgent(tsk1);
if (state == TASK_ACTIVE && g_slist_find(urgent_list, task1))
del_urgent(task1);
int hide = 0;
Taskbar *taskbar = (Taskbar *)tsk1->area.parent;
if (tsk->desktop == ALLDESKTOP && server.desktop != taskbar->desktop) {
Taskbar *taskbar = (Taskbar *)task1->area.parent;
if (task->desktop == ALLDESKTOP && server.desktop != taskbar->desktop) {
// Hide ALLDESKTOP task on non-current desktop
hide = 1;
}
@@ -573,43 +592,42 @@ void set_task_state(Task *tsk, int state)
hide = 1;
}
}
if (window_get_monitor(tsk->win) != ((Panel*)tsk->area.panel)->monitor &&
(hide_task_diff_monitor || nb_panel > 1)) {
if (get_window_monitor(task->win) != ((Panel *)task->area.panel)->monitor &&
(hide_task_diff_monitor || num_panels > 1)) {
hide = 1;
}
if (1 - hide != tsk1->area.on_screen) {
tsk1->area.on_screen = 1 - hide;
set_task_redraw(tsk1);
Panel *p = (Panel*)tsk->area.panel;
tsk->area.resize_needed = 1;
if (1 - hide != task1->area.on_screen) {
task1->area.on_screen = TRUE - hide;
set_task_redraw(task1);
Panel *p = (Panel *)task->area.panel;
task->area.resize_needed = 1;
p->taskbar->area.resize_needed = 1;
p->area.resize_needed = 1;
}
}
panel_refresh = 1;
panel_refresh = TRUE;
}
}
}
void set_task_redraw(Task* tsk)
void set_task_redraw(Task *task)
{
int k;
for (k=0; k<TASK_STATE_COUNT; ++k) {
if (tsk->state_pix[k]) XFreePixmap(server.dsp, tsk->state_pix[k]);
tsk->state_pix[k] = 0;
for (k = 0; k < TASK_STATE_COUNT; ++k) {
if (task->state_pix[k])
XFreePixmap(server.dsp, task->state_pix[k]);
task->state_pix[k] = 0;
}
tsk->area.pix = 0;
tsk->area.redraw_needed = 1;
task->area.pix = 0;
task->area.redraw_needed = TRUE;
}
void blink_urgent(void* arg)
void blink_urgent(void *arg)
{
GSList* urgent_task = urgent_list;
GSList *urgent_task = urgent_list;
while (urgent_task) {
Task* t = urgent_task->data;
if ( t->urgent_tick < max_tick_urgent) {
Task *t = urgent_task->data;
if (t->urgent_tick < max_tick_urgent) {
if (t->urgent_tick++ % 2)
set_task_state(t, TASK_URGENT);
else
@@ -617,39 +635,37 @@ void blink_urgent(void* arg)
}
urgent_task = urgent_task->next;
}
panel_refresh = 1;
panel_refresh = TRUE;
}
void add_urgent(Task *tsk)
void add_urgent(Task *task)
{
if (!tsk)
if (!task)
return;
// some programs set urgency hint although they are active
if ( task_active && task_active->win == tsk->win )
if (task_active && task_active->win == task->win)
return;
tsk = task_get_task(tsk->win); // always add the first tsk for a task group (omnipresent windows)
tsk->urgent_tick = 0;
if (g_slist_find(urgent_list, tsk))
task = task_get_task(task->win); // always add the first task for a task group (omnipresent windows)
task->urgent_tick = 0;
if (g_slist_find(urgent_list, task))
return;
// not yet in the list, so we have to add it
urgent_list = g_slist_prepend(urgent_list, tsk);
urgent_list = g_slist_prepend(urgent_list, task);
if (!urgent_timeout)
urgent_timeout = add_timeout(10, 1000, blink_urgent, 0, &urgent_timeout);
Panel *panel = tsk->area.panel;
Panel *panel = task->area.panel;
if (panel->is_hidden)
autohide_show(panel);
}
void del_urgent(Task *tsk)
void del_urgent(Task *task)
{
urgent_list = g_slist_remove(urgent_list, tsk);
urgent_list = g_slist_remove(urgent_list, task);
if (!urgent_list) {
stop_timeout(urgent_timeout);
urgent_timeout = NULL;

58
src/taskbar/task.h
View File

@@ -13,19 +13,25 @@
#include "common.h"
#include "timer.h"
typedef enum TaskState {
TASK_NORMAL = 0,
TASK_ACTIVE,
TASK_ICONIFIED,
TASK_URGENT,
TASK_STATE_COUNT,
} TaskState;
enum { TASK_NORMAL, TASK_ACTIVE, TASK_ICONIFIED, TASK_URGENT, TASK_STATE_COUNT };
extern timeout* urgent_timeout;
extern GSList* urgent_list;
extern timeout *urgent_timeout;
extern GSList *urgent_list;
// --------------------------------------------------
// global task parameter
typedef struct {
typedef struct GlobalTask {
Area area;
int text;
int icon;
int centered;
gboolean text;
gboolean icon;
gboolean centered;
int icon_posy;
int icon_size1;
@@ -35,7 +41,7 @@ typedef struct {
int saturation[TASK_STATE_COUNT];
int brightness[TASK_STATE_COUNT];
int config_asb_mask;
Background* background[TASK_STATE_COUNT];
Background *background[TASK_STATE_COUNT];
int config_background_mask;
// starting position for text ~ task_padding + task_border + icon_size
double text_posx, text_height;
@@ -43,10 +49,8 @@ typedef struct {
PangoFontDescription *font_desc;
Color font[TASK_STATE_COUNT];
int config_font_mask;
int tooltip_enabled;
} Global_task;
gboolean tooltip_enabled;
} GlobalTask;
typedef struct {
// always start with area
@@ -54,8 +58,8 @@ typedef struct {
// TODO: group task with list of windows here
Window win;
int desktop;
int current_state;
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];
@@ -71,25 +75,23 @@ typedef struct {
int win_h;
} Task;
Task *add_task(Window win);
void remove_task(Task *task);
Task *add_task (Window win);
void remove_task (Task *tsk);
void draw_task(void *obj, cairo_t *c);
void on_change_task(void *obj);
void draw_task (void *obj, cairo_t *c);
void on_change_task (void *obj);
void get_icon (Task *tsk);
int get_title(Task *tsk);
void get_icon(Task *task);
gboolean get_title(Task *task);
void active_task();
void set_task_state(Task* tsk, int state);
void set_task_redraw(Task* tsk);
void set_task_state(Task *task, TaskState state);
void set_task_redraw(Task *task);
Task *find_active_task(Task *current_task, Task *active_task);
Task *next_task (Task *tsk);
Task *prev_task (Task *tsk);
Task *next_task(Task *task);
Task *prev_task(Task *task);
void add_urgent(Task *tsk);
void del_urgent(Task *tsk);
void add_urgent(Task *task);
void del_urgent(Task *task);
#endif

340
src/taskbar/taskbar.c
View File

@@ -33,26 +33,33 @@
#include "panel.h"
#include "strnatcmp.h"
/* win_to_task_table holds for every Window an array of tasks. Usually the array contains only one
element. However for omnipresent windows (windows which are visible in every taskbar) the array
contains to every Task* on each panel a pointer (i.e. GPtrArray.len == server.nb_desktop)
contains to every Task* on each panel a pointer (i.e. GPtrArray.len == server.num_desktops)
*/
GHashTable* win_to_task_table;
GHashTable *win_to_task_table;
Task *task_active;
Task *task_drag;
int taskbar_enabled;
int taskbar_distribute_size;
int hide_inactive_tasks;
int hide_task_diff_monitor;
int taskbar_sort_method;
int taskbar_alignment;
guint win_hash(gconstpointer key) { return (guint)*((Window*)key); }
gboolean win_compare(gconstpointer a, gconstpointer b) { return (*((Window*)a) == *((Window*)b)); }
void free_ptr_array(gpointer data) { g_ptr_array_free(data, 1); }
gboolean taskbar_enabled;
gboolean taskbar_distribute_size;
gboolean hide_inactive_tasks;
gboolean hide_task_diff_monitor;
TaskbarSortMethod taskbar_sort_method;
Alignment taskbar_alignment;
guint win_hash(gconstpointer key)
{
return (guint) * ((const Window *)key);
}
gboolean win_compare(gconstpointer a, gconstpointer b)
{
return (*((const Window *)a) == *((const Window *)b));
}
void free_ptr_array(gpointer data)
{
g_ptr_array_free(data, 1);
}
void default_taskbar()
{
@@ -71,7 +78,7 @@ void default_taskbar()
void cleanup_taskbar()
{
Panel *panel;
Taskbar *tskbar;
Taskbar *taskbar;
int i, j, k;
cleanup_taskbarname();
@@ -88,18 +95,18 @@ void cleanup_taskbar()
g_hash_table_destroy(win_to_task_table);
win_to_task_table = NULL;
}
for (i = 0 ; i < nb_panel; i++) {
panel = &panel1[i];
for (j = 0; j < panel->nb_desktop; j++) {
tskbar = &panel->taskbar[j];
for (i = 0; i < num_panels; i++) {
panel = &panels[i];
for (j = 0; j < panel->num_desktops; j++) {
taskbar = &panel->taskbar[j];
for (k = 0; k < TASKBAR_STATE_COUNT; ++k) {
if (tskbar->state_pix[k])
XFreePixmap(server.dsp, tskbar->state_pix[k]);
tskbar->state_pix[k] = 0;
if (taskbar->state_pix[k])
XFreePixmap(server.dsp, taskbar->state_pix[k]);
taskbar->state_pix[k] = 0;
}
free_area(&tskbar->area);
free_area(&taskbar->area);
// remove taskbar from the panel
remove_area((Area*)tskbar);
remove_area((Area *)taskbar);
}
if (panel->taskbar) {
free(panel->taskbar);
@@ -113,33 +120,31 @@ void cleanup_taskbar()
stop_timeout(urgent_timeout);
}
void init_taskbar()
{
if (win_to_task_table == 0)
if (!win_to_task_table)
win_to_task_table = g_hash_table_new_full(win_hash, win_compare, free, free_ptr_array);
task_active = 0;
task_drag = 0;
}
void init_taskbar_panel(void *p)
{
Panel *panel =(Panel*)p;
Panel *panel = (Panel *)p;
int j;
if (panel->g_taskbar.background[TASKBAR_NORMAL] == 0) {
if (!panel->g_taskbar.background[TASKBAR_NORMAL]) {
panel->g_taskbar.background[TASKBAR_NORMAL] = &g_array_index(backgrounds, Background, 0);
panel->g_taskbar.background[TASKBAR_ACTIVE] = &g_array_index(backgrounds, Background, 0);
}
if (panel->g_taskbar.background_name[TASKBAR_NORMAL] == 0) {
if (!panel->g_taskbar.background_name[TASKBAR_NORMAL]) {
panel->g_taskbar.background_name[TASKBAR_NORMAL] = &g_array_index(backgrounds, Background, 0);
panel->g_taskbar.background_name[TASKBAR_ACTIVE] = &g_array_index(backgrounds, Background, 0);
}
if (!panel->g_task.font_desc)
panel->g_task.font_desc = pango_font_description_from_string(DEFAULT_FONT);
if (panel->g_task.area.bg == 0)
if (!panel->g_task.area.bg)
panel->g_task.area.bg = &g_array_index(backgrounds, Background, 0);
// taskbar name
@@ -149,7 +154,7 @@ void init_taskbar_panel(void *p)
panel->g_taskbar.area_name._draw_foreground = draw_taskbarname;
panel->g_taskbar.area_name._on_change_layout = 0;
panel->g_taskbar.area_name.resize_needed = 1;
panel->g_taskbar.area_name.on_screen = 1;
panel->g_taskbar.area_name.on_screen = TRUE;
// taskbar
panel->g_taskbar.area.parent = panel;
@@ -160,14 +165,13 @@ void init_taskbar_panel(void *p)
panel->g_taskbar.area._draw_foreground = draw_taskbar;
panel->g_taskbar.area._on_change_layout = on_change_taskbar;
panel->g_taskbar.area.resize_needed = 1;
panel->g_taskbar.area.on_screen = 1;
panel->g_taskbar.area.on_screen = TRUE;
if (panel_horizontal) {
panel->g_taskbar.area.posy = panel->area.bg->border.width + panel->area.paddingy;
panel->g_taskbar.area.height = panel->area.height - (2 * panel->g_taskbar.area.posy);
panel->g_taskbar.area_name.posy = panel->g_taskbar.area.posy;
panel->g_taskbar.area_name.height = panel->g_taskbar.area.height;
}
else {
} else {
panel->g_taskbar.area.posx = panel->area.bg->border.width + panel->area.paddingy;
panel->g_taskbar.area.width = panel->area.width - (2 * panel->g_taskbar.area.posx);
panel->g_taskbar.area_name.posx = panel->g_taskbar.area.posx;
@@ -180,60 +184,81 @@ void init_taskbar_panel(void *p)
panel->g_task.area._draw_foreground = draw_task;
panel->g_task.area._on_change_layout = on_change_task;
panel->g_task.area.resize_needed = 1;
panel->g_task.area.on_screen = 1;
if ((panel->g_task.config_asb_mask & (1<<TASK_NORMAL)) == 0) {
panel->g_task.area.on_screen = TRUE;
if ((panel->g_task.config_asb_mask & (1 << TASK_NORMAL)) == 0) {
panel->g_task.alpha[TASK_NORMAL] = 100;
panel->g_task.saturation[TASK_NORMAL] = 0;
panel->g_task.brightness[TASK_NORMAL] = 0;
}
if ((panel->g_task.config_asb_mask & (1<<TASK_ACTIVE)) == 0) {
if ((panel->g_task.config_asb_mask & (1 << TASK_ACTIVE)) == 0) {
panel->g_task.alpha[TASK_ACTIVE] = panel->g_task.alpha[TASK_NORMAL];
panel->g_task.saturation[TASK_ACTIVE] = panel->g_task.saturation[TASK_NORMAL];
panel->g_task.brightness[TASK_ACTIVE] = panel->g_task.brightness[TASK_NORMAL];
}
if ((panel->g_task.config_asb_mask & (1<<TASK_ICONIFIED)) == 0) {
if ((panel->g_task.config_asb_mask & (1 << TASK_ICONIFIED)) == 0) {
panel->g_task.alpha[TASK_ICONIFIED] = panel->g_task.alpha[TASK_NORMAL];
panel->g_task.saturation[TASK_ICONIFIED] = panel->g_task.saturation[TASK_NORMAL];
panel->g_task.brightness[TASK_ICONIFIED] = panel->g_task.brightness[TASK_NORMAL];
}
if ((panel->g_task.config_asb_mask & (1<<TASK_URGENT)) == 0) {
if ((panel->g_task.config_asb_mask & (1 << TASK_URGENT)) == 0) {
panel->g_task.alpha[TASK_URGENT] = panel->g_task.alpha[TASK_ACTIVE];
panel->g_task.saturation[TASK_URGENT] = panel->g_task.saturation[TASK_ACTIVE];
panel->g_task.brightness[TASK_URGENT] = panel->g_task.brightness[TASK_ACTIVE];
}
if ((panel->g_task.config_font_mask & (1<<TASK_NORMAL)) == 0) panel->g_task.font[TASK_NORMAL] = (Color){{0, 0, 0}, 0};
if ((panel->g_task.config_font_mask & (1<<TASK_ACTIVE)) == 0) panel->g_task.font[TASK_ACTIVE] = panel->g_task.font[TASK_NORMAL];
if ((panel->g_task.config_font_mask & (1<<TASK_ICONIFIED)) == 0) panel->g_task.font[TASK_ICONIFIED] = panel->g_task.font[TASK_NORMAL];
if ((panel->g_task.config_font_mask & (1<<TASK_URGENT)) == 0) panel->g_task.font[TASK_URGENT] = panel->g_task.font[TASK_ACTIVE];
if ((panel->g_task.config_background_mask & (1<<TASK_NORMAL)) == 0) panel->g_task.background[TASK_NORMAL] = &g_array_index(backgrounds, Background, 0);
if ((panel->g_task.config_background_mask & (1<<TASK_ACTIVE)) == 0) panel->g_task.background[TASK_ACTIVE] = panel->g_task.background[TASK_NORMAL];
if ((panel->g_task.config_background_mask & (1<<TASK_ICONIFIED)) == 0) panel->g_task.background[TASK_ICONIFIED] = panel->g_task.background[TASK_NORMAL];
if ((panel->g_task.config_background_mask & (1<<TASK_URGENT)) == 0) panel->g_task.background[TASK_URGENT] = panel->g_task.background[TASK_ACTIVE];
if ((panel->g_task.config_font_mask & (1 << TASK_NORMAL)) == 0)
panel->g_task.font[TASK_NORMAL] = (Color){{0, 0, 0}, 0};
if ((panel->g_task.config_font_mask & (1 << TASK_ACTIVE)) == 0)
panel->g_task.font[TASK_ACTIVE] = panel->g_task.font[TASK_NORMAL];
if ((panel->g_task.config_font_mask & (1 << TASK_ICONIFIED)) == 0)
panel->g_task.font[TASK_ICONIFIED] = panel->g_task.font[TASK_NORMAL];
if ((panel->g_task.config_font_mask & (1 << TASK_URGENT)) == 0)
panel->g_task.font[TASK_URGENT] = panel->g_task.font[TASK_ACTIVE];
if ((panel->g_task.config_background_mask & (1 << TASK_NORMAL)) == 0)
panel->g_task.background[TASK_NORMAL] = &g_array_index(backgrounds, Background, 0);
if ((panel->g_task.config_background_mask & (1 << TASK_ACTIVE)) == 0)
panel->g_task.background[TASK_ACTIVE] = panel->g_task.background[TASK_NORMAL];
if ((panel->g_task.config_background_mask & (1 << TASK_ICONIFIED)) == 0)
panel->g_task.background[TASK_ICONIFIED] = panel->g_task.background[TASK_NORMAL];
if ((panel->g_task.config_background_mask & (1 << TASK_URGENT)) == 0)
panel->g_task.background[TASK_URGENT] = panel->g_task.background[TASK_ACTIVE];
if (panel_horizontal) {
panel->g_task.area.posy = panel->g_taskbar.area.posy + panel->g_taskbar.background[TASKBAR_NORMAL]->border.width + panel->g_taskbar.area.paddingy;
panel->g_task.area.posy = panel->g_taskbar.area.posy +
panel->g_taskbar.background[TASKBAR_NORMAL]->border.width +
panel->g_taskbar.area.paddingy;
panel->g_task.area.height = panel->area.height - (2 * panel->g_task.area.posy);
}
else {
panel->g_task.area.posx = panel->g_taskbar.area.posx + panel->g_taskbar.background[TASKBAR_NORMAL]->border.width + panel->g_taskbar.area.paddingy;
} else {
panel->g_task.area.posx = panel->g_taskbar.area.posx +
panel->g_taskbar.background[TASKBAR_NORMAL]->border.width +
panel->g_taskbar.area.paddingy;
panel->g_task.area.width = panel->area.width - (2 * panel->g_task.area.posx);
panel->g_task.area.height = panel->g_task.maximum_height;
}
for (j=0; j<TASK_STATE_COUNT; ++j) {
if (panel->g_task.background[j] == 0)
for (j = 0; j < TASK_STATE_COUNT; ++j) {
if (!panel->g_task.background[j])
panel->g_task.background[j] = &g_array_index(backgrounds, Background, 0);
if (panel->g_task.background[j]->border.radius > panel->g_task.area.height/2) {
printf("task%sbackground_id has a too large rounded value. Please fix your tint2rc\n", j==0 ? "_" : j==1 ? "_active_" : j==2 ? "_iconified_" : "_urgent_");
if (panel->g_task.background[j]->border.radius > panel->g_task.area.height / 2) {
printf("task%sbackground_id has a too large rounded value. Please fix your tint2rc\n",
j == 0 ? "_" : j == 1 ? "_active_" : j == 2 ? "_iconified_" : "_urgent_");
g_array_append_val(backgrounds, *panel->g_task.background[j]);
panel->g_task.background[j] = &g_array_index(backgrounds, Background, backgrounds->len-1);
panel->g_task.background[j]->border.radius = panel->g_task.area.height/2;
panel->g_task.background[j] = &g_array_index(backgrounds, Background, backgrounds->len - 1);
panel->g_task.background[j]->border.radius = panel->g_task.area.height / 2;
}
}
// compute vertical position : text and icon
int height_ink, height, width;
get_text_size2(panel->g_task.font_desc, &height_ink, &height, &width, panel->area.height, panel->area.width, "TAjpg", 5, PANGO_WRAP_WORD_CHAR, PANGO_ELLIPSIZE_END);
get_text_size2(panel->g_task.font_desc,
&height_ink,
&height,
&width,
panel->area.height,
panel->area.width,
"TAjpg",
5,
PANGO_WRAP_WORD_CHAR,
PANGO_ELLIPSIZE_END);
if (!panel->g_task.maximum_width && panel_horizontal)
panel->g_task.maximum_width = server.monitor[panel->monitor].width;
@@ -245,41 +270,38 @@ void init_taskbar_panel(void *p)
panel->g_task.text_posx += panel->g_task.icon_size1 + panel->g_task.area.paddingx;
panel->g_task.icon_posy = (panel->g_task.area.height - panel->g_task.icon_size1) / 2;
}
//printf("monitor %d, task_maximum_width %d\n", panel->monitor, panel->g_task.maximum_width);
// printf("monitor %d, task_maximum_width %d\n", panel->monitor, panel->g_task.maximum_width);
Taskbar *tskbar;
panel->nb_desktop = server.nb_desktop;
panel->taskbar = calloc(server.nb_desktop, sizeof(Taskbar));
for (j=0 ; j < panel->nb_desktop ; j++) {
tskbar = &panel->taskbar[j];
memcpy(&tskbar->area, &panel->g_taskbar.area, sizeof(Area));
tskbar->desktop = j;
Taskbar *taskbar;
panel->num_desktops = server.num_desktops;
panel->taskbar = calloc(server.num_desktops, sizeof(Taskbar));
for (j = 0; j < panel->num_desktops; j++) {
taskbar = &panel->taskbar[j];
memcpy(&taskbar->area, &panel->g_taskbar.area, sizeof(Area));
taskbar->desktop = j;
if (j == server.desktop)
tskbar->area.bg = panel->g_taskbar.background[TASKBAR_ACTIVE];
taskbar->area.bg = panel->g_taskbar.background[TASKBAR_ACTIVE];
else
tskbar->area.bg = panel->g_taskbar.background[TASKBAR_NORMAL];
taskbar->area.bg = panel->g_taskbar.background[TASKBAR_NORMAL];
}
init_taskbarname_panel(panel);
}
void taskbar_remove_task(gpointer key, gpointer value, gpointer user_data)
{
remove_task(task_get_task(*(Window*)key));
remove_task(task_get_task(*(Window *)key));
}
Task *task_get_task (Window win)
Task *task_get_task(Window win)
{
GPtrArray* task_group = task_get_tasks(win);
GPtrArray *task_group = task_get_tasks(win);
if (task_group)
return g_ptr_array_index(task_group, 0);
else
return 0;
}
GPtrArray* task_get_tasks(Window win)
GPtrArray *task_get_tasks(Window win)
{
if (win_to_task_table && taskbar_enabled)
return g_hash_table_lookup(win_to_task_table, &win);
@@ -287,21 +309,22 @@ GPtrArray* task_get_tasks(Window win)
return 0;
}
void task_refresh_tasklist ()
void task_refresh_tasklist()
{
Window *win;
int num_results, i;
if (!taskbar_enabled) return;
win = server_get_property (server.root_win, server.atom._NET_CLIENT_LIST, XA_WINDOW, &num_results);
if (!win) return;
if (!taskbar_enabled)
return;
win = server_get_property(server.root_win, server.atom._NET_CLIENT_LIST, XA_WINDOW, &num_results);
if (!win)
return;
GList* win_list = g_hash_table_get_keys(win_to_task_table);
GList* it;
for (it=win_list; it; it=it->next) {
GList *win_list = g_hash_table_get_keys(win_to_task_table);
GList *it;
for (it = win_list; it; it = it->next) {
for (i = 0; i < num_results; i++)
if (*((Window*)it->data) == win[i])
if (*((Window *)it->data) == win[i])
break;
if (i == num_results)
taskbar_remove_task(it->data, 0, 0);
@@ -310,122 +333,121 @@ void task_refresh_tasklist ()
// Add any new
for (i = 0; i < num_results; i++)
if (!task_get_task (win[i]))
add_task (win[i]);
if (!task_get_task(win[i]))
add_task(win[i]);
XFree (win);
XFree(win);
}
void draw_taskbar (void *obj, cairo_t *c)
void draw_taskbar(void *obj, cairo_t *c)
{
Taskbar *taskbar = obj;
Taskbar *taskbar = (Taskbar *)obj;
int state = (taskbar->desktop == server.desktop) ? TASKBAR_ACTIVE : TASKBAR_NORMAL;
taskbar->state_pix[state] = taskbar->area.pix;
}
int resize_taskbar(void *obj)
gboolean resize_taskbar(void *obj)
{
Taskbar *taskbar = (Taskbar*)obj;
Panel *panel = (Panel*)taskbar->area.panel;
Taskbar *taskbar = (Taskbar *)obj;
Panel *panel = (Panel *)taskbar->area.panel;
int text_width;
//printf("resize_taskbar %d %d\n", taskbar->area.posx, taskbar->area.posy);
// printf("resize_taskbar %d %d\n", taskbar->area.posx, taskbar->area.posy);
if (panel_horizontal) {
relayout_with_constraint(&taskbar->area, panel->g_task.maximum_width);
text_width = panel->g_task.maximum_width;
GList *l = taskbar->area.children;
if (taskbarname_enabled) l = l->next;
if (taskbarname_enabled)
l = l->next;
for (; l != NULL; l = l->next) {
if (((Task *)l->data)->area.on_screen) {
text_width = ((Task *)l->data)->area.width;
break;
}
}
taskbar->text_width = text_width - panel->g_task.text_posx - panel->g_task.area.bg->border.width - panel->g_task.area.paddingxlr;
}
else {
taskbar->text_width =
text_width - panel->g_task.text_posx - panel->g_task.area.bg->border.width - panel->g_task.area.paddingxlr;
} else {
relayout_with_constraint(&taskbar->area, panel->g_task.maximum_height);
taskbar->text_width = taskbar->area.width - (2 * panel->g_taskbar.area.paddingy) - panel->g_task.text_posx - panel->g_task.area.bg->border.width - panel->g_task.area.paddingxlr;
taskbar->text_width = taskbar->area.width - (2 * panel->g_taskbar.area.paddingy) - panel->g_task.text_posx -
panel->g_task.area.bg->border.width - panel->g_task.area.paddingxlr;
}
return 0;
}
void on_change_taskbar (void *obj)
void on_change_taskbar(void *obj)
{
Taskbar *tskbar = obj;
Taskbar *taskbar = (Taskbar *)obj;
int k;
// reset Pixmap when position/size changed
for (k=0; k<TASKBAR_STATE_COUNT; ++k) {
if (tskbar->state_pix[k]) XFreePixmap(server.dsp, tskbar->state_pix[k]);
tskbar->state_pix[k] = 0;
for (k = 0; k < TASKBAR_STATE_COUNT; ++k) {
if (taskbar->state_pix[k])
XFreePixmap(server.dsp, taskbar->state_pix[k]);
taskbar->state_pix[k] = 0;
}
tskbar->area.pix = 0;
tskbar->area.redraw_needed = 1;
taskbar->area.pix = 0;
taskbar->area.redraw_needed = TRUE;
}
void set_taskbar_state(Taskbar *tskbar, int state)
void set_taskbar_state(Taskbar *taskbar, TaskbarState state)
{
tskbar->area.bg = panel1[0].g_taskbar.background[state];
tskbar->area.pix = tskbar->state_pix[state];
taskbar->area.bg = panels[0].g_taskbar.background[state];
taskbar->area.pix = taskbar->state_pix[state];
if (taskbarname_enabled) {
tskbar->bar_name.area.bg = panel1[0].g_taskbar.background_name[state];
taskbar->bar_name.area.bg = panels[0].g_taskbar.background_name[state];
if (!panel_config.mouse_effects) {
tskbar->bar_name.area.pix = tskbar->bar_name.state_pix[state];
taskbar->bar_name.area.pix = taskbar->bar_name.state_pix[state];
}
}
if (panel_mode != MULTI_DESKTOP) {
if (taskbar_mode != MULTI_DESKTOP) {
if (state == TASKBAR_NORMAL)
tskbar->area.on_screen = 0;
taskbar->area.on_screen = FALSE;
else
tskbar->area.on_screen = 1;
taskbar->area.on_screen = TRUE;
}
if (tskbar->area.on_screen == 1) {
if (tskbar->state_pix[state] == 0)
tskbar->area.redraw_needed = 1;
if (taskbar->area.on_screen) {
if (!taskbar->state_pix[state])
taskbar->area.redraw_needed = TRUE;
if (taskbarname_enabled) {
if (!panel_config.mouse_effects) {
if (tskbar->bar_name.state_pix[state] == 0)
tskbar->bar_name.area.redraw_needed = 1;
if (!taskbar->bar_name.state_pix[state])
taskbar->bar_name.area.redraw_needed = TRUE;
} else {
tskbar->bar_name.area.redraw_needed = 1;
taskbar->bar_name.area.redraw_needed = TRUE;
}
}
if (panel_mode == MULTI_DESKTOP && panel1[0].g_taskbar.background[TASKBAR_NORMAL] != panel1[0].g_taskbar.background[TASKBAR_ACTIVE]) {
GList *l = tskbar->area.children;
if (taskbarname_enabled) l = l->next;
for ( ; l ; l = l->next)
if (taskbar_mode == MULTI_DESKTOP &&
panels[0].g_taskbar.background[TASKBAR_NORMAL] != panels[0].g_taskbar.background[TASKBAR_ACTIVE]) {
GList *l = taskbar->area.children;
if (taskbarname_enabled)
l = l->next;
for (; l; l = l->next)
set_task_redraw(l->data);
}
}
panel_refresh = 1;
panel_refresh = TRUE;
}
void visible_taskbar(void *p)
{
Panel *panel =(Panel*)p;
Panel *panel = (Panel *)p;
int j;
Taskbar *taskbar;
for (j=0 ; j < panel->nb_desktop ; j++) {
for (j = 0; j < panel->num_desktops; j++) {
taskbar = &panel->taskbar[j];
if (panel_mode != MULTI_DESKTOP && taskbar->desktop != server.desktop) {
if (taskbar_mode != MULTI_DESKTOP && taskbar->desktop != server.desktop) {
// SINGLE_DESKTOP and not current desktop
taskbar->area.on_screen = 0;
}
else {
taskbar->area.on_screen = 1;
taskbar->area.on_screen = FALSE;
} else {
taskbar->area.on_screen = TRUE;
}
}
panel_refresh = 1;
panel_refresh = TRUE;
}
#define NONTRIVIAL 2
@@ -444,9 +466,7 @@ gint compare_tasks_trivial(Task *a, Task *b, Taskbar *taskbar)
gint contained_within(Task *a, Task *b)
{
if ((a->win_x <= b->win_x) &&
(a->win_y <= b->win_y) &&
(a->win_x + a->win_w >= b->win_x + b->win_w) &&
if ((a->win_x <= b->win_x) && (a->win_y <= b->win_y) && (a->win_x + a->win_w >= b->win_x + b->win_w) &&
(a->win_y + a->win_h >= b->win_y + b->win_h)) {
return 1;
}
@@ -461,10 +481,7 @@ gint compare_task_centers(Task *a, Task *b, Taskbar *taskbar)
// If a window has the same coordinates and size as the other,
// they are considered to be equal in the comparison.
if ((a->win_x == b->win_x) &&
(a->win_y == b->win_y) &&
(a->win_w == b->win_w) &&
(a->win_h == b->win_h)) {
if ((a->win_x == b->win_x) && (a->win_y == b->win_y) && (a->win_w == b->win_w) && (a->win_h == b->win_h)) {
return 0;
}
@@ -536,35 +553,34 @@ void sort_tasks(Taskbar *taskbar)
{
if (!taskbar)
return;
if (!taskbar_needs_sort(taskbar)) {
if (!taskbar_needs_sort(taskbar))
return;
}
taskbar->area.children = g_list_sort_with_data(taskbar->area.children, (GCompareDataFunc)compare_tasks, taskbar);
taskbar->area.resize_needed = 1;
panel_refresh = 1;
((Panel*)taskbar->area.panel)->area.resize_needed = 1;
panel_refresh = TRUE;
((Panel *)taskbar->area.panel)->area.resize_needed = 1;
}
void sort_taskbar_for_win(Window win)
{
if (taskbar_sort_method == TASKBAR_NOSORT)
return;
GPtrArray* task_group = task_get_tasks(win);
GPtrArray *task_group = task_get_tasks(win);
if (task_group) {
int i;
Task* tsk0 = g_ptr_array_index(task_group, 0);
if (tsk0) {
window_get_coordinates(win, &tsk0->win_x, &tsk0->win_y, &tsk0->win_w, &tsk0->win_h);
Task *task0 = g_ptr_array_index(task_group, 0);
if (task0) {
get_window_coordinates(win, &task0->win_x, &task0->win_y, &task0->win_w, &task0->win_h);
}
for (i = 0; i < task_group->len; ++i) {
Task* tsk = g_ptr_array_index(task_group, i);
tsk->win_x = tsk0->win_x;
tsk->win_y = tsk0->win_y;
tsk->win_w = tsk0->win_w;
tsk->win_h = tsk0->win_h;
sort_tasks(tsk->area.parent);
Task *task = g_ptr_array_index(task_group, i);
task->win_x = task0->win_x;
task->win_y = task0->win_y;
task->win_w = task0->win_w;
task->win_h = task0->win_h;
sort_tasks(task->area.parent);
}
}
}

63
src/taskbar/taskbar.h
View File

@@ -11,49 +11,51 @@
#include "task.h"
#include "taskbarname.h"
enum { TASKBAR_NORMAL, TASKBAR_ACTIVE, TASKBAR_STATE_COUNT };
typedef enum TaskbarState {
TASKBAR_NORMAL = 0,
TASKBAR_ACTIVE,
TASKBAR_STATE_COUNT,
} TaskbarState;
typedef enum TaskbarSortMethod {
TASKBAR_NOSORT = 0,
TASKBAR_SORT_CENTER,
TASKBAR_SORT_TITLE,
} TaskbarSortMethod;
extern GHashTable *win_to_task_table;
extern Task *task_active;
extern Task *task_drag;
extern int taskbar_enabled;
extern int taskbar_distribute_size;
extern int hide_inactive_tasks;
extern int hide_task_diff_monitor;
enum { TASKBAR_NOSORT, TASKBAR_SORT_CENTER, TASKBAR_SORT_TITLE };
extern int taskbar_sort_method;
extern int taskbar_alignment;
extern gboolean taskbar_enabled;
extern gboolean taskbar_distribute_size;
extern gboolean hide_inactive_tasks;
extern gboolean hide_task_diff_monitor;
extern TaskbarSortMethod taskbar_sort_method;
extern Alignment taskbar_alignment;
typedef struct {
// always start with area
Area area;
Pixmap state_pix[TASKBAR_STATE_COUNT];
gchar *name;
int posy;
int posy;
} Taskbarname;
// tint2 use one taskbar per desktop.
typedef struct {
// always start with area
Area area;
int desktop;
Pixmap state_pix[TASKBAR_STATE_COUNT];
int desktop;
Taskbarname bar_name;
// task parameters
int text_width;
} Taskbar;
typedef struct {
//always start with area
typedef struct GlobalTaskbar {
// always start with area
Area area;
Area area_name;
Background* background[TASKBAR_STATE_COUNT];
Background* background_name[TASKBAR_STATE_COUNT];
} Global_taskbar;
Background *background[TASKBAR_STATE_COUNT];
Background *background_name[TASKBAR_STATE_COUNT];
} GlobalTaskbar;
// default global data
void default_taskbar();
@@ -64,15 +66,15 @@ void cleanup_taskbar();
void init_taskbar();
void init_taskbar_panel(void *p);
void draw_taskbar (void *obj, cairo_t *c);
void draw_taskbar(void *obj, cairo_t *c);
void taskbar_remove_task(gpointer key, gpointer value, gpointer user_data);
Task *task_get_task (Window win);
GPtrArray* task_get_tasks(Window win);
void task_refresh_tasklist ();
Task *task_get_task(Window win);
GPtrArray *task_get_tasks(Window win);
void task_refresh_tasklist();
int resize_taskbar(void *obj);
void on_change_taskbar (void *obj);
void set_taskbar_state(Taskbar *tskbar, int state);
gboolean resize_taskbar(void *obj);
void on_change_taskbar(void *obj);
void set_taskbar_state(Taskbar *taskbar, TaskbarState state);
// show/hide taskbar according to current desktop
void visible_taskbar(void *p);
@@ -81,4 +83,3 @@ void sort_taskbar_for_win(Window win);
void sort_tasks(Taskbar *taskbar);
#endif

111
src/taskbar/taskbarname.c
View File

@@ -37,81 +37,76 @@ PangoFontDescription *taskbarname_font_desc;
Color taskbarname_font;
Color taskbarname_active_font;
void default_taskbarname()
{
taskbarname_enabled = 0;
taskbarname_font_desc = NULL;
}
void init_taskbarname_panel(void *p)
{
Panel *panel =(Panel*)p;
Taskbar *tskbar;
Panel *panel = (Panel *)p;
Taskbar *taskbar;
int j;
if (!taskbarname_enabled)
return;
if (!panel_config.taskbarname_font_desc)
panel_config.taskbarname_font_desc = pango_font_description_from_string(DEFAULT_FONT);
GSList *l, *list = server_get_name_of_desktop();
for (j=0, l=list ; j < panel->nb_desktop ; j++) {
tskbar = &panel->taskbar[j];
memcpy(&tskbar->bar_name.area, &panel->g_taskbar.area_name, sizeof(Area));
tskbar->bar_name.area.parent = tskbar;
tskbar->bar_name.area.has_mouse_over_effect = 1;
tskbar->bar_name.area.has_mouse_press_effect = 1;
GSList *l, *list = get_desktop_names();
for (j = 0, l = list; j < panel->num_desktops; j++) {
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 = 1;
taskbar->bar_name.area.has_mouse_press_effect = 1;
if (j == server.desktop)
tskbar->bar_name.area.bg = panel->g_taskbar.background_name[TASKBAR_ACTIVE];
taskbar->bar_name.area.bg = panel->g_taskbar.background_name[TASKBAR_ACTIVE];
else
tskbar->bar_name.area.bg = panel->g_taskbar.background_name[TASKBAR_NORMAL];
taskbar->bar_name.area.bg = panel->g_taskbar.background_name[TASKBAR_NORMAL];
// use desktop number if name is missing
if (l) {
tskbar->bar_name.name = g_strdup(l->data);
taskbar->bar_name.name = g_strdup(l->data);
l = l->next;
}
else
tskbar->bar_name.name = g_strdup_printf("%d", j+1);
} else
taskbar->bar_name.name = g_strdup_printf("%d", j + 1);
// append the name at the beginning of taskbar
tskbar->area.children = g_list_append(tskbar->area.children, &tskbar->bar_name);
taskbar->area.children = g_list_append(taskbar->area.children, &taskbar->bar_name);
}
for (l=list ; l ; l = l->next)
for (l = list; l; l = l->next)
g_free(l->data);
g_slist_free(list);
}
void cleanup_taskbarname()
{
int i, j, k;
Panel *panel;
Taskbar *tskbar;
Taskbar *taskbar;
for (i = 0; i < nb_panel; i++) {
panel = &panel1[i];
for (j = 0; j < panel->nb_desktop; j++) {
tskbar = &panel->taskbar[j];
g_free(tskbar->bar_name.name);
tskbar->bar_name.name = NULL;
free_area(&tskbar->bar_name.area);
for (i = 0; i < num_panels; i++) {
panel = &panels[i];
for (j = 0; j < panel->num_desktops; j++) {
taskbar = &panel->taskbar[j];
g_free(taskbar->bar_name.name);
taskbar->bar_name.name = NULL;
free_area(&taskbar->bar_name.area);
for (k = 0; k < TASKBAR_STATE_COUNT; ++k) {
if (tskbar->bar_name.state_pix[k])
XFreePixmap(server.dsp, tskbar->bar_name.state_pix[k]);
tskbar->bar_name.state_pix[k] = 0;
if (taskbar->bar_name.state_pix[k])
XFreePixmap(server.dsp, taskbar->bar_name.state_pix[k]);
taskbar->bar_name.state_pix[k] = 0;
}
remove_area((Area*)&tskbar->bar_name);
remove_area((Area *)&taskbar->bar_name);
}
}
}
void draw_taskbarname (void *obj, cairo_t *c)
void draw_taskbarname(void *obj, cairo_t *c)
{
Taskbarname *taskbar_name = obj;
Taskbar *taskbar = taskbar_name->area.parent;
@@ -121,54 +116,58 @@ void draw_taskbarname (void *obj, cairo_t *c)
int state = (taskbar->desktop == server.desktop) ? TASKBAR_ACTIVE : TASKBAR_NORMAL;
if (!panel_config.mouse_effects)
taskbar_name->state_pix[state] = taskbar_name->area.pix;
// draw content
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);
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));
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);
//printf("draw_taskbarname %s ******************************\n", taskbar_name->name);
g_object_unref(layout);
// printf("draw_taskbarname %s ******************************\n", taskbar_name->name);
}
int resize_taskbarname(void *obj)
gboolean resize_taskbarname(void *obj)
{
Taskbarname *taskbar_name = obj;
Panel *panel = taskbar_name->area.panel;
int name_height, name_width, name_height_ink;
int ret = 0;
taskbar_name->area.redraw_needed = 1;
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),
taskbar_name->area.redraw_needed = TRUE;
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);
if (panel_horizontal) {
int new_size = name_width + (2* (taskbar_name->area.paddingxlr + taskbar_name->area.bg->border.width));
int new_size = name_width + (2 * (taskbar_name->area.paddingxlr + taskbar_name->area.bg->border.width));
if (new_size != taskbar_name->area.width) {
taskbar_name->area.width = new_size;
taskbar_name->posy = (taskbar_name->area.height - name_height) / 2;
ret = 1;
}
}
else {
} else {
int new_size = name_height + (2 * (taskbar_name->area.paddingxlr + taskbar_name->area.bg->border.width));
if (new_size != taskbar_name->area.height) {
taskbar_name->area.height = new_size;
taskbar_name->area.height = new_size;
taskbar_name->posy = (taskbar_name->area.height - name_height) / 2;
ret = 1;
}
}
return ret;
}

6
src/taskbar/taskbarname.h
View File

@@ -8,7 +8,7 @@
#include "common.h"
#include "area.h"
extern int taskbarname_enabled;
extern gboolean taskbarname_enabled;
extern Color taskbarname_font;
extern Color taskbarname_active_font;
@@ -19,8 +19,6 @@ void init_taskbarname_panel(void *p);
void draw_taskbarname(void *obj, cairo_t *c);
int resize_taskbarname(void *obj);
gboolean resize_taskbarname(void *obj);
#endif