Dogcows Code - chaz/tint2/blob - src/taskbar/taskbar.c

   1 /**************************************************************************
   2 *
   3 * Tint2 : taskbar
   4 *
   5 * Copyright (C) 2008 thierry lorthiois (lorthiois@bbsoft.fr)
   6 *
   7 * This program is free software; you can redistribute it and/or
   8 * modify it under the terms of the GNU General Public License version 2
   9 * as published by the Free Software Foundation.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 * You should have received a copy of the GNU General Public License
  16 * along with this program; if not, write to the Free Software
  17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18 **************************************************************************/
  19
  20 #include <X11/Xlib.h>
  21 #include <X11/Xutil.h>
  22 #include <X11/Xatom.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <glib.h>
  27 #include <Imlib2.h>
  28
  29 #include "task.h"
  30 #include "taskbar.h"
  31 #include "server.h"
  32 #include "window.h"
  33 #include "panel.h"
  34
  35
  36 /* win_to_task_table holds for every Window an array of tasks. Usually the array contains only one
  37    element. However for omnipresent windows (windows which are visible in every taskbar) the array
  38    contains to every Task* on each panel a pointer (i.e. GPtrArray.len == server.nb_desktop)
  39 */
  40 GHashTable* win_to_task_table;
  41
  42 Task *task_active;
  43 Task *task_drag;
  44 int taskbar_enabled;
  45
  46 guint win_hash(gconstpointer key) { return (guint)*((Window*)key); }
  47 gboolean win_compare(gconstpointer a, gconstpointer b) { return (*((Window*)a) == *((Window*)b)); }
  48 void free_ptr_array(gpointer data) { g_ptr_array_free(data, 1); }
  49
  50
  51 void default_taskbar()
  52 {
  53         win_to_task_table = 0;
  54         urgent_timeout = 0;
  55         urgent_list = 0;
  56         taskbar_enabled = 0;
  57 }
  58
  59 void cleanup_taskbar()
  60 {
  61         Panel *panel;
  62         Taskbar *tskbar;
  63         int i, j;
  64
  65         if (win_to_task_table) g_hash_table_foreach(win_to_task_table, taskbar_remove_task, 0);
  66         for (i=0 ; i < nb_panel ; i++) {
  67                 panel = &panel1[i];
  68                 for (j=0 ; j < panel->nb_desktop ; j++) {
  69                         tskbar = &panel->taskbar[j];
  70                         free_area (&tskbar->area);
  71                         // remove taskbar from the panel
  72                         panel->area.list = g_slist_remove(panel->area.list, tskbar);
  73                 }
  74                 if (panel->taskbar) {
  75                         free(panel->taskbar);
  76                         panel->taskbar = 0;
  77                 }
  78         }
  79
  80         if (win_to_task_table) {
  81                 g_hash_table_destroy(win_to_task_table);
  82                 win_to_task_table = 0;
  83         }
  84 }
  85
  86
  87 void init_taskbar()
  88 {
  89         if (win_to_task_table == 0)
  90                 win_to_task_table = g_hash_table_new_full(win_hash, win_compare, free, free_ptr_array);
  91
  92         task_active = 0;
  93         task_drag = 0;
  94 }
  95
  96
  97 void init_taskbar_panel(void *p)
  98 {
  99         Panel *panel =(Panel*)p;
 100         int j;
 101
 102         if (panel->g_taskbar.bg == 0) {
 103                 panel->g_taskbar.bg = &g_array_index(backgrounds, Background, 0);
 104                 panel->g_taskbar.area.bg = panel->g_taskbar.bg;
 105         }
 106         if (panel->g_taskbar.bg_active == 0)
 107                 panel->g_taskbar.bg_active = panel->g_taskbar.bg;
 108         if (panel->g_task.area.bg == 0)
 109                 panel->g_task.area.bg = &g_array_index(backgrounds, Background, 0);
 110
 111         // taskbar
 112         panel->g_taskbar.area.size_mode = SIZE_BY_LAYOUT;
 113         panel->g_taskbar.area._resize = resize_taskbar;
 114         panel->g_taskbar.area.redraw = 1;
 115         panel->g_taskbar.area.on_screen = 1;
 116         if (panel_horizontal) {
 117                 panel->g_taskbar.area.posy = panel->area.bg->border.width + panel->area.paddingy;
 118                 panel->g_taskbar.area.height = panel->area.height - (2 * panel->g_taskbar.area.posy);
 119         }
 120         else {
 121                 panel->g_taskbar.area.posx = panel->area.bg->border.width + panel->area.paddingy;
 122                 panel->g_taskbar.area.width = panel->area.width - (2 * panel->g_taskbar.area.posx);
 123         }
 124
 125         // task
 126         panel->g_task.area.size_mode = SIZE_BY_LAYOUT;
 127         panel->g_task.area._draw_foreground = draw_task;
 128         panel->g_task.area.redraw = 1;
 129         panel->g_task.area.on_screen = 1;
 130         if ((panel->g_task.config_asb_mask & (1<<TASK_NORMAL)) == 0) {
 131                 panel->g_task.alpha[TASK_NORMAL] = 100;
 132                 panel->g_task.saturation[TASK_NORMAL] = 0;
 133                 panel->g_task.brightness[TASK_NORMAL] = 0;
 134         }
 135         if ((panel->g_task.config_asb_mask & (1<<TASK_ACTIVE)) == 0) {
 136                 panel->g_task.alpha[TASK_ACTIVE] = panel->g_task.alpha[TASK_NORMAL];
 137                 panel->g_task.saturation[TASK_ACTIVE] = panel->g_task.saturation[TASK_NORMAL];
 138                 panel->g_task.brightness[TASK_ACTIVE] = panel->g_task.brightness[TASK_NORMAL];
 139         }
 140         if ((panel->g_task.config_asb_mask & (1<<TASK_ICONIFIED)) == 0) {
 141                 panel->g_task.alpha[TASK_ICONIFIED] = panel->g_task.alpha[TASK_NORMAL];
 142                 panel->g_task.saturation[TASK_ICONIFIED] = panel->g_task.saturation[TASK_NORMAL];
 143                 panel->g_task.brightness[TASK_ICONIFIED] = panel->g_task.brightness[TASK_NORMAL];
 144         }
 145         if ((panel->g_task.config_asb_mask & (1<<TASK_URGENT)) == 0) {
 146                 panel->g_task.alpha[TASK_URGENT] = panel->g_task.alpha[TASK_ACTIVE];
 147                 panel->g_task.saturation[TASK_URGENT] = panel->g_task.saturation[TASK_ACTIVE];
 148                 panel->g_task.brightness[TASK_URGENT] = panel->g_task.brightness[TASK_ACTIVE];
 149         }
 150         if ((panel->g_task.config_font_mask & (1<<TASK_NORMAL)) == 0) panel->g_task.font[TASK_NORMAL] = (Color){{0, 0, 0}, 0};
 151         if ((panel->g_task.config_font_mask & (1<<TASK_ACTIVE)) == 0) panel->g_task.font[TASK_ACTIVE] = panel->g_task.font[TASK_NORMAL];
 152         if ((panel->g_task.config_font_mask & (1<<TASK_ICONIFIED)) == 0) panel->g_task.font[TASK_ICONIFIED] = panel->g_task.font[TASK_NORMAL];
 153         if ((panel->g_task.config_font_mask & (1<<TASK_URGENT)) == 0) panel->g_task.font[TASK_URGENT] = panel->g_task.font[TASK_ACTIVE];
 154         if ((panel->g_task.config_font_mask & (1<<TASK_NORMAL)) == 0) panel->g_task.background[TASK_NORMAL] = &g_array_index(backgrounds, Background, 0);
 155         if ((panel->g_task.config_background_mask & (1<<TASK_ACTIVE)) == 0) panel->g_task.background[TASK_ACTIVE] = panel->g_task.background[TASK_NORMAL];
 156         if ((panel->g_task.config_background_mask & (1<<TASK_ICONIFIED)) == 0) panel->g_task.background[TASK_ICONIFIED] = panel->g_task.background[TASK_NORMAL];
 157         if ((panel->g_task.config_background_mask & (1<<TASK_URGENT)) == 0) panel->g_task.background[TASK_URGENT] = panel->g_task.background[TASK_ACTIVE];
 158
 159         if (panel_horizontal) {
 160                 panel->g_task.area.posy = panel->g_taskbar.area.posy + panel->g_taskbar.bg->border.width + panel->g_taskbar.area.paddingy;
 161                 panel->g_task.area.height = panel->area.height - (2 * panel->g_task.area.posy);
 162         }
 163         else {
 164                 panel->g_task.area.posx = panel->g_taskbar.area.posx + panel->g_taskbar.bg->border.width + panel->g_taskbar.area.paddingy;
 165                 panel->g_task.area.width = panel->area.width - (2 * panel->g_task.area.posx);
 166                 panel->g_task.area.height = panel->g_task.maximum_height;
 167         }
 168
 169         for (j=0; j<TASK_STATE_COUNT; ++j) {
 170                 if (panel->g_task.background[j]->border.rounded > panel->g_task.area.height/2) {
 171                         printf("task%sbackground_id has a too large rounded value. Please fix your tint2rc\n", j==0 ? "_" : j==1 ? "_active_" : j==2 ? "_iconified_" : "_urgent_");
 172                         g_array_append_val(backgrounds, *panel->g_task.background[j]);
 173                         panel->g_task.background[j] = &g_array_index(backgrounds, Background, backgrounds->len-1);
 174                         panel->g_task.background[j]->border.rounded = panel->g_task.area.height/2;
 175                 }
 176         }
 177
 178         // compute vertical position : text and icon
 179         int height_ink, height;
 180         get_text_size(panel->g_task.font_desc, &height_ink, &height, panel->area.height, "TAjpg", 5);
 181
 182         if (!panel->g_task.maximum_width && panel_horizontal)
 183                 panel->g_task.maximum_width = server.monitor[panel->monitor].width;
 184
 185         panel->g_task.text_posx = panel->g_task.background[0]->border.width + panel->g_task.area.paddingxlr;
 186         panel->g_task.text_height = panel->g_task.area.height - (2 * panel->g_task.area.paddingy);
 187         if (panel->g_task.icon) {
 188                 panel->g_task.icon_size1 = panel->g_task.area.height - (2 * panel->g_task.area.paddingy);
 189                 panel->g_task.text_posx += panel->g_task.icon_size1;
 190                 panel->g_task.icon_posy = (panel->g_task.area.height - panel->g_task.icon_size1) / 2;
 191         }
 192         //printf("monitor %d, task_maximum_width %d\n", panel->monitor, panel->g_task.maximum_width);
 193
 194         Taskbar *tskbar;
 195         panel->nb_desktop = server.nb_desktop;
 196         panel->taskbar = calloc(server.nb_desktop, sizeof(Taskbar));
 197         for (j=0 ; j < panel->nb_desktop ; j++) {
 198                 tskbar = &panel->taskbar[j];
 199                 memcpy(&tskbar->area, &panel->g_taskbar, sizeof(Area));
 200                 tskbar->desktop = j;
 201                 if (j == server.desktop && panel->g_taskbar.use_active)
 202                         tskbar->area.bg = panel->g_taskbar.bg_active;
 203         }
 204 }
 205
 206
 207 void taskbar_remove_task(gpointer key, gpointer value, gpointer user_data)
 208 {
 209         remove_task(task_get_task(*(Window*)key));
 210 }
 211
 212
 213 Task *task_get_task (Window win)
 214 {
 215         GPtrArray* task_group = task_get_tasks(win);
 216         if (task_group)
 217                 return g_ptr_array_index(task_group, 0);
 218         else
 219                 return 0;
 220 }
 221
 222
 223 GPtrArray* task_get_tasks(Window win)
 224 {
 225         if (win_to_task_table && taskbar_enabled)
 226                 return g_hash_table_lookup(win_to_task_table, &win);
 227         else
 228                 return 0;
 229 }
 230
 231
 232 void task_refresh_tasklist ()
 233 {
 234         Window *win;
 235         int num_results, i;
 236
 237         if (!taskbar_enabled) return;
 238         win = server_get_property (server.root_win, server.atom._NET_CLIENT_LIST, XA_WINDOW, &num_results);
 239         if (!win) return;
 240
 241         GList* win_list = g_hash_table_get_keys(win_to_task_table);
 242         GList* it;
 243         for (it=win_list; it; it=it->next) {
 244                 for (i = 0; i < num_results; i++)
 245                         if (*((Window*)it->data) == win[i])
 246                                 break;
 247                 if (i == num_results)
 248                         taskbar_remove_task(it->data, 0, 0);
 249         }
 250         g_list_free(win_list);
 251
 252         // Add any new
 253         for (i = 0; i < num_results; i++)
 254                 if (!task_get_task (win[i]))
 255                         add_task (win[i]);
 256
 257         XFree (win);
 258 }
 259
 260
 261 int resize_taskbar(void *obj)
 262 {
 263         Taskbar *taskbar = (Taskbar*)obj;
 264         Panel *panel = (Panel*)taskbar->area.panel;
 265         Task *tsk;
 266         GSList *l;
 267         int  task_count, border_width;
 268
 269         //printf("resize_taskbar : posx et width des taches\n");
 270         taskbar->area.redraw = 1;
 271
 272         border_width = taskbar->area.bg->border.width;
 273
 274         if (panel_horizontal) {
 275                 int  pixel_width, modulo_width=0;
 276                 int  taskbar_width;
 277
 278                 // new task width for 'desktop'
 279                 task_count = g_slist_length(taskbar->area.list);
 280                 if (!task_count) pixel_width = panel->g_task.maximum_width;
 281                 else {
 282                         taskbar_width = taskbar->area.width - (2 * border_width) - (2 * panel->g_taskbar.area.paddingxlr);
 283                         if (task_count>1) taskbar_width -= ((task_count-1) * panel->g_taskbar.area.paddingx);
 284
 285                         pixel_width = taskbar_width / task_count;
 286                         if (pixel_width > panel->g_task.maximum_width)
 287                                 pixel_width = panel->g_task.maximum_width;
 288                         else
 289                                 modulo_width = taskbar_width % task_count;
 290                 }
 291
 292                 taskbar->task_width = pixel_width;
 293                 taskbar->task_modulo = modulo_width;
 294                 taskbar->text_width = pixel_width - panel->g_task.text_posx - panel->g_task.area.bg->border.width - panel->g_task.area.paddingx;
 295
 296                 // change pos_x and width for all tasks
 297                 for (l = taskbar->area.list; l ; l = l->next) {
 298                         tsk = l->data;
 299                         if (!tsk->area.on_screen) continue;
 300                         set_task_redraw(tsk);  // always redraw task, because the background could have changed (taskbar_active_id)
 301                         tsk->area.width = pixel_width;
 302 // TODO : move later (when posx is known)
 303 //                      long value[] = { panel->posx+x, panel->posy, pixel_width, panel->area.height };
 304 //                      XChangeProperty (server.dsp, tsk->win, server.atom._NET_WM_ICON_GEOMETRY, XA_CARDINAL, 32, PropModeReplace, (unsigned char*)value, 4);
 305
 306                         if (modulo_width) {
 307                                 tsk->area.width++;
 308                                 modulo_width--;
 309                         }
 310                 }
 311         }
 312         else {
 313                 int  pixel_height, modulo_height=0;
 314                 int  taskbar_height;
 315
 316                 // new task width for 'desktop'
 317                 task_count = g_slist_length(taskbar->area.list);
 318                 if (!task_count) pixel_height = panel->g_task.maximum_height;
 319                 else {
 320                         taskbar_height = taskbar->area.height - (2 * border_width) - (2 * panel->g_taskbar.area.paddingxlr);
 321                         if (task_count>1) taskbar_height -= ((task_count-1) * panel->g_taskbar.area.paddingx);
 322
 323                         pixel_height = taskbar_height / task_count;
 324                         if (pixel_height > panel->g_task.maximum_height)
 325                                 pixel_height = panel->g_task.maximum_height;
 326                         else
 327                                 modulo_height = taskbar_height % task_count;
 328                 }
 329
 330                 taskbar->task_width = pixel_height;
 331                 taskbar->task_modulo = modulo_height;
 332                 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.paddingx;
 333
 334                 // change pos_y and height for all tasks
 335                 for (l = taskbar->area.list; l ; l = l->next) {
 336                         tsk = l->data;
 337                         if (!tsk->area.on_screen) continue;
 338                         set_task_redraw(tsk);  // always redraw task, because the background could have changed (taskbar_active_id)
 339                         tsk->area.height = pixel_height;
 340 // TODO : move later (when posy is known)
 341 //                      long value[] = { panel->posx, panel->posy+y, panel->area.width, pixel_height };
 342 //                      XChangeProperty (server.dsp, tsk->win, server.atom._NET_WM_ICON_GEOMETRY, XA_CARDINAL, 32, PropModeReplace, (unsigned char*)value, 4);
 343
 344                         if (modulo_height) {
 345                                 tsk->area.height++;
 346                                 modulo_height--;
 347                         }
 348                 }
 349         }
 350         return 0;
 351 }
 352