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 focus_desktop(monitor_t *m, desktop_t *d)
  12 {
  13     focus_monitor(m);
  14
  15     if (d == mon->desk)
  16         return;
  17
  18     PRINTF("focus 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     d->tags_field = 1;
  99     return d;
 100 }
 101
 102 void insert_desktop(monitor_t *m, desktop_t *d)
 103 {
 104     if (m->desk == NULL) {
 105         m->desk = d;
 106         m->desk_head = d;
 107         m->desk_tail = d;
 108     } else {
 109         m->desk_tail->next = d;
 110         d->prev = m->desk_tail;
 111         m->desk_tail = d;
 112     }
 113 }
 114
 115 void add_desktop(monitor_t *m, desktop_t *d)
 116 {
 117     PRINTF("add desktop %s\n", d->name);
 118
 119     insert_desktop(m, d);
 120     num_desktops++;
 121     ewmh_update_number_of_desktops();
 122     ewmh_update_desktop_names();
 123     put_status();
 124 }
 125
 126 void empty_desktop(desktop_t *d)
 127 {
 128     destroy_tree(d->root);
 129     d->root = d->focus = NULL;
 130 }
 131
 132 void unlink_desktop(monitor_t *m, desktop_t *d)
 133 {
 134     desktop_t *prev = d->prev;
 135     desktop_t *next = d->next;
 136     desktop_t *last_desk = history_get_desktop(m, d);
 137     if (prev != NULL)
 138         prev->next = next;
 139     if (next != NULL)
 140         next->prev = prev;
 141     if (m->desk_head == d)
 142         m->desk_head = next;
 143     if (m->desk_tail == d)
 144         m->desk_tail = prev;
 145     if (m->desk == d)
 146         m->desk = (last_desk == NULL ? (prev == NULL ? next : prev) : last_desk);
 147     d->prev = d->next = NULL;
 148 }
 149
 150 void remove_desktop(monitor_t *m, desktop_t *d)
 151 {
 152     PRINTF("remove desktop %s\n", d->name);
 153
 154     unlink_desktop(m, d);
 155     history_remove(d, NULL);
 156     empty_desktop(d);
 157     free(d);
 158     num_desktops--;
 159     ewmh_update_number_of_desktops();
 160     ewmh_update_desktop_names();
 161     put_status();
 162 }
 163
 164 void merge_desktops(monitor_t *ms, desktop_t *ds, monitor_t *md, desktop_t *dd)
 165 {
 166     if (ds == NULL || dd == NULL || ds == dd)
 167         return;
 168     node_t *n = first_extrema(ds->root);
 169     while (n != NULL) {
 170         node_t *next = next_leaf(n, ds->root);
 171         transfer_node(ms, ds, n, md, dd, dd->focus);
 172         n = next;
 173     }
 174 }
 175
 176 void swap_desktops(monitor_t *m1, desktop_t *d1, monitor_t *m2, desktop_t *d2)
 177 {
 178     if (d1 == NULL || d2 == NULL || d1 == d2)
 179         return;
 180
 181     PRINTF("swap desktops %s %s\n", d1->name, d2->name);
 182
 183     bool d1_focused = (m1->desk == d1);
 184     bool d2_focused = (m2->desk == d2);
 185
 186     if (m1 != m2) {
 187         if (m1->desk == d1)
 188             m1->desk = d2;
 189         if (m1->desk_head == d1)
 190             m1->desk_head = d2;
 191         if (m1->desk_tail == d1)
 192             m1->desk_tail = d2;
 193         if (m2->desk == d2)
 194             m2->desk = d1;
 195         if (m2->desk_head == d2)
 196             m2->desk_head = d1;
 197         if (m2->desk_tail == d2)
 198             m2->desk_tail = d1;
 199     } else {
 200         if (m1->desk_head == d1)
 201             m1->desk_head = d2;
 202         else if (m1->desk_head == d2)
 203             m1->desk_head = d1;
 204         if (m1->desk_tail == d1)
 205             m1->desk_tail = d2;
 206         else if (m1->desk_tail == d2)
 207             m1->desk_tail = d1;
 208     }
 209
 210     desktop_t *p1 = d1->prev;
 211     desktop_t *n1 = d1->next;
 212     desktop_t *p2 = d2->prev;
 213     desktop_t *n2 = d2->next;
 214
 215     if (p1 != NULL && p1 != d2)
 216         p1->next = d2;
 217     if (n1 != NULL && n1 != d2)
 218         n1->prev = d2;
 219     if (p2 != NULL && p2 != d1)
 220         p2->next = d1;
 221     if (n2 != NULL && n2 != d1)
 222         n2->prev = d1;
 223
 224     d1->prev = p2 == d1 ? d2 : p2;
 225     d1->next = n2 == d1 ? d2 : n2;
 226     d2->prev = p1 == d2 ? d1 : p1;
 227     d2->next = n1 == d2 ? d1 : n1;
 228
 229     if (m1 != m2) {
 230         for (node_t *n = first_extrema(d1->root); n != NULL; n = next_leaf(n, d1->root))
 231             fit_monitor(m2, n->client);
 232         for (node_t *n = first_extrema(d2->root); n != NULL; n = next_leaf(n, d2->root))
 233             fit_monitor(m1, n->client);
 234         history_swap_desktops(m1, d1, m2, d2);
 235         arrange(m1, d2);
 236         arrange(m2, d1);
 237         if (d1_focused && !d2_focused) {
 238             hide_desktop(d1);
 239             show_desktop(d2);
 240         } else if (!d1_focused && d2_focused) {
 241             show_desktop(d1);
 242             hide_desktop(d2);
 243         }
 244     }
 245
 246     update_input_focus();
 247     ewmh_update_wm_desktops();
 248     ewmh_update_desktop_names();
 249     ewmh_update_current_desktop();
 250     put_status();
 251 }
 252
 253 void show_desktop(desktop_t *d)
 254 {
 255     if (!visible)
 256         return;
 257     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
 258         if (is_visible(d, n))
 259             window_show(n->client->window);
 260 }
 261
 262 void hide_desktop(desktop_t *d)
 263 {
 264     if (!visible)
 265         return;
 266     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
 267         if (is_visible(d, n))
 268             window_hide(n->client->window);
 269 }
 270
 271 bool is_urgent(desktop_t *d)
 272 {
 273     for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root))
 274         if (n->client->urgent)
 275             return true;
 276     return false;
 277 }