smart placement only avoids the focused window, and centers in its area
[dana/openbox.git] / 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)
126 {
127     gint ret;
128     const Rect *a1 = p1, *a2 = p2;
129
130     ret = RECT_TOP(*a1) - RECT_TOP(*a2);
131     if (!ret)
132         ret = RECT_LEFT(*a1) - RECT_LEFT(*a2);
133     return ret;
134 }
135
136 static gboolean place_smart(ObClient *client, gint *x, gint *y)
137 {
138     guint i;
139     gboolean ret = FALSE;
140     GSList *spaces = NULL, *sit;
141     GList *it, *list;
142
143     list = focus_order[client->desktop == DESKTOP_ALL ?
144                        screen_desktop : client->desktop];
145
146     for (i = 0; i < screen_num_monitors; ++i)
147         spaces = area_add(spaces, screen_area_monitor(client->desktop, i));
148
149     for (it = list; it; it = g_list_next(it)) {
150         ObClient *c = it->data;
151
152         if (c != client && !c->shaded && client_normal(c)) {
153             spaces = area_remove(spaces, &c->frame->area);
154             break;
155         }
156     }
157
158     spaces = g_slist_sort(spaces, area_cmp);
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                 *x = r->x + (r->width - client->frame->area.width) / 2;
168                 *y = r->y + (r->height - client->frame->area.height) / 2;
169             }
170         }
171
172         g_free(r);
173     }
174     g_slist_free(spaces);
175
176     return ret;
177 }
178
179 static gboolean place_under_mouse(ObClient *client, gint *x, gint *y)
180 {
181     guint i;
182     gint l, r, t, b;
183     gint px, py;
184     Rect *area;
185
186     screen_pointer_pos(&px, &py);
187
188     for (i = 0; i < screen_num_monitors; ++i) {
189         area = screen_area_monitor(client->desktop, i);
190         if (RECT_CONTAINS(*area, px, py))
191             break;
192     }
193     if (i == screen_num_monitors)
194         area = screen_area_monitor(client->desktop, 0);
195
196     l = area->x;
197     t = area->y;
198     r = area->x + area->width - client->frame->area.width;
199     b = area->y + area->height - client->frame->area.height;
200
201     *x = px - client->area.width / 2 - client->frame->size.left;
202     *x = MIN(MAX(*x, l), r);
203     *y = py - client->area.height / 2 - client->frame->size.top;
204     *y = MIN(MAX(*y, t), b);
205
206     return TRUE;
207 }
208
209 static gboolean place_transient(ObClient *client, gint *x, gint *y)
210 {
211     if (client->transient_for) {
212         if (client->transient_for != OB_TRAN_GROUP) {
213             ObClient *c = client;
214             ObClient *p = client->transient_for;
215             *x = (p->frame->area.width - c->frame->area.width) / 2 +
216                 p->frame->area.x;
217             *y = (p->frame->area.height - c->frame->area.height) / 2 +
218                 p->frame->area.y;
219             return TRUE;
220         } else {
221             GSList *it;
222             gboolean first = TRUE;
223             int l, r, t, b;
224             for (it = client->group->members; it; it = it->next) {
225                 ObClient *m = it->data;
226                 if (!(m == client || m->transient_for)) {
227                     if (first) {
228                         l = RECT_LEFT(m->frame->area);
229                         t = RECT_TOP(m->frame->area);
230                         r = RECT_RIGHT(m->frame->area);
231                         b = RECT_BOTTOM(m->frame->area);
232                         first = FALSE;
233                     } else {
234                         l = MIN(l, RECT_LEFT(m->frame->area));
235                         t = MIN(t, RECT_TOP(m->frame->area));
236                         r = MAX(r, RECT_RIGHT(m->frame->area));
237                         b = MAX(b, RECT_BOTTOM(m->frame->area));
238                     }
239                 }
240             }
241             if (!first) {
242                 *x = ((r + 1 - l) - client->frame->area.width) / 2 + l; 
243                 *y = ((b + 1 - t) - client->frame->area.height) / 2 + t;
244                 return TRUE;
245             }
246         }
247     }
248     return FALSE;
249 }
250
251 static gboolean place_dialog(ObClient *client, gint *x, gint *y)
252 {
253     /* center parentless dialogs on the screen */
254     if (client->type == OB_CLIENT_TYPE_DIALOG) {
255         Rect *area;
256
257         area = pick_head(client);
258         if (!area)
259             area = screen_area_monitor(client->desktop, 0);
260
261         *x = (area->width - client->frame->area.width) / 2 + area->x;
262         *y = (area->height - client->frame->area.height) / 2 + area->y;
263         return TRUE;
264     }
265     return FALSE;
266 }
267
268 void place_client(ObClient *client, gint *x, gint *y)
269 {
270     if (client->positioned)
271         return;
272     if (place_transient(client, x, y) ||
273         place_dialog(client, x, y)    ||
274         place_smart(client, x, y)     ||
275         (config_focus_follow ?
276          place_under_mouse(client, x, y) :
277          place_random(client, x, y)))
278     {
279         /* get where the client should be */
280         frame_frame_gravity(client->frame, x, y);
281     } else
282         g_assert_not_reached(); /* the last one better succeed */
283 }