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