widgets/tasklist.c

   1 /*
   2  * tasklist.c - task list widget
   3  *
   4  * Copyright © 2008 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  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  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include "client.h"
  23 #include "widget.h"
  24 #include "ewmh.h"
  25 #include "tag.h"
  26 #include "common/markup.h"
  27 #include "common/tokenize.h"
  28
  29 extern awesome_t globalconf;
  30
  31 /** Link a client and a label */
  32 typedef struct
  33 {
  34     /** A client */
  35     client_t *client;
  36     /** The client label */
  37     char *label;
  38     /** The client label len */
  39     size_t label_len;
  40 } client_label_t;
  41
  42 /** Delete a client label.
  43  * \param l The client label.
  44  */
  45 static void
  46 client_label_wipe(client_label_t *l)
  47 {
  48     p_delete(&l->label);
  49 }
  50
  51 DO_ARRAY(client_label_t, client_label, client_label_wipe)
  52
  53 typedef struct tasklist_object_data_t tasklist_object_data_t;
  54 /** Link an object with a client label array and other infos */
  55 struct tasklist_object_data_t
  56 {
  57     /** The object */
  58     void *object;
  59     /** The box width for each client */
  60     int box_width;
  61     /** The client label array for the object */
  62     client_label_array_t client_labels;
  63     /** This is a list */
  64     tasklist_object_data_t *prev, *next;
  65 };
  66
  67 static void
  68 tasklist_object_data_delete(tasklist_object_data_t **l)
  69 {
  70     client_label_array_wipe(&(*l)->client_labels);
  71     p_delete(l);
  72 }
  73
  74 DO_SLIST(tasklist_object_data_t, tasklist_object_data, tasklist_object_data_delete)
  75
  76 /** The tasklist private data structure. */
  77 typedef struct
  78 {
  79     bool show_icons;
  80     luaA_ref label;
  81     tasklist_object_data_t *objects_data;
  82 } tasklist_data_t;
  83
  84 /** Get an object data by its object.
  85  * \param od The object data list.
  86  * \param p The object.
  87  * \return A object data or NULL if not found.
  88  */
  89 static tasklist_object_data_t *
  90 tasklist_object_data_getbyobj(tasklist_object_data_t *od, void *p)
  91 {
  92     tasklist_object_data_t *o;
  93
  94     for(o = od; o; o = o->next)
  95         if(o->object == p)
  96             return o;
  97
  98     return NULL;
  99 }
 100
 101 /** Draw a tasklist widget.
 102  * \param ctx The draw context.
 103  * \param screen The screen number.
 104  * \param w The widget node we are called from.
 105  * \param offset The offset to draw at.
 106  * \param used The already used width.
 107  * \param p A pointer to the object we're drawing onto.
 108  * \param type The object type.
 109  * \return The widget width.
 110  */
 111 static int
 112 tasklist_draw(draw_context_t *ctx, int screen,
 113               widget_node_t *w,
 114               int offset, int used, void *p,
 115               awesome_type_t type)
 116 {
 117     client_t *c;
 118     tasklist_data_t *d = w->widget->data;
 119     area_t area;
 120     int i = 0, icon_width = 0, box_width_rest = 0;
 121     draw_image_t *image;
 122     draw_parser_data_t pdata, *parser_data;
 123     tasklist_object_data_t *odata;
 124
 125     if(used >= ctx->width)
 126         return (w->area.width = 0);
 127
 128     if(!(odata = tasklist_object_data_getbyobj(d->objects_data, p)))
 129     {
 130         odata = p_new(tasklist_object_data_t, 1);
 131         odata->object = p;
 132         tasklist_object_data_list_push(&d->objects_data, odata);
 133     }
 134
 135     client_label_array_wipe(&odata->client_labels);
 136     client_label_array_init(&odata->client_labels);
 137
 138     for(c = globalconf.clients; c; c = c->next)
 139         if(!c->skip && !c->skiptb)
 140         {
 141             /* push client */
 142             luaA_client_userdata_new(globalconf.L, c);
 143             /* push screen we're at */
 144             lua_pushnumber(globalconf.L, screen + 1);
 145             /* call label function with client as argument and wait for one
 146              * result */
 147             if(luaA_dofunction(globalconf.L, d->label, 2, 1))
 148             {
 149                 /* If we got a string as returned value, we got something to write:
 150                  * a label. So we store it in a client_label_t structure, pushed
 151                  * into the client_label_array_t which is owned by the object. */
 152                 if(lua_isstring(globalconf.L, -1))
 153                 {
 154                     client_label_t cl;
 155                     cl.client = c;
 156                     cl.label = a_strdup(lua_tolstring(globalconf.L, -1, &cl.label_len));
 157                     client_label_array_append(&odata->client_labels, cl);
 158                 }
 159
 160                 lua_pop(globalconf.L, 1);
 161             }
 162         }
 163
 164     if(!odata->client_labels.len)
 165         return (w->area.width = 0);
 166
 167     odata->box_width = (ctx->width - used) / odata->client_labels.len;
 168     /* compute how many pixel we left empty */
 169     box_width_rest = (ctx->width - used) % odata->client_labels.len;
 170
 171     w->area.x = widget_calculate_offset(ctx->width,
 172                                         0, offset, w->widget->align);
 173
 174     w->area.y = 0;
 175
 176     for(i = 0; i < odata->client_labels.len; i++)
 177     {
 178         icon_width = 0;
 179
 180         if(d->show_icons)
 181         {
 182             draw_parser_data_init(&pdata);
 183
 184             pdata.connection = ctx->connection;
 185             pdata.phys_screen = ctx->phys_screen;
 186
 187             /* Actually look for the proper background color, since
 188              * otherwise the background statusbar color is used instead */
 189             if(draw_text_markup_expand(&pdata,
 190                                        odata->client_labels.tab[i].label,
 191                                        odata->client_labels.tab[i].label_len))
 192             {
 193                 parser_data = &pdata;
 194                 if(pdata.has_bg_color)
 195                 {
 196                     /* draw a background for icons */
 197                     area.x = w->area.x + odata->box_width * i;
 198                     area.y = w->area.y;
 199                     area.height = ctx->height;
 200                     area.width = odata->box_width;
 201                     draw_rectangle(ctx, area, 1.0, true, &pdata.bg_color);
 202                 }
 203             }
 204             else
 205                 parser_data = NULL;
 206
 207             if((image = draw_image_new(odata->client_labels.tab[i].client->icon_path)))
 208             {
 209                 icon_width = ((double) ctx->height / (double) image->height) * image->width;
 210                 draw_image(ctx, w->area.x + odata->box_width * i,
 211                            w->area.y, ctx->height, image);
 212                 draw_image_delete(&image);
 213             }
 214
 215             if(!icon_width && odata->client_labels.tab[i].client->icon)
 216             {
 217                 netwm_icon_t *icon = odata->client_labels.tab[i].client->icon;
 218                 icon_width = ((double) ctx->height / (double) icon->height)
 219                     * icon->width;
 220                 draw_image_from_argb_data(ctx,
 221                                           w->area.x + odata->box_width * i,
 222                                           w->area.y,
 223                                           icon->width, icon->height,
 224                                           ctx->height, icon->image);
 225             }
 226         }
 227         else
 228             parser_data = NULL;
 229
 230         area.x = w->area.x + icon_width + odata->box_width * i;
 231         area.y = w->area.y;
 232         area.width = odata->box_width - icon_width;
 233         area.height = ctx->height;
 234
 235         /* if we're on last elem, it has the last pixels left */
 236         if(i == odata->client_labels.len - 1)
 237             area.width += box_width_rest;
 238
 239         draw_text(ctx, globalconf.font, area,
 240                   odata->client_labels.tab[i].label,
 241                   odata->client_labels.tab[i].label_len,
 242                   parser_data);
 243         draw_parser_data_wipe(parser_data);
 244     }
 245
 246     w->area.width = ctx->width - used;
 247     w->area.height = ctx->height;
 248
 249     return w->area.width;
 250 }
 251
 252 /** Handle button click on tasklist.
 253  * \param w The widget node.
 254  * \param ev The button press event.
 255  * \param screen The screen where the click was.
 256  * \param object The object we're onto.
 257  * \param type The type object.
 258  */
 259 static void
 260 tasklist_button_press(widget_node_t *w,
 261                       xcb_button_press_event_t *ev,
 262                       int screen,
 263                       void *object,
 264                       awesome_type_t type)
 265 {
 266     button_t *b;
 267     tasklist_data_t *d = w->widget->data;
 268     int ci = 0;
 269     tasklist_object_data_t *odata;
 270
 271     odata = tasklist_object_data_getbyobj(d->objects_data, object);
 272
 273     if(!odata || !odata->client_labels.len)
 274         return;
 275
 276     ci = (ev->event_x - w->area.x) / odata->box_width;
 277
 278     for(b = w->widget->buttons; b; b = b->next)
 279         if(ev->detail == b->button && XUTIL_MASK_CLEAN(ev->state) == b->mod && b->fct)
 280         {
 281             luaA_pushpointer(globalconf.L, object, type);
 282             luaA_client_userdata_new(globalconf.L, odata->client_labels.tab[ci].client);
 283             luaA_dofunction(globalconf.L, b->fct, 2, 0);
 284         }
 285 }
 286
 287 /** Tasklist widget.
 288  * \param L The Lua VM state.
 289  * \param token The key token.
 290  * \return The number of elements pushed on stack.
 291  * \luastack
 292  * \lfield show_icons Show icons near client title.
 293  * \lfield label Function used to get the string to display as the window title.
 294  * It gets the client and a screen number as argument, and must return a string.
 295  */
 296 static int
 297 luaA_tasklist_index(lua_State *L, awesome_token_t token)
 298 {
 299     widget_t **widget = luaA_checkudata(L, 1, "widget");
 300     tasklist_data_t *d = (*widget)->data;
 301
 302     switch(token)
 303     {
 304       case A_TK_SHOW_ICONS:
 305         lua_pushboolean(L, d->show_icons);
 306         return 1;
 307       case A_TK_LABEL:
 308         lua_rawgeti(L, LUA_REGISTRYINDEX, d->label);
 309         return 1;
 310       default:
 311         return 0;
 312     }
 313 }
 314
 315 /** Newindex function for tasklist widget.
 316  * \param L The Lua VM state.
 317  * \param token The key token.
 318  * \return The number of elements pushed on stack.
 319  */
 320 static int
 321 luaA_tasklist_newindex(lua_State *L, awesome_token_t token)
 322 {
 323     widget_t **widget = luaA_checkudata(L, 1, "widget");
 324     tasklist_data_t *d = (*widget)->data;
 325
 326     switch(token)
 327     {
 328       case A_TK_SHOW_ICONS:
 329         d->show_icons = luaA_checkboolean(L, 3);
 330         break;
 331       case A_TK_LABEL:
 332         luaA_registerfct(L, &d->label);
 333         break;
 334       default:
 335         return 0;
 336     }
 337
 338     widget_invalidate_bywidget(*widget);
 339
 340     return 0;
 341 }
 342
 343 /** Destructor for the tasklist widget.
 344  * \param widget The widget to destroy.
 345  */
 346 static void
 347 tasklist_destructor(widget_t *widget)
 348 {
 349     tasklist_data_t *d = widget->data;
 350     tasklist_object_data_list_wipe(&d->objects_data);
 351     p_delete(&d);
 352 }
 353
 354 /** Tasklist detach function.
 355  * \param widget The widget which is detaching.
 356  * \param object The object we are leaving.
 357  */
 358 static void
 359 tasklist_detach(widget_t *widget, void *object)
 360 {
 361     tasklist_data_t *d = widget->data;
 362     tasklist_object_data_t *od;
 363
 364     if((od = tasklist_object_data_getbyobj(d->objects_data, object)))
 365     {
 366         tasklist_object_data_list_detach(&d->objects_data, od);
 367         tasklist_object_data_delete(&od);
 368     }
 369 }
 370
 371 /** Create a new widget tasklist.
 372  * \param align The widget alignment, which is flex anyway.
 373  * \return A brand new tasklist widget.
 374  */
 375 widget_t *
 376 tasklist_new(alignment_t align __attribute__ ((unused)))
 377 {
 378     widget_t *w;
 379     tasklist_data_t *d;
 380
 381     w = p_new(widget_t, 1);
 382     widget_common_new(w);
 383     w->draw = tasklist_draw;
 384     w->button_press = tasklist_button_press;
 385     w->align = AlignFlex;
 386     w->index = luaA_tasklist_index;
 387     w->newindex = luaA_tasklist_newindex;
 388     w->data = d = p_new(tasklist_data_t, 1);
 389     w->destructor = tasklist_destructor;
 390     w->detach = tasklist_detach;
 391
 392     d->show_icons = true;
 393     d->label = LUA_REFNIL;
 394
 395     /* Set cache property */
 396     w->cache_flags = WIDGET_CACHE_CLIENTS | WIDGET_CACHE_TAGS;
 397
 398     return w;
 399 }
 400
 401 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80