diff options
Diffstat (limited to 'sway/layout.c')
-rw-r--r-- | sway/layout.c | 1770 |
1 files changed, 0 insertions, 1770 deletions
diff --git a/sway/layout.c b/sway/layout.c deleted file mode 100644 index 69291daf..00000000 --- a/sway/layout.c +++ /dev/null | |||
@@ -1,1770 +0,0 @@ | |||
1 | #define _XOPEN_SOURCE 500 | ||
2 | #include <stdlib.h> | ||
3 | #include <stdbool.h> | ||
4 | #include <math.h> | ||
5 | #include <wlc/wlc.h> | ||
6 | #include "sway/extensions.h" | ||
7 | #include "sway/config.h" | ||
8 | #include "sway/container.h" | ||
9 | #include "sway/workspace.h" | ||
10 | #include "sway/focus.h" | ||
11 | #include "sway/output.h" | ||
12 | #include "sway/ipc-server.h" | ||
13 | #include "sway/border.h" | ||
14 | #include "sway/layout.h" | ||
15 | #include "list.h" | ||
16 | #include "log.h" | ||
17 | |||
18 | swayc_t root_container; | ||
19 | swayc_t *current_focus; | ||
20 | list_t *scratchpad; | ||
21 | |||
22 | int min_sane_h = 60; | ||
23 | int min_sane_w = 100; | ||
24 | |||
25 | void init_layout(void) { | ||
26 | root_container.id = 0; // normally assigned in new_swayc() | ||
27 | root_container.type = C_ROOT; | ||
28 | root_container.layout = L_NONE; | ||
29 | root_container.name = strdup("root"); | ||
30 | root_container.children = create_list(); | ||
31 | root_container.handle = -1; | ||
32 | root_container.visible = true; | ||
33 | current_focus = &root_container; | ||
34 | scratchpad = create_list(); | ||
35 | } | ||
36 | |||
37 | int index_child(const swayc_t *child) { | ||
38 | swayc_t *parent = child->parent; | ||
39 | int i, len; | ||
40 | if (!child->is_floating) { | ||
41 | len = parent->children->length; | ||
42 | for (i = 0; i < len; ++i) { | ||
43 | if (parent->children->items[i] == child) { | ||
44 | break; | ||
45 | } | ||
46 | } | ||
47 | } else { | ||
48 | len = parent->floating->length; | ||
49 | for (i = 0; i < len; ++i) { | ||
50 | if (parent->floating->items[i] == child) { | ||
51 | break; | ||
52 | } | ||
53 | } | ||
54 | } | ||
55 | if (!sway_assert(i < len, "Stray container")) { | ||
56 | return -1; | ||
57 | } | ||
58 | return i; | ||
59 | } | ||
60 | |||
61 | void add_child(swayc_t *parent, swayc_t *child) { | ||
62 | sway_log(L_DEBUG, "Adding %p (%d, %fx%f) to %p (%d, %fx%f)", child, child->type, | ||
63 | child->width, child->height, parent, parent->type, parent->width, parent->height); | ||
64 | list_add(parent->children, child); | ||
65 | child->parent = parent; | ||
66 | // set focus for this container | ||
67 | if (!parent->focused) { | ||
68 | parent->focused = child; | ||
69 | } | ||
70 | if (parent->type == C_WORKSPACE && child->type == C_VIEW && (parent->workspace_layout == L_TABBED || parent->workspace_layout == L_STACKED)) { | ||
71 | child = new_container(child, parent->workspace_layout); | ||
72 | } | ||
73 | } | ||
74 | |||
75 | static double *get_height(swayc_t *cont) { | ||
76 | return &cont->height; | ||
77 | } | ||
78 | |||
79 | static double *get_width(swayc_t *cont) { | ||
80 | return &cont->width; | ||
81 | } | ||
82 | |||
83 | void insert_child(swayc_t *parent, swayc_t *child, int index) { | ||
84 | if (index > parent->children->length) { | ||
85 | index = parent->children->length; | ||
86 | } | ||
87 | if (index < 0) { | ||
88 | index = 0; | ||
89 | } | ||
90 | list_insert(parent->children, index, child); | ||
91 | child->parent = parent; | ||
92 | if (!parent->focused) { | ||
93 | parent->focused = child; | ||
94 | } | ||
95 | if (parent->type == C_WORKSPACE && child->type == C_VIEW && (parent->workspace_layout == L_TABBED || parent->workspace_layout == L_STACKED)) { | ||
96 | child = new_container(child, parent->workspace_layout); | ||
97 | } | ||
98 | if (is_auto_layout(parent->layout)) { | ||
99 | /* go through each group, adjust the size of the first child of each group */ | ||
100 | double *(*get_maj_dim)(swayc_t *cont); | ||
101 | double *(*get_min_dim)(swayc_t *cont); | ||
102 | if (parent->layout == L_AUTO_LEFT || parent->layout == L_AUTO_RIGHT) { | ||
103 | get_maj_dim = get_width; | ||
104 | get_min_dim = get_height; | ||
105 | } else { | ||
106 | get_maj_dim = get_height; | ||
107 | get_min_dim = get_width; | ||
108 | } | ||
109 | for (int i = index; i < parent->children->length;) { | ||
110 | int start = auto_group_start_index(parent, i); | ||
111 | int end = auto_group_end_index(parent, i); | ||
112 | swayc_t *first = parent->children->items[start]; | ||
113 | if (start + 1 < parent->children->length) { | ||
114 | /* preserve the group's dimension along major axis */ | ||
115 | *get_maj_dim(first) = *get_maj_dim(parent->children->items[start + 1]); | ||
116 | } else { | ||
117 | /* new group, let the apply_layout handle it */ | ||
118 | first->height = first->width = 0; | ||
119 | break; | ||
120 | } | ||
121 | double remaining = *get_min_dim(parent); | ||
122 | for (int j = end - 1; j > start; --j) { | ||
123 | swayc_t *sibling = parent->children->items[j]; | ||
124 | if (sibling == child) { | ||
125 | /* the inserted child won't yet have its minor | ||
126 | dimension set */ | ||
127 | remaining -= *get_min_dim(parent) / (end - start); | ||
128 | } else { | ||
129 | remaining -= *get_min_dim(sibling); | ||
130 | } | ||
131 | } | ||
132 | *get_min_dim(first) = remaining; | ||
133 | i = end; | ||
134 | } | ||
135 | } | ||
136 | } | ||
137 | |||
138 | void add_floating(swayc_t *ws, swayc_t *child) { | ||
139 | sway_log(L_DEBUG, "Adding %p (%d, %fx%f) to %p (%d, %fx%f)", child, child->type, | ||
140 | child->width, child->height, ws, ws->type, ws->width, ws->height); | ||
141 | if (!sway_assert(ws->type == C_WORKSPACE, "Must be of workspace type")) { | ||
142 | return; | ||
143 | } | ||
144 | list_add(ws->floating, child); | ||
145 | child->parent = ws; | ||
146 | child->is_floating = true; | ||
147 | if (!ws->focused) { | ||
148 | ws->focused = child; | ||
149 | } | ||
150 | ipc_event_window(child, "floating"); | ||
151 | } | ||
152 | |||
153 | swayc_t *add_sibling(swayc_t *fixed, swayc_t *active) { | ||
154 | swayc_t *parent = fixed->parent; | ||
155 | if (fixed->is_floating) { | ||
156 | if (active->is_floating) { | ||
157 | int i = index_child(fixed); | ||
158 | list_insert(parent->floating, i + 1, active); | ||
159 | } else { | ||
160 | list_add(parent->children, active); | ||
161 | } | ||
162 | } else { | ||
163 | if (active->is_floating) { | ||
164 | list_add(parent->floating, active); | ||
165 | } else { | ||
166 | int i = index_child(fixed); | ||
167 | if (is_auto_layout(parent->layout)) { | ||
168 | list_add(parent->children, active); | ||
169 | } else { | ||
170 | list_insert(parent->children, i + 1, active); | ||
171 | } | ||
172 | } | ||
173 | } | ||
174 | active->parent = parent; | ||
175 | // focus new child | ||
176 | parent->focused = active; | ||
177 | return active->parent; | ||
178 | } | ||
179 | |||
180 | swayc_t *replace_child(swayc_t *child, swayc_t *new_child) { | ||
181 | swayc_t *parent = child->parent; | ||
182 | if (parent == NULL) { | ||
183 | return NULL; | ||
184 | } | ||
185 | int i = index_child(child); | ||
186 | if (child->is_floating) { | ||
187 | parent->floating->items[i] = new_child; | ||
188 | } else { | ||
189 | parent->children->items[i] = new_child; | ||
190 | } | ||
191 | // Set parent and focus for new_child | ||
192 | new_child->parent = child->parent; | ||
193 | if (child->parent->focused == child) { | ||
194 | child->parent->focused = new_child; | ||
195 | } | ||
196 | child->parent = NULL; | ||
197 | |||
198 | // Set geometry for new child | ||
199 | new_child->x = child->x; | ||
200 | new_child->y = child->y; | ||
201 | new_child->width = child->width; | ||
202 | new_child->height = child->height; | ||
203 | |||
204 | // reset geometry for child | ||
205 | child->width = 0; | ||
206 | child->height = 0; | ||
207 | |||
208 | // deactivate child | ||
209 | if (child->type == C_VIEW) { | ||
210 | wlc_view_set_state(child->handle, WLC_BIT_ACTIVATED, false); | ||
211 | } | ||
212 | return parent; | ||
213 | } | ||
214 | |||
215 | swayc_t *remove_child(swayc_t *child) { | ||
216 | int i; | ||
217 | swayc_t *parent = child->parent; | ||
218 | if (child->is_floating) { | ||
219 | // Special case for floating views | ||
220 | for (i = 0; i < parent->floating->length; ++i) { | ||
221 | if (parent->floating->items[i] == child) { | ||
222 | list_del(parent->floating, i); | ||
223 | break; | ||
224 | } | ||
225 | } | ||
226 | i = 0; | ||
227 | } else { | ||
228 | for (i = 0; i < parent->children->length; ++i) { | ||
229 | if (parent->children->items[i] == child) { | ||
230 | list_del(parent->children, i); | ||
231 | break; | ||
232 | } | ||
233 | } | ||
234 | if (is_auto_layout(parent->layout) && parent->children->length) { | ||
235 | /* go through each group, adjust the size of the last child of each group */ | ||
236 | double *(*get_maj_dim)(swayc_t *cont); | ||
237 | double *(*get_min_dim)(swayc_t *cont); | ||
238 | if (parent->layout == L_AUTO_LEFT || parent->layout == L_AUTO_RIGHT) { | ||
239 | get_maj_dim = get_width; | ||
240 | get_min_dim = get_height; | ||
241 | } else { | ||
242 | get_maj_dim = get_height; | ||
243 | get_min_dim = get_width; | ||
244 | } | ||
245 | for (int j = parent->children->length - 1; j >= i;) { | ||
246 | int start = auto_group_start_index(parent, j); | ||
247 | int end = auto_group_end_index(parent, j); | ||
248 | swayc_t *first = parent->children->items[start]; | ||
249 | if (i == start) { | ||
250 | /* removed element was first child in the current group, | ||
251 | use its size along the major axis */ | ||
252 | *get_maj_dim(first) = *get_maj_dim(child); | ||
253 | } else if (start > i) { | ||
254 | /* preserve the group's dimension along major axis */ | ||
255 | *get_maj_dim(first) = *get_maj_dim(parent->children->items[start - 1]); | ||
256 | } | ||
257 | if (end != parent->children->length) { | ||
258 | double remaining = *get_min_dim(parent); | ||
259 | for (int k = start; k < end - 1; ++k) { | ||
260 | swayc_t *sibling = parent->children->items[k]; | ||
261 | remaining -= *get_min_dim(sibling); | ||
262 | } | ||
263 | /* last element of the group gets remaining size, elements | ||
264 | that don't change groups keep their ratio */ | ||
265 | *get_min_dim((swayc_t *) parent->children->items[end - 1]) = remaining; | ||
266 | } /* else last group, let apply_layout handle it */ | ||
267 | j = start - 1; | ||
268 | } | ||
269 | } | ||
270 | } | ||
271 | // Set focused to new container | ||
272 | if (parent->focused == child) { | ||
273 | if (parent->children->length > 0) { | ||
274 | parent->focused = parent->children->items[i ? i-1:0]; | ||
275 | } else if (parent->floating && parent->floating->length) { | ||
276 | parent->focused = parent->floating->items[parent->floating->length - 1]; | ||
277 | } else { | ||
278 | parent->focused = NULL; | ||
279 | } | ||
280 | } | ||
281 | child->parent = NULL; | ||
282 | // deactivate view | ||
283 | if (child->type == C_VIEW) { | ||
284 | wlc_view_set_state(child->handle, WLC_BIT_ACTIVATED, false); | ||
285 | } | ||
286 | return parent; | ||
287 | } | ||
288 | |||
289 | void swap_container(swayc_t *a, swayc_t *b) { | ||
290 | if (!sway_assert(a&&b, "parameters must be non null") || | ||
291 | !sway_assert(a->parent && b->parent, "containers must have parents")) { | ||
292 | return; | ||
293 | } | ||
294 | size_t a_index = index_child(a); | ||
295 | size_t b_index = index_child(b); | ||
296 | swayc_t *a_parent = a->parent; | ||
297 | swayc_t *b_parent = b->parent; | ||
298 | // Swap the pointers | ||
299 | if (a->is_floating) { | ||
300 | a_parent->floating->items[a_index] = b; | ||
301 | } else { | ||
302 | a_parent->children->items[a_index] = b; | ||
303 | } | ||
304 | if (b->is_floating) { | ||
305 | b_parent->floating->items[b_index] = a; | ||
306 | } else { | ||
307 | b_parent->children->items[b_index] = a; | ||
308 | } | ||
309 | a->parent = b_parent; | ||
310 | b->parent = a_parent; | ||
311 | if (a_parent->focused == a) { | ||
312 | a_parent->focused = b; | ||
313 | } | ||
314 | // don't want to double switch | ||
315 | if (b_parent->focused == b && a_parent != b_parent) { | ||
316 | b_parent->focused = a; | ||
317 | } | ||
318 | } | ||
319 | |||
320 | void swap_geometry(swayc_t *a, swayc_t *b) { | ||
321 | double x = a->x; | ||
322 | double y = a->y; | ||
323 | double w = a->width; | ||
324 | double h = a->height; | ||
325 | a->x = b->x; | ||
326 | a->y = b->y; | ||
327 | a->width = b->width; | ||
328 | a->height = b->height; | ||
329 | b->x = x; | ||
330 | b->y = y; | ||
331 | b->width = w; | ||
332 | b->height = h; | ||
333 | } | ||
334 | |||
335 | static void swap_children(swayc_t *container, int a, int b) { | ||
336 | if (a >= 0 && b >= 0 && a < container->children->length | ||
337 | && b < container->children->length | ||
338 | && a != b) { | ||
339 | swayc_t *pa = (swayc_t *)container->children->items[a]; | ||
340 | swayc_t *pb = (swayc_t *)container->children->items[b]; | ||
341 | container->children->items[a] = container->children->items[b]; | ||
342 | container->children->items[b] = pa; | ||
343 | if (is_auto_layout(container->layout)) { | ||
344 | size_t ga = auto_group_index(container, a); | ||
345 | size_t gb = auto_group_index(container, b); | ||
346 | if (ga != gb) { | ||
347 | swap_geometry(pa, pb); | ||
348 | } | ||
349 | } | ||
350 | } | ||
351 | } | ||
352 | |||
353 | void move_container(swayc_t *container, enum movement_direction dir, int move_amt) { | ||
354 | enum swayc_layouts layout = L_NONE; | ||
355 | swayc_t *parent = container->parent; | ||
356 | if (container->is_floating) { | ||
357 | swayc_t *output = swayc_parent_by_type(container, C_OUTPUT); | ||
358 | switch(dir) { | ||
359 | case MOVE_LEFT: | ||
360 | container->x = MAX(0, container->x - move_amt); | ||
361 | break; | ||
362 | case MOVE_RIGHT: | ||
363 | container->x = MIN(output->width - container->width, container->x + move_amt); | ||
364 | break; | ||
365 | case MOVE_UP: | ||
366 | container->y = MAX(0, container->y - move_amt); | ||
367 | break; | ||
368 | case MOVE_DOWN: | ||
369 | container->y = MIN(output->height - container->height, container->y + move_amt); | ||
370 | break; | ||
371 | default: | ||
372 | break; | ||
373 | } | ||
374 | update_geometry(container); | ||
375 | return; | ||
376 | } | ||
377 | if (container->type != C_VIEW && container->type != C_CONTAINER) { | ||
378 | return; | ||
379 | } | ||
380 | if (dir == MOVE_UP || dir == MOVE_DOWN) { | ||
381 | layout = L_VERT; | ||
382 | } else if (dir == MOVE_LEFT || dir == MOVE_RIGHT) { | ||
383 | layout = L_HORIZ; | ||
384 | } else if (dir == MOVE_FIRST) { | ||
385 | // swap first child in auto layout with currently focused child | ||
386 | if (is_auto_layout(parent->layout)) { | ||
387 | int focused_idx = index_child(container); | ||
388 | swayc_t *first = parent->children->items[0]; | ||
389 | if (focused_idx > 0) { | ||
390 | list_swap(parent->children, 0, focused_idx); | ||
391 | swap_geometry(first, container); | ||
392 | } | ||
393 | arrange_windows(parent->parent, -1, -1); | ||
394 | ipc_event_window(container, "move"); | ||
395 | set_focused_container_for(parent->parent, container); | ||
396 | } | ||
397 | return; | ||
398 | } else if (! (dir == MOVE_NEXT || dir == MOVE_PREV)) { | ||
399 | return; | ||
400 | } | ||
401 | swayc_t *child = container; | ||
402 | bool ascended = false; | ||
403 | |||
404 | // View is wrapped in intermediate container which is needed for displaying | ||
405 | // the titlebar. Moving only the view outside of its parent container would just | ||
406 | // wrap it again under worspace. There would effectively be no movement, | ||
407 | // just a change of wrapping container. | ||
408 | if (child->type == C_VIEW && | ||
409 | parent->type == C_CONTAINER && | ||
410 | parent->children->length == 1 && | ||
411 | parent->parent->type == C_WORKSPACE) { | ||
412 | child = parent; | ||
413 | parent = parent->parent; | ||
414 | } | ||
415 | |||
416 | while (true) { | ||
417 | sway_log(L_DEBUG, "container:%p, parent:%p, child %p,", | ||
418 | container,parent,child); | ||
419 | if (parent->layout == layout | ||
420 | || (layout == L_NONE && (parent->type == C_CONTAINER || parent->type == C_WORKSPACE)) /* accept any layout for next/prev direction */ | ||
421 | || (parent->layout == L_TABBED && layout == L_HORIZ) | ||
422 | || (parent->layout == L_STACKED && layout == L_VERT) | ||
423 | || is_auto_layout(parent->layout)) { | ||
424 | int diff; | ||
425 | // If it has ascended (parent has moved up), no container is removed | ||
426 | // so insert it at index, or index+1. | ||
427 | // if it has not, the moved container is removed, so it needs to be | ||
428 | // inserted at index-1, or index+1 | ||
429 | if (ascended) { | ||
430 | diff = dir == MOVE_LEFT || dir == MOVE_UP || dir == MOVE_PREV ? 0 : 1; | ||
431 | } else { | ||
432 | diff = dir == MOVE_LEFT || dir == MOVE_UP || dir == MOVE_PREV ? -1 : 1; | ||
433 | } | ||
434 | int idx = index_child(child); | ||
435 | int desired = idx + diff; | ||
436 | if (dir == MOVE_NEXT || dir == MOVE_PREV) { | ||
437 | // Next/Prev always wrap. | ||
438 | if (desired < 0) { | ||
439 | desired += parent->children->length; | ||
440 | } else if (desired >= parent->children->length) { | ||
441 | desired = 0; | ||
442 | } | ||
443 | } | ||
444 | // when it has ascended, legal insertion position is 0:len | ||
445 | // when it has not, legal insertion position is 0:len-1 | ||
446 | if (desired >= 0 && desired - ascended < parent->children->length) { | ||
447 | if (!ascended) { | ||
448 | child = parent->children->items[desired]; | ||
449 | // Move container into sibling container | ||
450 | if (child->type == C_CONTAINER) { | ||
451 | parent = child; | ||
452 | // Insert it in first/last if matching layout, otherwise | ||
453 | // insert it next to focused container | ||
454 | if (parent->layout == layout | ||
455 | || (parent->layout == L_TABBED && layout == L_HORIZ) | ||
456 | || (parent->layout == L_STACKED && layout == L_VERT) | ||
457 | || is_auto_layout(parent->layout)) { | ||
458 | desired = (diff < 0) * parent->children->length; | ||
459 | } else { | ||
460 | desired = index_child(child->focused) + 1; | ||
461 | } | ||
462 | //reset geometry | ||
463 | container->width = container->height = 0; | ||
464 | } | ||
465 | } | ||
466 | if (container->parent == parent) { | ||
467 | swap_children(parent, idx, desired); | ||
468 | } else { | ||
469 | swayc_t *old_parent = remove_child(container); | ||
470 | insert_child(parent, container, desired); | ||
471 | destroy_container(old_parent); | ||
472 | sway_log(L_DEBUG,"Moving to %p %d", parent, desired); | ||
473 | } | ||
474 | break; | ||
475 | } | ||
476 | } | ||
477 | // Change parent layout if we need to | ||
478 | if (parent->children->length == 1 && parent->layout != layout && layout != L_NONE) { | ||
479 | /* swayc_change_layout(parent, layout); */ | ||
480 | parent->layout = layout; | ||
481 | continue; | ||
482 | } | ||
483 | if (parent->type == C_WORKSPACE) { | ||
484 | // If moving to an adjacent output we need a starting position (since this | ||
485 | // output might border to multiple outputs). | ||
486 | struct wlc_point abs_pos; | ||
487 | get_absolute_center_position(container, &abs_pos); | ||
488 | |||
489 | swayc_t *output = swayc_adjacent_output(parent->parent, dir, &abs_pos, true); | ||
490 | |||
491 | if (output) { | ||
492 | sway_log(L_DEBUG, "Moving between outputs"); | ||
493 | swayc_t *old_parent = remove_child(container); | ||
494 | destroy_container(old_parent); | ||
495 | |||
496 | swayc_t *dest = output->focused; | ||
497 | switch (dir) { | ||
498 | case MOVE_LEFT: | ||
499 | case MOVE_UP: | ||
500 | // reset container geometry | ||
501 | container->width = container->height = 0; | ||
502 | add_child(dest, container); | ||
503 | break; | ||
504 | case MOVE_RIGHT: | ||
505 | case MOVE_DOWN: | ||
506 | // reset container geometry | ||
507 | container->width = container->height = 0; | ||
508 | insert_child(dest, container, 0); | ||
509 | break; | ||
510 | default: | ||
511 | break; | ||
512 | } | ||
513 | // arrange new workspace | ||
514 | arrange_windows(dest, -1, -1); | ||
515 | set_focused_container(container); | ||
516 | break; | ||
517 | } | ||
518 | |||
519 | // We simply cannot move any further. | ||
520 | if (parent->layout == layout) { | ||
521 | break; | ||
522 | } | ||
523 | // Create container around workspace to insert child into | ||
524 | parent = new_container(parent, layout); | ||
525 | // Previous line set the resulting container's layout to | ||
526 | // workspace_layout. It should have been just layout. | ||
527 | parent->layout = parent->parent->layout; | ||
528 | } | ||
529 | ascended = true; | ||
530 | child = parent; | ||
531 | parent = child->parent; | ||
532 | } | ||
533 | arrange_windows(parent->parent, -1, -1); | ||
534 | ipc_event_window(container, "move"); | ||
535 | set_focused_container_for(parent->parent, container); | ||
536 | } | ||
537 | |||
538 | void move_container_to(swayc_t* container, swayc_t* destination) { | ||
539 | if (container == destination || swayc_is_parent_of(container, destination)) { | ||
540 | return; | ||
541 | } | ||
542 | swayc_t *parent = remove_child(container); | ||
543 | // Send to new destination | ||
544 | if (container->is_floating) { | ||
545 | swayc_t *ws = swayc_active_workspace_for(destination); | ||
546 | add_floating(ws, container); | ||
547 | |||
548 | // If the workspace only has one child after adding one, it | ||
549 | // means that the workspace was just initialized. | ||
550 | if (ws->children->length + ws->floating->length == 1) { | ||
551 | ipc_event_workspace(NULL, ws, "init"); | ||
552 | } | ||
553 | } else if (destination->type == C_WORKSPACE) { | ||
554 | // reset container geometry | ||
555 | container->width = container->height = 0; | ||
556 | add_child(destination, container); | ||
557 | |||
558 | // If the workspace only has one child after adding one, it | ||
559 | // means that the workspace was just initialized. | ||
560 | if (destination->children->length + destination->floating->length == 1) { | ||
561 | ipc_event_workspace(NULL, destination, "init"); | ||
562 | } | ||
563 | } else { | ||
564 | // reset container geometry | ||
565 | container->width = container->height = 0; | ||
566 | add_sibling(destination, container); | ||
567 | } | ||
568 | // Destroy old container if we need to | ||
569 | parent = destroy_container(parent); | ||
570 | // Refocus | ||
571 | swayc_t *op1 = swayc_parent_by_type(destination, C_OUTPUT); | ||
572 | swayc_t *op2 = swayc_parent_by_type(parent, C_OUTPUT); | ||
573 | set_focused_container(get_focused_view(op1)); | ||
574 | arrange_windows(op1, -1, -1); | ||
575 | update_visibility(op1); | ||
576 | if (op1 != op2) { | ||
577 | set_focused_container(get_focused_view(op2)); | ||
578 | arrange_windows(op2, -1, -1); | ||
579 | update_visibility(op2); | ||
580 | } | ||
581 | } | ||
582 | |||
583 | void move_workspace_to(swayc_t* workspace, swayc_t* destination) { | ||
584 | if (workspace == destination || swayc_is_parent_of(workspace, destination)) { | ||
585 | return; | ||
586 | } | ||
587 | swayc_t *src_op = remove_child(workspace); | ||
588 | // reset container geometry | ||
589 | workspace->width = workspace->height = 0; | ||
590 | add_child(destination, workspace); | ||
591 | sort_workspaces(destination); | ||
592 | // Refocus destination (change to new workspace) | ||
593 | set_focused_container(get_focused_view(workspace)); | ||
594 | arrange_windows(destination, -1, -1); | ||
595 | update_visibility(destination); | ||
596 | |||
597 | // make sure source output has a workspace | ||
598 | if (src_op->children->length == 0) { | ||
599 | char *ws_name = workspace_next_name(src_op->name); | ||
600 | swayc_t *ws = new_workspace(src_op, ws_name); | ||
601 | ws->is_focused = true; | ||
602 | free(ws_name); | ||
603 | } | ||
604 | set_focused_container(get_focused_view(src_op)); | ||
605 | update_visibility(src_op); | ||
606 | } | ||
607 | |||
608 | static void adjust_border_geometry(swayc_t *c, struct wlc_geometry *g, | ||
609 | const struct wlc_size *res, int left, int right, int top, int bottom) { | ||
610 | |||
611 | g->size.w += left + right; | ||
612 | if (g->origin.x - left < 0) { | ||
613 | g->size.w += g->origin.x - left; | ||
614 | } else if (g->origin.x + g->size.w - right > res->w) { | ||
615 | g->size.w = res->w - g->origin.x + right; | ||
616 | } | ||
617 | |||
618 | g->size.h += top + bottom; | ||
619 | if (g->origin.y - top < 0) { | ||
620 | g->size.h += g->origin.y - top; | ||
621 | } else if (g->origin.y + g->size.h - top > res->h) { | ||
622 | g->size.h = res->h - g->origin.y + top; | ||
623 | } | ||
624 | |||
625 | g->origin.x = MIN((uint32_t)MAX(g->origin.x - left, 0), res->w); | ||
626 | g->origin.y = MIN((uint32_t)MAX(g->origin.y - top, 0), res->h); | ||
627 | |||
628 | } | ||
629 | |||
630 | static void update_border_geometry_floating(swayc_t *c, struct wlc_geometry *geometry) { | ||
631 | struct wlc_geometry g = *geometry; | ||
632 | c->actual_geometry = g; | ||
633 | |||
634 | swayc_t *output = swayc_parent_by_type(c, C_OUTPUT); | ||
635 | struct wlc_size res; | ||
636 | output_get_scaled_size(output->handle, &res); | ||
637 | |||
638 | switch (c->border_type) { | ||
639 | case B_NONE: | ||
640 | break; | ||
641 | case B_PIXEL: | ||
642 | adjust_border_geometry(c, &g, &res, c->border_thickness, | ||
643 | c->border_thickness, c->border_thickness, c->border_thickness); | ||
644 | break; | ||
645 | case B_NORMAL: | ||
646 | { | ||
647 | int title_bar_height = config->font_height + 4; // borders + padding | ||
648 | |||
649 | adjust_border_geometry(c, &g, &res, c->border_thickness, | ||
650 | c->border_thickness, title_bar_height, c->border_thickness); | ||
651 | |||
652 | struct wlc_geometry title_bar = { | ||
653 | .origin = { | ||
654 | .x = c->actual_geometry.origin.x - c->border_thickness, | ||
655 | .y = c->actual_geometry.origin.y - title_bar_height | ||
656 | }, | ||
657 | .size = { | ||
658 | .w = c->actual_geometry.size.w + (2 * c->border_thickness), | ||
659 | .h = title_bar_height | ||
660 | } | ||
661 | }; | ||
662 | c->title_bar_geometry = title_bar; | ||
663 | break; | ||
664 | } | ||
665 | } | ||
666 | |||
667 | c->border_geometry = g; | ||
668 | *geometry = c->actual_geometry; | ||
669 | |||
670 | update_container_border(c); | ||
671 | } | ||
672 | |||
673 | void update_layout_geometry(swayc_t *parent, enum swayc_layouts prev_layout) { | ||
674 | switch (parent->layout) { | ||
675 | case L_TABBED: | ||
676 | case L_STACKED: | ||
677 | if (prev_layout != L_TABBED && prev_layout != L_STACKED) { | ||
678 | // cache current geometry for all non-float children | ||
679 | int i; | ||
680 | for (i = 0; i < parent->children->length; ++i) { | ||
681 | swayc_t *child = parent->children->items[i]; | ||
682 | child->cached_geometry.origin.x = child->x; | ||
683 | child->cached_geometry.origin.y = child->y; | ||
684 | child->cached_geometry.size.w = child->width; | ||
685 | child->cached_geometry.size.h = child->height; | ||
686 | } | ||
687 | } | ||
688 | break; | ||
689 | default: | ||
690 | if (prev_layout == L_TABBED || prev_layout == L_STACKED) { | ||
691 | // recover cached geometry for all non-float children | ||
692 | int i; | ||
693 | for (i = 0; i < parent->children->length; ++i) { | ||
694 | swayc_t *child = parent->children->items[i]; | ||
695 | // only recoverer cached geometry if non-zero | ||
696 | if (!wlc_geometry_equals(&child->cached_geometry, &wlc_geometry_zero)) { | ||
697 | child->x = child->cached_geometry.origin.x; | ||
698 | child->y = child->cached_geometry.origin.y; | ||
699 | child->width = child->cached_geometry.size.w; | ||
700 | child->height = child->cached_geometry.size.h; | ||
701 | } | ||
702 | } | ||
703 | } | ||
704 | break; | ||
705 | } | ||
706 | } | ||
707 | |||
708 | static int update_gap_geometry(swayc_t *container, struct wlc_geometry *g) { | ||
709 | swayc_t *ws = swayc_parent_by_type(container, C_WORKSPACE); | ||
710 | swayc_t *op = ws->parent; | ||
711 | int gap = container->is_floating ? 0 : swayc_gap(container); | ||
712 | if (gap % 2 != 0) { | ||
713 | // because gaps are implemented as "half sized margins" it's currently | ||
714 | // not possible to align views properly with odd sized gaps. | ||
715 | gap -= 1; | ||
716 | } | ||
717 | |||
718 | g->origin.x = container->x + gap/2 < op->width ? container->x + gap/2 : op->width-1; | ||
719 | g->origin.y = container->y + gap/2 < op->height ? container->y + gap/2 : op->height-1; | ||
720 | g->size.w = container->width > gap ? container->width - gap : 1; | ||
721 | g->size.h = container->height > gap ? container->height - gap : 1; | ||
722 | |||
723 | if ((!config->edge_gaps && gap > 0) || (config->smart_gaps && ws->children->length == 1)) { | ||
724 | // Remove gap against the workspace edges. Because a pixel is not | ||
725 | // divisable, depending on gap size and the number of siblings our view | ||
726 | // might be at the workspace edge without being exactly so (thus test | ||
727 | // with gap, and align correctly). | ||
728 | if (container->x - gap <= ws->x) { | ||
729 | g->origin.x = ws->x; | ||
730 | g->size.w = container->width - gap/2; | ||
731 | } | ||
732 | if (container->y - gap <= ws->y) { | ||
733 | g->origin.y = ws->y; | ||
734 | g->size.h = container->height - gap/2; | ||
735 | } | ||
736 | if (container->x + container->width + gap >= ws->x + ws->width) { | ||
737 | g->size.w = ws->x + ws->width - g->origin.x; | ||
738 | } | ||
739 | if (container->y + container->height + gap >= ws->y + ws->height) { | ||
740 | g->size.h = ws->y + ws->height - g->origin.y; | ||
741 | } | ||
742 | } | ||
743 | |||
744 | return gap; | ||
745 | } | ||
746 | |||
747 | void update_geometry(swayc_t *container) { | ||
748 | if (container->type != C_VIEW && container->type != C_CONTAINER) { | ||
749 | return; | ||
750 | } | ||
751 | |||
752 | swayc_t *workspace = swayc_parent_by_type(container, C_WORKSPACE); | ||
753 | swayc_t *op = workspace->parent; | ||
754 | swayc_t *parent = container->parent; | ||
755 | |||
756 | struct wlc_geometry geometry = { | ||
757 | .origin = { | ||
758 | .x = container->x < op->width ? container->x : op->width-1, | ||
759 | .y = container->y < op->height ? container->y : op->height-1 | ||
760 | }, | ||
761 | .size = { | ||
762 | .w = container->width, | ||
763 | .h = container->height, | ||
764 | } | ||
765 | }; | ||
766 | |||
767 | int gap = 0; | ||
768 | |||
769 | // apply inner gaps to non-tabbed/stacked containers | ||
770 | swayc_t *p = swayc_tabbed_stacked_ancestor(container); | ||
771 | if (p == NULL) { | ||
772 | gap = update_gap_geometry(container, &geometry); | ||
773 | } | ||
774 | |||
775 | swayc_t *output = swayc_parent_by_type(container, C_OUTPUT); | ||
776 | struct wlc_size size; | ||
777 | output_get_scaled_size(output->handle, &size); | ||
778 | |||
779 | if (swayc_is_fullscreen(container)) { | ||
780 | geometry.origin.x = 0; | ||
781 | geometry.origin.y = 0; | ||
782 | geometry.size.w = size.w; | ||
783 | geometry.size.h = size.h; | ||
784 | if (op->focused == workspace) { | ||
785 | wlc_view_bring_to_front(container->handle); | ||
786 | } | ||
787 | |||
788 | container->border_geometry = wlc_geometry_zero; | ||
789 | container->title_bar_geometry = wlc_geometry_zero; | ||
790 | border_clear(container->border); | ||
791 | } else if (container->is_floating) { // allocate border for floating window | ||
792 | update_border_geometry_floating(container, &geometry); | ||
793 | } else if (!container->is_floating) { // allocate border for titled window | ||
794 | container->border_geometry = geometry; | ||
795 | |||
796 | int border_top = container->border_thickness; | ||
797 | int border_bottom = container->border_thickness; | ||
798 | int border_left = container->border_thickness; | ||
799 | int border_right = container->border_thickness; | ||
800 | |||
801 | // handle hide_edge_borders | ||
802 | if (config->hide_edge_borders != E_NONE && (gap <= 0 || (config->smart_gaps && workspace->children->length == 1))) { | ||
803 | if (config->hide_edge_borders == E_VERTICAL || config->hide_edge_borders == E_BOTH) { | ||
804 | if (geometry.origin.x == workspace->x) { | ||
805 | border_left = 0; | ||
806 | } | ||
807 | |||
808 | if (geometry.origin.x + geometry.size.w == workspace->x + workspace->width) { | ||
809 | border_right = 0; | ||
810 | } | ||
811 | } | ||
812 | |||
813 | if (config->hide_edge_borders == E_HORIZONTAL || config->hide_edge_borders == E_BOTH) { | ||
814 | if (geometry.origin.y == workspace->y || should_hide_top_border(container, geometry.origin.y)) { | ||
815 | border_top = 0; | ||
816 | } | ||
817 | |||
818 | if (geometry.origin.y + geometry.size.h == workspace->y + workspace->height) { | ||
819 | border_bottom = 0; | ||
820 | } | ||
821 | } | ||
822 | |||
823 | if (config->hide_edge_borders == E_SMART && workspace->children->length == 1) { | ||
824 | border_top = 0; | ||
825 | border_bottom = 0; | ||
826 | border_left = 0; | ||
827 | border_right = 0; | ||
828 | } | ||
829 | } | ||
830 | |||
831 | int title_bar_height = config->font_height + 4; //borders + padding | ||
832 | |||
833 | if (parent->layout == L_TABBED && parent->children->length > 1) { | ||
834 | int i, x = 0, w, l, r; | ||
835 | l = parent->children->length; | ||
836 | w = geometry.size.w / l; | ||
837 | r = geometry.size.w % l; | ||
838 | for (i = 0; i < parent->children->length; ++i) { | ||
839 | swayc_t *view = parent->children->items[i]; | ||
840 | if (view == container) { | ||
841 | x = w * i; | ||
842 | if (i == l - 1) { | ||
843 | w += r; | ||
844 | } | ||
845 | break; | ||
846 | } | ||
847 | } | ||
848 | |||
849 | struct wlc_geometry title_bar = { | ||
850 | .origin = { | ||
851 | .x = container->border_geometry.origin.x + x, | ||
852 | .y = container->border_geometry.origin.y | ||
853 | }, | ||
854 | .size = { | ||
855 | .w = w, | ||
856 | .h = title_bar_height | ||
857 | } | ||
858 | }; | ||
859 | geometry.origin.x += border_left; | ||
860 | geometry.origin.y += title_bar.size.h; | ||
861 | geometry.size.w -= (border_left + border_right); | ||
862 | geometry.size.h -= (border_bottom + title_bar.size.h); | ||
863 | container->title_bar_geometry = title_bar; | ||
864 | } else if (parent->layout == L_STACKED && parent->children->length > 1) { | ||
865 | int i, y = 0; | ||
866 | for (i = 0; i < parent->children->length; ++i) { | ||
867 | swayc_t *view = parent->children->items[i]; | ||
868 | if (view == container) { | ||
869 | y = title_bar_height * i; | ||
870 | } | ||
871 | } | ||
872 | |||
873 | struct wlc_geometry title_bar = { | ||
874 | .origin = { | ||
875 | .x = container->border_geometry.origin.x, | ||
876 | .y = container->border_geometry.origin.y + y | ||
877 | }, | ||
878 | .size = { | ||
879 | .w = container->border_geometry.size.w, | ||
880 | .h = title_bar_height | ||
881 | } | ||
882 | }; | ||
883 | title_bar_height = title_bar_height * parent->children->length; | ||
884 | geometry.origin.x += border_left; | ||
885 | geometry.origin.y += title_bar_height; | ||
886 | geometry.size.w -= (border_left + border_right); | ||
887 | geometry.size.h -= (border_bottom + title_bar_height); | ||
888 | container->title_bar_geometry = title_bar; | ||
889 | } else { | ||
890 | switch (container->border_type) { | ||
891 | case B_NONE: | ||
892 | break; | ||
893 | case B_PIXEL: | ||
894 | geometry.origin.x += border_left; | ||
895 | geometry.origin.y += border_top; | ||
896 | geometry.size.w -= (border_left + border_right); | ||
897 | geometry.size.h -= (border_top + border_bottom); | ||
898 | break; | ||
899 | case B_NORMAL: | ||
900 | { | ||
901 | struct wlc_geometry title_bar = { | ||
902 | .origin = { | ||
903 | .x = container->border_geometry.origin.x, | ||
904 | .y = container->border_geometry.origin.y | ||
905 | }, | ||
906 | .size = { | ||
907 | .w = container->border_geometry.size.w, | ||
908 | .h = title_bar_height | ||
909 | } | ||
910 | }; | ||
911 | geometry.origin.x += border_left; | ||
912 | geometry.origin.y += title_bar.size.h; | ||
913 | geometry.size.w -= (border_left + border_right); | ||
914 | geometry.size.h -= (border_bottom + title_bar.size.h); | ||
915 | container->title_bar_geometry = title_bar; | ||
916 | break; | ||
917 | } | ||
918 | } | ||
919 | } | ||
920 | |||
921 | container->actual_geometry = geometry; | ||
922 | |||
923 | if (container->type == C_VIEW) { | ||
924 | update_container_border(container); | ||
925 | } | ||
926 | } | ||
927 | |||
928 | if (container->type == C_VIEW) { | ||
929 | wlc_view_set_geometry(container->handle, 0, &geometry); | ||
930 | } | ||
931 | } | ||
932 | |||
933 | /** | ||
934 | * Layout application prototypes | ||
935 | */ | ||
936 | static void apply_horiz_layout(swayc_t *container, const double x, | ||
937 | const double y, const double width, | ||
938 | const double height, const int start, | ||
939 | const int end); | ||
940 | static void apply_vert_layout(swayc_t *container, const double x, | ||
941 | const double y, const double width, | ||
942 | const double height, const int start, | ||
943 | const int end); | ||
944 | static void apply_tabbed_or_stacked_layout(swayc_t *container, double x, | ||
945 | double y, double width, | ||
946 | double height); | ||
947 | |||
948 | static void apply_auto_layout(swayc_t *container, const double x, const double y, | ||
949 | const double width, const double height, | ||
950 | enum swayc_layouts group_layout, | ||
951 | bool master_first); | ||
952 | |||
953 | static void arrange_windows_r(swayc_t *container, double width, double height) { | ||
954 | int i; | ||
955 | if (width == -1 || height == -1) { | ||
956 | swayc_log(L_DEBUG, container, "Arranging layout for %p", container); | ||
957 | width = container->width; | ||
958 | height = container->height; | ||
959 | } | ||
960 | // pixels are indivisible. if we don't round the pixels, then the view | ||
961 | // calculations will be off (e.g. 50.5 + 50.5 = 101, but in reality it's | ||
962 | // 50 + 50 = 100). doing it here cascades properly to all width/height/x/y. | ||
963 | width = floor(width); | ||
964 | height = floor(height); | ||
965 | |||
966 | sway_log(L_DEBUG, "Arranging layout for %p %s %fx%f+%f,%f", container, | ||
967 | container->name, container->width, container->height, container->x, | ||
968 | container->y); | ||
969 | |||
970 | double x = 0, y = 0; | ||
971 | switch (container->type) { | ||
972 | case C_ROOT: | ||
973 | for (i = 0; i < container->children->length; ++i) { | ||
974 | swayc_t *output = container->children->items[i]; | ||
975 | sway_log(L_DEBUG, "Arranging output '%s' at %f,%f", output->name, output->x, output->y); | ||
976 | arrange_windows_r(output, -1, -1); | ||
977 | } | ||
978 | return; | ||
979 | case C_OUTPUT: | ||
980 | { | ||
981 | struct wlc_size resolution; | ||
982 | output_get_scaled_size(container->handle, &resolution); | ||
983 | width = resolution.w; height = resolution.h; | ||
984 | // output must have correct size due to e.g. seamless mouse, | ||
985 | // but a workspace might be smaller depending on panels. | ||
986 | container->width = width; | ||
987 | container->height = height; | ||
988 | } | ||
989 | // arrange all workspaces: | ||
990 | for (i = 0; i < container->children->length; ++i) { | ||
991 | swayc_t *child = container->children->items[i]; | ||
992 | arrange_windows_r(child, -1, -1); | ||
993 | } | ||
994 | // Bring all unmanaged views to the front | ||
995 | for (i = 0; i < container->unmanaged->length; ++i) { | ||
996 | wlc_handle *handle = container->unmanaged->items[i]; | ||
997 | wlc_view_bring_to_front(*handle); | ||
998 | } | ||
999 | return; | ||
1000 | case C_WORKSPACE: | ||
1001 | { | ||
1002 | swayc_t *output = swayc_parent_by_type(container, C_OUTPUT); | ||
1003 | width = output->width, height = output->height; | ||
1004 | for (i = 0; i < desktop_shell.panels->length; ++i) { | ||
1005 | struct panel_config *config = desktop_shell.panels->items[i]; | ||
1006 | if (config->output == output->handle) { | ||
1007 | struct wlc_size size = *wlc_surface_get_size(config->surface); | ||
1008 | sway_log(L_DEBUG, "-> Found panel for this workspace: %ux%u, position: %u", size.w, size.h, config->panel_position); | ||
1009 | switch (config->panel_position) { | ||
1010 | case DESKTOP_SHELL_PANEL_POSITION_TOP: | ||
1011 | y += size.h; height -= size.h; | ||
1012 | break; | ||
1013 | case DESKTOP_SHELL_PANEL_POSITION_BOTTOM: | ||
1014 | height -= size.h; | ||
1015 | break; | ||
1016 | case DESKTOP_SHELL_PANEL_POSITION_LEFT: | ||
1017 | x += size.w; width -= size.w; | ||
1018 | break; | ||
1019 | case DESKTOP_SHELL_PANEL_POSITION_RIGHT: | ||
1020 | width -= size.w; | ||
1021 | break; | ||
1022 | } | ||
1023 | } | ||
1024 | } | ||
1025 | int gap = swayc_gap(container); | ||
1026 | x = container->x = x + gap; | ||
1027 | y = container->y = y + gap; | ||
1028 | width = container->width = width - gap * 2; | ||
1029 | height = container->height = height - gap * 2; | ||
1030 | sway_log(L_DEBUG, "Arranging workspace '%s' at %f, %f", container->name, container->x, container->y); | ||
1031 | } | ||
1032 | // children are properly handled below | ||
1033 | break; | ||
1034 | case C_VIEW: | ||
1035 | { | ||
1036 | container->width = width; | ||
1037 | container->height = height; | ||
1038 | update_geometry(container); | ||
1039 | sway_log(L_DEBUG, "Set view to %.f x %.f @ %.f, %.f", container->width, | ||
1040 | container->height, container->x, container->y); | ||
1041 | } | ||
1042 | return; | ||
1043 | default: | ||
1044 | container->width = width; | ||
1045 | container->height = height; | ||
1046 | x = container->x; | ||
1047 | y = container->y; | ||
1048 | |||
1049 | // add gaps to top level tapped/stacked container | ||
1050 | if (container->parent->type == C_WORKSPACE && | ||
1051 | (container->layout == L_TABBED || container->layout == L_STACKED)) { | ||
1052 | update_geometry(container); | ||
1053 | width = container->border_geometry.size.w; | ||
1054 | height = container->border_geometry.size.h; | ||
1055 | x = container->border_geometry.origin.x; | ||
1056 | y = container->border_geometry.origin.y; | ||
1057 | } | ||
1058 | |||
1059 | // update container size if it's a direct child in a tabbed/stacked layout | ||
1060 | // if parent is a workspace, its actual_geometry won't be initialized | ||
1061 | if (swayc_tabbed_stacked_parent(container) != NULL && | ||
1062 | container->parent->type != C_WORKSPACE) { | ||
1063 | // Use parent actual_geometry as a base for calculating | ||
1064 | // container geometry | ||
1065 | container->width = container->parent->actual_geometry.size.w; | ||
1066 | container->height = container->parent->actual_geometry.size.h; | ||
1067 | container->x = container->parent->actual_geometry.origin.x; | ||
1068 | container->y = container->parent->actual_geometry.origin.y; | ||
1069 | |||
1070 | update_geometry(container); | ||
1071 | width = container->width = container->actual_geometry.size.w; | ||
1072 | height = container->height = container->actual_geometry.size.h; | ||
1073 | x = container->x = container->actual_geometry.origin.x; | ||
1074 | y = container->y = container->actual_geometry.origin.y; | ||
1075 | } | ||
1076 | |||
1077 | break; | ||
1078 | } | ||
1079 | |||
1080 | switch (container->layout) { | ||
1081 | case L_HORIZ: | ||
1082 | default: | ||
1083 | apply_horiz_layout(container, x, y, width, height, 0, | ||
1084 | container->children->length); | ||
1085 | break; | ||
1086 | case L_VERT: | ||
1087 | apply_vert_layout(container, x, y, width, height, 0, | ||
1088 | container->children->length); | ||
1089 | break; | ||
1090 | case L_TABBED: | ||
1091 | case L_STACKED: | ||
1092 | apply_tabbed_or_stacked_layout(container, x, y, width, height); | ||
1093 | break; | ||
1094 | case L_AUTO_LEFT: | ||
1095 | apply_auto_layout(container, x, y, width, height, L_VERT, true); | ||
1096 | break; | ||
1097 | case L_AUTO_RIGHT: | ||
1098 | apply_auto_layout(container, x, y, width, height, L_VERT, false); | ||
1099 | break; | ||
1100 | case L_AUTO_TOP: | ||
1101 | apply_auto_layout(container, x, y, width, height, L_HORIZ, true); | ||
1102 | break; | ||
1103 | case L_AUTO_BOTTOM: | ||
1104 | apply_auto_layout(container, x, y, width, height, L_HORIZ, false); | ||
1105 | break; | ||
1106 | } | ||
1107 | |||
1108 | // Arrage floating layouts for workspaces last | ||
1109 | if (container->type == C_WORKSPACE) { | ||
1110 | for (int i = 0; i < container->floating->length; ++i) { | ||
1111 | swayc_t *view = container->floating->items[i]; | ||
1112 | if (view->type == C_VIEW) { | ||
1113 | update_geometry(view); | ||
1114 | sway_log(L_DEBUG, "Set floating view to %.f x %.f @ %.f, %.f", | ||
1115 | view->width, view->height, view->x, view->y); | ||
1116 | if (swayc_is_fullscreen(view)) { | ||
1117 | wlc_view_bring_to_front(view->handle); | ||
1118 | } else if (!container->focused || | ||
1119 | !swayc_is_fullscreen(container->focused)) { | ||
1120 | wlc_view_bring_to_front(view->handle); | ||
1121 | } | ||
1122 | } | ||
1123 | } | ||
1124 | } | ||
1125 | } | ||
1126 | |||
1127 | void apply_horiz_layout(swayc_t *container, const double x, const double y, | ||
1128 | const double width, const double height, | ||
1129 | const int start, const int end) { | ||
1130 | double scale = 0; | ||
1131 | // Calculate total width | ||
1132 | for (int i = start; i < end; ++i) { | ||
1133 | double *old_width = &((swayc_t *)container->children->items[i])->width; | ||
1134 | if (*old_width <= 0) { | ||
1135 | if (end - start > 1) { | ||
1136 | *old_width = width / (end - start - 1); | ||
1137 | } else { | ||
1138 | *old_width = width; | ||
1139 | } | ||
1140 | } | ||
1141 | scale += *old_width; | ||
1142 | } | ||
1143 | scale = width / scale; | ||
1144 | |||
1145 | // Resize windows | ||
1146 | double child_x = x; | ||
1147 | if (scale > 0.1) { | ||
1148 | sway_log(L_DEBUG, "Arranging %p horizontally", container); | ||
1149 | swayc_t *focused = NULL; | ||
1150 | for (int i = start; i < end; ++i) { | ||
1151 | swayc_t *child = container->children->items[i]; | ||
1152 | sway_log(L_DEBUG, | ||
1153 | "Calculating arrangement for %p:%d (will scale %f by %f)", child, | ||
1154 | child->type, width, scale); | ||
1155 | child->x = child_x; | ||
1156 | child->y = y; | ||
1157 | |||
1158 | if (child == container->focused) { | ||
1159 | focused = child; | ||
1160 | } | ||
1161 | |||
1162 | if (i == end - 1) { | ||
1163 | double remaining_width = x + width - child_x; | ||
1164 | arrange_windows_r(child, remaining_width, height); | ||
1165 | } else { | ||
1166 | arrange_windows_r(child, child->width * scale, height); | ||
1167 | } | ||
1168 | child_x += child->width; | ||
1169 | } | ||
1170 | |||
1171 | // update focused view border last because it may | ||
1172 | // depend on the title bar geometry of its siblings. | ||
1173 | if (focused && container->children->length > 1) { | ||
1174 | update_container_border(focused); | ||
1175 | } | ||
1176 | } | ||
1177 | } | ||
1178 | |||
1179 | void apply_vert_layout(swayc_t *container, const double x, const double y, | ||
1180 | const double width, const double height, const int start, | ||
1181 | const int end) { | ||
1182 | int i; | ||
1183 | double scale = 0; | ||
1184 | // Calculate total height | ||
1185 | for (i = start; i < end; ++i) { | ||
1186 | double *old_height = &((swayc_t *)container->children->items[i])->height; | ||
1187 | if (*old_height <= 0) { | ||
1188 | if (end - start > 1) { | ||
1189 | *old_height = height / (end - start - 1); | ||
1190 | } else { | ||
1191 | *old_height = height; | ||
1192 | } | ||
1193 | } | ||
1194 | scale += *old_height; | ||
1195 | } | ||
1196 | scale = height / scale; | ||
1197 | |||
1198 | // Resize | ||
1199 | double child_y = y; | ||
1200 | if (scale > 0.1) { | ||
1201 | sway_log(L_DEBUG, "Arranging %p vertically", container); | ||
1202 | swayc_t *focused = NULL; | ||
1203 | for (i = start; i < end; ++i) { | ||
1204 | swayc_t *child = container->children->items[i]; | ||
1205 | sway_log(L_DEBUG, | ||
1206 | "Calculating arrangement for %p:%d (will scale %f by %f)", child, | ||
1207 | child->type, height, scale); | ||
1208 | child->x = x; | ||
1209 | child->y = child_y; | ||
1210 | |||
1211 | if (child == container->focused) { | ||
1212 | focused = child; | ||
1213 | } | ||
1214 | |||
1215 | if (i == end - 1) { | ||
1216 | double remaining_height = y + height - child_y; | ||
1217 | arrange_windows_r(child, width, remaining_height); | ||
1218 | } else { | ||
1219 | arrange_windows_r(child, width, child->height * scale); | ||
1220 | } | ||
1221 | child_y += child->height; | ||
1222 | } | ||
1223 | |||
1224 | // update focused view border last because it may | ||
1225 | // depend on the title bar geometry of its siblings. | ||
1226 | if (focused && container->children->length > 1) { | ||
1227 | update_container_border(focused); | ||
1228 | } | ||
1229 | } | ||
1230 | } | ||
1231 | |||
1232 | void apply_tabbed_or_stacked_layout(swayc_t *container, double x, double y, | ||
1233 | double width, double height) { | ||
1234 | int i; | ||
1235 | swayc_t *focused = NULL; | ||
1236 | for (i = 0; i < container->children->length; ++i) { | ||
1237 | swayc_t *child = container->children->items[i]; | ||
1238 | child->x = x; | ||
1239 | child->y = y; | ||
1240 | if (child == container->focused) { | ||
1241 | focused = child; | ||
1242 | } else { | ||
1243 | arrange_windows_r(child, width, height); | ||
1244 | } | ||
1245 | } | ||
1246 | |||
1247 | if (focused) { | ||
1248 | arrange_windows_r(focused, width, height); | ||
1249 | } | ||
1250 | } | ||
1251 | |||
1252 | void apply_auto_layout(swayc_t *container, const double x, const double y, | ||
1253 | const double width, const double height, | ||
1254 | enum swayc_layouts group_layout, | ||
1255 | bool master_first) { | ||
1256 | // Auto layout "container" in width x height @ x, y | ||
1257 | // using "group_layout" for each of the groups in the container. | ||
1258 | // There is one "master" group, plus container->nb_slave_groups. | ||
1259 | // Each group is layed out side by side following the "major" axis. | ||
1260 | // The direction of the layout used for groups is the "minor" axis. | ||
1261 | // Example: | ||
1262 | // | ||
1263 | // ---- major axis --> | ||
1264 | // +---------+-----------+ | ||
1265 | // | | | | | ||
1266 | // | master | slave 1 | | | ||
1267 | // | +-----------+ | minor axis (direction of group_layout) | ||
1268 | // | | | | | ||
1269 | // | | slave 2 | V | ||
1270 | // +---------+-----------+ | ||
1271 | // | ||
1272 | // container with three children (one master and two slaves) and | ||
1273 | // a single slave group (containing slave 1 and 2). The master | ||
1274 | // group and slave group are layed out using L_VERT. | ||
1275 | |||
1276 | size_t nb_groups = auto_group_count(container); | ||
1277 | |||
1278 | // the target dimension of the container along the "major" axis, each | ||
1279 | // group in the container will be layed out using "group_layout" along | ||
1280 | // the "minor" axis. | ||
1281 | double dim_maj; | ||
1282 | double pos_maj; | ||
1283 | |||
1284 | // x and y coords for the next group to be laid out. | ||
1285 | const double *group_x, *group_y; | ||
1286 | |||
1287 | // pos of the next group to layout along the major axis | ||
1288 | double pos; | ||
1289 | |||
1290 | // size of the next group along the major axis. | ||
1291 | double group_dim; | ||
1292 | |||
1293 | // height and width of next group to be laid out. | ||
1294 | const double *group_h, *group_w; | ||
1295 | |||
1296 | switch (group_layout) { | ||
1297 | default: | ||
1298 | sway_log(L_DEBUG, "Unknown layout type (%d) used in %s()", | ||
1299 | group_layout, __func__); | ||
1300 | /* fall through */ | ||
1301 | case L_VERT: | ||
1302 | dim_maj = width; | ||
1303 | pos_maj = x; | ||
1304 | |||
1305 | group_x = &pos; | ||
1306 | group_y = &y; | ||
1307 | group_w = &group_dim; | ||
1308 | group_h = &height; | ||
1309 | break; | ||
1310 | case L_HORIZ: | ||
1311 | dim_maj = height; | ||
1312 | pos_maj = y; | ||
1313 | |||
1314 | group_x = &x; | ||
1315 | group_y = &pos; | ||
1316 | group_w = &width; | ||
1317 | group_h = &group_dim; | ||
1318 | break; | ||
1319 | } | ||
1320 | |||
1321 | /* Determine the dimension of each of the groups in the layout. | ||
1322 | * Dimension will be width for a VERT layout and height for a HORIZ | ||
1323 | * layout. */ | ||
1324 | double old_group_dim[nb_groups]; | ||
1325 | double old_dim = 0; | ||
1326 | for (size_t group = 0; group < nb_groups; ++group) { | ||
1327 | int idx; | ||
1328 | if (auto_group_bounds(container, group, &idx, NULL)) { | ||
1329 | swayc_t *child = container->children->items[idx]; | ||
1330 | double *dim = group_layout == L_HORIZ ? &child->height : &child->width; | ||
1331 | if (*dim <= 0) { | ||
1332 | // New child with uninitialized dimension | ||
1333 | *dim = dim_maj; | ||
1334 | if (nb_groups > 1) { | ||
1335 | // child gets a dimension proportional to existing groups, | ||
1336 | // it will be later scaled based on to the available size | ||
1337 | // in the major axis. | ||
1338 | *dim /= (nb_groups - 1); | ||
1339 | } | ||
1340 | } | ||
1341 | old_dim += *dim; | ||
1342 | old_group_dim[group] = *dim; | ||
1343 | } | ||
1344 | } | ||
1345 | double scale = dim_maj / old_dim; | ||
1346 | |||
1347 | /* Apply layout to each group */ | ||
1348 | pos = pos_maj; | ||
1349 | |||
1350 | for (size_t group = 0; group < nb_groups; ++group) { | ||
1351 | int start, end; // index of first (inclusive) and last (exclusive) child in the group | ||
1352 | if (auto_group_bounds(container, group, &start, &end)) { | ||
1353 | // adjusted size of the group | ||
1354 | group_dim = old_group_dim[group] * scale; | ||
1355 | if (group == nb_groups - 1) { | ||
1356 | group_dim = pos_maj + dim_maj - pos; // remaining width | ||
1357 | } | ||
1358 | sway_log(L_DEBUG, "Arranging container %p column %zu, children [%d,%d[ (%fx%f+%f,%f)", | ||
1359 | container, group, start, end, *group_w, *group_h, *group_x, *group_y); | ||
1360 | switch (group_layout) { | ||
1361 | default: | ||
1362 | case L_VERT: | ||
1363 | apply_vert_layout(container, *group_x, *group_y, *group_w, *group_h, start, end); | ||
1364 | break; | ||
1365 | case L_HORIZ: | ||
1366 | apply_horiz_layout(container, *group_x, *group_y, *group_w, *group_h, start, end); | ||
1367 | break; | ||
1368 | } | ||
1369 | |||
1370 | /* update position for next group */ | ||
1371 | pos += group_dim; | ||
1372 | } | ||
1373 | } | ||
1374 | } | ||
1375 | |||
1376 | void arrange_windows(swayc_t *container, double width, double height) { | ||
1377 | update_visibility(container); | ||
1378 | arrange_windows_r(container, width, height); | ||
1379 | layout_log(&root_container, 0); | ||
1380 | } | ||
1381 | |||
1382 | void arrange_backgrounds(void) { | ||
1383 | struct background_config *bg; | ||
1384 | for (int i = 0; i < desktop_shell.backgrounds->length; ++i) { | ||
1385 | bg = desktop_shell.backgrounds->items[i]; | ||
1386 | wlc_view_send_to_back(bg->handle); | ||
1387 | } | ||
1388 | } | ||
1389 | |||
1390 | /** | ||
1391 | * Get swayc in the direction of newly entered output. | ||
1392 | */ | ||
1393 | static swayc_t *get_swayc_in_output_direction(swayc_t *output, enum movement_direction dir) { | ||
1394 | if (!output) { | ||
1395 | return NULL; | ||
1396 | } | ||
1397 | |||
1398 | swayc_t *ws = swayc_focus_by_type(output, C_WORKSPACE); | ||
1399 | if (ws && ws->children->length > 0) { | ||
1400 | switch (dir) { | ||
1401 | case MOVE_LEFT: | ||
1402 | // get most right child of new output | ||
1403 | return ws->children->items[ws->children->length-1]; | ||
1404 | case MOVE_RIGHT: | ||
1405 | // get most left child of new output | ||
1406 | return ws->children->items[0]; | ||
1407 | case MOVE_UP: | ||
1408 | case MOVE_DOWN: | ||
1409 | { | ||
1410 | swayc_t *focused_view = swayc_focus_by_type(ws, C_VIEW); | ||
1411 | if (focused_view && focused_view->parent) { | ||
1412 | swayc_t *parent = focused_view->parent; | ||
1413 | if (parent->layout == L_VERT) { | ||
1414 | if (dir == MOVE_UP) { | ||
1415 | // get child furthest down on new output | ||
1416 | return parent->children->items[parent->children->length-1]; | ||
1417 | } else if (dir == MOVE_DOWN) { | ||
1418 | // get child furthest up on new output | ||
1419 | return parent->children->items[0]; | ||
1420 | } | ||
1421 | } | ||
1422 | return focused_view; | ||
1423 | } | ||
1424 | break; | ||
1425 | } | ||
1426 | default: | ||
1427 | break; | ||
1428 | } | ||
1429 | } | ||
1430 | |||
1431 | return output; | ||
1432 | } | ||
1433 | |||
1434 | swayc_t *get_swayc_in_direction_under(swayc_t *container, enum movement_direction dir, swayc_t *limit) { | ||
1435 | if (dir == MOVE_CHILD) { | ||
1436 | return container->focused; | ||
1437 | } | ||
1438 | |||
1439 | swayc_t *parent = container->parent; | ||
1440 | if (dir == MOVE_PARENT) { | ||
1441 | if (parent->type == C_OUTPUT) { | ||
1442 | return NULL; | ||
1443 | } else { | ||
1444 | return parent; | ||
1445 | } | ||
1446 | } | ||
1447 | |||
1448 | if (dir == MOVE_PREV || dir == MOVE_NEXT) { | ||
1449 | int focused_idx = index_child(container); | ||
1450 | if (focused_idx == -1) { | ||
1451 | return NULL; | ||
1452 | } else { | ||
1453 | int desired = (focused_idx + (dir == MOVE_NEXT ? 1 : -1)) % | ||
1454 | parent->children->length; | ||
1455 | if (desired < 0) { | ||
1456 | desired += parent->children->length; | ||
1457 | } | ||
1458 | return parent->children->items[desired]; | ||
1459 | } | ||
1460 | } | ||
1461 | |||
1462 | // If moving to an adjacent output we need a starting position (since this | ||
1463 | // output might border to multiple outputs). | ||
1464 | struct wlc_point abs_pos; | ||
1465 | get_absolute_center_position(container, &abs_pos); | ||
1466 | |||
1467 | if (container->type == C_VIEW && swayc_is_fullscreen(container)) { | ||
1468 | sway_log(L_DEBUG, "Moving from fullscreen view, skipping to output"); | ||
1469 | container = swayc_parent_by_type(container, C_OUTPUT); | ||
1470 | get_absolute_center_position(container, &abs_pos); | ||
1471 | swayc_t *output = swayc_adjacent_output(container, dir, &abs_pos, true); | ||
1472 | return get_swayc_in_output_direction(output, dir); | ||
1473 | } | ||
1474 | |||
1475 | if (container->type == C_WORKSPACE && container->fullscreen) { | ||
1476 | sway_log(L_DEBUG, "Moving to fullscreen view"); | ||
1477 | return container->fullscreen; | ||
1478 | } | ||
1479 | |||
1480 | swayc_t *wrap_candidate = NULL; | ||
1481 | while (true) { | ||
1482 | // Test if we can even make a difference here | ||
1483 | bool can_move = false; | ||
1484 | int desired; | ||
1485 | int idx = index_child(container); | ||
1486 | if (parent->type == C_ROOT) { | ||
1487 | swayc_t *output = swayc_adjacent_output(container, dir, &abs_pos, true); | ||
1488 | if (!output || output == container) { | ||
1489 | return wrap_candidate; | ||
1490 | } | ||
1491 | sway_log(L_DEBUG, "Moving between outputs"); | ||
1492 | return get_swayc_in_output_direction(output, dir); | ||
1493 | } else { | ||
1494 | if (is_auto_layout(parent->layout)) { | ||
1495 | bool is_major = parent->layout == L_AUTO_LEFT || parent->layout == L_AUTO_RIGHT | ||
1496 | ? dir == MOVE_LEFT || dir == MOVE_RIGHT | ||
1497 | : dir == MOVE_DOWN || dir == MOVE_UP; | ||
1498 | size_t gidx = auto_group_index(parent, idx); | ||
1499 | if (is_major) { | ||
1500 | size_t desired_grp = gidx + (dir == MOVE_RIGHT || dir == MOVE_DOWN ? 1 : -1); | ||
1501 | can_move = auto_group_bounds(parent, desired_grp, &desired, NULL); | ||
1502 | } else { | ||
1503 | desired = idx + (dir == MOVE_RIGHT || dir == MOVE_DOWN ? 1 : -1); | ||
1504 | int start, end; | ||
1505 | can_move = auto_group_bounds(parent, gidx, &start, &end) | ||
1506 | && desired >= start && desired < end; | ||
1507 | } | ||
1508 | } else { | ||
1509 | if (dir == MOVE_LEFT || dir == MOVE_RIGHT) { | ||
1510 | if (parent->layout == L_HORIZ || parent->layout == L_TABBED) { | ||
1511 | can_move = true; | ||
1512 | desired = idx + (dir == MOVE_LEFT ? -1 : 1); | ||
1513 | } | ||
1514 | } else { | ||
1515 | if (parent->layout == L_VERT || parent->layout == L_STACKED) { | ||
1516 | can_move = true; | ||
1517 | desired = idx + (dir == MOVE_UP ? -1 : 1); | ||
1518 | } | ||
1519 | } | ||
1520 | } | ||
1521 | } | ||
1522 | |||
1523 | if (can_move) { | ||
1524 | if (container->is_floating) { | ||
1525 | if (desired < 0) { | ||
1526 | wrap_candidate = parent->floating->items[parent->floating->length-1]; | ||
1527 | } else if (desired >= parent->floating->length){ | ||
1528 | wrap_candidate = parent->floating->items[0]; | ||
1529 | } else { | ||
1530 | wrap_candidate = parent->floating->items[desired]; | ||
1531 | } | ||
1532 | if (wrap_candidate) { | ||
1533 | wlc_view_bring_to_front(wrap_candidate->handle); | ||
1534 | } | ||
1535 | return wrap_candidate; | ||
1536 | } else if (desired < 0 || desired >= parent->children->length) { | ||
1537 | can_move = false; | ||
1538 | int len = parent->children->length; | ||
1539 | if (!wrap_candidate && len > 1) { | ||
1540 | if (desired < 0) { | ||
1541 | wrap_candidate = parent->children->items[len-1]; | ||
1542 | } else { | ||
1543 | wrap_candidate = parent->children->items[0]; | ||
1544 | } | ||
1545 | if (config->force_focus_wrapping) { | ||
1546 | return wrap_candidate; | ||
1547 | } | ||
1548 | } | ||
1549 | } else { | ||
1550 | sway_log(L_DEBUG, "%s cont %d-%p dir %i sibling %d: %p", __func__, | ||
1551 | idx, container, dir, desired, parent->children->items[desired]); | ||
1552 | return parent->children->items[desired]; | ||
1553 | } | ||
1554 | } | ||
1555 | if (!can_move) { | ||
1556 | container = parent; | ||
1557 | parent = parent->parent; | ||
1558 | if (!parent || container == limit) { | ||
1559 | // wrapping is the last chance | ||
1560 | return wrap_candidate; | ||
1561 | } | ||
1562 | } | ||
1563 | } | ||
1564 | } | ||
1565 | |||
1566 | swayc_t *get_swayc_in_direction(swayc_t *container, enum movement_direction dir) { | ||
1567 | return get_swayc_in_direction_under(container, dir, NULL); | ||
1568 | } | ||
1569 | |||
1570 | void recursive_resize(swayc_t *container, double amount, enum wlc_resize_edge edge) { | ||
1571 | int i; | ||
1572 | bool layout_match = true; | ||
1573 | sway_log(L_DEBUG, "Resizing %p with amount: %f", container, amount); | ||
1574 | if (edge == WLC_RESIZE_EDGE_LEFT || edge == WLC_RESIZE_EDGE_RIGHT) { | ||
1575 | container->width += amount; | ||
1576 | layout_match = container->layout == L_HORIZ; | ||
1577 | } else if (edge == WLC_RESIZE_EDGE_TOP || edge == WLC_RESIZE_EDGE_BOTTOM) { | ||
1578 | container->height += amount; | ||
1579 | layout_match = container->layout == L_VERT; | ||
1580 | } | ||
1581 | if (container->type == C_VIEW) { | ||
1582 | update_geometry(container); | ||
1583 | return; | ||
1584 | } | ||
1585 | if (layout_match) { | ||
1586 | for (i = 0; i < container->children->length; i++) { | ||
1587 | recursive_resize(container->children->items[i], amount/container->children->length, edge); | ||
1588 | } | ||
1589 | } else { | ||
1590 | for (i = 0; i < container->children->length; i++) { | ||
1591 | recursive_resize(container->children->items[i], amount, edge); | ||
1592 | } | ||
1593 | } | ||
1594 | } | ||
1595 | |||
1596 | enum swayc_layouts default_layout(swayc_t *output) { | ||
1597 | if (config->default_layout != L_NONE) { | ||
1598 | return config->default_layout; | ||
1599 | } else if (config->default_orientation != L_NONE) { | ||
1600 | return config->default_orientation; | ||
1601 | } else if (output->width >= output->height) { | ||
1602 | return L_HORIZ; | ||
1603 | } else { | ||
1604 | return L_VERT; | ||
1605 | } | ||
1606 | } | ||
1607 | |||
1608 | bool is_auto_layout(enum swayc_layouts layout) { | ||
1609 | return (layout >= L_AUTO_FIRST) && (layout <= L_AUTO_LAST); | ||
1610 | } | ||
1611 | |||
1612 | /** | ||
1613 | * Return the number of master elements in a container | ||
1614 | */ | ||
1615 | static inline size_t auto_master_count(const swayc_t *container) { | ||
1616 | sway_assert(container->children->length >= 0, "Container %p has (negative) children %d", | ||
1617 | container, container->children->length); | ||
1618 | return MIN(container->nb_master, (size_t)container->children->length); | ||
1619 | } | ||
1620 | |||
1621 | /** | ||
1622 | * Return the number of children in the slave groups. This corresponds to the children | ||
1623 | * that are not members of the master group. | ||
1624 | */ | ||
1625 | static inline size_t auto_slave_count(const swayc_t *container) { | ||
1626 | return container->children->length - auto_master_count(container); | ||
1627 | } | ||
1628 | |||
1629 | /** | ||
1630 | * Return the number of slave groups in the container. | ||
1631 | */ | ||
1632 | size_t auto_slave_group_count(const swayc_t *container) { | ||
1633 | return MIN(container->nb_slave_groups, auto_slave_count(container)); | ||
1634 | } | ||
1635 | |||
1636 | /** | ||
1637 | * Return the combined number of master and slave groups in the container. | ||
1638 | */ | ||
1639 | size_t auto_group_count(const swayc_t *container) { | ||
1640 | return auto_slave_group_count(container) | ||
1641 | + (container->children->length && container->nb_master ? 1 : 0); | ||
1642 | } | ||
1643 | |||
1644 | /** | ||
1645 | * given the index of a container's child, return the index of the first child of the group | ||
1646 | * which index is a member of. | ||
1647 | */ | ||
1648 | int auto_group_start_index(const swayc_t *container, int index) { | ||
1649 | if (index < 0 || ! is_auto_layout(container->layout) | ||
1650 | || (size_t)index < container->nb_master) { | ||
1651 | return 0; | ||
1652 | } else { | ||
1653 | size_t nb_slaves = auto_slave_count(container); | ||
1654 | size_t nb_slave_grp = auto_slave_group_count(container); | ||
1655 | size_t grp_sz = nb_slaves / nb_slave_grp; | ||
1656 | size_t remainder = nb_slaves % nb_slave_grp; | ||
1657 | int idx2 = (nb_slave_grp - remainder) * grp_sz + container->nb_master; | ||
1658 | int start_idx; | ||
1659 | if (index < idx2) { | ||
1660 | start_idx = ((index - container->nb_master) / grp_sz) * grp_sz + container->nb_master; | ||
1661 | } else { | ||
1662 | start_idx = idx2 + ((index - idx2) / (grp_sz + 1)) * (grp_sz + 1); | ||
1663 | } | ||
1664 | return MIN(start_idx, container->children->length); | ||
1665 | } | ||
1666 | } | ||
1667 | |||
1668 | /** | ||
1669 | * given the index of a container's child, return the index of the first child of the group | ||
1670 | * that follows the one which index is a member of. | ||
1671 | * This makes the function usable to walk through the groups in a container. | ||
1672 | */ | ||
1673 | int auto_group_end_index(const swayc_t *container, int index) { | ||
1674 | if (index < 0 || ! is_auto_layout(container->layout)) { | ||
1675 | return container->children->length; | ||
1676 | } else { | ||
1677 | int nxt_idx; | ||
1678 | if ((size_t)index < container->nb_master) { | ||
1679 | nxt_idx = auto_master_count(container); | ||
1680 | } else { | ||
1681 | size_t nb_slaves = auto_slave_count(container); | ||
1682 | size_t nb_slave_grp = auto_slave_group_count(container); | ||
1683 | size_t grp_sz = nb_slaves / nb_slave_grp; | ||
1684 | size_t remainder = nb_slaves % nb_slave_grp; | ||
1685 | int idx2 = (nb_slave_grp - remainder) * grp_sz + container->nb_master; | ||
1686 | if (index < idx2) { | ||
1687 | nxt_idx = ((index - container->nb_master) / grp_sz + 1) * grp_sz + container->nb_master; | ||
1688 | } else { | ||
1689 | nxt_idx = idx2 + ((index - idx2) / (grp_sz + 1) + 1) * (grp_sz + 1); | ||
1690 | } | ||
1691 | } | ||
1692 | return MIN(nxt_idx, container->children->length); | ||
1693 | } | ||
1694 | } | ||
1695 | |||
1696 | /** | ||
1697 | * return the index of the Group containing <index>th child of <container>. | ||
1698 | * The index is the order of the group along the container's major axis (starting at 0). | ||
1699 | */ | ||
1700 | size_t auto_group_index(const swayc_t *container, int index) { | ||
1701 | if (index < 0) { | ||
1702 | return 0; | ||
1703 | } | ||
1704 | bool master_first = (container->layout == L_AUTO_LEFT || container->layout == L_AUTO_TOP); | ||
1705 | size_t nb_slaves = auto_slave_count(container); | ||
1706 | if ((size_t)index < container->nb_master) { | ||
1707 | if (master_first || nb_slaves <= 0) { | ||
1708 | return 0; | ||
1709 | } else { | ||
1710 | return auto_slave_group_count(container); | ||
1711 | } | ||
1712 | } else { | ||
1713 | size_t nb_slave_grp = auto_slave_group_count(container); | ||
1714 | size_t grp_sz = nb_slaves / nb_slave_grp; | ||
1715 | size_t remainder = nb_slaves % nb_slave_grp; | ||
1716 | int idx2 = (nb_slave_grp - remainder) * grp_sz + container->nb_master; | ||
1717 | size_t grp_idx; | ||
1718 | if (index < idx2) { | ||
1719 | grp_idx = (index - container->nb_master) / grp_sz; | ||
1720 | } else { | ||
1721 | grp_idx = (nb_slave_grp - remainder) + (index - idx2) / (grp_sz + 1) ; | ||
1722 | } | ||
1723 | return grp_idx + (master_first && container-> nb_master ? 1 : 0); | ||
1724 | } | ||
1725 | } | ||
1726 | |||
1727 | /** | ||
1728 | * Return the first index (inclusive) and last index (exclusive) of the elements of a group in | ||
1729 | * an auto layout. | ||
1730 | * If the bounds of the given group can be calculated, they are returned in the start/end | ||
1731 | * parameters (int pointers) and the return value will be true. | ||
1732 | * The indexes are passed by reference and can be NULL. | ||
1733 | */ | ||
1734 | bool auto_group_bounds(const swayc_t *container, size_t group_index, int *start, int *end) { | ||
1735 | size_t nb_grp = auto_group_count(container); | ||
1736 | if (group_index >= nb_grp) { | ||
1737 | return false; | ||
1738 | } | ||
1739 | bool master_first = (container->layout == L_AUTO_LEFT || container->layout == L_AUTO_TOP); | ||
1740 | size_t nb_master = auto_master_count(container); | ||
1741 | size_t nb_slave_grp = auto_slave_group_count(container); | ||
1742 | int g_start, g_end; | ||
1743 | if (nb_master && (master_first ? group_index == 0 : group_index == nb_grp - 1)) { | ||
1744 | g_start = 0; | ||
1745 | g_end = nb_master; | ||
1746 | } else { | ||
1747 | size_t nb_slaves = auto_slave_count(container); | ||
1748 | size_t grp_sz = nb_slaves / nb_slave_grp; | ||
1749 | size_t remainder = nb_slaves % nb_slave_grp; | ||
1750 | size_t g0 = master_first && container->nb_master ? 1 : 0; | ||
1751 | size_t g1 = g0 + nb_slave_grp - remainder; | ||
1752 | if (group_index < g1) { | ||
1753 | g_start = container->nb_master + (group_index - g0) * grp_sz; | ||
1754 | g_end = g_start + grp_sz; | ||
1755 | } else { | ||
1756 | size_t g2 = group_index - g1; | ||
1757 | g_start = container->nb_master | ||
1758 | + (nb_slave_grp - remainder) * grp_sz | ||
1759 | + g2 * (grp_sz + 1); | ||
1760 | g_end = g_start + grp_sz + 1; | ||
1761 | } | ||
1762 | } | ||
1763 | if (start) { | ||
1764 | *start = g_start; | ||
1765 | } | ||
1766 | if (end) { | ||
1767 | *end = g_end; | ||
1768 | } | ||
1769 | return true; | ||
1770 | } | ||