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 }
 297
 298 void
 299 tag_view(int screen, int dindex)
 300 {
 301     Tag *target_tag, *tag;
 302
 303     if(dindex < 0)
 304         return;
 305
 306     for(target_tag = globalconf.screens[screen].tags; target_tag && dindex > 0;
 307         target_tag = target_tag->next, dindex--);
 308     if(target_tag)
 309     {
 310         for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 311             tag->selected = False;
 312         target_tag->selected = True;
 313     }
 314     saveawesomeprops(screen);
 315     arrange(screen);
 316     ewmh_update_net_current_desktop(get_phys_screen(screen));
 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(screen, atoi(arg) - 1);
 331     else
 332     {
 333         for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 334             tag->selected = True;
 335         saveawesomeprops(screen);
 336         arrange(screen);
 337         ewmh_update_net_current_desktop(get_phys_screen(screen));
 338     }
 339 }
 340
 341 /** View previously selected tags
 342  * \param screen Screen ID
 343  * \param arg unused
 344  * \ingroup ui_callback
 345  */
 346 void
 347 uicb_tag_prev_selected(int screen, char *arg __attribute__ ((unused)))
 348 {
 349     Tag *tag;
 350     Bool t;
 351
 352     for(tag =  globalconf.screens[screen].tags; tag; tag = tag->next)
 353     {
 354         t = tag->selected;
 355         tag->selected = tag->was_selected;
 356         tag->was_selected = t;
 357     }
 358     arrange(screen);
 359     ewmh_update_net_current_desktop(get_phys_screen(screen));
 360 }
 361
 362 /** View next tag
 363  * \param screen Screen ID
 364  * \param arg unused
 365  * \ingroup ui_callback
 366  */
 367 void
 368 uicb_tag_viewnext(int screen, char *arg __attribute__ ((unused)))
 369 {
 370     Tag **curtags = get_current_tags(screen);
 371
 372     if(!curtags[0]->next)
 373         return;
 374
 375     curtags[0]->selected = False;
 376     curtags[0]->next->selected = True;
 377
 378     p_delete(&curtags);
 379
 380     saveawesomeprops(screen);
 381     arrange(screen);
 382     ewmh_update_net_current_desktop(get_phys_screen(screen));
 383 }
 384
 385 /** View previous tag
 386  * \param screen Screen ID
 387  * \param arg unused
 388  * \ingroup ui_callback
 389  */
 390 void
 391 uicb_tag_viewprev(int screen, char *arg __attribute__ ((unused)))
 392 {
 393     Tag *tag, **curtags = get_current_tags(screen);
 394
 395     for(tag = globalconf.screens[screen].tags; tag && tag->next != curtags[0]; tag = tag->next);
 396     if(tag)
 397     {
 398         tag->selected = True;
 399         curtags[0]->selected = False;
 400         saveawesomeprops(screen);
 401         arrange(screen);
 402     }
 403     p_delete(&curtags);
 404     ewmh_update_net_current_desktop(get_phys_screen(screen));
 405 }
 406
 407 void
 408 uicb_tag_create(int screen, char *arg)
 409 {
 410     Tag *last_tag, *tag;
 411
 412     if(!a_strlen(arg))
 413         return;
 414
 415     for(last_tag = globalconf.screens[screen].tags; last_tag && last_tag->next; last_tag = last_tag->next);
 416     last_tag->next = tag = p_new(Tag, 1);
 417     tag->name = a_strdup(arg);
 418     tag->layout = globalconf.screens[screen].layouts;
 419     tag->mwfact = 0.5;
 420     tag->nmaster = 1;
 421     tag->ncol = 1;
 422 }
 423
 424 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80