desktop.c

   1 #include <stdlib.h>
   2 #include "bspwm.h"
   3 #include "ewmh.h"
   4 #include "history.h"
   5 #include "monitor.h"
   6 #include "query.h"
   7 #include "tree.h"
   8 #include "window.h"
   9 #include "desktop.h"
  10
  11 void select_desktop(monitor_t *m, desktop_t *d)
  12 {
  13     select_monitor(m);
  14
  15     if (d == mon->desk)
  16         return;
  17
  18     PRINTF("select desktop %s\n", d->name);
  19
  20     show_desktop(d);
  21     hide_desktop(mon->desk);
  22
  23     mon->desk = d;
  24
  25     ewmh_update_current_desktop();
  26     put_status();
  27 }
  28
  29 desktop_t *closest_desktop(monitor_t *m, desktop_t *d, cycle_dir_t dir, desktop_select_t sel)
  30 {
  31     desktop_t *f = (dir == CYCLE_PREV ? d->prev : d->next);
  32     if (f == NULL)
  33         f = (dir == CYCLE_PREV ? m->desk_tail : m->desk_head);
  34
  35     while (f != d) {
  36         if (desktop_matches(f, sel))
  37             return f;
  38         f = (dir == CYCLE_PREV ? f->prev : f->next);
  39         if (f == NULL)
  40             f = (dir == CYCLE_PREV ? m->desk_tail : m->desk_head);
  41     }
  42
  43     return NULL;
  44 }
  45
  46 void change_layout(monitor_t *m, desktop_t *d, layout_t l)
  47 {
  48     d->layout = l;
  49     arrange(m, d);
  50     if (d == mon->desk)
  51         put_status();
  52 }
  53
  54 void transfer_desktop(monitor_t *ms, monitor_t *md, desktop_t *d)
  55 {
  56     if (ms == md)
  57         return;
  58
  59     desktop_t *dd = ms->desk;
  60     unlink_desktop(ms, d);
  61     insert_desktop(md, d);
  62
  63     if (d == dd) {
  64         if (ms->desk != NULL)
  65             show_desktop(ms->desk);
  66         if (md->desk != d)
  67             hide_desktop(d);
  68     }
  69
  70     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
  71         fit_monitor(md, n->client);
  72
  73     arrange(md, d);
  74
  75     if (d != dd && md->desk == d)
  76         show_desktop(d);
  77
  78     history_transfer_desktop(md, d);
  79
  80     ewmh_update_wm_desktops();
  81     ewmh_update_desktop_names();
  82     ewmh_update_current_desktop();
  83     put_status();
  84 }
  85
  86 desktop_t *make_desktop(const char *name)
  87 {
  88     desktop_t *d = malloc(sizeof(desktop_t));
  89     if (name == NULL)
  90         snprintf(d->name, sizeof(d->name), "%s%d", DEFAULT_DESK_NAME, ++desktop_uid);
  91     else
  92         snprintf(d->name, sizeof(d->name), "%s", name);
  93     d->layout = LAYOUT_TILED;
  94     d->prev = d->next = NULL;
  95     d->root = d->focus = NULL;
  96     d->window_gap = WINDOW_GAP;
  97     d->border_width = BORDER_WIDTH;
  98     return d;
  99 }
 100
 101 void insert_desktop(monitor_t *m, desktop_t *d)
 102 {
 103     if (m->desk == NULL) {
 104         m->desk = d;
 105         m->desk_head = d;
 106         m->desk_tail = d;
 107     } else {
 108         m->desk_tail->next = d;
 109         d->prev = m->desk_tail;
 110         m->desk_tail = d;
 111     }
 112 }
 113
 114 void add_desktop(monitor_t *m, desktop_t *d)
 115 {
 116     PRINTF("add desktop %s\n", d->name);
 117
 118     insert_desktop(m, d);
 119     num_desktops++;
 120     ewmh_update_number_of_desktops();
 121     ewmh_update_desktop_names();
 122     put_status();
 123 }
 124
 125 void empty_desktop(desktop_t *d)
 126 {
 127     destroy_tree(d->root);
 128     d->root = d->focus = NULL;
 129 }
 130
 131 void unlink_desktop(monitor_t *m, desktop_t *d)
 132 {
 133     desktop_t *prev = d->prev;
 134     desktop_t *next = d->next;
 135     desktop_t *last_desk = history_get_desktop(m, d);
 136     if (prev != NULL)
 137         prev->next = next;
 138     if (next != NULL)
 139         next->prev = prev;
 140     if (m->desk_head == d)
 141         m->desk_head = next;
 142     if (m->desk_tail == d)
 143         m->desk_tail = prev;
 144     if (m->desk == d)
 145         m->desk = (last_desk == NULL ? (prev == NULL ? next : prev) : last_desk);
 146     d->prev = d->next = NULL;
 147 }
 148
 149 void remove_desktop(monitor_t *m, desktop_t *d)
 150 {
 151     PRINTF("remove desktop %s\n", d->name);
 152
 153     unlink_desktop(m, d);
 154     history_remove(d, NULL);
 155     empty_desktop(d);
 156     free(d);
 157     num_desktops--;
 158     ewmh_update_number_of_desktops();
 159     ewmh_update_desktop_names();
 160     put_status();
 161 }
 162
 163 void swap_desktops(monitor_t *m1, desktop_t *d1, monitor_t *m2, desktop_t *d2)
 164 {
 165     if (d1 == NULL || d2 == NULL || d1 == d2)
 166         return;
 167
 168     PRINTF("swap desktops %s %s\n", d1->name, d2->name);
 169
 170     bool d1_focused = (m1->desk == d1);
 171     bool d2_focused = (m2->desk == d2);
 172
 173     if (m1 != m2) {
 174         if (m1->desk == d1)
 175             m1->desk = d2;
 176         if (m1->desk_head == d1)
 177             m1->desk_head = d2;
 178         if (m1->desk_tail == d1)
 179             m1->desk_tail = d2;
 180         if (m2->desk == d2)
 181             m2->desk = d1;
 182         if (m2->desk_head == d2)
 183             m2->desk_head = d1;
 184         if (m2->desk_tail == d2)
 185             m2->desk_tail = d1;
 186     } else {
 187         if (m1->desk_head == d1)
 188             m1->desk_head = d2;
 189         else if (m1->desk_head == d2)
 190             m1->desk_head = d1;
 191         if (m1->desk_tail == d1)
 192             m1->desk_tail = d2;
 193         else if (m1->desk_tail == d2)
 194             m1->desk_tail = d1;
 195     }
 196
 197     desktop_t *p1 = d1->prev;
 198     desktop_t *n1 = d1->next;
 199     desktop_t *p2 = d2->prev;
 200     desktop_t *n2 = d2->next;
 201
 202     if (p1 != NULL && p1 != d2)
 203         p1->next = d2;
 204     if (n1 != NULL && n1 != d2)
 205         n1->prev = d2;
 206     if (p2 != NULL && p2 != d1)
 207         p2->next = d1;
 208     if (n2 != NULL && n2 != d1)
 209         n2->prev = d1;
 210
 211     d1->prev = p2 == d1 ? d2 : p2;
 212     d1->next = n2 == d1 ? d2 : n2;
 213     d2->prev = p1 == d2 ? d1 : p1;
 214     d2->next = n1 == d2 ? d1 : n1;
 215
 216     if (m1 != m2) {
 217         for (node_t *n = first_extrema(d1->root); n != NULL; n = next_leaf(n, d1->root))
 218             fit_monitor(m2, n->client);
 219         for (node_t *n = first_extrema(d2->root); n != NULL; n = next_leaf(n, d2->root))
 220             fit_monitor(m1, n->client);
 221         history_swap_desktops(m1, d1, m2, d2);
 222         arrange(m1, d2);
 223         arrange(m2, d1);
 224         if (d1_focused && !d2_focused) {
 225             hide_desktop(d1);
 226             show_desktop(d2);
 227         } else if (!d1_focused && d2_focused) {
 228             show_desktop(d1);
 229             hide_desktop(d2);
 230         }
 231     }
 232
 233     update_input_focus();
 234     ewmh_update_wm_desktops();
 235     ewmh_update_desktop_names();
 236     ewmh_update_current_desktop();
 237     put_status();
 238 }
 239
 240 void show_desktop(desktop_t *d)
 241 {
 242     if (!visible)
 243         return;
 244     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
 245         window_show(n->client->window);
 246 }
 247
 248 void hide_desktop(desktop_t *d)
 249 {
 250     if (!visible)
 251         return;
 252     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
 253         window_hide(n->client->window);
 254 }
 255
 256 bool is_urgent(desktop_t *d)
 257 {
 258     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
 259         if (n->client->urgent)
 260             return true;
 261     return false;
 262 }