stack.c

   1 /* Copyright (c) 2012, Bastien Dejean
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  * 1. Redistributions of source code must retain the above copyright notice, this
   8  *    list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright notice,
  10  *    this list of conditions and the following disclaimer in the documentation
  11  *    and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  16  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 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
  20  * ON 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 "window.h"
  28 #include "stack.h"
  29
  30 stacking_list_t *make_stack(node_t *n)
  31 {
  32         stacking_list_t *s = malloc(sizeof(stacking_list_t));
  33         s->node = n;
  34         s->prev = s->next = NULL;
  35         return s;
  36 }
  37
  38 void stack_insert_after(stacking_list_t *a, node_t *n)
  39 {
  40         stacking_list_t *s = make_stack(n);
  41         if (a == NULL) {
  42                 stack_head = stack_tail = s;
  43         } else {
  44                 if (a->node == n)
  45                         return;
  46                 remove_stack_node(n);
  47                 stacking_list_t *b = a->next;
  48                 if (b != NULL)
  49                         b->prev = s;
  50                 s->next = b;
  51                 s->prev = a;
  52                 a->next = s;
  53                 if (stack_tail == a)
  54                         stack_tail = s;
  55         }
  56 }
  57
  58 void stack_insert_before(stacking_list_t *a, node_t *n)
  59 {
  60         stacking_list_t *s = make_stack(n);
  61         if (a == NULL) {
  62                 stack_head = stack_tail = s;
  63         } else {
  64                 if (a->node == n)
  65                         return;
  66                 remove_stack_node(n);
  67                 stacking_list_t *b = a->prev;
  68                 if (b != NULL)
  69                         b->next = s;
  70                 s->prev = b;
  71                 s->next = a;
  72                 a->prev = s;
  73                 if (stack_head == a)
  74                         stack_head = s;
  75         }
  76 }
  77
  78 void remove_stack(stacking_list_t *s)
  79 {
  80         if (s == NULL)
  81                 return;
  82         stacking_list_t *a = s->prev;
  83         stacking_list_t *b = s->next;
  84         if (a != NULL)
  85                 a->next = b;
  86         if (b != NULL)
  87                 b->prev = a;
  88         if (s == stack_head)
  89                 stack_head = b;
  90         if (s == stack_tail)
  91                 stack_tail = a;
  92         free(s);
  93 }
  94
  95 void remove_stack_node(node_t *n)
  96 {
  97         for (stacking_list_t *s = stack_head; s != NULL; s = s->next) {
  98                 if (s->node == n) {
  99                         remove_stack(s);
 100                         return;
 101                 }
 102         }
 103 }
 104
 105 int stack_level(client_t *c)
 106 {
 107         int layer_level = (c->layer == LAYER_NORMAL ? 1 : (c->layer == LAYER_BELOW ? 0 : 2));
 108         int state_level = (IS_TILED(c) ? 0 : (IS_FLOATING(c) ? 2 : 1));
 109         return 3 * layer_level + state_level;
 110 }
 111
 112 int stack_cmp(client_t *c1, client_t *c2)
 113 {
 114         return stack_level(c1) - stack_level(c2);
 115 }
 116
 117 stacking_list_t *limit_above(node_t *n)
 118 {
 119         stacking_list_t *s = stack_head;
 120         while (s != NULL && stack_cmp(n->client, s->node->client) >= 0) {
 121                 s = s->next;
 122         }
 123         if (s == NULL) {
 124                 s = stack_tail;
 125         }
 126         if (s->node == n) {
 127                 s = s->prev;
 128         }
 129         return s;
 130 }
 131
 132 stacking_list_t *limit_below(node_t *n)
 133 {
 134         stacking_list_t *s = stack_tail;
 135         while (s != NULL && stack_cmp(n->client, s->node->client) <= 0) {
 136                 s = s->prev;
 137         }
 138         if (s == NULL) {
 139                 s = stack_head;
 140         }
 141         if (s->node == n) {
 142                 s = s->next;
 143         }
 144         return s;
 145 }
 146
 147 void stack(node_t *n, bool focused)
 148 {
 149         if (IS_FLOATING(n->client) && !auto_raise) {
 150                 return;
 151         }
 152
 153         PRINTF("stack %X\n", n->client->window);
 154
 155         if (stack_head == NULL) {
 156                 stack_insert_after(NULL, n);
 157         } else {
 158                 stacking_list_t *s = (focused ? limit_above(n) : limit_below(n));
 159                 if (s == NULL) {
 160                         return;
 161                 }
 162                 int i = stack_cmp(n->client, s->node->client);
 163                 if (i < 0 || (i == 0 && !focused)) {
 164                         stack_insert_before(s, n);
 165                         window_below(n->client->window, s->node->client->window);
 166                 } else {
 167                         stack_insert_after(s, n);
 168                         window_above(n->client->window, s->node->client->window);
 169                 }
 170         }
 171 }