tag.c

   1 /*
   2  * tag.c - tag management
   3  *
   4  * Copyright © 2007 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 <stdio.h>
  23 #include <X11/Xutil.h>
  24
  25 #include "screen.h"
  26 #include "tag.h"
  27 #include "util.h"
  28 #include "rules.h"
  29 #include "client.h"
  30 #include "ewmh.h"
  31 #include "widget.h"
  32
  33 extern AwesomeConf globalconf;
  34
  35 Tag *
  36 tag_new(const char *name, Layout *layout, double mwfact, int nmaster, int ncol)
  37 {
  38     Tag *tag;
  39
  40     tag = p_new(Tag, 1);
  41     tag->name = a_strdup(name);
  42     tag->layout = layout;
  43     tag->mwfact = mwfact;
  44     tag->nmaster = nmaster;
  45     tag->ncol = ncol;
  46
  47     return tag;
  48 }
  49
  50 static void
  51 tag_append_to_screen(Tag *tag, int screen)
  52 {
  53     tag->screen = screen;
  54     tag_list_append(&globalconf.screens[screen].tags, tag);
  55     widget_invalidate_cache(screen, WIDGET_CACHE_TAGS);
  56 }
  57
  58 void
  59 tag_push_to_screen(Tag *tag, int screen)
  60 {
  61     tag->screen = screen;
  62     tag_list_push(&globalconf.screens[screen].tags, tag);
  63     widget_invalidate_cache(screen, WIDGET_CACHE_TAGS);
  64 }
  65
  66 void
  67 tag_client(Client *c, Tag *t)
  68 {
  69     tag_client_node_t *tc;
  70
  71     /* don't tag twice */
  72     if(is_client_tagged(c, t))
  73         return;
  74
  75     tc = p_new(tag_client_node_t, 1);
  76     tc->client = c;
  77     tc->tag = t;
  78     tag_client_node_list_push(&globalconf.tclink, tc);
  79
  80     client_saveprops(c);
  81     widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
  82     globalconf.screens[c->screen].need_arrange = True;
  83 }
  84
  85 void
  86 untag_client(Client *c, Tag *t)
  87 {
  88     tag_client_node_t *tc;
  89
  90     for(tc = globalconf.tclink; tc; tc = tc->next)
  91         if(tc->client == c && tc->tag == t)
  92         {
  93             tag_client_node_list_detach(&globalconf.tclink, tc);
  94             p_delete(&tc);
  95             break;
  96         }
  97
  98     client_saveprops(c);
  99     widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
 100     globalconf.screens[c->screen].need_arrange = True;
 101 }
 102
 103 Bool
 104 is_client_tagged(Client *c, Tag *t)
 105 {
 106     tag_client_node_t *tc;
 107
 108     if(!c)
 109         return False;
 110
 111     for(tc = globalconf.tclink; tc; tc = tc->next)
 112         if(tc->client == c && tc->tag == t)
 113             return True;
 114
 115     return False;
 116 }
 117
 118 void
 119 tag_client_with_current_selected(Client *c)
 120 {
 121     Tag *tag;
 122     VirtScreen vscreen = globalconf.screens[c->screen];
 123
 124     for(tag = vscreen.tags; tag; tag = tag->next)
 125         if(tag->selected)
 126             tag_client(c, tag);
 127         else
 128             untag_client(c, tag);
 129 }
 130
 131 void
 132 tag_client_with_rule(Client *c, Rule *r)
 133 {
 134     Tag *tag;
 135     Bool matched = False;
 136
 137     if(!r) return;
 138
 139     /* check if at least one tag match */
 140     for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next)
 141         if(tag_match_rule(tag, r))
 142         {
 143             matched = True;
 144             break;
 145         }
 146
 147     if(matched)
 148         for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next)
 149             if(tag_match_rule(tag, r))
 150                 tag_client(c, tag);
 151             else
 152                 untag_client(c, tag);
 153 }
 154
 155 Tag **
 156 get_current_tags(int screen)
 157 {
 158     Tag *tag, **tags = NULL;
 159     int n = 1;
 160
 161     tags = p_new(Tag *, n);
 162     for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 163         if(tag->selected)
 164         {
 165             p_realloc(&tags, ++n);
 166             tags[n - 2] = tag;
 167         }
 168
 169     /* finish with null */
 170     tags[n - 1] = NULL;
 171
 172     return tags;
 173 }
 174
 175 /** Tag selected window with tag
 176  * \param screen Screen ID
 177  * \param arg Tag name
 178  * \ingroup ui_callback
 179  */
 180 void
 181 uicb_client_tag(int screen, char *arg)
 182 {
 183     int tag_id = -1;
 184     Tag *tag, *target_tag;
 185     Client *sel = globalconf.focus->client;
 186
 187     if(!sel)
 188         return;
 189
 190     if(arg)
 191     {
 192         tag_id = atoi(arg) - 1;
 193         if(tag_id != -1)
 194         {
 195             for(target_tag = globalconf.screens[screen].tags; target_tag && tag_id > 0;
 196                 target_tag = target_tag->next, tag_id--);
 197             if(target_tag)
 198             {
 199                 for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 200                     untag_client(sel, tag);
 201                 tag_client(sel, target_tag);
 202             }
 203         }
 204     }
 205     else
 206         for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 207             tag_client(sel, tag);
 208 }
 209
 210 /** Toggle a tag on client
 211  * \param screen Screen ID
 212  * \param arg Tag name
 213  * \ingroup ui_callback
 214  */
 215 void
 216 uicb_client_toggletag(int screen, char *arg)
 217 {
 218     Client *sel = globalconf.focus->client;
 219     int i;
 220     Tag *tag, *target_tag;
 221
 222     if(!sel)
 223         return;
 224
 225     if(arg)
 226     {
 227         i = atoi(arg) - 1;
 228         for(target_tag = globalconf.screens[screen].tags; target_tag && i > 0;
 229             target_tag = target_tag->next, i--);
 230         if(target_tag)
 231         {
 232             if(is_client_tagged(sel, target_tag))
 233                 untag_client(sel, target_tag);
 234             else
 235                 tag_client(sel, target_tag);
 236         }
 237
 238         /* check that there's at least one tag selected for this client*/
 239         for(tag = globalconf.screens[screen].tags; tag
 240             && !is_client_tagged(sel, tag); tag = tag->next)
 241
 242         if(!tag)
 243             tag_client(sel, target_tag);
 244     }
 245     else
 246         for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 247             if(is_client_tagged(sel, tag))
 248                 tag_client(sel, tag);
 249             else
 250                 untag_client(sel, tag);
 251 }
 252
 253 /** Add a tag to viewed tags
 254  * \param screen Screen ID
 255  * \param arg Tag name
 256  * \ingroup ui_callback
 257  */
 258 void
 259 uicb_tag_toggleview(int screen, char *arg)
 260 {
 261     int i;
 262     Tag *tag, *target_tag;
 263
 264     if(arg)
 265     {
 266         i = atoi(arg) - 1;
 267         for(target_tag = globalconf.screens[screen].tags; target_tag && i > 0;
 268             target_tag = target_tag->next, i--);
 269
 270         if(target_tag)
 271             tag_view(target_tag, !target_tag->selected);
 272
 273         /* check that there's at least one tag selected */
 274         for(tag = globalconf.screens[screen].tags; tag && !tag->selected; tag = tag->next);
 275         if(!tag)
 276             tag_view(target_tag, True);
 277     }
 278     else
 279         for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 280             tag_view(tag, !tag->selected);
 281 }
 282
 283 static void
 284 tag_view_only(Tag *target)
 285 {
 286     Tag *tag;
 287
 288     if(!target) return;
 289
 290     for(tag = globalconf.screens[target->screen].tags; tag; tag = tag->next)
 291         tag_view(tag, False);
 292
 293     tag_view(target, True);
 294 }
 295
 296 void
 297 tag_view_only_byindex(int screen, int dindex)
 298 {
 299     Tag *tag;
 300
 301     if(dindex < 0)
 302         return;
 303
 304     for(tag = globalconf.screens[screen].tags; tag && dindex > 0;
 305         tag = tag->next, dindex--);
 306     tag_view_only(tag);
 307 }
 308
 309 void
 310 tag_view(Tag *tag, Bool view)
 311 {
 312     tag->selected = view;
 313     ewmh_update_net_current_desktop(get_phys_screen(tag->screen));
 314     widget_invalidate_cache(tag->screen, WIDGET_CACHE_TAGS);
 315     saveawesomeprops(tag->screen);
 316     globalconf.screens[tag->screen].need_arrange = True;
 317 }
 318
 319 /** View tag
 320  * \param screen Screen ID
 321  * \param arg tag to view
 322  * \ingroup ui_callback
 323  */
 324 void
 325 uicb_tag_view(int screen, char *arg)
 326 {
 327     Tag *tag;
 328
 329     if(arg)
 330         tag_view_only_byindex(screen, atoi(arg) - 1);
 331     else
 332         for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 333             tag_view(tag, True);
 334 }
 335
 336 /** View previously selected tags
 337  * \param screen Screen ID
 338  * \param arg unused
 339  * \ingroup ui_callback
 340  */
 341 void
 342 uicb_tag_prev_selected(int screen, char *arg __attribute__ ((unused)))
 343 {
 344     Tag *tag;
 345     Bool t;
 346
 347     for(tag =  globalconf.screens[screen].tags; tag; tag = tag->next)
 348     {
 349         t = tag->selected;
 350         tag_view(tag, tag->was_selected);
 351         tag->was_selected = t;
 352     }
 353 }
 354
 355 /** View next tag
 356  * \param screen Screen ID
 357  * \param arg unused
 358  * \ingroup ui_callback
 359  */
 360 void
 361 uicb_tag_viewnext(int screen, char *arg __attribute__ ((unused)))
 362 {
 363     Tag *tag, **curtags = get_current_tags(screen);
 364
 365     tag = tag_list_next_cycle(&globalconf.screens[screen].tags, curtags[0]);
 366
 367     tag_view(curtags[0], False);
 368     tag_view(tag, True);
 369
 370     p_delete(&curtags);
 371 }
 372
 373 /** View previous tag
 374  * \param screen Screen ID
 375  * \param arg unused
 376  * \ingroup ui_callback
 377  */
 378 void
 379 uicb_tag_viewprev(int screen, char *arg __attribute__ ((unused)))
 380 {
 381     Tag *tag, **curtags = get_current_tags(screen);
 382
 383     tag = tag_list_prev_cycle(&globalconf.screens[screen].tags, curtags[0]);
 384
 385     tag_view(curtags[0], False);
 386     tag_view(tag, True);
 387
 388     p_delete(&curtags);
 389 }
 390
 391 void
 392 uicb_tag_create(int screen, char *arg)
 393 {
 394     Tag *tag;
 395
 396     if(!a_strlen(arg))
 397         return;
 398
 399     tag = tag_new(arg, globalconf.screens[screen].layouts, 0.5, 1, 1);
 400     tag_append_to_screen(tag, screen);
 401 }
 402
 403 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80