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 "rules.h"
  28 #include "client.h"
  29 #include "ewmh.h"
  30 #include "widget.h"
  31 #include "common/util.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_byindex(int screen, int dindex, Bool view)
 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(tag, view);
 307 }
 308
 309 void
 310 tag_view_only_byindex(int screen, int dindex)
 311 {
 312     Tag *tag;
 313
 314     if(dindex < 0)
 315         return;
 316
 317     for(tag = globalconf.screens[screen].tags; tag && dindex > 0;
 318         tag = tag->next, dindex--);
 319     tag_view_only(tag);
 320 }
 321
 322 void
 323 tag_view(Tag *tag, Bool view)
 324 {
 325     tag->selected = view;
 326     ewmh_update_net_current_desktop(get_phys_screen(tag->screen));
 327     widget_invalidate_cache(tag->screen, WIDGET_CACHE_TAGS);
 328     saveawesomeprops(tag->screen);
 329     globalconf.screens[tag->screen].need_arrange = True;
 330 }
 331
 332 /** View tag
 333  * \param screen Screen ID
 334  * \param arg tag to view
 335  * \ingroup ui_callback
 336  */
 337 void
 338 uicb_tag_view(int screen, char *arg)
 339 {
 340     Tag *tag;
 341
 342     if(arg)
 343         tag_view_only_byindex(screen, atoi(arg) - 1);
 344     else
 345         for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 346             tag_view(tag, True);
 347 }
 348
 349 /** View previously selected tags
 350  * \param screen Screen ID
 351  * \param arg unused
 352  * \ingroup ui_callback
 353  */
 354 void
 355 uicb_tag_prev_selected(int screen, char *arg __attribute__ ((unused)))
 356 {
 357     Tag *tag;
 358     Bool t;
 359
 360     for(tag =  globalconf.screens[screen].tags; tag; tag = tag->next)
 361     {
 362         t = tag->selected;
 363         tag_view(tag, tag->was_selected);
 364         tag->was_selected = t;
 365     }
 366 }
 367
 368 /** View next tag
 369  * \param screen Screen ID
 370  * \param arg unused
 371  * \ingroup ui_callback
 372  */
 373 void
 374 uicb_tag_viewnext(int screen, char *arg __attribute__ ((unused)))
 375 {
 376     Tag *tag, **curtags = get_current_tags(screen);
 377
 378     tag = tag_list_next_cycle(&globalconf.screens[screen].tags, curtags[0]);
 379
 380     tag_view(curtags[0], False);
 381     tag_view(tag, True);
 382
 383     p_delete(&curtags);
 384 }
 385
 386 /** View previous tag
 387  * \param screen Screen ID
 388  * \param arg unused
 389  * \ingroup ui_callback
 390  */
 391 void
 392 uicb_tag_viewprev(int screen, char *arg __attribute__ ((unused)))
 393 {
 394     Tag *tag, **curtags = get_current_tags(screen);
 395
 396     tag = tag_list_prev_cycle(&globalconf.screens[screen].tags, curtags[0]);
 397
 398     tag_view(curtags[0], False);
 399     tag_view(tag, True);
 400
 401     p_delete(&curtags);
 402 }
 403
 404 void
 405 uicb_tag_create(int screen, char *arg)
 406 {
 407     Tag *tag;
 408
 409     if(!a_strlen(arg))
 410         return;
 411
 412     tag = tag_new(arg, globalconf.screens[screen].layouts, 0.5, 1, 1);
 413     tag_append_to_screen(tag, screen);
 414 }
 415
 416 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80