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