widget.c

   1 /*
   2  * widget.c - widget managing
   3  *
   4  * Copyright © 2007-2009 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 <math.h>
  23
  24 #include <xcb/xcb.h>
  25 #include <xcb/xcb_atom.h>
  26
  27 #include "screen.h"
  28 #include "mouse.h"
  29 #include "widget.h"
  30 #include "wibox.h"
  31 #include "client.h"
  32 #include "luaa.h"
  33 #include "common/atoms.h"
  34 #include "common/xutil.h"
  35
  36 LUA_OBJECT_FUNCS(widget_class, widget_t, widget);
  37
  38 /** Collect a widget structure.
  39  * \param L The Lua VM state.
  40  * \return 0
  41  */
  42 static int
  43 luaA_widget_gc(lua_State *L)
  44 {
  45     widget_t *widget = luaA_checkudata(L, 1, &widget_class);
  46     if(widget->destructor)
  47         widget->destructor(widget);
  48     button_array_wipe(&widget->buttons);
  49     return luaA_object_gc(L);
  50 }
  51
  52 /** Get a widget node from a wibox by coords.
  53  * \param orientation Wibox orientation.
  54  * \param widgets The widget list.
  55  * \param width The container width.
  56  * \param height The container height.
  57  * \param x X coordinate of the widget.
  58  * \param y Y coordinate of the widget.
  59  * \return A widget.
  60  */
  61 widget_t *
  62 widget_getbycoords(orientation_t orientation, widget_node_array_t *widgets,
  63                    int width, int height, int16_t *x, int16_t *y)
  64 {
  65     int tmp;
  66
  67     /* Need to transform coordinates like it was top/bottom */
  68     switch(orientation)
  69     {
  70       case South:
  71         tmp = *y;
  72         *y = width - *x;
  73         *x = tmp;
  74         break;
  75       case North:
  76         tmp = *y;
  77         *y = *x;
  78         *x = height - tmp;
  79         break;
  80       default:
  81         break;
  82     }
  83     foreach(w, *widgets)
  84         if(w->widget->isvisible
  85            && *x >= w->geometry.x && *x < w->geometry.x + w->geometry.width
  86            && *y >= w->geometry.y && *y < w->geometry.y + w->geometry.height)
  87             return w->widget;
  88
  89     return NULL;
  90 }
  91
  92 /** Convert a Lua table to a list of widget nodes.
  93  * \param L The Lua VM state.
  94  * \param idx Index of the table where to store the widgets references.
  95  * \param widgets The linked list of widget node.
  96  */
  97 static void
  98 luaA_table2widgets(lua_State *L, int idx, widget_node_array_t *widgets)
  99 {
 100     if(lua_istable(L, -1))
 101     {
 102         int table_idx = luaA_absindex(L, idx);
 103         lua_pushnil(L);
 104         while(luaA_next(L, -2))
 105             luaA_table2widgets(L, table_idx, widgets);
 106         /* remove the table */
 107         lua_pop(L, 1);
 108     }
 109     else
 110     {
 111         widget_t *widget = luaA_toudata(L, -1, &widget_class);
 112         if(widget)
 113         {
 114             widget_node_t w;
 115             p_clear(&w, 1);
 116             w.widget = luaA_object_ref_item(L, idx, -1);
 117             widget_node_array_append(widgets, w);
 118         }
 119         else
 120             lua_pop(L, 1); /* remove value */
 121     }
 122 }
 123
 124 /** Retrieve a list of widget geometries using a Lua layout function.
 125  * a table which contains the geometries is then pushed onto the stack
 126  * \param wibox The wibox.
 127  * \return True is everything is ok, false otherwise.
 128  */
 129 static bool
 130 widget_geometries(wibox_t *wibox)
 131 {
 132     /* get the layout field of the widget table */
 133     if(wibox->widgets_table)
 134     {
 135         /* push wibox */
 136         luaA_object_push(globalconf.L, wibox);
 137         /* push widgets table */
 138         luaA_object_push_item(globalconf.L, -1, wibox->widgets_table);
 139         /* remove wibox */
 140         lua_remove(globalconf.L, -2);
 141         /* get layout field from the table */
 142         lua_getfield(globalconf.L, -1, "layout");
 143         /* remove the widget table */
 144         lua_remove(globalconf.L, -2);
 145     }
 146     else
 147         lua_pushnil(globalconf.L);
 148
 149     /* if the layout field is a function */
 150     if(lua_isfunction(globalconf.L, -1))
 151     {
 152         /* Push 1st argument: wibox geometry */
 153         area_t geometry = wibox->geometry;
 154         geometry.x = 0;
 155         geometry.y = 0;
 156         /* we need to exchange the width and height of the wibox window if it
 157          * it is rotated, so the layout function doesn't need to care about that
 158          */
 159         if(wibox->orientation != East)
 160         {
 161             int i = geometry.height;
 162             geometry.height = geometry.width;
 163             geometry.width = i;
 164         }
 165         luaA_pusharea(globalconf.L, geometry);
 166         /* Push 2nd argument: widget table */
 167         luaA_object_push(globalconf.L, wibox);
 168         luaA_object_push_item(globalconf.L, -1, wibox->widgets_table);
 169         lua_remove(globalconf.L, -2);
 170         /* Push 3rd argument: wibox screen */
 171         lua_pushnumber(globalconf.L, screen_array_indexof(&globalconf.screens, wibox->screen) + 1);
 172         /* Re-push the layout function */
 173         lua_pushvalue(globalconf.L, -4);
 174         /* call the layout function with 3 arguments (wibox geometry, widget
 175          * table, screen) and wait for one result */
 176         if(!luaA_dofunction(globalconf.L, 3, 1))
 177             return false;
 178
 179         /* Remove the left over layout function */
 180         lua_remove(globalconf.L, -2);
 181     }
 182     else
 183     {
 184         /* Remove the "nil function" */
 185         lua_pop(globalconf.L, 1);
 186
 187         /* If no layout function has been specified, we just push a table with
 188          * geometries onto the stack. These geometries are nothing fancy, they
 189          * have x = y = 0 and their height and width set to the widgets demands
 190          * or the wibox size, depending on which is less.
 191          */
 192
 193         /* push wibox */
 194         luaA_object_push(globalconf.L, wibox);
 195
 196         widget_node_array_t *widgets = &wibox->widgets;
 197         wibox_widget_node_array_wipe(globalconf.L, -1);
 198         widget_node_array_init(widgets);
 199
 200         /* push widgets table */
 201         luaA_object_push_item(globalconf.L, -1, wibox->widgets_table);
 202         /* Convert widgets table */
 203         luaA_table2widgets(globalconf.L, -2, widgets);
 204         /* remove wibox */
 205         lua_remove(globalconf.L, -1);
 206
 207         lua_newtable(globalconf.L);
 208         for(int i = 0; i < widgets->len; i++)
 209         {
 210             lua_pushnumber(globalconf.L, i + 1);
 211             widget_t *widget = widgets->tab[i].widget;
 212             lua_pushnumber(globalconf.L, screen_array_indexof(&globalconf.screens, wibox->screen) + 1);
 213             area_t geometry = widget->extents(globalconf.L, widget);
 214             lua_pop(globalconf.L, 1);
 215             geometry.x = geometry.y = 0;
 216             geometry.width = MIN(wibox->geometry.width, geometry.width);
 217             geometry.height = MIN(wibox->geometry.height, geometry.height);
 218
 219             luaA_pusharea(globalconf.L, geometry);
 220
 221             lua_settable(globalconf.L, -3);
 222         }
 223     }
 224     return true;
 225 }
 226
 227 /** Render a list of widgets.
 228  * \param wibox The wibox.
 229  * \todo Remove GC.
 230  */
 231 void
 232 widget_render(wibox_t *wibox)
 233 {
 234     lua_State *L = globalconf.L;
 235     draw_context_t *ctx = &wibox->ctx;
 236     area_t rectangle = { 0, 0, 0, 0 };
 237     color_t col;
 238
 239     rectangle.width = ctx->width;
 240     rectangle.height = ctx->height;
 241
 242     if (!widget_geometries(wibox))
 243         return;
 244
 245     if(ctx->bg.alpha != 0xffff)
 246     {
 247         int x = wibox->geometry.x + wibox->border_width,
 248             y = wibox->geometry.y + wibox->border_width;
 249         xcb_get_property_reply_t *prop_r;
 250         char *data;
 251         xcb_pixmap_t rootpix;
 252         xcb_get_property_cookie_t prop_c;
 253         xcb_screen_t *s = xutil_screen_get(globalconf.connection, ctx->phys_screen);
 254         prop_c = xcb_get_property_unchecked(globalconf.connection, false, s->root, _XROOTPMAP_ID,
 255                                             XCB_ATOM_PIXMAP, 0, 1);
 256         if((prop_r = xcb_get_property_reply(globalconf.connection, prop_c, NULL)))
 257         {
 258             if(prop_r->value_len
 259                && (data = xcb_get_property_value(prop_r))
 260                && (rootpix = *(xcb_pixmap_t *) data))
 261                switch(wibox->orientation)
 262                {
 263                  case North:
 264                    draw_rotate(ctx,
 265                                rootpix, ctx->pixmap,
 266                                s->width_in_pixels, s->height_in_pixels,
 267                                ctx->width, ctx->height,
 268                                M_PI_2,
 269                                y + ctx->width,
 270                                - x);
 271                    break;
 272                  case South:
 273                    draw_rotate(ctx,
 274                                rootpix, ctx->pixmap,
 275                                s->width_in_pixels, s->height_in_pixels,
 276                                ctx->width, ctx->height,
 277                                - M_PI_2,
 278                                - y,
 279                                x + ctx->height);
 280                    break;
 281                  case East:
 282                    xcb_copy_area(globalconf.connection, rootpix,
 283                                  wibox->pixmap, wibox->gc,
 284                                  x, y,
 285                                  0, 0,
 286                                  ctx->width, ctx->height);
 287                    break;
 288                }
 289             p_delete(&prop_r);
 290         }
 291     }
 292
 293     widget_node_array_t *widgets = &wibox->widgets;
 294
 295     /* push wibox */
 296     luaA_object_push(globalconf.L, wibox);
 297
 298     wibox_widget_node_array_wipe(globalconf.L, -1);
 299     widget_node_array_init(widgets);
 300
 301     /* push widgets table */
 302     luaA_object_push_item(globalconf.L, -1, wibox->widgets_table);
 303     luaA_table2widgets(L, -2, widgets);
 304     /* remove wibox */
 305     lua_remove(globalconf.L, -1);
 306
 307     /* get computed geometries */
 308     for(unsigned int i = 0; i < lua_objlen(L, -1); i++)
 309     {
 310         lua_pushnumber(L, i + 1);
 311         lua_gettable(L, -2);
 312
 313         widgets->tab[i].geometry.x = luaA_getopt_number(L, -1, "x", wibox->geometry.x);
 314         widgets->tab[i].geometry.y = luaA_getopt_number(L, -1, "y", wibox->geometry.y);
 315         widgets->tab[i].geometry.width = luaA_getopt_number(L, -1, "width", 1);
 316         widgets->tab[i].geometry.height = luaA_getopt_number(L, -1, "height", 1);
 317
 318         lua_pop(L, 1);
 319     }
 320     lua_pop(L, 1);
 321
 322     /* draw background image, only if the background color is not opaque */
 323     if(wibox->bg_image && ctx->bg.alpha != 0xffff)
 324         draw_image(ctx, 0, 0, 1.0, wibox->bg_image);
 325
 326     /* draw background color */
 327     xcolor_to_color(&ctx->bg, &col);
 328     draw_rectangle(ctx, rectangle, 1.0, true, &col);
 329
 330     /* draw everything! */
 331     for(int i = 0; i < widgets->len; i++)
 332         if(widgets->tab[i].widget->isvisible)
 333             widgets->tab[i].widget->draw(widgets->tab[i].widget,
 334                                          ctx, widgets->tab[i].geometry, wibox);
 335
 336     switch(wibox->orientation)
 337     {
 338         case South:
 339           draw_rotate(ctx, ctx->pixmap, wibox->pixmap,
 340                       ctx->width, ctx->height,
 341                       ctx->height, ctx->width,
 342                       M_PI_2, ctx->height, 0);
 343           break;
 344         case North:
 345           draw_rotate(ctx, ctx->pixmap, wibox->pixmap,
 346                       ctx->width, ctx->height,
 347                       ctx->height, ctx->width,
 348                       - M_PI_2, 0, ctx->width);
 349           break;
 350         case East:
 351           break;
 352     }
 353 }
 354
 355 /** Invalidate widgets which should be refresh depending on their types.
 356  * \param type Widget type to invalidate.
 357  */
 358 void
 359 widget_invalidate_bytype(widget_constructor_t *type)
 360 {
 361     foreach(wibox, globalconf.wiboxes)
 362         foreach(wnode, (*wibox)->widgets)
 363             if(wnode->widget->type == type)
 364             {
 365                 (*wibox)->need_update = true;
 366                 break;
 367             }
 368 }
 369
 370 /** Set a wibox needs update because it has widget, or redraw a titlebar.
 371  * \param widget The widget to look for.
 372  */
 373 void
 374 widget_invalidate_bywidget(widget_t *widget)
 375 {
 376     foreach(wibox, globalconf.wiboxes)
 377         if(!(*wibox)->need_update)
 378             foreach(wnode, (*wibox)->widgets)
 379                 if(wnode->widget == widget)
 380                 {
 381                     (*wibox)->need_update = true;
 382                     break;
 383                 }
 384
 385     foreach(_c, globalconf.clients)
 386     {
 387         client_t *c = *_c;
 388         if(c->titlebar && !c->titlebar->need_update)
 389             for(int j = 0; j < c->titlebar->widgets.len; j++)
 390                 if(c->titlebar->widgets.tab[j].widget == widget)
 391                 {
 392                     c->titlebar->need_update = true;
 393                     break;
 394                 }
 395     }
 396 }
 397
 398 /** Create a new widget.
 399  * \param L The Lua VM state.
 400  *
 401  * \luastack
 402  * \lparam A table with at least a type value.
 403  * \lreturn A brand new widget.
 404  */
 405 static int
 406 luaA_widget_new(lua_State *L)
 407 {
 408     luaA_class_new(L, &widget_class);
 409
 410     widget_t *w = luaA_checkudata(L, -1, &widget_class);
 411     /* Set visible by default. */
 412     w->isvisible = true;
 413
 414     return 1;
 415 }
 416
 417 /** Get or set mouse buttons bindings to a widget.
 418  * \param L The Lua VM state.
 419  *
 420  * \luastack
 421  * \lvalue A widget.
 422  * \lparam An array of mouse button bindings objects, or nothing.
 423  * \return The array of mouse button bindings objects of this widget.
 424  */
 425 static int
 426 luaA_widget_buttons(lua_State *L)
 427 {
 428     widget_t *widget = luaA_checkudata(L, 1, &widget_class);
 429
 430     if(lua_gettop(L) == 2)
 431     {
 432         luaA_button_array_set(L, 1, 2, &widget->buttons);
 433         luaA_object_emit_signal(L, 1, "property::buttons", 0);
 434         return 1;
 435     }
 436
 437     return luaA_button_array_get(L, 1, &widget->buttons);
 438 }
 439
 440 /** Generic widget.
 441  * \param L The Lua VM state.
 442  * \return The number of elements pushed on stack.
 443  * \luastack
 444  * \lfield visible The widget visibility.
 445  * \lfield mouse_enter A function to execute when the mouse enter the widget.
 446  * \lfield mouse_leave A function to execute when the mouse leave the widget.
 447  */
 448 static int
 449 luaA_widget_index(lua_State *L)
 450 {
 451     size_t len;
 452     const char *prop = luaL_checklstring(L, 2, &len);
 453     awesome_token_t token = a_tokenize(prop, len);
 454
 455     /* Try standard method */
 456     if(luaA_class_index(L))
 457         return 1;
 458
 459     /* Then call special widget index */
 460     widget_t *widget = luaA_checkudata(L, 1, &widget_class);
 461     return widget->index ? widget->index(L, token) : 0;
 462 }
 463
 464 /** Generic widget newindex.
 465  * \param L The Lua VM state.
 466  * \return The number of elements pushed on stack.
 467  */
 468 static int
 469 luaA_widget_newindex(lua_State *L)
 470 {
 471     size_t len;
 472     const char *prop = luaL_checklstring(L, 2, &len);
 473     awesome_token_t token = a_tokenize(prop, len);
 474
 475     /* Try standard method */
 476     luaA_class_newindex(L);
 477
 478     /* Then call special widget newindex */
 479     widget_t *widget = luaA_checkudata(L, 1, &widget_class);
 480     return widget->newindex ? widget->newindex(L, token) : 0;
 481 }
 482
 483 static int
 484 luaA_widget_extents(lua_State *L)
 485 {
 486     widget_t *widget = luaA_checkudata(L, 1, &widget_class);
 487     area_t g = {
 488         .x = 0,
 489         .y = 0,
 490         .width = 0,
 491         .height = 0
 492     };
 493
 494     if(widget->extents)
 495         g = widget->extents(L, widget);
 496
 497     lua_newtable(L);
 498     lua_pushnumber(L, g.width);
 499     lua_setfield(L, -2, "width");
 500     lua_pushnumber(L, g.height);
 501     lua_setfield(L, -2, "height");
 502
 503     return 1;
 504 }
 505
 506 static int
 507 luaA_widget_set_type(lua_State *L, widget_t *w)
 508 {
 509     size_t len;
 510     const char *type = luaL_checklstring(L, -1, &len);
 511     widget_constructor_t *wc = NULL;
 512
 513     switch(a_tokenize(type, len))
 514     {
 515       case A_TK_TEXTBOX:
 516         wc = widget_textbox;
 517         break;
 518       case A_TK_PROGRESSBAR:
 519         wc = widget_progressbar;
 520         break;
 521       case A_TK_GRAPH:
 522         wc = widget_graph;
 523         break;
 524       case A_TK_SYSTRAY:
 525         wc = widget_systray;
 526         break;
 527       case A_TK_IMAGEBOX:
 528         wc = widget_imagebox;
 529         break;
 530       default:
 531         break;
 532     }
 533
 534     if(!wc)
 535         luaL_error(L, "unknown widget type: %s", type);
 536
 537     wc(w);
 538     w->type = wc;
 539     luaA_object_emit_signal(L, -3, "property::type", 0);
 540
 541     return 0;
 542 }
 543
 544 static int
 545 luaA_widget_get_visible(lua_State *L, widget_t *w)
 546 {
 547     lua_pushboolean(L, w->isvisible);
 548     return 1;
 549 }
 550
 551 static int
 552 luaA_widget_set_visible(lua_State *L, widget_t *w)
 553 {
 554     w->isvisible = luaA_checkboolean(L, -1);
 555     widget_invalidate_bywidget(w);
 556     luaA_object_emit_signal(L, -3, "property::visible", 0);
 557     return 0;
 558 }
 559
 560 void
 561 widget_class_setup(lua_State *L)
 562 {
 563     static const struct luaL_reg widget_methods[] =
 564     {
 565         LUA_CLASS_METHODS(widget)
 566         { "__call", luaA_widget_new },
 567         { NULL, NULL }
 568     };
 569
 570     static const struct luaL_reg widget_meta[] =
 571     {
 572         LUA_OBJECT_META(widget)
 573         { "buttons", luaA_widget_buttons },
 574         { "extents", luaA_widget_extents },
 575         { "__index", luaA_widget_index },
 576         { "__newindex", luaA_widget_newindex },
 577         { "__gc", luaA_widget_gc },
 578         { NULL, NULL }
 579     };
 580
 581     luaA_class_setup(L, &widget_class, "widget", (lua_class_allocator_t) widget_new,
 582                      NULL, NULL,
 583                      widget_methods, widget_meta);
 584     luaA_class_add_property(&widget_class, A_TK_VISIBLE,
 585                             (lua_class_propfunc_t) luaA_widget_set_visible,
 586                             (lua_class_propfunc_t) luaA_widget_get_visible,
 587                             (lua_class_propfunc_t) luaA_widget_set_visible);
 588     luaA_class_add_property(&widget_class, A_TK_TYPE,
 589                             (lua_class_propfunc_t) luaA_widget_set_type,
 590                             NULL,
 591                             NULL);
 592 }
 593
 594 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80