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 #include "layoutgen.h"
  29
  30 extern awesome_t globalconf;
  31
  32 DO_LUA_NEW(extern, tag_t, tag, "tag", tag_ref)
  33 DO_LUA_GC(tag_t, tag, "tag", tag_unref)
  34 DO_LUA_EQ(tag_t, tag, "tag")
  35
  36 /** View or unview a tag.
  37  * \param tag the tag
  38  * \param view set visible or not
  39  */
  40 static void
  41 tag_view(tag_t *tag, bool view)
  42 {
  43     tag->selected = view;
  44     ewmh_update_net_current_desktop(screen_virttophys(tag->screen));
  45     globalconf.screens[tag->screen].need_arrange = true;
  46 }
  47
  48 /** Create a new tag. Parameters values are checked.
  49  * \param name Tag name.
  50  * \param len Tag name length.
  51  * \param layout Layout to use.
  52  * \param mwfact Master width factor.
  53  * \param nmaster Number of master windows.
  54  * \param ncol Number of columns for slaves windows.
  55  * \return A new tag with all these parameters.
  56  */
  57 tag_t *
  58 tag_new(const char *name, ssize_t len, layout_t *layout, double mwfact, int nmaster, int ncol)
  59 {
  60     tag_t *tag;
  61
  62     tag = p_new(tag_t, 1);
  63     a_iso2utf8(&tag->name, name, len);
  64     tag->layout = layout;
  65
  66     /* to avoid error */
  67     tag->screen = SCREEN_UNDEF;
  68
  69     tag->mwfact = mwfact;
  70     if(tag->mwfact <= 0 || tag->mwfact >= 1)
  71         tag->mwfact = 0.5;
  72
  73     if((tag->nmaster = nmaster) < 0)
  74         tag->nmaster = 1;
  75
  76     if((tag->ncol = ncol) < 1)
  77         tag->ncol = 1;
  78
  79     return tag;
  80 }
  81
  82 /** Append a tag to a screen.
  83  * \param tag the tag to append
  84  * \param screen the screen id
  85  */
  86 void
  87 tag_append_to_screen(tag_t *tag, screen_t *s)
  88 {
  89     int phys_screen = screen_virttophys(s->index);
  90
  91     tag->screen = s->index;
  92     tag_array_append(&s->tags, tag_ref(&tag));
  93     ewmh_update_net_numbers_of_desktop(phys_screen);
  94     ewmh_update_net_desktop_names(phys_screen);
  95     ewmh_update_workarea(phys_screen);
  96     /* call hook */
  97     lua_pushnumber(globalconf.L, s->index+ 1);
  98     luaA_dofunction(globalconf.L, globalconf.hooks.tags, 1, 0);
  99 }
 100
 101 /** Remove a tag from screen. Tag must be on a screen and have no clients.
 102  * \param tag The tag to remove.
 103  */
 104 static void
 105 tag_remove_from_screen(tag_t *tag)
 106 {
 107     int screen = tag->screen;
 108     int phys_screen = screen_virttophys(tag->screen);
 109     tag_array_t *tags = &globalconf.screens[tag->screen].tags;
 110
 111     for(int i = 0; i < tags->len; i++)
 112         if(tags->tab[i] == tag)
 113         {
 114             tag_array_take(tags, i);
 115             break;
 116         }
 117     ewmh_update_net_numbers_of_desktop(phys_screen);
 118     ewmh_update_net_desktop_names(phys_screen);
 119     ewmh_update_workarea(phys_screen);
 120     tag->screen = SCREEN_UNDEF;
 121     tag_unref(&tag);
 122     /* call hook */
 123     lua_pushnumber(globalconf.L, screen + 1);
 124     luaA_dofunction(globalconf.L, globalconf.hooks.tags, 1, 0);
 125 }
 126
 127 /** Tag a client with specified tag.
 128  * \param c the client to tag
 129  * \param t the tag to tag the client with
 130  */
 131 void
 132 tag_client(client_t *c, tag_t *t)
 133 {
 134     /* don't tag twice */
 135     if(is_client_tagged(c, t))
 136         return;
 137
 138     tag_ref(&t);
 139     client_array_append(&t->clients, c);
 140     client_saveprops_tags(c);
 141     client_need_arrange(c);
 142     /* call hook */
 143     luaA_client_userdata_new(globalconf.L, c);
 144     luaA_dofunction(globalconf.L, globalconf.hooks.tagged, 1, 0);
 145 }
 146
 147 /** Untag a client with specified tag.
 148  * \param c the client to tag
 149  * \param t the tag to tag the client with
 150  */
 151 void
 152 untag_client(client_t *c, tag_t *t)
 153 {
 154     for(int i = 0; i < t->clients.len; i++)
 155         if(t->clients.tab[i] == c)
 156         {
 157             client_need_arrange(c);
 158             client_array_take(&t->clients, i);
 159             tag_unref(&t);
 160             client_saveprops_tags(c);
 161             /* call hook */
 162             luaA_client_userdata_new(globalconf.L, c);
 163             luaA_tag_userdata_new(globalconf.L, t);
 164             luaA_dofunction(globalconf.L, globalconf.hooks.tagged, 2, 0);
 165             return;
 166         }
 167 }
 168
 169 /** Check if a client is tagged with the specified tag.
 170  * \param c the client
 171  * \param t the tag
 172  * \return true if the client is tagged with the tag, false otherwise.
 173  */
 174 bool
 175 is_client_tagged(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             return true;
 180
 181     return false;
 182 }
 183
 184 /** Get the current tags for the specified screen.
 185  * Returned pointer must be p_delete'd after.
 186  * \param screen screen id
 187  * \return a double pointer of tag list finished with a NULL element
 188  */
 189 tag_t **
 190 tags_get_current(int screen)
 191 {
 192     tag_array_t *tags = &globalconf.screens[screen].tags;
 193     tag_t **out = p_new(tag_t *, tags->len + 1);
 194     int n = 0;
 195
 196     for(int i = 0; i < tags->len; i++)
 197         if(tags->tab[i]->selected)
 198             out[n++] = tags->tab[i];
 199
 200     return out;
 201 }
 202
 203
 204 /** Set a tag to be the only one viewed.
 205  * \param target the tag to see
 206  */
 207 static void
 208 tag_view_only(tag_t *target)
 209 {
 210     if (target)
 211     {
 212         tag_array_t *tags = &globalconf.screens[target->screen].tags;
 213
 214         for(int i = 0; i < tags->len; i++)
 215             tag_view(tags->tab[i], tags->tab[i] == target);
 216     }
 217 }
 218
 219 /** View only a tag, selected by its index.
 220  * \param screen screen id
 221  * \param dindex the index
 222  */
 223 void
 224 tag_view_only_byindex(int screen, int dindex)
 225 {
 226     tag_array_t *tags = &globalconf.screens[screen].tags;
 227
 228     if(dindex < 0 || dindex >= tags->len)
 229         return;
 230     tag_view_only(tags->tab[dindex]);
 231 }
 232
 233 /** Create a new tag.
 234  * \param L The Lua VM state.
 235  *
 236  * \luastack
 237  * \lparam A table with at least a name attribute.
 238  * Optional attributes are: mwfact, ncol, nmaster and layout.
 239  * \lreturn A new tag object.
 240  */
 241 static int
 242 luaA_tag_new(lua_State *L)
 243 {
 244     size_t len;
 245     tag_t *tag;
 246     int ncol, nmaster;
 247     const char *name, *lay;
 248     double mwfact;
 249     layout_t *layout;
 250
 251     luaA_checktable(L, 2);
 252
 253     if(!(name = luaA_getopt_string(L, 2, "name", NULL)))
 254         luaL_error(L, "object tag must have a name");
 255
 256     mwfact = luaA_getopt_number(L, 2, "mwfact", 0.5);
 257     ncol = luaA_getopt_number(L, 2, "ncol", 1);
 258     nmaster = luaA_getopt_number(L, 2, "nmaster", 1);
 259     lay = luaA_getopt_lstring(L, 2, "layout", "tile", &len);
 260
 261     layout = name_func_lookup(lay, LayoutList);
 262
 263     tag = tag_new(name, len,
 264                   layout,
 265                   mwfact, nmaster, ncol);
 266
 267     return luaA_tag_userdata_new(L, tag);
 268 }
 269
 270 /** Get or set the clients attached to this tag.
 271  * \param L The Lua VM state.
 272  * \return The number of elements pushed on stack.
 273  * \luastack
 274  * \lparam None or a table of clients to set.
 275  * \lreturn A table with the clients attached to this tags.
 276  */
 277 static int
 278 luaA_tag_clients(lua_State *L)
 279 {
 280     tag_t **tag = luaA_checkudata(L, 1, "tag");
 281     client_array_t *clients = &(*tag)->clients;
 282     int i;
 283
 284     if(lua_gettop(L) == 2)
 285     {
 286         client_t **c;
 287
 288         luaA_checktable(L, 2);
 289         for(i = 0; i < (*tag)->clients.len; i++)
 290             untag_client((*tag)->clients.tab[i], *tag);
 291         lua_pushnil(L);
 292         while(lua_next(L, 2))
 293         {
 294             c = luaA_checkudata(L, -1, "client");
 295             tag_client(*c, *tag);
 296             lua_pop(L, 1);
 297         }
 298     }
 299
 300     luaA_otable_new(L);
 301     for(i = 0; i < clients->len; i++)
 302     {
 303         luaA_client_userdata_new(L, clients->tab[i]);
 304         lua_rawseti(L, -2, i + 1);
 305     }
 306
 307     return 1;
 308 }
 309
 310 /** Tag object.
 311  * \param L The Lua VM state.
 312  * \return The number of elements pushed on stack.
 313  * \luastack
 314  * \lfield name Tag name.
 315  * \lfield screen Screen number of the tag.
 316  * \lfield layout Tag layout.
 317  * \lfield selected True if the client is selected to be viewed.
 318  * \lfield mwfact Master width factor.
 319  * \lfield nmaster Number of master windows.
 320  * \lfield ncol Number of column for slave windows.
 321  */
 322 static int
 323 luaA_tag_index(lua_State *L)
 324 {
 325     size_t len;
 326     tag_t **tag = luaA_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 == SCREEN_UNDEF)
 341             return 0;
 342         lua_pushnumber(L, (*tag)->screen + 1);
 343         break;
 344       case A_TK_LAYOUT:
 345         lua_pushstring(L, name_func_rlookup((*tag)->layout, LayoutList));
 346         break;
 347       case A_TK_SELECTED:
 348         lua_pushboolean(L, (*tag)->selected);
 349         break;
 350       case A_TK_MWFACT:
 351         lua_pushnumber(L, (*tag)->mwfact);
 352         break;
 353       case A_TK_NMASTER:
 354         lua_pushnumber(L, (*tag)->nmaster);
 355         break;
 356       case A_TK_NCOL:
 357         lua_pushnumber(L, (*tag)->ncol);
 358         break;
 359       default:
 360         return 0;
 361     }
 362
 363     return 1;
 364 }
 365
 366 /** Get a screen by its name.
 367  * \param screen The screen to look into.
 368  * \param name The name.
 369  */
 370 static tag_t *
 371 tag_getbyname(int screen, const char *name)
 372 {
 373     int i;
 374     tag_array_t *tags = &globalconf.screens[screen].tags;
 375
 376     for(i = 0; i < tags->len; i++)
 377         if(!a_strcmp(name, tags->tab[i]->name))
 378             return tags->tab[i];
 379     return NULL;
 380 }
 381
 382 /** Tag newindex.
 383  * \param L The Lua VM state.
 384  * \return The number of elements pushed on stack.
 385  */
 386 static int
 387 luaA_tag_newindex(lua_State *L)
 388 {
 389     size_t len;
 390     tag_t **tag = luaA_checkudata(L, 1, "tag");
 391     const char *buf, *attr = luaL_checklstring(L, 2, &len);
 392     double d;
 393     int i, screen;
 394     layout_t *l;
 395
 396     switch(a_tokenize(attr, len))
 397     {
 398       case A_TK_NAME:
 399         buf = luaL_checklstring(L, 3, &len);
 400         if((*tag)->screen != SCREEN_UNDEF)
 401             if(tag_getbyname((*tag)->screen, (*tag)->name) != *tag)
 402                 luaL_error(L, "a tag with the name `%s' is already on screen %d",
 403                            buf, (*tag)->screen);
 404         p_delete(&(*tag)->name);
 405         a_iso2utf8(&(*tag)->name, buf, len);
 406         break;
 407       case A_TK_SCREEN:
 408         if(!lua_isnil(L, 3))
 409         {
 410             screen = luaL_checknumber(L, 3) - 1;
 411             luaA_checkscreen(screen);
 412         }
 413         else
 414             screen = SCREEN_UNDEF;
 415
 416         if((*tag)->screen != SCREEN_UNDEF)
 417             tag_remove_from_screen(*tag);
 418
 419         if(screen != SCREEN_UNDEF)
 420         {
 421             if(tag_getbyname(screen, (*tag)->name))
 422                 luaL_error(L, "a tag with the name `%s' is already on screen %d",
 423                            (*tag)->name, screen);
 424
 425             tag_append_to_screen(*tag, &globalconf.screens[screen]);
 426         }
 427         break;
 428       case A_TK_LAYOUT:
 429         buf = luaL_checkstring(L, 3);
 430         l = name_func_lookup(buf, LayoutList);
 431         if(l)
 432             (*tag)->layout = l;
 433         else
 434             luaL_error(L, "unknown layout: %s", buf);
 435         break;
 436       case A_TK_SELECTED:
 437         if((*tag)->screen != SCREEN_UNDEF)
 438             tag_view(*tag, luaA_checkboolean(L, 3));
 439         return 0;
 440       case A_TK_MWFACT:
 441         d = luaL_checknumber(L, 3);
 442         if(d > 0 && d < 1)
 443             (*tag)->mwfact = d;
 444         else
 445             luaL_error(L, "bad value, must be between 0 and 1");
 446         break;
 447       case A_TK_NMASTER:
 448         i = luaL_checknumber(L, 3);
 449         if(i >= 0)
 450             (*tag)->nmaster = i;
 451         else
 452             luaL_error(L, "bad value, must be greater than 0");
 453         break;
 454       case A_TK_NCOL:
 455         i = luaL_checknumber(L, 3);
 456         if(i >= 1)
 457             (*tag)->ncol = i;
 458         else
 459             luaL_error(L, "bad value, must be greater than 1");
 460         break;
 461       default:
 462         return 0;
 463     }
 464
 465     if((*tag)->screen != SCREEN_UNDEF && (*tag)->selected)
 466         globalconf.screens[(*tag)->screen].need_arrange = true;
 467
 468     return 0;
 469 }
 470
 471 const struct luaL_reg awesome_tag_methods[] =
 472 {
 473     { "__call", luaA_tag_new },
 474     { NULL, NULL }
 475 };
 476 const struct luaL_reg awesome_tag_meta[] =
 477 {
 478     { "clients", luaA_tag_clients },
 479     { "__index", luaA_tag_index },
 480     { "__newindex", luaA_tag_newindex },
 481     { "__eq", luaA_tag_eq },
 482     { "__gc", luaA_tag_gc },
 483     { "__tostring", luaA_tag_tostring },
 484     { NULL, NULL },
 485 };
 486
 487 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80