desktop.c

   1 /* * Copyright (c) 2012-2013 Bastien Dejean
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without modification,
   5  * are permitted provided that the following conditions are met:
   6  *
   7  *  * Redistributions of source code must retain the above copyright notice, this
   8  * list of conditions and the following disclaimer.
   9  *  * Redistributions in binary form must reproduce the above copyright notice,
  10  * this list of conditions and the following disclaimer in the documentation and/or
  11  * other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  16  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
  17  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include <stdlib.h>
  26 #include "bspwm.h"
  27 #include "ewmh.h"
  28 #include "history.h"
  29 #include "monitor.h"
  30 #include "query.h"
  31 #include "tree.h"
  32 #include "window.h"
  33 #include "desktop.h"
  34
  35 void focus_desktop(monitor_t *m, desktop_t *d)
  36 {
  37     focus_monitor(m);
  38
  39     if (d == mon->desk)
  40         return;
  41
  42     PRINTF("focus desktop %s\n", d->name);
  43
  44     show_desktop(d);
  45     hide_desktop(mon->desk);
  46
  47     mon->desk = d;
  48
  49     ewmh_update_current_desktop();
  50     put_status();
  51 }
  52
  53 desktop_t *closest_desktop(monitor_t *m, desktop_t *d, cycle_dir_t dir, desktop_select_t sel)
  54 {
  55     desktop_t *f = (dir == CYCLE_PREV ? d->prev : d->next);
  56     if (f == NULL)
  57         f = (dir == CYCLE_PREV ? m->desk_tail : m->desk_head);
  58
  59     while (f != d) {
  60         coordinates_t loc = {m, f, NULL};
  61         if (desktop_matches(&loc, &loc, sel))
  62             return f;
  63         f = (dir == CYCLE_PREV ? f->prev : f->next);
  64         if (f == NULL)
  65             f = (dir == CYCLE_PREV ? m->desk_tail : m->desk_head);
  66     }
  67
  68     return NULL;
  69 }
  70
  71 void change_layout(monitor_t *m, desktop_t *d, layout_t l)
  72 {
  73     d->layout = l;
  74     arrange(m, d);
  75     if (d == mon->desk)
  76         put_status();
  77 }
  78
  79 void transfer_desktop(monitor_t *ms, monitor_t *md, desktop_t *d)
  80 {
  81     if (ms == md)
  82         return;
  83
  84     desktop_t *dd = ms->desk;
  85     unlink_desktop(ms, d);
  86     insert_desktop(md, d);
  87
  88     if (d == dd) {
  89         if (ms->desk != NULL)
  90             show_desktop(ms->desk);
  91         if (md->desk != d)
  92             hide_desktop(d);
  93     }
  94
  95     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
  96         translate_client(ms, md, n->client);
  97
  98     arrange(md, d);
  99
 100     if (d != dd && md->desk == d)
 101         show_desktop(d);
 102
 103     history_transfer_desktop(md, d);
 104
 105     ewmh_update_wm_desktops();
 106     ewmh_update_desktop_names();
 107     ewmh_update_current_desktop();
 108     put_status();
 109 }
 110
 111 desktop_t *make_desktop(const char *name)
 112 {
 113     desktop_t *d = malloc(sizeof(desktop_t));
 114     if (name == NULL)
 115         snprintf(d->name, sizeof(d->name), "%s%d", DEFAULT_DESK_NAME, ++desktop_uid);
 116     else
 117         snprintf(d->name, sizeof(d->name), "%s", name);
 118     d->layout = LAYOUT_TILED;
 119     d->prev = d->next = NULL;
 120     d->root = d->focus = NULL;
 121     d->top_padding = d->right_padding = d->bottom_padding = d->left_padding = 0;
 122     d->window_gap = WINDOW_GAP;
 123     d->border_width = BORDER_WIDTH;
 124     d->floating = false;
 125     return d;
 126 }
 127
 128 void insert_desktop(monitor_t *m, desktop_t *d)
 129 {
 130     if (m->desk == NULL) {
 131         m->desk = d;
 132         m->desk_head = d;
 133         m->desk_tail = d;
 134     } else {
 135         m->desk_tail->next = d;
 136         d->prev = m->desk_tail;
 137         m->desk_tail = d;
 138     }
 139 }
 140
 141 void add_desktop(monitor_t *m, desktop_t *d)
 142 {
 143     PRINTF("add desktop %s\n", d->name);
 144
 145     insert_desktop(m, d);
 146     num_desktops++;
 147     ewmh_update_number_of_desktops();
 148     ewmh_update_desktop_names();
 149     put_status();
 150 }
 151
 152 void empty_desktop(desktop_t *d)
 153 {
 154     destroy_tree(d->root);
 155     d->root = d->focus = NULL;
 156 }
 157
 158 void unlink_desktop(monitor_t *m, desktop_t *d)
 159 {
 160     desktop_t *prev = d->prev;
 161     desktop_t *next = d->next;
 162     desktop_t *last_desk = history_get_desktop(m, d);
 163     if (prev != NULL)
 164         prev->next = next;
 165     if (next != NULL)
 166         next->prev = prev;
 167     if (m->desk_head == d)
 168         m->desk_head = next;
 169     if (m->desk_tail == d)
 170         m->desk_tail = prev;
 171     if (m->desk == d)
 172         m->desk = (last_desk == NULL ? (prev == NULL ? next : prev) : last_desk);
 173     d->prev = d->next = NULL;
 174 }
 175
 176 void remove_desktop(monitor_t *m, desktop_t *d)
 177 {
 178     PRINTF("remove desktop %s\n", d->name);
 179
 180     unlink_desktop(m, d);
 181     history_remove(d, NULL);
 182     empty_desktop(d);
 183     free(d);
 184     num_desktops--;
 185     ewmh_update_number_of_desktops();
 186     ewmh_update_desktop_names();
 187     put_status();
 188 }
 189
 190 void merge_desktops(monitor_t *ms, desktop_t *ds, monitor_t *md, desktop_t *dd)
 191 {
 192     if (ds == NULL || dd == NULL || ds == dd)
 193         return;
 194     node_t *n = first_extrema(ds->root);
 195     while (n != NULL) {
 196         node_t *next = next_leaf(n, ds->root);
 197         transfer_node(ms, ds, n, md, dd, dd->focus);
 198         n = next;
 199     }
 200 }
 201
 202 void swap_desktops(monitor_t *m1, desktop_t *d1, monitor_t *m2, desktop_t *d2)
 203 {
 204     if (d1 == NULL || d2 == NULL || d1 == d2)
 205         return;
 206
 207     PRINTF("swap desktops %s %s\n", d1->name, d2->name);
 208
 209     bool d1_focused = (m1->desk == d1);
 210     bool d2_focused = (m2->desk == d2);
 211
 212     if (m1 != m2) {
 213         if (m1->desk == d1)
 214             m1->desk = d2;
 215         if (m1->desk_head == d1)
 216             m1->desk_head = d2;
 217         if (m1->desk_tail == d1)
 218             m1->desk_tail = d2;
 219         if (m2->desk == d2)
 220             m2->desk = d1;
 221         if (m2->desk_head == d2)
 222             m2->desk_head = d1;
 223         if (m2->desk_tail == d2)
 224             m2->desk_tail = d1;
 225     } else {
 226         if (m1->desk_head == d1)
 227             m1->desk_head = d2;
 228         else if (m1->desk_head == d2)
 229             m1->desk_head = d1;
 230         if (m1->desk_tail == d1)
 231             m1->desk_tail = d2;
 232         else if (m1->desk_tail == d2)
 233             m1->desk_tail = d1;
 234     }
 235
 236     desktop_t *p1 = d1->prev;
 237     desktop_t *n1 = d1->next;
 238     desktop_t *p2 = d2->prev;
 239     desktop_t *n2 = d2->next;
 240
 241     if (p1 != NULL && p1 != d2)
 242         p1->next = d2;
 243     if (n1 != NULL && n1 != d2)
 244         n1->prev = d2;
 245     if (p2 != NULL && p2 != d1)
 246         p2->next = d1;
 247     if (n2 != NULL && n2 != d1)
 248         n2->prev = d1;
 249
 250     d1->prev = p2 == d1 ? d2 : p2;
 251     d1->next = n2 == d1 ? d2 : n2;
 252     d2->prev = p1 == d2 ? d1 : p1;
 253     d2->next = n1 == d2 ? d1 : n1;
 254
 255     if (m1 != m2) {
 256         for (node_t *n = first_extrema(d1->root); n != NULL; n = next_leaf(n, d1->root))
 257             translate_client(m1, m2, n->client);
 258         for (node_t *n = first_extrema(d2->root); n != NULL; n = next_leaf(n, d2->root))
 259             translate_client(m2, m1, n->client);
 260         history_swap_desktops(m1, d1, m2, d2);
 261         arrange(m1, d2);
 262         arrange(m2, d1);
 263         if (d1_focused && !d2_focused) {
 264             hide_desktop(d1);
 265             show_desktop(d2);
 266         } else if (!d1_focused && d2_focused) {
 267             show_desktop(d1);
 268             hide_desktop(d2);
 269         }
 270     }
 271
 272     update_input_focus();
 273     ewmh_update_wm_desktops();
 274     ewmh_update_desktop_names();
 275     ewmh_update_current_desktop();
 276     put_status();
 277 }
 278
 279 void show_desktop(desktop_t *d)
 280 {
 281     if (!visible)
 282         return;
 283     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
 284         window_show(n->client->window);
 285 }
 286
 287 void hide_desktop(desktop_t *d)
 288 {
 289     if (!visible)
 290         return;
 291     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
 292         window_hide(n->client->window);
 293 }
 294
 295 bool is_urgent(desktop_t *d)
 296 {
 297     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
 298         if (n->client->urgent)
 299             return true;
 300     return false;
 301 }