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