?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Force windows on-screen when using:
[fvwm.git] / fvwm / placement.c
blobd6ac0bade9c663cdc43ae3e87bff598a74893938
1 /* -*-c-*- */
2 /* This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or
5 * (at your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15 */
16
17 /* ---------------------------- included header files ---------------------- */
18
19 #include "config.h"
20
21 #include <stdio.h>
22
23 #include "libs/fvwmlib.h"
24 #include "libs/FScreen.h"
25 #include "libs/Grab.h"
26 #include "libs/Parse.h"
27 #include "libs/XResource.h"
28 #include "fvwm.h"
29 #include "externs.h"
30 #include "execcontext.h"
31 #include "cursor.h"
32 #include "bindings.h"
33 #include "misc.h"
34 #include "screen.h"
35 #include "placement.h"
36 #include "geometry.h"
37 #include "update.h"
38 #include "style.h"
39 #include "move_resize.h"
40 #include "virtual.h"
41 #include "stack.h"
42 #include "ewmh.h"
43 #include "icons.h"
44 #include "add_window.h"
45
46 /* ---------------------------- local definitions -------------------------- */
47
48 #define MAX_NUM_PLACEMENT_ALGOS 31
49 #define CP_GET_NEXT_STEP 5
50
51 /* ---------------------------- local macros ------------------------------- */
52
53 #ifndef MIN
54 #define MIN(A,B) ((A)<(B)? (A):(B))
55 #endif
56 #ifndef MAX
57 #define MAX(A,B) ((A)>(B)? (A):(B))
58 #endif
59
60 #define NORMAL_PLACEMENT_PENALTY(p) (p->normal)
61 #define ONTOP_PLACEMENT_PENALTY(p) (p->ontop)
62 #define ICON_PLACEMENT_PENALTY(p) (p->icon)
63 #define STICKY_PLACEMENT_PENALTY(p) (p->sticky)
64 #define BELOW_PLACEMENT_PENALTY(p) (p->below)
65 #define EWMH_STRUT_PLACEMENT_PENALTY(p) (p->strut)
66
67 #define PERCENTAGE_99_PENALTY(p) (p->p99)
68 #define PERCENTAGE_95_PENALTY(p) (p->p95)
69 #define PERCENTAGE_85_PENALTY(p) (p->p85)
70 #define PERCENTAGE_75_PENALTY(p) (p->p75)
71
72 /* ---------------------------- imports ------------------------------------ */
73
74 /* ---------------------------- included code files ------------------------ */
75
76 /* ---------------------------- local types -------------------------------- */
77
78 typedef enum
79 {
80 PR_POS_NORMAL = 0,
81 PR_POS_IGNORE_PPOS,
82 PR_POS_USE_PPOS,
83 PR_POS_IGNORE_USPOS,
84 PR_POS_USE_USPOS,
85 PR_POS_PLACE_AGAIN,
86 PR_POS_CAPTURE,
87 PR_POS_USPOS_OVERRIDE_SOS
88 } preason_pos_t;
89
90 typedef enum
91 {
92 PR_SCREEN_CURRENT = 0,
93 PR_SCREEN_STYLE,
94 PR_SCREEN_X_RESOURCE_FVWMSCREEN,
95 PR_SCREEN_IGNORE_CAPTURE
96 } preason_screen_t;
97
98 typedef enum
99 {
100 PR_PAGE_CURRENT = 0,
101 PR_PAGE_STYLE,
102 PR_PAGE_X_RESOURCE_PAGE,
103 PR_PAGE_IGNORE_CAPTURE,
104 PR_PAGE_IGNORE_INVALID,
105 PR_PAGE_STICKY
106 } preason_page_t;
107
108 typedef enum
109 {
110 PR_DESK_CURRENT = 0,
111 PR_DESK_STYLE,
112 PR_DESK_X_RESOURCE_DESK,
113 PR_DESK_X_RESOURCE_PAGE,
114 PR_DESK_CAPTURE,
115 PR_DESK_STICKY,
116 PR_DESK_WINDOW_GROUP_LEADER,
117 PR_DESK_WINDOW_GROUP_MEMBER,
118 PR_DESK_TRANSIENT,
119 PR_DESK_XPROP_XA_WM_DESKTOP
120 } preason_desk_t;
121
122 typedef struct
123 {
124 struct
125 {
126 preason_pos_t reason;
127 int x;
128 int y;
129 int algo;
130 char *pl_position_string;
131 unsigned do_not_manual_icon_placement : 1;
132 unsigned do_adjust_off_screen : 1;
133 unsigned do_adjust_off_page : 1;
134 unsigned is_pl_position_string_invalid : 1;
135 unsigned has_tile_failed : 1;
136 unsigned has_manual_failed : 1;
137 unsigned has_placement_failed : 1;
138 } pos;
139 struct
140 {
141 preason_screen_t reason;
142 int screen;
143 rectangle g;
144 unsigned was_modified_by_ewmh_workingarea : 1;
145 } screen;
146 struct
147 {
148 preason_page_t reason;
149 int px;
150 int py;
151 unsigned do_switch_page : 1;
152 unsigned do_honor_starts_on_page : 1;
153 unsigned do_ignore_starts_on_page : 1;
154 } page;
155 struct
156 {
157 preason_desk_t reason;
158 preason_desk_t sod_reason;
159 int desk;
160 unsigned do_switch_desk : 1;
161 } desk;
162 } pl_reason_t;
163
164 typedef struct
165 {
166 int desk;
167 int page_x;
168 int page_y;
169 int screen;
170 } pl_start_style_t;
171
172 typedef struct
173 {
174 unsigned do_forbid_manual_placement : 1;
175 unsigned do_honor_starts_on_page : 1;
176 unsigned do_honor_starts_on_screen : 1;
177 unsigned do_not_use_wm_placement : 1;
178 } pl_flags_t;
179
180 typedef float pl_penalty_t;
181
182 typedef enum
183 {
184 PL_LOOP_END,
185 PL_LOOP_CONT
186 } pl_loop_rc_t;
187
188 struct pl_arg_t;
189 struct pl_ret_t;
190
191 typedef struct
192 {
193 /* If this funtion pointer is not NULL, use this function to return
194 * the desired position in a single call */
195 pl_penalty_t (*get_pos_simple)(
196 position *ret_p, struct pl_ret_t *ret,
197 const struct pl_arg_t *arg);
198 /* otherwise use these three in a loop */
199 pl_loop_rc_t (*get_first_pos)(
200 position *ret_p, struct pl_ret_t *ret,
201 const struct pl_arg_t *arg);
202 pl_loop_rc_t (*get_next_pos)(
203 position *ret_p, struct pl_ret_t *ret,
204 const struct pl_arg_t *arg, position hint_p);
205 pl_penalty_t (*get_pos_penalty)(
206 position *ret_hint_p, struct pl_ret_t *ret,
207 const struct pl_arg_t *arg);
208 } pl_algo_t;
209
210 typedef struct pl_scratch_t
211 {
212 const pl_penalty_struct *pp;
213 const pl_percent_penalty_struct *ppp;
214 } pl_scratch_t;
215
216 typedef struct pl_arg_t
217 {
218 const pl_algo_t *algo;
219 const exec_context_t *exc;
220 const window_style *style;
221 pl_reason_t *reason;
222 FvwmWindow *place_fw;
223 pl_scratch_t *scratch;
224 rectangle place_g;
225 position place_p2;
226 rectangle screen_g;
227 position page_p1;
228 position page_p2;
229 position pdelta_p;
230 struct
231 {
232 unsigned use_percent : 1;
233 unsigned use_ewmh_dynamic_working_areapercent : 1;
234 unsigned do_honor_starts_on_page : 1;
235 } flags;
236 } pl_arg_t;
237
238 typedef struct pl_ret_t
239 {
240 position best_p;
241 pl_penalty_t best_penalty;
242 struct
243 {
244 unsigned do_resize_too : 1;
245 } flags;
246 } pl_ret_t;
247
248 /* ---------------------------- forward declarations ----------------------- */
249
250 static pl_loop_rc_t __pl_minoverlap_get_first_pos(
251 position *ret_p, struct pl_ret_t *ret, const struct pl_arg_t *arg);
252 static pl_loop_rc_t __pl_minoverlap_get_next_pos(
253 position *ret_p, struct pl_ret_t *ret, const struct pl_arg_t *arg,
254 position hint_p);
255 static pl_penalty_t __pl_minoverlap_get_pos_penalty(
256 position *ret_hint_p, struct pl_ret_t *ret, const pl_arg_t *arg);
257
258 static pl_penalty_t __pl_smart_get_pos_penalty(
259 position *ret_hint_p, struct pl_ret_t *ret, const pl_arg_t *arg);
260
261 static pl_penalty_t __pl_position_get_pos_simple(
262 position *ret_p, struct pl_ret_t *ret, const struct pl_arg_t *arg);
263
264 static pl_penalty_t __pl_cascade_get_pos_simple(
265 position *ret_p, struct pl_ret_t *ret, const struct pl_arg_t *arg);
266
267 static pl_penalty_t __pl_manual_get_pos_simple(
268 position *ret_p, struct pl_ret_t *ret, const struct pl_arg_t *arg);
269
270 /* ---------------------------- local variables ---------------------------- */
271
272 const pl_algo_t minoverlap_placement_algo =
273 {
274 NULL,
275 __pl_minoverlap_get_first_pos,
276 __pl_minoverlap_get_next_pos,
277 __pl_minoverlap_get_pos_penalty
278 };
279
280 const pl_algo_t smart_placement_algo =
281 {
282 NULL,
283 __pl_minoverlap_get_first_pos,
284 __pl_minoverlap_get_next_pos,
285 __pl_smart_get_pos_penalty
286 };
287
288 const pl_algo_t position_placement_algo =
289 {
290 __pl_position_get_pos_simple
291 };
292
293 const pl_algo_t cascade_placement_algo =
294 {
295 __pl_cascade_get_pos_simple
296 };
297
298 const pl_algo_t manual_placement_algo =
299 {
300 __pl_manual_get_pos_simple
301 };
302
303 /* ---------------------------- exported variables (globals) --------------- */
304
305 const pl_penalty_struct default_pl_penalty =
306 {
307 1,
308 PLACEMENT_AVOID_ONTOP,
309 PLACEMENT_AVOID_ICON,
310 PLACEMENT_AVOID_STICKY,
311 PLACEMENT_AVOID_BELOW,
312 PLACEMENT_AVOID_EWMH_STRUT
313 };
314
315 const pl_percent_penalty_struct default_pl_percent_penalty =
316 {
317 PLACEMENT_AVOID_COVER_99,
318 PLACEMENT_AVOID_COVER_95,
319 PLACEMENT_AVOID_COVER_85,
320 PLACEMENT_AVOID_COVER_75
321 };
322
323 /* ---------------------------- local functions (PositionPlacement) -------- */
324
325 static pl_penalty_t __pl_position_get_pos_simple(
326 position *ret_p, struct pl_ret_t *ret, const struct pl_arg_t *arg)
327 {
328 char *spos;
329 Bool fPointer;
330 int n;
331 int i;
332 Bool is_under_mouse;
333
334 is_under_mouse = False;
335 spos = SGET_PLACEMENT_POSITION_STRING(*arg->style);
336 if (spos == NULL || *spos == 0)
337 {
338 spos = DEFAULT_PLACEMENT_POSITION_STRING;
339 i = 1;
340 }
341 else if (StrEquals(spos, "Center"))
342 {
343 spos = DEFAULT_PLACEMENT_POS_CENTER_STRING;
344 i = 1;
345 }
346 else if (StrEquals(spos, "UnderMouse"))
347 {
348 spos = DEFAULT_PLACEMENT_POS_MOUSE_STRING;
349 i = 1;
350 is_under_mouse = True;
351 }
352 else
353 {
354 i = 0;
355 }
356 arg->reason->pos.pl_position_string = spos;
357 for (n = -1; i < 2 && n < 2; i++)
358 {
359 fPointer = False;
360 ret_p->x = 0;
361 ret_p->y = 0;
362 n = GetMoveArguments(
363 &spos, arg->place_g.width, arg->place_g.height,
364 &ret_p->x, &ret_p->y, NULL, &fPointer, False);
365 spos = DEFAULT_PLACEMENT_POSITION_STRING;
366 if (n < 2)
367 {
368 arg->reason->pos.is_pl_position_string_invalid = 1;
369 }
370 }
371 if (n < 2)
372 {
373 /* bug */
374 abort();
375 }
376 if (is_under_mouse)
377 {
378 /* TA: 20090218: Try and keep the window on-screen if we
379 * can.
380 */
381 if (ret_p->x + arg->place_fw->g.frame.width > arg->screen_g.x
382 + arg->screen_g.width)
383 {
384 ret_p->x = (arg->screen_g.x + arg->screen_g.width) -
385 arg->place_fw->g.frame.width;
386 }
387 if (ret_p->y + arg->place_fw->g.frame.height > arg->screen_g.y
388 + arg->screen_g.height)
389 {
390 ret_p->y = (arg->screen_g.y + arg->screen_g.height) -
391 arg->place_fw->g.frame.height;
392 }
393 }
394 /* Don't let the upper left corner be offscreen. */
395 if (ret_p->x < arg->screen_g.x)
396 {
397 ret_p->x = arg->screen_g.x;
398 }
399 if (ret_p->y < arg->screen_g.y)
400 {
401 ret_p->y = arg->screen_g.y;
402 }
403 if (arg->flags.do_honor_starts_on_page)
404 {
405 ret_p->x -= arg->pdelta_p.x;
406 ret_p->y -= arg->pdelta_p.y;
407 }
408
409 return 0;
410 }
411
412 /* ---------------------------- local functions (CascadePlacement)---------- */
413
414 static pl_penalty_t __pl_cascade_get_pos_simple(
415 position *ret_p, struct pl_ret_t *ret, const struct pl_arg_t *arg)
416 {
417 size_borders b;
418 int w;
419 FvwmWindow *t;
420
421 t = (Scr.cascade_window != NULL) ? Scr.cascade_window : arg->place_fw;
422 w = t->title_thickness;
423 if (w == 0)
424 {
425 w = t->boundary_width;
426 }
427 if (w == 0)
428 {
429 w = PLACEMENT_FALLBACK_CASCADE_STEP;
430 }
431
432 if (Scr.cascade_window != NULL)
433 {
434
435 Scr.cascade_x += w;
436 Scr.cascade_y += w;
437 switch (GET_TITLE_DIR(t))
438 {
439 case DIR_S:
440 case DIR_N:
441 Scr.cascade_y += w;
442 break;
443 case DIR_E:
444 case DIR_W:
445 Scr.cascade_x += w;
446 break;
447 default:
448 break;
449 }
450 }
451 Scr.cascade_window = arg->place_fw;
452 if (Scr.cascade_x > arg->screen_g.width / 2)
453 {
454 Scr.cascade_x = arg->place_fw->title_thickness;
455 }
456 if (Scr.cascade_y > arg->screen_g.height / 2)
457 {
458 Scr.cascade_y = 2 * arg->place_fw->title_thickness;
459 }
460 ret_p->x = Scr.cascade_x + arg->page_p1.x;
461 ret_p->y = Scr.cascade_y + arg->page_p1.y;
462 /* try to keep the window on the screen */
463 get_window_borders(arg->place_fw, &b);
464 if (ret_p->x + arg->place_g.width >= arg->page_p2.x)
465 {
466 ret_p->x = arg->page_p2.x - arg->place_g.width -
467 b.total_size.width;
468 Scr.cascade_x = arg->place_fw->title_thickness;
469 switch (GET_TITLE_DIR(t))
470 {
471 case DIR_E:
472 case DIR_W:
473 Scr.cascade_x += arg->place_fw->title_thickness;
474 default:
475 break;
476 }
477 }
478 if (ret_p->y + arg->place_g.height >= arg->page_p2.y)
479 {
480 ret_p->y = arg->page_p2.y - arg->place_g.height -
481 b.total_size.height;
482 Scr.cascade_y = arg->place_fw->title_thickness;
483 switch (GET_TITLE_DIR(t))
484 {
485 case DIR_N:
486 case DIR_S:
487 Scr.cascade_y += arg->place_fw->title_thickness;
488 default:
489 break;
490 }
491 }
492
493 /* the left and top sides are more important in huge windows */
494 if (ret_p->x < arg->page_p1.x)
495 {
496 ret_p->x = arg->page_p1.x;
497 }
498 if (ret_p->y < arg->page_p1.y)
499 {
500 ret_p->y = arg->page_p1.y;
501 }
502
503 return 0;
504 }
505
506 /* ---------------------------- local functions (ManualPlacement)----------- */
507
508 static pl_penalty_t __pl_manual_get_pos_simple(
509 position *ret_p, struct pl_ret_t *ret, const struct pl_arg_t *arg)
510 {
511 ret_p->x = 0;
512 ret_p->y = 0;
513 if (GrabEm(CRS_POSITION, GRAB_NORMAL))
514 {
515 int DragWidth;
516 int DragHeight;
517 int mx;
518 int my;
519
520 /* Grabbed the pointer - continue */
521 MyXGrabServer(dpy);
522 if (
523 XGetGeometry(
524 dpy, FW_W(arg->place_fw), &JunkRoot, &JunkX,
525 &JunkY, (unsigned int*)&DragWidth,
526 (unsigned int*)&DragHeight,
527 (unsigned int*)&JunkBW,
528 (unsigned int*)&JunkDepth) == 0)
529 {
530 MyXUngrabServer(dpy);
531 UngrabEm(GRAB_NORMAL);
532
533 return -1;
534 }
535 SET_PLACED_BY_FVWM(arg->place_fw, 0);
536 MyXGrabKeyboard(dpy);
537 DragWidth = arg->place_g.width;
538 DragHeight = arg->place_g.height;
539
540 if (Scr.SizeWindow != None)
541 {
542 XMapRaised(dpy, Scr.SizeWindow);
543 }
544 FScreenGetScrRect(
545 NULL, FSCREEN_GLOBAL, &mx, &my, NULL, NULL);
546 if (__move_loop(
547 arg->exc, mx, my, DragWidth, DragHeight, &ret_p->x,
548 &ret_p->y, False, CRS_POSITION))
549 {
550 ret->flags.do_resize_too = 1;
551 }
552 if (Scr.SizeWindow != None)
553 {
554 XUnmapWindow(dpy, Scr.SizeWindow);
555 }
556 MyXUngrabKeyboard(dpy);
557 MyXUngrabServer(dpy);
558 UngrabEm(GRAB_NORMAL);
559 }
560 else
561 {
562 /* couldn't grab the pointer - better do something */
563 XBell(dpy, 0);
564 ret_p->x = 0;
565 ret_p->y = 0;
566 arg->reason->pos.has_manual_failed = 1;
567 }
568 if (arg->flags.do_honor_starts_on_page)
569 {
570 ret_p->x -= arg->pdelta_p.x;
571 ret_p->y -= arg->pdelta_p.y;
572 }
573
574 return 0;
575 }
576
577 /* ---------------------------- local functions (MinoverlapPlacement) ------ */
578
579 /* MinoverlapPlacement by Anthony Martin <amartin@engr.csulb.edu>
580 * This algorithm places a new window such that there is a minimum amount of
581 * interference with other windows. If it can place a window without any
582 * interference, fine. Otherwise, it places it so that the area of of
583 * interference between the new window and the other windows is minimized */
584
585 static int __pl_minoverlap_get_next_x(const pl_arg_t *arg)
586 {
587 FvwmWindow *other_fw;
588 int xnew;
589 int xtest;
590 int stickyx;
591 int stickyy;
592 int start,i;
593 int win_left;
594 rectangle g;
595 Bool rc;
596 int x;
597 int y;
598
599 x = arg->place_g.x;
600 y = arg->place_g.y;
601 if (arg->flags.use_percent == 1)
602 {
603 start = 0;
604 }
605 else
606 {
607 start = CP_GET_NEXT_STEP;
608 }
609
610 /* Test window at far right of screen */
611 xnew = arg->page_p2.x;
612 xtest = arg->page_p2.x - arg->place_g.width;
613 if (xtest > x)
614 {
615 xnew = xtest;
616 }
617 /* test the borders of the working area */
618 xtest = arg->page_p1.x + Scr.Desktops->ewmh_working_area.x;
619 if (xtest > x)
620 {
621 xnew = MIN(xnew, xtest);
622 }
623 xtest = arg->page_p1.x +
624 (Scr.Desktops->ewmh_working_area.x +
625 Scr.Desktops->ewmh_working_area.width) -
626 arg->place_g.width;
627 if (xtest > x)
628 {
629 xnew = MIN(xnew, xtest);
630 }
631 /* Test the values of the right edges of every window */
632 for (
633 other_fw = Scr.FvwmRoot.next; other_fw != NULL;
634 other_fw = other_fw->next)
635 {
636 if (
637 other_fw == arg->place_fw ||
638 (other_fw->Desk != arg->place_fw->Desk &&
639 !IS_STICKY_ACROSS_DESKS(other_fw)) ||
640 IS_EWMH_DESKTOP(FW_W(other_fw)))
641 {
642 continue;
643 }
644 if (IS_STICKY_ACROSS_PAGES(other_fw))
645 {
646 stickyx = arg->pdelta_p.x;
647 stickyy = arg->pdelta_p.y;
648 }
649 else
650 {
651 stickyx = 0;
652 stickyy = 0;
653 }
654 if (IS_ICONIFIED(other_fw))
655 {
656 rc = get_visible_icon_geometry(other_fw, &g);
657 if (rc == True && y < g.y + g.height - stickyy &&
658 g.y - stickyy < arg->place_g.height + y)
659 {
660 win_left = arg->page_p1.x + g.x - stickyx -
661 arg->place_g.width;
662 for (i = start; i <= CP_GET_NEXT_STEP; i++)
663 {
664 xtest = win_left + g.width *
665 (CP_GET_NEXT_STEP - i) /
666 CP_GET_NEXT_STEP;
667 if (xtest > x)
668 {
669 xnew = MIN(xnew, xtest);
670 }
671 }
672 win_left = arg->page_p1.x + g.x - stickyx;
673 for (i = start; i <= CP_GET_NEXT_STEP; i++)
674 {
675 xtest = (win_left) + g.width * i /
676 CP_GET_NEXT_STEP;
677 if (xtest > x)
678 {
679 xnew = MIN(xnew, xtest);
680 }
681 }
682 }
683 }
684 else if (
685 y < other_fw->g.frame.height + other_fw->g.frame.y -
686 stickyy &&
687 other_fw->g.frame.y - stickyy <
688 arg->place_g.height + y &&
689 arg->page_p1.x < other_fw->g.frame.width +
690 other_fw->g.frame.x - stickyx &&
691 other_fw->g.frame.x - stickyx < arg->page_p2.x)
692 {
693 win_left =
694 other_fw->g.frame.x - stickyx -
695 arg->place_g.width;
696 for (i = start; i <= CP_GET_NEXT_STEP; i++)
697 {
698 xtest = win_left + other_fw->g.frame.width *
699 (CP_GET_NEXT_STEP - i) /
700 CP_GET_NEXT_STEP;
701 if (xtest > x)
702 {
703 xnew = MIN(xnew, xtest);
704 }
705 }
706 win_left = other_fw->g.frame.x - stickyx;
707 for (i = start; i <= CP_GET_NEXT_STEP; i++)
708 {
709 xtest = win_left + other_fw->g.frame.width *
710 i / CP_GET_NEXT_STEP;
711 if (xtest > x)
712 {
713 xnew = MIN(xnew, xtest);
714 }
715 }
716 }
717 }
718
719 return xnew;
720 }
721
722 static int __pl_minoverlap_get_next_y(const pl_arg_t *arg)
723 {
724 FvwmWindow *other_fw;
725 int ynew;
726 int ytest;
727 int stickyy;
728 int win_top;
729 int start;
730 int i;
731 rectangle g;
732 int y;
733
734 y = arg->place_g.y;
735 if (arg->flags.use_percent == 1)
736 {
737 start = 0;
738 }
739 else
740 {
741 start = CP_GET_NEXT_STEP;
742 }
743
744 /* Test window at far bottom of screen */
745 ynew = arg->page_p2.y;
746 ytest = arg->page_p2.y - arg->place_g.height;
747 if (ytest > y)
748 {
749 ynew = ytest;
750 }
751 /* test the borders of the working area */
752 ytest = arg->page_p1.y + Scr.Desktops->ewmh_working_area.y;
753 if (ytest > y)
754 {
755 ynew = MIN(ynew, ytest);
756 }
757 ytest = arg->screen_g.y +
758 (Scr.Desktops->ewmh_working_area.y +
759 Scr.Desktops->ewmh_working_area.height) -
760 arg->place_g.height;
761 if (ytest > y)
762 {
763 ynew = MIN(ynew, ytest);
764 }
765 /* Test the values of the bottom edge of every window */
766 for (
767 other_fw = Scr.FvwmRoot.next; other_fw != NULL;
768 other_fw = other_fw->next)
769 {
770 if (
771 other_fw == arg->place_fw ||
772 (
773 other_fw->Desk != arg->place_fw->Desk &&
774 !IS_STICKY_ACROSS_DESKS(other_fw)) ||
775 IS_EWMH_DESKTOP(FW_W(other_fw)))
776 {
777 continue;
778 }
779
780 if (IS_STICKY_ACROSS_PAGES(other_fw))
781 {
782 stickyy = arg->pdelta_p.y;
783 }
784 else
785 {
786 stickyy = 0;
787 }
788
789 if (IS_ICONIFIED(other_fw))
790 {
791 get_visible_icon_geometry(other_fw, &g);
792 win_top = g.y - stickyy;
793 for (i = start; i <= CP_GET_NEXT_STEP; i++)
794 {
795 ytest =
796 win_top + g.height * i /
797 CP_GET_NEXT_STEP;
798 if (ytest > y)
799 {
800 ynew = MIN(ynew, ytest);
801 }
802 }
803 win_top = g.y - stickyy - arg->place_g.height;
804 for (i = start; i <= CP_GET_NEXT_STEP; i++)
805 {
806 ytest =
807 win_top + g.height *
808 (CP_GET_NEXT_STEP - i) /
809 CP_GET_NEXT_STEP;
810 if (ytest > y)
811 {
812 ynew = MIN(ynew, ytest);
813 }
814 }
815 }
816 else
817 {
818 win_top = other_fw->g.frame.y - stickyy;
819 for (i = start; i <= CP_GET_NEXT_STEP; i++)
820 {
821 ytest =
822 win_top + other_fw->g.frame.height *
823 i / CP_GET_NEXT_STEP;
824 if (ytest > y)
825 {
826 ynew = MIN(ynew, ytest);
827 }
828 }
829 win_top = other_fw->g.frame.y - stickyy -
830 arg->place_g.height;
831 for (i = start; i <= CP_GET_NEXT_STEP; i++)
832 {
833 ytest =
834 win_top + other_fw->g.frame.height *
835 (CP_GET_NEXT_STEP - i) /
836 CP_GET_NEXT_STEP;
837 if (ytest > y)
838 {
839 ynew = MIN(ynew, ytest);
840 }
841 }
842 }
843 }
844
845 return ynew;
846 }
847
848 static pl_loop_rc_t __pl_minoverlap_get_first_pos(
849 position *ret_p, struct pl_ret_t *ret, const pl_arg_t *arg)
850 {
851 /* top left corner of page */
852 ret_p->x = arg->page_p1.x;
853 ret_p->y = arg->page_p1.y;
854
855 return PL_LOOP_CONT;
856 }
857
858 static pl_loop_rc_t __pl_minoverlap_get_next_pos(
859 position *ret_p, struct pl_ret_t *ret, const struct pl_arg_t *arg,
860 position hint_p)
861 {
862 ret_p->x = arg->place_g.x;
863 ret_p->y = arg->place_g.y;
864 if (ret_p->x + arg->place_g.width <= arg->page_p2.x)
865 {
866 /* try next x */
867 ret_p->x = __pl_minoverlap_get_next_x(arg);
868 ret_p->y = arg->place_g.y;
869 }
870 if (ret_p->x + arg->place_g.width > arg->page_p2.x)
871 {
872 /* out of room in x direction. Try next y. Reset x.*/
873 ret_p->x = arg->page_p1.x;
874 ret_p->y = __pl_minoverlap_get_next_y(arg);
875 }
876 if (ret_p->y + arg->place_g.height > arg->page_p2.y)
877 {
878 /* PageBottom */
879 return PL_LOOP_END;
880 }
881
882 return PL_LOOP_CONT;
883 }
884
885 static pl_penalty_t __pl_minoverlap_get_avoidance_penalty(
886 const pl_arg_t *arg, FvwmWindow *other_fw, const rectangle *other_g)
887 {
888 pl_penalty_t anew;
889 pl_penalty_t avoidance_factor;
890 position other_p2;
891 const pl_penalty_struct *opp;
892 const pl_percent_penalty_struct *oppp;
893
894 opp = (arg->scratch->pp != 0 && 0) ? arg->scratch->pp :
895 &other_fw->pl_penalty;
896 oppp = (arg->scratch->ppp != 0 && 0) ? arg->scratch->ppp :
897 &other_fw->pl_percent_penalty;
898 other_p2.x = other_g->x + other_g->width;
899 other_p2.y = other_g->y + other_g->height;
900 {
901 long x1 = MAX(arg->place_g.x, other_g->x);
902 long x2 = MIN(arg->place_p2.x, other_p2.x);
903 long y1 = MAX(arg->place_g.y, other_g->y);
904 long y2 = MIN(arg->place_p2.y, other_p2.y);
905
906 /* overlapping area in pixels (windows are guaranteed to
907 * overlap when this function is called) */
908 anew = (x2 - x1) * (y2 - y1);
909 }
910 if (IS_ICONIFIED(other_fw))
911 {
912 avoidance_factor = ICON_PLACEMENT_PENALTY(opp);
913 }
914 else if (compare_window_layers(other_fw, arg->place_fw) > 0)
915 {
916 avoidance_factor = ONTOP_PLACEMENT_PENALTY(opp);
917 }
918 else if (compare_window_layers(other_fw, arg->place_fw) < 0)
919 {
920 avoidance_factor = BELOW_PLACEMENT_PENALTY(opp);
921 }
922 else if (
923 IS_STICKY_ACROSS_PAGES(other_fw) ||
924 IS_STICKY_ACROSS_DESKS(other_fw))
925 {
926 avoidance_factor = STICKY_PLACEMENT_PENALTY(opp);
927 }
928 else
929 {
930 avoidance_factor = NORMAL_PLACEMENT_PENALTY(opp);
931 }
932 if (arg->flags.use_percent == 1)
933 {
934 pl_penalty_t cover_factor;
935 long other_area;
936 long place_area;
937
938 other_area = other_g->width * other_g->height;
939 place_area = arg->place_g.width * arg->place_g.height;
940 cover_factor = 0;
941 if (other_area != 0 && place_area != 0)
942 {
943 anew = 100 * MAX(anew / other_area, anew / place_area);
944 if (anew >= 99)
945 {
946 cover_factor = PERCENTAGE_99_PENALTY(oppp);
947 }
948 else if (anew > 94)
949 {
950 cover_factor = PERCENTAGE_95_PENALTY(oppp);
951 }
952 else if (anew > 84)
953 {
954 cover_factor = PERCENTAGE_85_PENALTY(oppp);
955 }
956 else if (anew > 74)
957 {
958 cover_factor = PERCENTAGE_75_PENALTY(oppp);
959 }
960 }
961 if (avoidance_factor >= 1)
962 {
963 avoidance_factor += cover_factor;
964 }
965 }
966 if (
967 arg->flags.use_ewmh_dynamic_working_areapercent == 1 &&
968 DO_EWMH_IGNORE_STRUT_HINTS(other_fw) == 0 &&
969 (
970 other_fw->dyn_strut.left > 0 ||
971 other_fw->dyn_strut.right > 0 ||
972 other_fw->dyn_strut.top > 0 ||
973 other_fw->dyn_strut.bottom > 0))
974 {
975 const pl_penalty_struct *mypp;
976
977 mypp = (arg->scratch->pp != 0 && 0) ? arg->scratch->pp :
978 &arg->place_fw->pl_penalty;
979 /* if we intersect a window which reserves space */
980 avoidance_factor += (avoidance_factor >= 1) ?
981 EWMH_STRUT_PLACEMENT_PENALTY(mypp) : 0;
982 }
983 anew *= avoidance_factor;
984
985 return anew;
986 }
987
988 static pl_penalty_t __pl_minoverlap_get_pos_penalty(
989 position *ret_hint_p, struct pl_ret_t *ret, const struct pl_arg_t *arg)
990 {
991 FvwmWindow *other_fw;
992 pl_penalty_t penalty;
993
994 penalty = 0;
995 for (
996 other_fw = Scr.FvwmRoot.next; other_fw != NULL;
997 other_fw = other_fw->next)
998 {
999 rectangle other_g;
1000 Bool rc;
1001
1002 if (
1003 arg->place_fw == other_fw ||
1004 IS_EWMH_DESKTOP(FW_W(other_fw)))
1005 {
1006 continue;
1007 }
1008 /* RBW - account for sticky windows... */
1009 if (
1010 other_fw->Desk != arg->place_fw->Desk &&
1011 IS_STICKY_ACROSS_DESKS(other_fw) == 0)
1012 {
1013 continue;
1014 }
1015 rc = get_visible_window_or_icon_geometry(other_fw, &other_g);
1016 if (IS_STICKY_ACROSS_PAGES(other_fw))
1017 {
1018 other_g.x -= arg->pdelta_p.x;
1019 other_g.y -= arg->pdelta_p.y;
1020 }
1021 if (
1022 arg->place_g.x < other_g.x + other_g.width &&
1023 arg->place_p2.x > other_g.x &&
1024 arg->place_g.y < other_g.y + other_g.height &&
1025 arg->place_p2.y > other_g.y)
1026 {
1027 pl_penalty_t anew;
1028
1029 anew = __pl_minoverlap_get_avoidance_penalty(
1030 arg, other_fw, &other_g);
1031 penalty += anew;
1032 if (
1033 penalty > ret->best_penalty &&
1034 ret->best_penalty != -1)
1035 {
1036 /* stop looking; the penalty is too high */
1037 return penalty;
1038 }
1039 }
1040 }
1041 /* now handle the working area */
1042 {
1043 const pl_penalty_struct *mypp;
1044
1045 mypp = (arg->scratch->pp != 0 && 0) ? arg->scratch->pp :
1046 &arg->place_fw->pl_penalty;
1047 if (arg->flags.use_ewmh_dynamic_working_areapercent == 1)
1048 {
1049 penalty += EWMH_STRUT_PLACEMENT_PENALTY(mypp) *
1050 EWMH_GetStrutIntersection(
1051 arg->place_g.x, arg->place_g.y,
1052 arg->place_p2.x, arg->place_p2.y,
1053 arg->flags.use_percent);
1054 }
1055 else
1056 {
1057 /* EWMH_USE_DYNAMIC_WORKING_AREA, count the base strut
1058 */
1059 penalty +=
1060 EWMH_STRUT_PLACEMENT_PENALTY(mypp) *
1061 EWMH_GetBaseStrutIntersection(
1062 arg->place_g.x, arg->place_g.y,
1063 arg->place_p2.x, arg->place_p2.y,
1064 arg->flags.use_percent);
1065 }
1066 }
1067
1068 return penalty;
1069 }
1070
1071 /* ---------------------------- local functions (SmartPlacement) ----------- */
1072
1073 static pl_penalty_t __pl_smart_get_pos_penalty(
1074 position *ret_hint_p, struct pl_ret_t *ret, const struct pl_arg_t *arg)
1075 {
1076 pl_penalty_t p;
1077
1078 arg->scratch->pp = &default_pl_penalty;
1079 arg->scratch->ppp = &default_pl_percent_penalty;
1080 p = __pl_minoverlap_get_pos_penalty(ret_hint_p, ret, arg);
1081 if (p != 0)
1082 {
1083 p = -1;
1084 }
1085
1086 return p;
1087 }
1088
1089 /* ---------------------------- local functions ---------------------------- */
1090
1091 static int placement_loop(pl_ret_t *ret, pl_arg_t *arg)
1092 {
1093 position next_p;
1094 pl_penalty_t penalty;
1095 pl_loop_rc_t loop_rc;
1096
1097 if (arg->algo->get_pos_simple != NULL)
1098 {
1099 position pos;
1100
1101 penalty = arg->algo->get_pos_simple(&pos, ret, arg);
1102 arg->place_g.x = pos.x;
1103 arg->place_g.y = pos.y;
1104 ret->best_penalty = penalty;
1105 ret->best_p.x = pos.x;
1106 ret->best_p.y = pos.y;
1107 loop_rc = PL_LOOP_END;
1108 }
1109 else
1110 {
1111 loop_rc = arg->algo->get_first_pos(&next_p, ret, arg);
1112 arg->place_g.x = next_p.x;
1113 arg->place_g.y = next_p.y;
1114 ret->best_p.x = next_p.x;
1115 ret->best_p.y = next_p.y;
1116 }
1117 while (loop_rc != PL_LOOP_END)
1118 {
1119 position hint_p;
1120 pl_scratch_t scratch;
1121
1122 memset(&scratch, 0, sizeof(scratch));
1123 arg->scratch = &scratch;
1124 arg->place_p2.x = arg->place_g.x + arg->place_g.width;
1125 arg->place_p2.y = arg->place_g.y + arg->place_g.height;
1126 hint_p.x = arg->place_g.x;
1127 hint_p.y = arg->place_g.y;
1128 penalty = arg->algo->get_pos_penalty(&hint_p, ret, arg);
1129 /* I've added +0.0001 because with my machine the < test fail
1130 * with certain *equal* float numbers! */
1131 if (
1132 penalty >= 0 &&
1133 (
1134 ret->best_penalty < 0 ||
1135 penalty + 0.0001 < ret->best_penalty))
1136 {
1137 ret->best_p.x = arg->place_g.x;
1138 ret->best_p.y = arg->place_g.y;
1139 ret->best_penalty = penalty;
1140 }
1141 if (penalty == 0)
1142 {
1143 break;
1144 }
1145 loop_rc = arg->algo->get_next_pos(&next_p, ret, arg, hint_p);
1146 arg->place_g.x = next_p.x;
1147 arg->place_g.y = next_p.y;
1148 }
1149 if (ret->best_penalty < 0)
1150 {
1151 ret->best_penalty = -1;
1152 }
1153
1154 return (ret->best_penalty == -1) ? -1 : 0;
1155 }
1156
1157 static void __place_get_placement_flags(
1158 pl_flags_t *ret_flags, FvwmWindow *fw, window_style *pstyle,
1159 initial_window_options_t *win_opts, int mode, pl_reason_t *reason)
1160 {
1161 Bool override_ppos;
1162 Bool override_uspos;
1163 Bool has_ppos = False;
1164 Bool has_uspos = False;
1165
1166 /* Windows use the position hint if these conditions are met:
1167 *
1168 * The program specified a USPosition hint and it is not overridden
1169 * with the No(Transient)USPosition style.
1170 *
1171 * OR
1172 *
1173 * The program specified a PPosition hint and it is not overridden
1174 * with the No(Transient)PPosition style.
1175 *
1176 * Windows without a position hint are placed using wm placement.
1177 */
1178 if (IS_TRANSIENT(fw))
1179 {
1180 override_ppos = SUSE_NO_TRANSIENT_PPOSITION(&pstyle->flags);
1181 override_uspos = SUSE_NO_TRANSIENT_USPOSITION(&pstyle->flags);
1182 }
1183 else
1184 {
1185 override_ppos = SUSE_NO_PPOSITION(&pstyle->flags);
1186 override_uspos = SUSE_NO_USPOSITION(&pstyle->flags);
1187 }
1188 if (fw->hints.flags & PPosition)
1189 {
1190 if (!override_ppos)
1191 {
1192 has_ppos = True;
1193 reason->pos.reason = PR_POS_USE_PPOS;
1194 }
1195 else
1196 {
1197 reason->pos.reason = PR_POS_IGNORE_PPOS;
1198 }
1199 }
1200 if (fw->hints.flags & USPosition)
1201 {
1202 if (!override_uspos)
1203 {
1204 has_uspos = True;
1205 reason->pos.reason = PR_POS_USE_USPOS;
1206 }
1207 else if (reason->pos.reason != PR_POS_USE_PPOS)
1208 {
1209 reason->pos.reason = PR_POS_USE_USPOS;
1210 }
1211 }
1212 if (mode == PLACE_AGAIN)
1213 {
1214 ret_flags->do_not_use_wm_placement = 0;
1215 reason->pos.reason = PR_POS_PLACE_AGAIN;
1216 }
1217 else if (has_ppos || has_uspos)
1218 {
1219 ret_flags->do_not_use_wm_placement = 1;
1220 }
1221 else if (win_opts->flags.do_override_ppos)
1222 {
1223 ret_flags->do_not_use_wm_placement = 1;
1224 reason->pos.reason = PR_POS_CAPTURE;
1225 }
1226 else if (!ret_flags->do_honor_starts_on_page &&
1227 fw->wmhints && (fw->wmhints->flags & StateHint) &&
1228 fw->wmhints->initial_state == IconicState)
1229 {
1230 ret_flags->do_forbid_manual_placement = 1;
1231 reason->pos.do_not_manual_icon_placement = 1;
1232 }
1233
1234 return;
1235 }
1236
1237 static int __add_algo(
1238 const pl_algo_t **algos, int num_algos, const pl_algo_t *new_algo)
1239 {
1240 if (num_algos >= MAX_NUM_PLACEMENT_ALGOS)
1241 {
1242 return MAX_NUM_PLACEMENT_ALGOS;
1243 }
1244 algos[num_algos] = new_algo;
1245 num_algos++;
1246
1247 return num_algos;
1248 }
1249
1250 static int __place_get_wm_pos(
1251 const exec_context_t *exc, window_style *pstyle, rectangle *attr_g,
1252 pl_flags_t flags, rectangle screen_g, pl_start_style_t start_style,
1253 int mode, initial_window_options_t *win_opts, pl_reason_t *reason,
1254 int pdeltax, int pdeltay)
1255 {
1256 const pl_algo_t *algos[MAX_NUM_PLACEMENT_ALGOS + 1];
1257 int num_algos;
1258 unsigned int placement_mode = SPLACEMENT_MODE(&pstyle->flags);
1259 pl_arg_t arg;
1260 pl_ret_t ret;
1261 int i;
1262
1263 /* BEGIN init placement agrs and ret */
1264 memset(&arg, 0, sizeof(arg));
1265 arg.exc = exc;
1266 arg.style = pstyle;
1267 arg.reason = reason;
1268 arg.place_fw = exc->w.fw;
1269 arg.place_g = arg.place_fw->g.frame;
1270 arg.screen_g = screen_g;
1271 arg.page_p1.x = arg.screen_g.x - pdeltax;
1272 arg.page_p1.y = arg.screen_g.y - pdeltay;
1273 arg.page_p2.x = arg.page_p1.x + screen_g.width;
1274 arg.page_p2.y = arg.page_p1.y + screen_g.height;
1275 arg.pdelta_p.x = pdeltax;
1276 arg.pdelta_p.y = pdeltay;
1277 arg.flags.use_percent = 0;
1278 arg.flags.do_honor_starts_on_page = flags.do_honor_starts_on_page;
1279 if (SEWMH_PLACEMENT_MODE(&pstyle->flags) == EWMH_USE_WORKING_AREA)
1280 {
1281 arg.flags.use_ewmh_dynamic_working_areapercent = 1;
1282 }
1283 memset(&ret, 0, sizeof(ret));
1284 ret.best_penalty = -1.0;
1285 /* END init placement agrs and ret */
1286 /* override if manual placement happens */
1287 SET_PLACED_BY_FVWM(arg.place_fw, 1);
1288 if (flags.do_forbid_manual_placement)
1289 {
1290 switch (placement_mode)
1291 {
1292 case PLACE_MANUAL:
1293 case PLACE_MANUAL_B:
1294 placement_mode = PLACE_CASCADE;
1295 break;
1296 case PLACE_TILEMANUAL:
1297 placement_mode = PLACE_TILECASCADE;
1298 break;
1299 default:
1300 break;
1301 }
1302 }
1303 reason->pos.algo = placement_mode;
1304 /* first, try various "smart" placement */
1305 num_algos = 0;
1306 switch (placement_mode)
1307 {
1308 case PLACE_POSITION:
1309 num_algos = __add_algo(
1310 algos, num_algos, &position_placement_algo);
1311 break;
1312 case PLACE_TILEMANUAL:
1313 num_algos = __add_algo(
1314 algos, num_algos, &smart_placement_algo);
1315 num_algos = __add_algo(
1316 algos, num_algos, &manual_placement_algo);
1317 break;
1318 case PLACE_MINOVERLAPPERCENT:
1319 arg.flags.use_percent = 1;
1320 /* fall through */
1321 case PLACE_MINOVERLAP:
1322 num_algos = __add_algo(
1323 algos, num_algos, &minoverlap_placement_algo);
1324 break;
1325 case PLACE_TILECASCADE:
1326 num_algos = __add_algo(
1327 algos, num_algos, &smart_placement_algo);
1328 num_algos = __add_algo(
1329 algos, num_algos, &cascade_placement_algo);
1330 break;
1331 case PLACE_MANUAL:
1332 case PLACE_MANUAL_B:
1333 num_algos = __add_algo(
1334 algos, num_algos, &manual_placement_algo);
1335 break;
1336 case PLACE_CASCADE:
1337 case PLACE_CASCADE_B:
1338 num_algos = __add_algo(
1339 algos, num_algos, &cascade_placement_algo);
1340 break;
1341 default:
1342 /* can't happen */
1343 break;
1344 }
1345 /* try all the placement algorithms */
1346 for (i = 0 ; ret.best_penalty < 0 && i < num_algos; i++)
1347 {
1348 arg.algo = algos[i];
1349 placement_loop(&ret, &arg);
1350 }
1351 if (ret.best_penalty >= 0)
1352 {
1353 /* placement succed */
1354 attr_g->x = ret.best_p.x;
1355 attr_g->y = ret.best_p.y;
1356 }
1357 else
1358 {
1359 /* fall back to default position */
1360 attr_g->x = 0;
1361 attr_g->y = 0;
1362 reason->pos.has_placement_failed = 1;
1363 }
1364
1365 return ret.flags.do_resize_too;
1366 }
1367
1368 static int __place_get_nowm_pos(
1369 const exec_context_t *exc, window_style *pstyle, rectangle *attr_g,
1370 pl_flags_t flags, rectangle screen_g, pl_start_style_t start_style,
1371 int mode, initial_window_options_t *win_opts, pl_reason_t *reason,
1372 int pdeltax, int pdeltay)
1373 {
1374 FvwmWindow *fw = exc->w.fw;
1375 size_borders b;
1376
1377 if (!win_opts->flags.do_override_ppos)
1378 {
1379 SET_PLACED_BY_FVWM(fw, False);
1380 }
1381 /* the USPosition was specified, or the window is a transient, or it
1382 * starts iconic so place it automatically */
1383 if (
1384 SUSE_START_ON_SCREEN(&pstyle->flags) &&
1385 flags.do_honor_starts_on_screen)
1386 {
1387 fscreen_scr_t mangle_screen;
1388
1389 /* If StartsOnScreen has been given for a window, translate its
1390 * USPosition so that it is relative to that particular screen.
1391 * If we don't do this, then a geometry would completely
1392 * cancel the effect of the StartsOnScreen style. However, some
1393 * applications try to remember their position. This would
1394 * break if these were translated to screen coordinates. There
1395 * is no reliable way to do it. Currently, if the desired
1396 * place does not intersect the target screen, we assume the
1397 * window position must be adjusted to the screen origin. So
1398 * there are two ways to get a window to pop up on a particular
1399 * Xinerama screen. 1: The intuitive way giving a geometry
1400 * hint relative to the desired screen's 0,0 along with the
1401 * appropriate StartsOnScreen style (or *wmscreen resource), or
1402 * 2: Do NOT specify a Xinerama screen (or specify it to be
1403 * 'g') and give the geometry hint in terms of the global
1404 * screen. */
1405 mangle_screen = FScreenFetchMangledScreenFromUSPosHints(
1406 &(fw->hints));
1407 if (mangle_screen != FSCREEN_GLOBAL)
1408 {
1409 /* whoever set this hint knew exactly what he was
1410 * doing; so ignore the StartsOnScreen style */
1411 flags.do_honor_starts_on_screen = 0;
1412 reason->pos.reason = PR_POS_USPOS_OVERRIDE_SOS;
1413 }
1414 else if (attr_g->x + attr_g->width < screen_g.x ||
1415 attr_g->x >= screen_g.x + screen_g.width ||
1416 attr_g->y + attr_g->height < screen_g.y ||
1417 attr_g->y >= screen_g.y + screen_g.height)
1418 {
1419 /* desired coordinates do not intersect the target
1420 * screen. Let's assume the application specified
1421 * global coordinates and translate them to the screen.
1422 */
1423 FScreenTranslateCoordinates(
1424 NULL, start_style.screen, NULL, FSCREEN_GLOBAL,
1425 &attr_g->x, &attr_g->y);
1426 reason->pos.do_adjust_off_screen = 1;
1427 }
1428 }
1429 /* If SkipMapping, and other legalities are observed, adjust for
1430 * StartsOnPage. */
1431 if (DO_NOT_SHOW_ON_MAP(fw) && flags.do_honor_starts_on_page &&
1432 (!IS_TRANSIENT(fw) ||
1433 SUSE_START_ON_PAGE_FOR_TRANSIENT(&pstyle->flags))
1434 #if 0
1435 /* dv 08-Jul-2003: Do not use this. Instead, force the window on
1436 * the requested page even if the application requested a different
1437 * position. */
1438 && (SUSE_NO_PPOSITION(&pstyle->flags) ||
1439 !(fw->hints.flags & PPosition))
1440 /* dv 08-Jul-2003: This condition is always true because we
1441 * already checked for flags.do_honor_starts_on_page above. */
1442 /* RBW - allow StartsOnPage to go through, even if iconic. */
1443 && ((!(fw->wmhints && (fw->wmhints->flags & StateHint) &&
1444 fw->wmhints->initial_state == IconicState))
1445 || flags.do_honor_starts_on_page)
1446 #endif
1447 )
1448 {
1449 int old_x;
1450 int old_y;
1451
1452 old_x = attr_g->x;
1453 old_y = attr_g->y;
1454 /* We're placing a SkipMapping window - either capturing one
1455 * that's previously been mapped, or overriding USPosition - so
1456 * what we have here is its actual untouched coordinates. In
1457 * case it was a StartsOnPage window, we have to 1) convert the
1458 * existing x,y offsets relative to the requested page (i.e.,
1459 * as though there were only one page, no virtual desktop),
1460 * then 2) readjust relative to the current page. */
1461 if (attr_g->x < 0)
1462 {
1463 attr_g->x += Scr.MyDisplayWidth;
1464 }
1465 attr_g->x %= Scr.MyDisplayWidth;
1466 attr_g->x -= pdeltax;
1467 /* Noticed a quirk here. With some apps (e.g., xman), we find
1468 * the placement has moved 1 pixel away from where we
1469 * originally put it when we come through here. Why is this
1470 * happening? Probably attr_backup.border_width, try xclock
1471 * -borderwidth 100 */
1472 if (attr_g->y < 0)
1473 {
1474 attr_g->y += Scr.MyDisplayHeight;
1475 }
1476 attr_g->y %= Scr.MyDisplayHeight;
1477 attr_g->y -= pdeltay;
1478 if (attr_g->x != old_x || attr_g->y != old_y)
1479 {
1480 reason->pos.do_adjust_off_page = 1;
1481 }
1482 }
1483 /* put it where asked, mod title bar */
1484 /* if the gravity is towards the top, move it by the title height */
1485 {
1486 rectangle final_g;
1487 int gravx;
1488 int gravy;
1489
1490 gravity_get_offsets(fw->hints.win_gravity, &gravx, &gravy);
1491 final_g.x = attr_g->x + gravx * fw->attr_backup.border_width;
1492 final_g.y = attr_g->y + gravy * fw->attr_backup.border_width;
1493 /* Virtually all applications seem to share a common bug: they
1494 * request the top left pixel of their *border* as their origin
1495 * instead of the top left pixel of their client window, e.g.
1496 * 'xterm -g +0+0' creates an xterm that tries to map at (0 0)
1497 * although its border (width 1) would not be visible if it ran
1498 * under plain X. It should have tried to map at (1 1)
1499 * instead. This clearly violates the ICCCM, but trying to
1500 * change this is like tilting at windmills. So we have to add
1501 * the border width here. */
1502 final_g.x += fw->attr_backup.border_width;
1503 final_g.y += fw->attr_backup.border_width;
1504 final_g.width = 0;
1505 final_g.height = 0;
1506 if (mode == PLACE_INITIAL)
1507 {
1508 get_window_borders(fw, &b);
1509 gravity_resize(
1510 fw->hints.win_gravity, &final_g,
1511 b.total_size.width, b.total_size.height);
1512 }
1513 attr_g->x = final_g.x;
1514 attr_g->y = final_g.y;
1515 }
1516
1517 return 0;
1518 }
1519
1520 /* Handles initial placement and sizing of a new window
1521 *
1522 * Return value:
1523 *
1524 * 0 = window lost
1525 * 1 = OK
1526 * 2 = OK, window must be resized too */
1527 static int __place_window(
1528 const exec_context_t *exc, window_style *pstyle, rectangle *attr_g,
1529 pl_start_style_t start_style, int mode,
1530 initial_window_options_t *win_opts, pl_reason_t *reason)
1531 {
1532 FvwmWindow *t;
1533 int is_skipmapping_forbidden;
1534 int px = 0;
1535 int py = 0;
1536 int pdeltax = 0;
1537 int pdeltay = 0;
1538 rectangle screen_g;
1539 int rc = 0;
1540 pl_flags_t flags;
1541 extern Bool Restarting;
1542 FvwmWindow *fw = exc->w.fw;
1543
1544 memset(&flags, 0, sizeof(flags));
1545
1546 /* Select a desk to put the window on (in list of priority):
1547 * 1. Sticky Windows stay on the current desk.
1548 * 2. Windows specified with StartsOnDesk go where specified
1549 * 3. Put it on the desk it was on before the restart.
1550 * 4. Transients go on the same desk as their parents.
1551 * 5. Window groups stay together (if the KeepWindowGroupsOnDesk style
1552 * is used). */
1553
1554 /* Let's get the StartsOnDesk/Page tests out of the way first. */
1555 if (
1556 SUSE_START_ON_DESK(&pstyle->flags) ||
1557 SUSE_START_ON_SCREEN(&pstyle->flags))
1558 {
1559 flags.do_honor_starts_on_page = 1;
1560 flags.do_honor_starts_on_screen = 1;
1561 /*
1562 * Honor the flag unless...
1563 * it's a restart or recapture, and that option's disallowed...
1564 */
1565 if (win_opts->flags.do_override_ppos &&
1566 (Restarting || (Scr.flags.are_windows_captured)) &&
1567 !SRECAPTURE_HONORS_STARTS_ON_PAGE(&pstyle->flags))
1568 {
1569 flags.do_honor_starts_on_page = 0;
1570 flags.do_honor_starts_on_screen = 0;
1571 reason->page.reason = PR_PAGE_IGNORE_CAPTURE;
1572 reason->page.do_ignore_starts_on_page = 1;
1573 reason->screen.reason = PR_PAGE_IGNORE_CAPTURE;
1574 }
1575 /*
1576 * it's a cold start window capture, and that's disallowed...
1577 */
1578 if (win_opts->flags.do_override_ppos &&
1579 (!Restarting && !(Scr.flags.are_windows_captured)) &&
1580 !SCAPTURE_HONORS_STARTS_ON_PAGE(&pstyle->flags))
1581 {
1582 flags.do_honor_starts_on_page = 0;
1583 flags.do_honor_starts_on_screen = 0;
1584 reason->page.reason = PR_PAGE_IGNORE_CAPTURE;
1585 reason->page.do_ignore_starts_on_page = 1;
1586 reason->screen.reason = PR_PAGE_IGNORE_CAPTURE;
1587 }
1588 /*
1589 * it's ActivePlacement and SkipMapping, and that's disallowed.
1590 */
1591 switch (SPLACEMENT_MODE(&pstyle->flags))
1592 {
1593 case PLACE_MANUAL:
1594 case PLACE_MANUAL_B:
1595 case PLACE_TILEMANUAL:
1596 is_skipmapping_forbidden =
1597 !SMANUAL_PLACEMENT_HONORS_STARTS_ON_PAGE(
1598 &pstyle->flags);
1599 break;
1600 default:
1601 is_skipmapping_forbidden = 0;
1602 break;
1603 }
1604 if (win_opts->flags.do_override_ppos ||
1605 !DO_NOT_SHOW_ON_MAP(fw))
1606 {
1607 is_skipmapping_forbidden = 0;
1608 }
1609 if (is_skipmapping_forbidden == 1)
1610 {
1611 flags.do_honor_starts_on_page = 0;
1612 reason->page.reason = PR_PAGE_IGNORE_INVALID;
1613 reason->page.do_ignore_starts_on_page = 1;
1614 fvwm_msg(
1615 WARN, "__place_window",
1616 "invalid style combination used: StartsOnPage"
1617 "/StartsOnDesk and SkipMapping don't work with"
1618 " ManualPlacement and TileManualPlacement."
1619 " Putting window on current page, please use"
1620 " another placement style or"
1621 " ActivePlacementHonorsStartsOnPage.");
1622 }
1623 }
1624 /* get the screen coordinates to place window on */
1625 if (SUSE_START_ON_SCREEN(&pstyle->flags))
1626 {
1627 if (flags.do_honor_starts_on_screen)
1628 {
1629 /* use screen from style */
1630 FScreenGetScrRect(
1631 NULL, start_style.screen, &screen_g.x,
1632 &screen_g.y, &screen_g.width,
1633 &screen_g.height);
1634 reason->screen.screen = start_style.screen;
1635 }
1636 else
1637 {
1638 /* use global screen */
1639 FScreenGetScrRect(
1640 NULL, FSCREEN_GLOBAL, &screen_g.x, &screen_g.y,
1641 &screen_g.width, &screen_g.height);
1642 reason->screen.screen = FSCREEN_GLOBAL;
1643 }
1644 }
1645 else
1646 {
1647 /* use current screen */
1648 FScreenGetScrRect(
1649 NULL, FSCREEN_CURRENT, &screen_g.x, &screen_g.y,
1650 &screen_g.width, &screen_g.height);
1651 reason->screen.screen = FSCREEN_CURRENT;
1652 }
1653
1654 if (SPLACEMENT_MODE(&pstyle->flags) != PLACE_MINOVERLAPPERCENT &&
1655 SPLACEMENT_MODE(&pstyle->flags) != PLACE_MINOVERLAP)
1656 {
1657 EWMH_GetWorkAreaIntersection(
1658 fw, &screen_g.x, &screen_g.y, &screen_g.width,
1659 &screen_g.height,
1660 SEWMH_PLACEMENT_MODE(&pstyle->flags));
1661 reason->screen.was_modified_by_ewmh_workingarea = 1;
1662 }
1663 reason->screen.g = screen_g;
1664 /* Don't alter the existing desk location during Capture/Recapture. */
1665 if (!win_opts->flags.do_override_ppos)
1666 {
1667 fw->Desk = Scr.CurrentDesk;
1668 reason->desk.reason = PR_DESK_CURRENT;
1669 }
1670 else
1671 {
1672 reason->desk.reason = PR_DESK_CAPTURE;
1673 }
1674 if (S_IS_STICKY_ACROSS_DESKS(SFC(pstyle->flags)))
1675 {
1676 fw->Desk = Scr.CurrentDesk;
1677 reason->desk.reason = PR_DESK_STICKY;
1678 }
1679 else if (SUSE_START_ON_DESK(&pstyle->flags) && start_style.desk &&
1680 flags.do_honor_starts_on_page)
1681 {
1682 fw->Desk = (start_style.desk > -1) ?
1683 start_style.desk - 1 : start_style.desk;
1684 reason->desk.reason = reason->desk.sod_reason;
1685 }
1686 else
1687 {
1688 if ((DO_USE_WINDOW_GROUP_HINT(fw)) &&
1689 (fw->wmhints) && (fw->wmhints->flags & WindowGroupHint)&&
1690 (fw->wmhints->window_group != None) &&
1691 (fw->wmhints->window_group != Scr.Root))
1692 {
1693 /* Try to find the group leader or another window in
1694 * the group */
1695 for (t = Scr.FvwmRoot.next; t != NULL; t = t->next)
1696 {
1697 if (FW_W(t) == fw->wmhints->window_group)
1698 {
1699 /* found the group leader, break out */
1700 fw->Desk = t->Desk;
1701 reason->desk.reason =
1702 PR_DESK_WINDOW_GROUP_LEADER;
1703 break;
1704 }
1705 else if (t->wmhints &&
1706 (t->wmhints->flags &
1707 WindowGroupHint) &&
1708 (t->wmhints->window_group ==
1709 fw->wmhints->window_group))
1710 {
1711 /* found a window from the same group,
1712 * but keep looking for the group
1713 * leader */
1714 fw->Desk = t->Desk;
1715 reason->desk.reason =
1716 PR_DESK_WINDOW_GROUP_MEMBER;
1717 }
1718 }
1719 }
1720 if ((IS_TRANSIENT(fw))&&(FW_W_TRANSIENTFOR(fw)!=None)&&
1721 (FW_W_TRANSIENTFOR(fw) != Scr.Root))
1722 {
1723 /* Try to find the parent's desktop */
1724 for (t = Scr.FvwmRoot.next; t != NULL; t = t->next)
1725 {
1726 if (FW_W(t) == FW_W_TRANSIENTFOR(fw))
1727 {
1728 fw->Desk = t->Desk;
1729 reason->desk.reason =
1730 PR_DESK_TRANSIENT;
1731 break;
1732 }
1733 }
1734 }
1735
1736 {
1737 /* migo - I am not sure this block is ever needed */
1738
1739 Atom atype;
1740 int aformat;
1741 unsigned long nitems, bytes_remain;
1742 unsigned char *prop;
1743
1744 if (
1745 XGetWindowProperty(
1746 dpy, FW_W(fw), _XA_WM_DESKTOP, 0L, 1L,
1747 True, _XA_WM_DESKTOP, &atype, &aformat,
1748 &nitems, &bytes_remain, &prop) ==
1749 Success)
1750 {
1751 if (prop != NULL)
1752 {
1753 fw->Desk = *(unsigned long *)prop;
1754 XFree(prop);
1755 reason->desk.reason =
1756 PR_DESK_XPROP_XA_WM_DESKTOP;
1757 }
1758 }
1759 }
1760 }
1761 reason->desk.desk = fw->Desk;
1762 /* I think it would be good to switch to the selected desk
1763 * whenever a new window pops up, except during initialization */
1764 /* RBW - 11/02/1998 -- I dont. */
1765 if (!win_opts->flags.do_override_ppos && !DO_NOT_SHOW_ON_MAP(fw))
1766 {
1767 if (Scr.CurrentDesk != fw->Desk)
1768 {
1769 reason->desk.do_switch_desk = 1;
1770 }
1771 goto_desk(fw->Desk);
1772 }
1773 /* Don't move viewport if SkipMapping, or if recapturing the window,
1774 * adjust the coordinates later. Otherwise, just switch to the target
1775 * page - it's ever so much simpler. */
1776 if (S_IS_STICKY_ACROSS_PAGES(SFC(pstyle->flags)))
1777 {
1778 reason->page.reason = PR_PAGE_STICKY;
1779 }
1780 else if (SUSE_START_ON_DESK(&pstyle->flags))
1781 {
1782 if (start_style.page_x != 0 && start_style.page_y != 0)
1783 {
1784 px = start_style.page_x - 1;
1785 py = start_style.page_y - 1;
1786 reason->page.reason = PR_PAGE_STYLE;
1787 px *= Scr.MyDisplayWidth;
1788 py *= Scr.MyDisplayHeight;
1789 if (!win_opts->flags.do_override_ppos &&
1790 !DO_NOT_SHOW_ON_MAP(fw))
1791 {
1792 MoveViewport(px,py,True);
1793 reason->page.do_switch_page = 1;
1794 }
1795 else if (flags.do_honor_starts_on_page)
1796 {
1797 /* Save the delta from current page */
1798 pdeltax = Scr.Vx - px;
1799 pdeltay = Scr.Vy - py;
1800 reason->page.do_honor_starts_on_page = 1;
1801 }
1802 }
1803 }
1804
1805 /* pick a location for the window. */
1806 __place_get_placement_flags(
1807 &flags, fw, pstyle, win_opts, mode, reason);
1808 if (flags.do_not_use_wm_placement)
1809 {
1810 rc = __place_get_nowm_pos(
1811 exc, pstyle, attr_g, flags, screen_g, start_style,
1812 mode, win_opts, reason, pdeltax, pdeltay);
1813 }
1814 else
1815 {
1816 rc = __place_get_wm_pos(
1817 exc, pstyle, attr_g, flags, screen_g, start_style,
1818 mode, win_opts, reason, pdeltax, pdeltay);
1819 }
1820 reason->pos.x = attr_g->x;
1821 reason->pos.y = attr_g->y;
1822
1823 return rc;
1824 }
1825
1826 static void __place_handle_x_resources(
1827 FvwmWindow *fw, window_style *pstyle, pl_reason_t *reason)
1828 {
1829 int client_argc = 0;
1830 char **client_argv = NULL;
1831 XrmValue rm_value;
1832 /* Used to parse command line of clients for specific desk requests. */
1833 /* Todo: check for multiple desks. */
1834 XrmDatabase db = NULL;
1835 static XrmOptionDescRec table [] = {
1836 /* Want to accept "-workspace N" or -xrm "fvwm*desk:N" as
1837 * options to specify the desktop. I have to include dummy
1838 * options that are meaningless since Xrm seems to allow -w to
1839 * match -workspace if there would be no ambiguity. */
1840 {"-workspacf", "*junk", XrmoptionSepArg, (caddr_t) NULL},
1841 {"-workspace", "*desk", XrmoptionSepArg, (caddr_t) NULL},
1842 {"-xrn", NULL, XrmoptionResArg, (caddr_t) NULL},
1843 {"-xrm", NULL, XrmoptionResArg, (caddr_t) NULL},
1844 };
1845 int t1 = -1, t2 = -1, t3 = -1, spargs = 0;
1846
1847 /* Find out if the client requested a specific desk on the command
1848 * line.
1849 * RBW - 11/20/1998 - allow a desk of -1 to work. */
1850 if (XGetCommand(dpy, FW_W(fw), &client_argv, &client_argc) == 0)
1851 {
1852 return;
1853 }
1854 if (client_argc <= 0 || client_argv == NULL)
1855 {
1856 return;
1857 }
1858 /* Get global X resources */
1859 MergeXResources(dpy, &db, False);
1860 /* command line takes precedence over all */
1861 MergeCmdLineResources(
1862 &db, table, 4, client_argv[0], &client_argc, client_argv,
1863 True);
1864 /* parse the database values */
1865 if (GetResourceString(db, "desk", client_argv[0], &rm_value) &&
1866 rm_value.size != 0)
1867 {
1868 SGET_START_DESK(*pstyle) = atoi(rm_value.addr);
1869 /* RBW - 11/20/1998 */
1870 if (SGET_START_DESK(*pstyle) > -1)
1871 {
1872 SSET_START_DESK(
1873 *pstyle, SGET_START_DESK(*pstyle) + 1);
1874 }
1875 reason->desk.sod_reason = PR_DESK_X_RESOURCE_DESK;
1876 pstyle->flags.use_start_on_desk = 1;
1877 }
1878 if (GetResourceString(db, "fvwmscreen", client_argv[0], &rm_value) &&
1879 rm_value.size != 0)
1880 {
1881 SSET_START_SCREEN(
1882 *pstyle, FScreenGetScreenArgument(rm_value.addr, 'c'));
1883 reason->screen.reason = PR_SCREEN_X_RESOURCE_FVWMSCREEN;
1884 reason->screen.screen = SGET_START_SCREEN(*pstyle);
1885 pstyle->flags.use_start_on_screen = 1;
1886 }
1887 if (GetResourceString(db, "page", client_argv[0], &rm_value) &&
1888 rm_value.size != 0)
1889 {
1890 spargs = sscanf(
1891 rm_value.addr, "%d %d %d", &t1, &t2, &t3);
1892 switch (spargs)
1893 {
1894 case 1:
1895 pstyle->flags.use_start_on_desk = 1;
1896 SSET_START_DESK(*pstyle, (t1 > -1) ? t1 + 1 : t1);
1897 reason->desk.sod_reason = PR_DESK_X_RESOURCE_PAGE;
1898 break;
1899 case 2:
1900 pstyle->flags.use_start_on_desk = 1;
1901 SSET_START_PAGE_X(*pstyle, (t1 > -1) ? t1 + 1 : t1);
1902 SSET_START_PAGE_Y(*pstyle, (t2 > -1) ? t2 + 1 : t2);
1903 reason->page.reason = PR_PAGE_X_RESOURCE_PAGE;
1904 reason->page.px = SGET_START_PAGE_X(*pstyle);
1905 reason->page.py = SGET_START_PAGE_Y(*pstyle);
1906 break;
1907 case 3:
1908 pstyle->flags.use_start_on_desk = 1;
1909 SSET_START_DESK(*pstyle, (t1 > -1) ? t1 + 1 : t1);
1910 reason->desk.sod_reason =
1911 PR_DESK_X_RESOURCE_PAGE;
1912 SSET_START_PAGE_X(*pstyle, (t2 > -1) ? t2 + 1 : t2);
1913 SSET_START_PAGE_Y(*pstyle, (t3 > -1) ? t3 + 1 : t3);
1914 reason->page.reason = PR_PAGE_X_RESOURCE_PAGE;
1915 reason->page.px = SGET_START_PAGE_X(*pstyle);
1916 reason->page.py = SGET_START_PAGE_Y(*pstyle);
1917 break;
1918 default:
1919 break;
1920 }
1921 }
1922 XFreeStringList(client_argv);
1923 XrmDestroyDatabase(db);
1924
1925 return;
1926 }
1927
1928 static void __explain_placement(FvwmWindow *fw, pl_reason_t *reason)
1929 {
1930 char explanation[2048];
1931 char *r;
1932 char *s;
1933 char t[32];
1934 int do_show_page;
1935 int is_placed_by_algo;
1936
1937 *explanation = 0;
1938 s = explanation;
1939 strcat(s, "placed new window 0x%x '%s':\n");
1940 s += strlen(s);
1941 sprintf(
1942 s, " initial size %dx%d\n", fw->g.frame.width,
1943 fw->g.frame.height);
1944 s += strlen(s);
1945 switch (reason->desk.reason)
1946 {
1947 case PR_DESK_CURRENT:
1948 r = "current desk";
1949 break;
1950 case PR_DESK_STYLE:
1951 r = "specified by style";
1952 break;
1953 case PR_DESK_X_RESOURCE_DESK:
1954 r = "specified by 'desk' X resource";
1955 break;
1956 case PR_DESK_X_RESOURCE_PAGE:
1957 r = "specified by 'page' X resource";
1958 break;
1959 case PR_DESK_CAPTURE:
1960 r = "window was (re)captured";
1961 break;
1962 case PR_DESK_STICKY:
1963 r = "window is sticky";
1964 break;
1965 case PR_DESK_WINDOW_GROUP_LEADER:
1966 r = "same desk as window group leader";
1967 break;
1968 case PR_DESK_WINDOW_GROUP_MEMBER:
1969 r = "same desk as window group member";
1970 break;
1971 case PR_DESK_TRANSIENT:
1972 r = "transient window placed on same desk as parent";
1973 break;
1974 case PR_DESK_XPROP_XA_WM_DESKTOP:
1975 r = "specified by _XA_WM_DESKTOP property";
1976 break;
1977 default:
1978 r = "bug";
1979 break;
1980 }
1981 sprintf(s, " desk %d (%s)\n", reason->desk.desk, r);
1982 s += strlen(s);
1983 if (reason->desk.do_switch_desk == 1)
1984 {
1985 sprintf(s, " (switched to desk)\n");
1986 s += strlen(s);
1987 }
1988 /* page */
1989 do_show_page = 1;
1990 switch (reason->page.reason)
1991 {
1992 case PR_PAGE_CURRENT:
1993 do_show_page = 0;
1994 r = "current page";
1995 break;
1996 case PR_PAGE_STYLE:
1997 r = "specified by style";
1998 break;
1999 case PR_PAGE_X_RESOURCE_PAGE:
2000 r = "specified by 'page' X resource";
2001 break;
2002 case PR_PAGE_IGNORE_CAPTURE:
2003 r = "window was (re)captured";
2004 break;
2005 case PR_PAGE_IGNORE_INVALID:
2006 r = "requested page ignored because of invalid style"
2007 " combination";
2008 break;
2009 case PR_PAGE_STICKY:
2010 do_show_page = 0;
2011 r = "current page (window is sticky)";
2012 break;
2013 default:
2014 r = "bug";
2015 break;
2016 }
2017 if (do_show_page == 0)
2018 {
2019 sprintf(s, " %s\n", r);
2020 }
2021 else
2022 {
2023 sprintf(
2024 s, " page %d %d (%s)\n", reason->page.px - 1,
2025 reason->page.py - 1, r);
2026 }
2027 s += strlen(s);
2028 if (reason->page.do_switch_page == 1)
2029 {
2030 sprintf(s, " (switched to page)\n");
2031 s += strlen(s);
2032 }
2033 if (reason->page.do_ignore_starts_on_page == 1)
2034 {
2035 sprintf(s, " (possibly ignored StartsOnPage)\n");
2036 s += strlen(s);
2037 }
2038 /* screen */
2039 if (FScreenIsEnabled() == True || FScreenIsSLSEnabled() == True)
2040 {
2041 switch (reason->screen.reason)
2042 {
2043 case PR_SCREEN_CURRENT:
2044 r = "current screen";
2045 break;
2046 case PR_SCREEN_STYLE:
2047 r = "specified by style";
2048 break;
2049 case PR_SCREEN_X_RESOURCE_FVWMSCREEN:
2050 r = "specified by 'fvwmscreen' X resource";
2051 break;
2052 case PR_SCREEN_IGNORE_CAPTURE:
2053 r = "window was (re)captured";
2054 break;
2055 default:
2056 r = "bug";
2057 break;
2058 }
2059 FScreenSpecToString(t, 32, reason->screen.screen);
2060 sprintf(
2061 s, " screen: %s: %d %d %dx%d (%s)\n",
2062 t, reason->screen.g.x, reason->screen.g.y,
2063 reason->screen.g.width, reason->screen.g.height, r);
2064 s += strlen(s);
2065 if (reason->screen.was_modified_by_ewmh_workingarea == 1)
2066 {
2067 sprintf(
2068 s, " (screen area modified by EWMH working"
2069 " area)\n");
2070 s += strlen(s);
2071 }
2072 }
2073 /* position */
2074 is_placed_by_algo = 0;
2075 switch (reason->pos.reason)
2076 {
2077 case PR_POS_NORMAL:
2078 is_placed_by_algo = 1;
2079 r = "normal placement";
2080 break;
2081 case PR_POS_IGNORE_PPOS:
2082 is_placed_by_algo = 1;
2083 r = "ignored program specified position";
2084 break;
2085 case PR_POS_USE_PPOS:
2086 r = "used program specified position";
2087 break;
2088 case PR_POS_IGNORE_USPOS:
2089 is_placed_by_algo = 1;
2090 r = "ignored user specified position";
2091 break;
2092 case PR_POS_USE_USPOS:
2093 r = "used user specified position";
2094 break;
2095 case PR_POS_PLACE_AGAIN:
2096 is_placed_by_algo = 1;
2097 r = "by PlaceAgain command";
2098 break;
2099 case PR_POS_CAPTURE:
2100 r = "window was (re)captured";
2101 break;
2102 case PR_POS_USPOS_OVERRIDE_SOS:
2103 r = "StartsOnPage style overridden by application via USPos";
2104 break;
2105 default:
2106 r = "bug";
2107 break;
2108 }
2109 sprintf(s, " position %d %d", reason->pos.x, reason->pos.y);
2110 s += strlen(s);
2111 if (is_placed_by_algo == 1)
2112 {
2113 char *a;
2114 char *b;
2115
2116 b = "";
2117 switch (reason->pos.algo)
2118 {
2119 case PLACE_POSITION:
2120 a = "Position args: ";
2121 b = reason->pos.pl_position_string;
2122 break;
2123 case PLACE_TILEMANUAL:
2124 a = "TileManual";
2125 break;
2126 case PLACE_MANUAL:
2127 case PLACE_MANUAL_B:
2128 a = "Manual";
2129 break;
2130 case PLACE_MINOVERLAPPERCENT:
2131 a = "MinOverlapPercent";
2132 break;
2133 case PLACE_TILECASCADE:
2134 a = "TileCascade";
2135 break;
2136 case PLACE_CASCADE:
2137 case PLACE_CASCADE_B:
2138 a = "Cascade";
2139 break;
2140 case PLACE_MINOVERLAP:
2141 a = "MinOverlap";
2142 break;
2143 default:
2144 a = "bug";
2145 break;
2146 }
2147 sprintf(s, ", placed by fvwm (%s)\n", r);
2148 s += strlen(s);
2149 sprintf(s, " placement method: %s%s\n", a, b);
2150 s += strlen(s);
2151 if (reason->pos.do_not_manual_icon_placement == 1)
2152 {
2153 sprintf(s, " (icon not placed manually)\n");
2154 s += strlen(s);
2155 }
2156 if (reason->pos.is_pl_position_string_invalid == 1)
2157 {
2158 sprintf(s, " (invalid position string)\n");
2159 s += strlen(s);
2160 }
2161 if (reason->pos.has_tile_failed == 1)
2162 {
2163 sprintf(s, " (tile placement failed)\n");
2164 s += strlen(s);
2165 }
2166 if (reason->pos.has_manual_failed == 1)
2167 {
2168 sprintf(s, " (manual placement failed)\n");
2169 s += strlen(s);
2170 }
2171 if (reason->pos.has_placement_failed == 1)
2172 {
2173 sprintf(s, " (placement failed default pos 0 0)\n");
2174 s += strlen(s);
2175 }
2176 }
2177 else
2178 {
2179 sprintf(s, " (%s)\n", r);
2180 s += strlen(s);
2181 }
2182 if (reason->pos.do_adjust_off_screen == 1)
2183 {
2184 sprintf(s, " (adjusted to force window on screen)\n");
2185 s += strlen(s);
2186 }
2187 if (reason->pos.do_adjust_off_page == 1)
2188 {
2189 sprintf(s, " (adjusted to force window on page)\n");
2190 s += strlen(s);
2191 }
2192 fvwm_msg(
2193 INFO, "__explain_placement", explanation, (int)FW_W(fw),
2194 fw->name.name);
2195
2196 return;
2197 }
2198
2199 /* ---------------------------- interface functions ------------------------ */
2200
2201 Bool setup_window_placement(
2202 FvwmWindow *fw, window_style *pstyle, rectangle *attr_g,
2203 initial_window_options_t *win_opts, placement_mode_t mode)
2204 {
2205 int rc;
2206 const exec_context_t *exc;
2207 exec_context_changes_t ecc;
2208 pl_reason_t reason;
2209 pl_start_style_t start_style;
2210
2211 memset(&reason, 0, sizeof(reason));
2212 if (pstyle->flags.use_start_on_desk)
2213 {
2214 reason.desk.sod_reason = PR_DESK_STYLE;
2215 reason.page.px = SGET_START_PAGE_X(*pstyle);
2216 reason.page.py = SGET_START_PAGE_Y(*pstyle);
2217 }
2218 if (pstyle->flags.use_start_on_screen)
2219 {
2220 reason.screen.reason = PR_SCREEN_STYLE;
2221 reason.screen.screen = SGET_START_SCREEN(*pstyle);
2222 }
2223 __place_handle_x_resources(fw, pstyle, &reason);
2224 if (pstyle->flags.do_start_iconic)
2225 {
2226 win_opts->initial_state = IconicState;
2227 }
2228 ecc.type = EXCT_NULL;
2229 ecc.w.fw = fw;
2230 exc = exc_create_context(&ecc, ECC_TYPE | ECC_FW);
2231 start_style.desk = SGET_START_DESK(*pstyle);
2232 start_style.page_x = SGET_START_PAGE_X(*pstyle);
2233 start_style.page_y = SGET_START_PAGE_Y(*pstyle);
2234 start_style.screen = SGET_START_SCREEN(*pstyle);
2235 rc = __place_window(
2236 exc, pstyle, attr_g, start_style, mode, win_opts, &reason);
2237 exc_destroy_context(exc);
2238 if (Scr.bo.do_explain_window_placement == 1)
2239 {
2240 __explain_placement(fw, &reason);
2241 }
2242
2243 return (rc == 0) ? False : True;
2244 }
2245
2246 /* ---------------------------- builtin commands --------------------------- */
2247
2248 void CMD_PlaceAgain(F_CMD_ARGS)
2249 {
2250 int old_desk;
2251 char *token;
2252 float noMovement[1] = {1.0};
2253 float *ppctMovement = noMovement;
2254 rectangle attr_g;
2255 XWindowAttributes attr;
2256 Bool do_move_animated = False;
2257 Bool do_place_icon = False;
2258 FvwmWindow * const fw = exc->w.fw;
2259
2260 if (!XGetWindowAttributes(dpy, FW_W(fw), &attr))
2261 {
2262 return;
2263 }
2264 while ((token = PeekToken(action, &action)) != NULL)
2265 {
2266 if (StrEquals("Anim", token))
2267 {
2268 ppctMovement = NULL;
2269 do_move_animated = True;
2270 }
2271 else if (StrEquals("icon", token))
2272 {
2273 do_place_icon = True;
2274 }
2275 }
2276 old_desk = fw->Desk;
2277 if (IS_ICONIFIED(fw) && !do_place_icon)
2278 {
2279 return;
2280 }
2281 if (IS_ICONIFIED(fw) && do_place_icon)
2282 {
2283 rectangle new_g;
2284 rectangle old_g;
2285
2286 if (IS_ICON_SUPPRESSED(fw))
2287 {
2288 return;
2289 }
2290 fw->Desk = Scr.CurrentDesk;
2291 get_icon_geometry(fw, &old_g);
2292 SET_ICON_MOVED(fw, 0);
2293 AutoPlaceIcon(fw, NULL, False);
2294 get_icon_geometry(fw, &new_g);
2295 __move_icon(
2296 fw, new_g.x, new_g.y, old_g.x, old_g.y,
2297 do_move_animated, False);
2298 }
2299 else
2300 {
2301 window_style style;
2302 initial_window_options_t win_opts;
2303
2304 memset(&win_opts, 0, sizeof(win_opts));
2305 lookup_style(fw, &style);
2306 attr_g.x = attr.x;
2307 attr_g.y = attr.y;
2308 attr_g.width = attr.width;
2309 attr_g.height = attr.height;
2310
2311 setup_window_placement(
2312 exc->w.fw, &style, &attr_g, &win_opts, PLACE_AGAIN);
2313 AnimatedMoveFvwmWindow(
2314 fw, FW_W_FRAME(fw), -1, -1, attr_g.x, attr_g.y, False,
2315 -1, ppctMovement);
2316 }
2317 if (fw->Desk != old_desk)
2318 {
2319 int new_desk = fw->Desk;
2320
2321 fw->Desk = old_desk;
2322 do_move_window_to_desk(fw, new_desk);
2323 }
2324
2325 return;
2326 }
CVS import of FVWM to Git.