tag.c

   1 /*
   2  * tag.c - tag management
   3  *
   4  * Copyright © 2007-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 "screen.h"
  23 #include "tag.h"
  24 #include "client.h"
  25 #include "ewmh.h"
  26 #include "widget.h"
  27
  28 DO_LUA_TOSTRING(tag_t, tag, "tag")
  29
  30 void
  31 tag_unref_simplified(tag_t **tag)
  32 {
  33     tag_unref(globalconf.L, *tag);
  34 }
  35
  36 /** Garbage collect a tag.
  37  * \param L The Lua VM state.
  38  * \return 0.
  39  */
  40 static int
  41 luaA_tag_gc(lua_State *L)
  42 {
  43     tag_t *tag = luaL_checkudata(L, 1, "tag");
  44     client_array_wipe(&tag->clients);
  45     p_delete(&tag->name);
  46     return luaA_object_gc(L);
  47 }
  48
  49 /** View or unview a tag.
  50  * \param tag the tag
  51  * \param view set visible or not
  52  */
  53 static void
  54 tag_view(tag_t *tag, bool view)
  55 {
  56     if(tag->selected != view)
  57     {
  58         int screen_index = screen_array_indexof(&globalconf.screens, tag->screen);
  59
  60         tag->selected = view;
  61         tag->screen->need_reban = true;
  62         ewmh_update_net_current_desktop(screen_virttophys(screen_index));
  63
  64         if(globalconf.hooks.tags != LUA_REFNIL)
  65         {
  66             lua_pushnumber(globalconf.L, screen_index + 1);
  67             tag_push(globalconf.L, tag);
  68             if(view)
  69                 lua_pushliteral(globalconf.L, "select");
  70             else
  71                 lua_pushliteral(globalconf.L, "unselect");
  72             luaA_dofunction_from_registry(globalconf.L, globalconf.hooks.tags, 3, 0);
  73         }
  74     }
  75 }
  76
  77 /** Append a tag which on top of the stack to a screen.
  78  * \param screen the screen id
  79  */
  80 void
  81 tag_append_to_screen(screen_t *s)
  82 {
  83     tag_t *tag = luaL_checkudata(globalconf.L, -1, "tag");
  84
  85     /* can't attach a tag twice */
  86     if(tag->screen)
  87         return;
  88
  89     int screen_index = screen_array_indexof(&globalconf.screens, s);
  90     int phys_screen = screen_virttophys(screen_index);
  91
  92     tag->screen = s;
  93     tag_array_append(&s->tags, tag_ref(globalconf.L, -1));
  94     ewmh_update_net_numbers_of_desktop(phys_screen);
  95     ewmh_update_net_desktop_names(phys_screen);
  96     ewmh_update_workarea(phys_screen);
  97
  98     /* call hook */
  99     if(globalconf.hooks.tags != LUA_REFNIL)
 100     {
 101         lua_pushnumber(globalconf.L, screen_index + 1);
 102         tag_push(globalconf.L, tag);
 103         lua_pushliteral(globalconf.L, "add");
 104         luaA_dofunction_from_registry(globalconf.L, globalconf.hooks.tags, 3, 0);
 105     }
 106 }
 107
 108 /** Remove a tag from screen. Tag must be on a screen and have no clients.
 109  * \param tag The tag to remove.
 110  */
 111 static void
 112 tag_remove_from_screen(tag_t *tag)
 113 {
 114     int screen_index = screen_array_indexof(&globalconf.screens, tag->screen);
 115     int phys_screen = screen_virttophys(screen_index);
 116     tag_array_t *tags = &tag->screen->tags;
 117
 118     for(int i = 0; i < tags->len; i++)
 119         if(tags->tab[i] == tag)
 120         {
 121             tag_array_take(tags, i);
 122             break;
 123         }
 124     ewmh_update_net_numbers_of_desktop(phys_screen);
 125     ewmh_update_net_desktop_names(phys_screen);
 126     ewmh_update_workarea(phys_screen);
 127
 128     /* call hook */
 129     if(globalconf.hooks.tags != LUA_REFNIL)
 130     {
 131         lua_pushnumber(globalconf.L, screen_index + 1);
 132         tag_push(globalconf.L, tag);
 133         lua_pushliteral(globalconf.L, "remove");
 134         luaA_dofunction_from_registry(globalconf.L, globalconf.hooks.tags, 3, 0);
 135     }
 136
 137     tag->screen = NULL;
 138
 139     tag_unref(globalconf.L, tag);
 140 }
 141
 142 /** Tag a client with the tag on top of the stack.
 143  * \param c the client to tag
 144  */
 145 void
 146 tag_client(client_t *c)
 147 {
 148     tag_t *t = tag_ref(globalconf.L, -1);
 149
 150     /* don't tag twice */
 151     if(is_client_tagged(c, t))
 152     {
 153         tag_unref(globalconf.L, t);
 154         return;
 155     }
 156
 157     client_array_append(&t->clients, c);
 158     ewmh_client_update_desktop(c);
 159     client_need_reban(c);
 160
 161     /* call hook */
 162     if(globalconf.hooks.tagged != LUA_REFNIL)
 163     {
 164         client_push(globalconf.L, c);
 165         tag_push(globalconf.L, t);
 166         luaA_dofunction_from_registry(globalconf.L, globalconf.hooks.tagged, 2, 0);
 167     }
 168 }
 169
 170 /** Untag a client with specified tag.
 171  * \param c the client to tag
 172  * \param t the tag to tag the client with
 173  */
 174 void
 175 untag_client(client_t *c, tag_t *t)
 176 {
 177     for(int i = 0; i < t->clients.len; i++)
 178         if(t->clients.tab[i] == c)
 179         {
 180             client_need_reban(c);
 181             client_array_take(&t->clients, i);
 182             client_need_reban(c);
 183             ewmh_client_update_desktop(c);
 184             /* call hook */
 185             if(globalconf.hooks.tagged != LUA_REFNIL)
 186             {
 187                 client_push(globalconf.L, c);
 188                 tag_push(globalconf.L, t);
 189                 luaA_dofunction_from_registry(globalconf.L, globalconf.hooks.tagged, 2, 0);
 190             }
 191             tag_unref(globalconf.L, t);
 192             return;
 193         }
 194 }
 195
 196 /** Check if a client is tagged with the specified tag.
 197  * \param c the client
 198  * \param t the tag
 199  * \return true if the client is tagged with the tag, false otherwise.
 200  */
 201 bool
 202 is_client_tagged(client_t *c, tag_t *t)
 203 {
 204     for(int i = 0; i < t->clients.len; i++)
 205         if(t->clients.tab[i] == c)
 206             return true;
 207
 208     return false;
 209 }
 210
 211 /** Get the current tags for the specified screen.
 212  * Returned pointer must be p_delete'd after.
 213  * \param screen Screen.
 214  * \return A double pointer of tag list finished with a NULL element.
 215  */
 216 tag_t **
 217 tags_get_current(screen_t *screen)
 218 {
 219     tag_t **out = p_new(tag_t *, screen->tags.len + 1);
 220     int n = 0;
 221
 222     foreach(tag, screen->tags)
 223         if((*tag)->selected)
 224             out[n++] = *tag;
 225
 226     return out;
 227 }
 228
 229
 230 /** Set a tag to be the only one viewed.
 231  * \param target the tag to see
 232  */
 233 static void
 234 tag_view_only(tag_t *target)
 235 {
 236     if(target)
 237         foreach(tag, target->screen->tags)
 238             tag_view(*tag, *tag == target);
 239 }
 240
 241 /** View only a tag, selected by its index.
 242  * \param screen Screen.
 243  * \param dindex The index.
 244  */
 245 void
 246 tag_view_only_byindex(screen_t *screen, int dindex)
 247 {
 248     tag_array_t *tags = &screen->tags;
 249
 250     if(dindex < 0 || dindex >= tags->len)
 251         return;
 252     tag_view_only(tags->tab[dindex]);
 253 }
 254
 255 /** Create a new tag.
 256  * \param L The Lua VM state.
 257  * \luastack
 258  * \lparam A name.
 259  * \lreturn A new tag object.
 260  */
 261 static int
 262 luaA_tag_new(lua_State *L)
 263 {
 264     size_t len;
 265     const char *name = luaL_checklstring(L, 2, &len);
 266     tag_t *tag = tag_new(globalconf.L);
 267
 268     a_iso2utf8(name, len, &tag->name, NULL);
 269
 270     return 1;
 271 }
 272
 273 /** Get or set the clients attached to this tag.
 274  * \param L The Lua VM state.
 275  * \return The number of elements pushed on stack.
 276  * \luastack
 277  * \lparam None or a table of clients to set.
 278  * \lreturn A table with the clients attached to this tags.
 279  */
 280 static int
 281 luaA_tag_clients(lua_State *L)
 282 {
 283     tag_t *tag = luaL_checkudata(L, 1, "tag");
 284     client_array_t *clients = &tag->clients;
 285     int i;
 286
 287     if(lua_gettop(L) == 2)
 288     {
 289         luaA_checktable(L, 2);
 290         foreach(c, tag->clients)
 291             untag_client(*c, tag);
 292         lua_pushnil(L);
 293         while(lua_next(L, 2))
 294         {
 295             client_t *c = luaA_client_checkudata(L, -1);
 296             /* push tag on top of the stack */
 297             lua_pushvalue(L, 1);
 298             tag_client(c);
 299             lua_pop(L, 1);
 300         }
 301     }
 302
 303     lua_createtable(L, clients->len, 0);
 304     for(i = 0; i < clients->len; i++)
 305     {
 306         client_push(L, clients->tab[i]);
 307         lua_rawseti(L, -2, i + 1);
 308     }
 309
 310     return 1;
 311 }
 312
 313 /** Tag object.
 314  * \param L The Lua VM state.
 315  * \return The number of elements pushed on stack.
 316  * \luastack
 317  * \lfield name Tag name.
 318  * \lfield screen Screen number of the tag.
 319  * \lfield layout Tag layout.
 320  * \lfield selected True if the client is selected to be viewed.
 321  */
 322 static int
 323 luaA_tag_index(lua_State *L)
 324 {
 325     size_t len;
 326     tag_t *tag = luaL_checkudata(L, 1, "tag");
 327     const char *attr;
 328
 329     if(luaA_usemetatable(L, 1, 2))
 330         return 1;
 331
 332     attr = luaL_checklstring(L, 2, &len);
 333
 334     switch(a_tokenize(attr, len))
 335     {
 336       case A_TK_NAME:
 337         lua_pushstring(L, tag->name);
 338         break;
 339       case A_TK_SCREEN:
 340         if(!tag->screen)
 341             return 0;
 342         lua_pushnumber(L, screen_array_indexof(&globalconf.screens, tag->screen) + 1);
 343         break;
 344       case A_TK_SELECTED:
 345         lua_pushboolean(L, tag->selected);
 346         break;
 347       default:
 348         return 0;
 349     }
 350
 351     return 1;
 352 }
 353
 354 /** Tag newindex.
 355  * \param L The Lua VM state.
 356  * \return The number of elements pushed on stack.
 357  */
 358 static int
 359 luaA_tag_newindex(lua_State *L)
 360 {
 361     size_t len;
 362     tag_t *tag = luaL_checkudata(L, 1, "tag");
 363     const char *attr = luaL_checklstring(L, 2, &len);
 364
 365     switch(a_tokenize(attr, len))
 366     {
 367         int screen;
 368
 369       case A_TK_NAME:
 370         {
 371             const char *buf = luaL_checklstring(L, 3, &len);
 372             p_delete(&tag->name);
 373             a_iso2utf8(buf, len, &tag->name, NULL);
 374         }
 375         break;
 376       case A_TK_SCREEN:
 377         if(!lua_isnil(L, 3))
 378         {
 379             screen = luaL_checknumber(L, 3) - 1;
 380             luaA_checkscreen(screen);
 381         }
 382         else
 383             screen = -1;
 384
 385         if(tag->screen)
 386             tag_remove_from_screen(tag);
 387
 388         if(screen != -1)
 389         {
 390             /* push tag on top of the stack */
 391             lua_pushvalue(L, 1);
 392             tag_append_to_screen(&globalconf.screens.tab[screen]);
 393         }
 394         break;
 395       case A_TK_SELECTED:
 396         if(tag->screen)
 397             tag_view(tag, luaA_checkboolean(L, 3));
 398         return 0;
 399       default:
 400         return 0;
 401     }
 402
 403     return 0;
 404 }
 405
 406 const struct luaL_reg awesome_tag_methods[] =
 407 {
 408     { "__call", luaA_tag_new },
 409     { NULL, NULL }
 410 };
 411 const struct luaL_reg awesome_tag_meta[] =
 412 {
 413     { "clients", luaA_tag_clients },
 414     { "__index", luaA_tag_index },
 415     { "__newindex", luaA_tag_newindex },
 416     { "__gc", luaA_tag_gc },
 417     { "__tostring", luaA_tag_tostring },
 418     { NULL, NULL },
 419 };
 420
 421 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80