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