openbox/place.c

   1 #include "client.h"
   2 #include "group.h"
   3 #include "screen.h"
   4 #include "frame.h"
   5 #include "focus.h"
   6 #include "config.h"
   7
   8 static Rect* pick_head(ObClient *c)
   9 {
  10     /* try direct parent first */
  11     if (c->transient_for && c->transient_for != OB_TRAN_GROUP) {
  12         return screen_area_monitor(c->desktop,
  13                                    client_monitor(c->transient_for));
  14     }
  15
  16     /* more than one guy in his group (more than just him) */
  17     if (c->group && c->group->members->next) {
  18         GSList *it;
  19
  20         /* try on the client's desktop */
  21         for (it = c->group->members; it; it = g_slist_next(it)) {
  22             ObClient *itc = it->data;
  23             if (itc != c &&
  24                 (itc->desktop == c->desktop ||
  25                  itc->desktop == DESKTOP_ALL || c->desktop == DESKTOP_ALL))
  26                 return screen_area_monitor(c->desktop,
  27                                            client_monitor(it->data));
  28         }
  29
  30         /* try on all desktops */
  31         for (it = c->group->members; it; it = g_slist_next(it)) {
  32             ObClient *itc = it->data;
  33             if (itc != c)
  34                 return screen_area_monitor(c->desktop,
  35                                            client_monitor(it->data));
  36         }
  37     }
  38
  39     return NULL;
  40 }
  41
  42 static gboolean place_random(ObClient *client, gint *x, gint *y)
  43 {
  44     int l, r, t, b;
  45     Rect *area;
  46
  47     area = pick_head(client);
  48     if (!area)
  49         area = screen_area_monitor(client->desktop,
  50                                    g_random_int_range(0, screen_num_monitors));
  51
  52     l = area->x;
  53     t = area->y;
  54     r = area->x + area->width - client->frame->area.width;
  55     b = area->y + area->height - client->frame->area.height;
  56
  57     if (r > l) *x = g_random_int_range(l, r + 1);
  58     else       *x = 0;
  59     if (b > t) *y = g_random_int_range(t, b + 1);
  60     else       *y = 0;
  61
  62     return TRUE;
  63 }
  64
  65 static GSList* area_add(GSList *list, Rect *a)
  66 {
  67     Rect *r = g_new(Rect, 1);
  68     *r = *a;
  69     return g_slist_prepend(list, r);
  70 }
  71
  72 static GSList* area_remove(GSList *list, Rect *a)
  73 {
  74     GSList *sit;
  75     GSList *result = NULL;
  76
  77     for (sit = list; sit; sit = g_slist_next(sit)) {
  78         Rect *r = sit->data;
  79
  80         if (!RECT_INTERSECTS_RECT(*r, *a)) {
  81             result = g_slist_prepend(result, r);
  82             r = NULL; /* dont free it */
  83         } else {
  84             Rect isect, extra;
  85
  86             /* Use an intersection of a and r to determine the space
  87                around r that we can use.
  88
  89                NOTE: the spaces calculated can overlap.
  90             */
  91
  92             RECT_SET_INTERSECTION(isect, *r, *a);
  93
  94             if (RECT_LEFT(isect) > RECT_LEFT(*r)) {
  95                 RECT_SET(extra, r->x, r->y,
  96                          RECT_LEFT(isect) - r->x, r->height);
  97                 result = area_add(result, &extra);
  98             }
  99
 100             if (RECT_TOP(isect) > RECT_TOP(*r)) {
 101                 RECT_SET(extra, r->x, r->y,
 102                          r->width, RECT_TOP(isect) - r->y + 1);
 103                 result = area_add(result, &extra);
 104             }
 105
 106             if (RECT_RIGHT(isect) < RECT_RIGHT(*r)) {
 107                 RECT_SET(extra, RECT_RIGHT(isect) + 1, r->y,
 108                          RECT_RIGHT(*r) - RECT_RIGHT(isect), r->height);
 109                 result = area_add(result, &extra);
 110             }
 111
 112             if (RECT_BOTTOM(isect) < RECT_BOTTOM(*r)) {
 113                 RECT_SET(extra, r->x, RECT_BOTTOM(isect) + 1,
 114                          r->width, RECT_BOTTOM(*r) - RECT_BOTTOM(isect));
 115                 result = area_add(result, &extra);
 116             }
 117         }
 118
 119         g_free(r);
 120     }
 121     g_slist_free(list);
 122     return result;
 123 }
 124
 125 static gint area_cmp(gconstpointer p1, gconstpointer p2, gpointer data)
 126 {
 127     Rect *carea = data;
 128     const Rect *a1 = p1, *a2 = p2;
 129
 130     return MIN((a1->width - carea->width), (a1->height - carea->height)) -
 131         MIN((a2->width - carea->width), (a2->height - carea->height));
 132 }
 133
 134 static gboolean place_smart(ObClient *client, gint *x, gint *y,
 135                             gboolean only_focused)
 136 {
 137     guint i;
 138     gboolean ret = FALSE;
 139     GSList *spaces = NULL, *sit;
 140     GList *it, *list;
 141
 142     list = focus_order[client->desktop == DESKTOP_ALL ?
 143                        screen_desktop : client->desktop];
 144
 145     for (i = 0; i < screen_num_monitors; ++i)
 146         spaces = area_add(spaces, screen_area_monitor(client->desktop, i));
 147
 148     for (it = list; it; it = g_list_next(it)) {
 149         ObClient *c = it->data;
 150
 151         if (c != client && !c->shaded && client_normal(c)) {
 152             spaces = area_remove(spaces, &c->frame->area);
 153             if (only_focused)
 154                 break;
 155         }
 156     }
 157
 158     spaces = g_slist_sort_with_data(spaces, area_cmp, &client->frame->area);
 159
 160     for (sit = spaces; sit; sit = g_slist_next(sit)) {
 161         Rect *r = sit->data;
 162
 163         if (!ret) {
 164             if (r->width >= client->frame->area.width &&
 165                 r->height >= client->frame->area.height) {
 166                 ret = TRUE;
 167                 if (only_focused) {
 168                     *x = r->x + (r->width - client->frame->area.width) / 2;
 169                     *y = r->y + (r->height - client->frame->area.height) / 2;
 170                 } else {
 171                     *x = r->x;
 172                     *y = r->y;
 173                 }
 174             }
 175         }
 176
 177         g_free(r);
 178     }
 179     g_slist_free(spaces);
 180
 181     return ret;
 182 }
 183
 184 static gboolean place_under_mouse(ObClient *client, gint *x, gint *y)
 185 {
 186     guint i;
 187     gint l, r, t, b;
 188     gint px, py;
 189     Rect *area;
 190
 191     screen_pointer_pos(&px, &py);
 192
 193     for (i = 0; i < screen_num_monitors; ++i) {
 194         area = screen_area_monitor(client->desktop, i);
 195         if (RECT_CONTAINS(*area, px, py))
 196             break;
 197     }
 198     if (i == screen_num_monitors)
 199         area = screen_area_monitor(client->desktop, 0);
 200
 201     l = area->x;
 202     t = area->y;
 203     r = area->x + area->width - client->frame->area.width;
 204     b = area->y + area->height - client->frame->area.height;
 205
 206     *x = px - client->area.width / 2 - client->frame->size.left;
 207     *x = MIN(MAX(*x, l), r);
 208     *y = py - client->area.height / 2 - client->frame->size.top;
 209     *y = MIN(MAX(*y, t), b);
 210
 211     return TRUE;
 212 }
 213
 214 static gboolean place_transient(ObClient *client, gint *x, gint *y)
 215 {
 216     if (client->transient_for) {
 217         if (client->transient_for != OB_TRAN_GROUP) {
 218             ObClient *c = client;
 219             ObClient *p = client->transient_for;
 220             *x = (p->frame->area.width - c->frame->area.width) / 2 +
 221                 p->frame->area.x;
 222             *y = (p->frame->area.height - c->frame->area.height) / 2 +
 223                 p->frame->area.y;
 224             return TRUE;
 225         } else {
 226             GSList *it;
 227             gboolean first = TRUE;
 228             int l, r, t, b;
 229             for (it = client->group->members; it; it = it->next) {
 230                 ObClient *m = it->data;
 231                 if (!(m == client || m->transient_for)) {
 232                     if (first) {
 233                         l = RECT_LEFT(m->frame->area);
 234                         t = RECT_TOP(m->frame->area);
 235                         r = RECT_RIGHT(m->frame->area);
 236                         b = RECT_BOTTOM(m->frame->area);
 237                         first = FALSE;
 238                     } else {
 239                         l = MIN(l, RECT_LEFT(m->frame->area));
 240                         t = MIN(t, RECT_TOP(m->frame->area));
 241                         r = MAX(r, RECT_RIGHT(m->frame->area));
 242                         b = MAX(b, RECT_BOTTOM(m->frame->area));
 243                     }
 244                 }
 245             }
 246             if (!first) {
 247                 *x = ((r + 1 - l) - client->frame->area.width) / 2 + l;
 248                 *y = ((b + 1 - t) - client->frame->area.height) / 2 + t;
 249                 return TRUE;
 250             }
 251         }
 252     }
 253     return FALSE;
 254 }
 255
 256 static gboolean place_dialog(ObClient *client, gint *x, gint *y)
 257 {
 258     /* center parentless dialogs on the screen */
 259     if (client->type == OB_CLIENT_TYPE_DIALOG) {
 260         Rect *area;
 261
 262         area = pick_head(client);
 263         if (!area)
 264             area = screen_area_monitor(client->desktop, 0);
 265
 266         *x = (area->width - client->frame->area.width) / 2 + area->x;
 267         *y = (area->height - client->frame->area.height) / 2 + area->y;
 268         return TRUE;
 269     }
 270     return FALSE;
 271 }
 272
 273 void place_client(ObClient *client, gint *x, gint *y)
 274 {
 275     if (client->positioned)
 276         return;
 277     if (place_transient(client, x, y)    ||
 278         place_dialog(client, x, y)       ||
 279         place_smart(client, x, y, FALSE) ||
 280         place_smart(client, x, y, TRUE)  ||
 281         (config_focus_follow ?
 282          place_under_mouse(client, x, y) :
 283          place_random(client, x, y)))
 284     {
 285         /* get where the client should be */
 286         frame_frame_gravity(client->frame, x, y);
 287     } else
 288         g_assert_not_reached(); /* the last one better succeed */
 289 }