Left Half / Right Half Maximize
[wmaker-crm.git] / src / actions.c
1 /* action.c- misc. window commands (miniaturize, hide etc.)
2 *
3 * Window Maker window manager
4 *
5 * Copyright (c) 1997-2003 Alfredo K. Kojima
6 * Copyright (c) 1998-2003 Dan Pascu
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
21 * USA.
22 */
23
24 #include "wconfig.h"
25
26 #include <X11/Xlib.h>
27 #include <X11/Xutil.h>
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <unistd.h>
31 #include <math.h>
32 #include <time.h>
33
34 #include "WindowMaker.h"
35 #include "wcore.h"
36 #include "framewin.h"
37 #include "window.h"
38 #include "client.h"
39 #include "icon.h"
40 #include "funcs.h"
41 #include "application.h"
42 #include "actions.h"
43 #include "stacking.h"
44 #include "appicon.h"
45 #include "dock.h"
46 #include "appmenu.h"
47 #include "winspector.h"
48 #include "workspace.h"
49 #include "wsound.h"
50 #include "xinerama.h"
51
52 /****** Global Variables ******/
53 extern Time LastTimestamp;
54 extern Time LastFocusChange;
55
56 extern Cursor wCursor[WCUR_LAST];
57
58 extern WPreferences wPreferences;
59
60 extern Atom _XA_WM_TAKE_FOCUS;
61
62 extern void ProcessPendingEvents();
63
64 /******* Local Variables *******/
65 static struct {
66 int steps;
67 int delay;
68 } shadePars[5] = {
69 {
70 SHADE_STEPS_UF, SHADE_DELAY_UF}, {
71 SHADE_STEPS_F, SHADE_DELAY_F}, {
72 SHADE_STEPS_M, SHADE_DELAY_M}, {
73 SHADE_STEPS_S, SHADE_DELAY_S}, {
74 SHADE_STEPS_US, SHADE_DELAY_US}};
75
76 #define SHADE_STEPS shadePars[(int)wPreferences.shade_speed].steps
77 #define SHADE_DELAY shadePars[(int)wPreferences.shade_speed].delay
78
79 static int compareTimes(Time t1, Time t2)
80 {
81 Time diff;
82 if (t1 == t2)
83 return 0;
84 diff = t1 - t2;
85 return (diff < 60000) ? 1 : -1;
86 }
87
88 /*
89 *----------------------------------------------------------------------
90 * wSetFocusTo--
91 * Changes the window focus to the one passed as argument.
92 * If the window to focus is not already focused, it will be brought
93 * to the head of the list of windows. Previously focused window is
94 * unfocused.
95 *
96 * Side effects:
97 * Window list may be reordered and the window focus is changed.
98 *
99 *----------------------------------------------------------------------
100 */
101 void wSetFocusTo(WScreen * scr, WWindow * wwin)
102 {
103 static WScreen *old_scr = NULL;
104
105 WWindow *old_focused;
106 WWindow *focused = scr->focused_window;
107 Time timestamp = LastTimestamp;
108 WApplication *oapp = NULL, *napp = NULL;
109 int wasfocused;
110
111 if (scr->flags.ignore_focus_events || compareTimes(LastFocusChange, timestamp) > 0)
112 return;
113
114 if (!old_scr)
115 old_scr = scr;
116 old_focused = old_scr->focused_window;
117
118 LastFocusChange = timestamp;
119
120 if (old_focused)
121 oapp = wApplicationOf(old_focused->main_window);
122
123 if (wwin == NULL) {
124 XSetInputFocus(dpy, scr->no_focus_win, RevertToParent, CurrentTime);
125 if (old_focused) {
126 wWindowUnfocus(old_focused);
127 }
128 if (oapp) {
129 wAppMenuUnmap(oapp->menu);
130 #ifdef NEWAPPICON
131 wApplicationDeactivate(oapp);
132 #endif
133 }
134
135 WMPostNotificationName(WMNChangedFocus, NULL, (void *)True);
136 return;
137 } else if (old_scr != scr && old_focused) {
138 wWindowUnfocus(old_focused);
139 }
140
141 wasfocused = wwin->flags.focused;
142 napp = wApplicationOf(wwin->main_window);
143
144 /* remember last workspace where the app has been */
145 if (napp) {
146 /*napp->last_workspace = wwin->screen_ptr->current_workspace; */
147 napp->last_workspace = wwin->frame->workspace;
148 }
149
150 if (wwin->flags.mapped && !WFLAGP(wwin, no_focusable)) {
151 /* install colormap if colormap mode is lock mode */
152 if (wPreferences.colormap_mode == WCM_CLICK)
153 wColormapInstallForWindow(scr, wwin);
154
155 /* set input focus */
156 switch (wwin->focus_mode) {
157 case WFM_NO_INPUT:
158 XSetInputFocus(dpy, scr->no_focus_win, RevertToParent, CurrentTime);
159 break;
160
161 case WFM_PASSIVE:
162 case WFM_LOCALLY_ACTIVE:
163 XSetInputFocus(dpy, wwin->client_win, RevertToParent, CurrentTime);
164 break;
165
166 case WFM_GLOBALLY_ACTIVE:
167 break;
168 }
169 XFlush(dpy);
170 if (wwin->protocols.TAKE_FOCUS) {
171 wClientSendProtocol(wwin, _XA_WM_TAKE_FOCUS, timestamp);
172 }
173 XSync(dpy, False);
174 } else {
175 XSetInputFocus(dpy, scr->no_focus_win, RevertToParent, CurrentTime);
176 }
177 if (WFLAGP(wwin, no_focusable))
178 return;
179
180 /* if this is not the focused window focus it */
181 if (focused != wwin) {
182 /* change the focus window list order */
183 if (wwin->prev)
184 wwin->prev->next = wwin->next;
185
186 if (wwin->next)
187 wwin->next->prev = wwin->prev;
188
189 wwin->prev = focused;
190 focused->next = wwin;
191 wwin->next = NULL;
192 scr->focused_window = wwin;
193
194 if (oapp && oapp != napp) {
195 wAppMenuUnmap(oapp->menu);
196 #ifdef NEWAPPICON
197 wApplicationDeactivate(oapp);
198 #endif
199 }
200 }
201
202 wWindowFocus(wwin, focused);
203
204 if (napp && !wasfocused) {
205 #ifdef USER_MENU
206 wUserMenuRefreshInstances(napp->menu, wwin);
207 #endif /* USER_MENU */
208
209 if (wwin->flags.mapped)
210 wAppMenuMap(napp->menu, wwin);
211 #ifdef NEWAPPICON
212 wApplicationActivate(napp);
213 #endif
214 }
215
216 XFlush(dpy);
217 old_scr = scr;
218 }
219
220 void wShadeWindow(WWindow * wwin)
221 {
222 time_t time0;
223 #ifdef ANIMATIONS
224 int y, s, w, h;
225 #endif
226
227 if (wwin->flags.shaded)
228 return;
229
230 time0 = time(NULL);
231
232 XLowerWindow(dpy, wwin->client_win);
233
234 wSoundPlay(WSOUND_SHADE);
235
236 #ifdef ANIMATIONS
237 if (!wwin->screen_ptr->flags.startup && !wwin->flags.skip_next_animation && !wPreferences.no_animations) {
238 /* do the shading animation */
239 h = wwin->frame->core->height;
240 s = h / SHADE_STEPS;
241 if (s < 1)
242 s = 1;
243 w = wwin->frame->core->width;
244 y = wwin->frame->top_width;
245 while (h > wwin->frame->top_width + 1) {
246 XMoveWindow(dpy, wwin->client_win, 0, y);
247 XResizeWindow(dpy, wwin->frame->core->window, w, h);
248 XFlush(dpy);
249
250 if (time(NULL) - time0 > MAX_ANIMATION_TIME)
251 break;
252
253 if (SHADE_DELAY > 0) {
254 wusleep(SHADE_DELAY * 1000L);
255 } else {
256 wusleep(10);
257 }
258 h -= s;
259 y -= s;
260 }
261 XMoveWindow(dpy, wwin->client_win, 0, wwin->frame->top_width);
262 }
263 #endif /* ANIMATIONS */
264
265 wwin->flags.skip_next_animation = 0;
266 wwin->flags.shaded = 1;
267 wwin->flags.mapped = 0;
268 /* prevent window withdrawal when getting UnmapNotify */
269 XSelectInput(dpy, wwin->client_win, wwin->event_mask & ~StructureNotifyMask);
270 XUnmapWindow(dpy, wwin->client_win);
271 XSelectInput(dpy, wwin->client_win, wwin->event_mask);
272
273 /* for the client it's just like iconification */
274 wFrameWindowResize(wwin->frame, wwin->frame->core->width, wwin->frame->top_width - 1);
275
276 wwin->client.y = wwin->frame_y - wwin->client.height + wwin->frame->top_width;
277 wWindowSynthConfigureNotify(wwin);
278
279 /*
280 wClientSetState(wwin, IconicState, None);
281 */
282
283 WMPostNotificationName(WMNChangedState, wwin, "shade");
284
285 #ifdef ANIMATIONS
286 if (!wwin->screen_ptr->flags.startup) {
287 /* Catch up with events not processed while animation was running */
288 ProcessPendingEvents();
289 }
290 #endif
291 }
292
293 void wUnshadeWindow(WWindow * wwin)
294 {
295 time_t time0;
296 #ifdef ANIMATIONS
297 int y, s, w, h;
298 #endif /* ANIMATIONS */
299
300 if (!wwin->flags.shaded)
301 return;
302
303 time0 = time(NULL);
304
305 wwin->flags.shaded = 0;
306 wwin->flags.mapped = 1;
307 XMapWindow(dpy, wwin->client_win);
308
309 wSoundPlay(WSOUND_UNSHADE);
310
311 #ifdef ANIMATIONS
312 if (!wPreferences.no_animations && !wwin->flags.skip_next_animation) {
313 /* do the shading animation */
314 h = wwin->frame->top_width + wwin->frame->bottom_width;
315 y = wwin->frame->top_width - wwin->client.height;
316 s = abs(y) / SHADE_STEPS;
317 if (s < 1)
318 s = 1;
319 w = wwin->frame->core->width;
320 XMoveWindow(dpy, wwin->client_win, 0, y);
321 if (s > 0) {
322 while (h < wwin->client.height + wwin->frame->top_width + wwin->frame->bottom_width) {
323 XResizeWindow(dpy, wwin->frame->core->window, w, h);
324 XMoveWindow(dpy, wwin->client_win, 0, y);
325 XFlush(dpy);
326 if (SHADE_DELAY > 0) {
327 wusleep(SHADE_DELAY * 2000L / 3);
328 } else {
329 wusleep(10);
330 }
331 h += s;
332 y += s;
333
334 if (time(NULL) - time0 > MAX_ANIMATION_TIME)
335 break;
336 }
337 }
338 XMoveWindow(dpy, wwin->client_win, 0, wwin->frame->top_width);
339 }
340 #endif /* ANIMATIONS */
341
342 wwin->flags.skip_next_animation = 0;
343 wFrameWindowResize(wwin->frame, wwin->frame->core->width,
344 wwin->frame->top_width + wwin->client.height + wwin->frame->bottom_width);
345
346 wwin->client.y = wwin->frame_y + wwin->frame->top_width;
347 wWindowSynthConfigureNotify(wwin);
348
349 /*
350 wClientSetState(wwin, NormalState, None);
351 */
352 /* if the window is focused, set the focus again as it was disabled during
353 * shading */
354 if (wwin->flags.focused)
355 wSetFocusTo(wwin->screen_ptr, wwin);
356
357 WMPostNotificationName(WMNChangedState, wwin, "shade");
358 }
359
360 void wMaximizeWindow(WWindow * wwin, int directions)
361 {
362 int new_x, new_y;
363 unsigned int new_width, new_height;
364 int changed_h, changed_v, shrink_h, shrink_v;
365 WArea usableArea, totalArea;
366
367 if (!IS_RESIZABLE(wwin))
368 return;
369
370 totalArea.x1 = 0;
371 totalArea.y1 = 0;
372 totalArea.x2 = wwin->screen_ptr->scr_width;
373 totalArea.y2 = wwin->screen_ptr->scr_height;
374 usableArea = totalArea;
375
376 if (!(directions & MAX_IGNORE_XINERAMA)) {
377 WScreen *scr = wwin->screen_ptr;
378 int head;
379
380 if (directions & MAX_KEYBOARD)
381 head = wGetHeadForWindow(wwin);
382 else
383 head = wGetHeadForPointerLocation(scr);
384
385 usableArea = wGetUsableAreaForHead(scr, head, &totalArea, True);
386 }
387
388 if (WFLAGP(wwin, full_maximize)) {
389 usableArea = totalArea;
390 }
391
392 if (wwin->flags.shaded) {
393 wwin->flags.skip_next_animation = 1;
394 wUnshadeWindow(wwin);
395 }
396 /* Only save directions, not kbd or xinerama hints */
397 directions &= (MAX_HORIZONTAL|MAX_VERTICAL|MAX_LEFTHALF|MAX_RIGHTHALF);
398
399 changed_h = ((wwin->flags.maximized ^ directions) & MAX_HORIZONTAL);
400 changed_v = ((wwin->flags.maximized ^ directions) & MAX_VERTICAL);
401 shrink_h = (changed_h && (directions & MAX_HORIZONTAL) == 0);
402 shrink_v = (changed_v && (directions & MAX_VERTICAL) == 0);
403
404 if (wwin->flags.maximized) {
405 /* if already maximized in some direction, we only update the
406 * appropriate old x, old y coordinates. This is necessary to
407 * allow succesive maximizations in different directions without
408 * the need to first do an un-maximize (to avoid flicker).
409 */
410 if (!(wwin->flags.maximized & (MAX_HORIZONTAL|MAX_LEFTHALF|MAX_RIGHTHALF))) {
411 wwin->old_geometry.x = wwin->frame_x;
412 }
413 if (!(wwin->flags.maximized & MAX_VERTICAL)) {
414 wwin->old_geometry.y = wwin->frame_y;
415 }
416 } else {
417 wwin->old_geometry.width = wwin->client.width;
418 wwin->old_geometry.height = wwin->client.height;
419 wwin->old_geometry.x = wwin->frame_x;
420 wwin->old_geometry.y = wwin->frame_y;
421 }
422 wwin->flags.maximized = directions;
423
424 if (directions & MAX_HORIZONTAL) {
425 new_width = usableArea.x2 - usableArea.x1;
426 if (HAS_BORDER(wwin))
427 new_width -= FRAME_BORDER_WIDTH * 2;
428 new_x = usableArea.x1;
429 } else if (directions & MAX_LEFTHALF) {
430 new_width = (usableArea.x2 - usableArea.x1)/2;
431 if (HAS_BORDER(wwin))
432 new_width -= FRAME_BORDER_WIDTH * 2;
433 new_x = usableArea.x1;
434 } else if (directions & MAX_RIGHTHALF) {
435 new_width = (usableArea.x2 - usableArea.x1)/2;
436 if (HAS_BORDER(wwin))
437 new_width -= FRAME_BORDER_WIDTH * 2;
438 new_x = usableArea.x1+((usableArea.x2 - usableArea.x1)/2);
439 } else if (shrink_h) {
440 new_x = wwin->old_geometry.x;
441 new_width = wwin->old_geometry.width;
442 } else {
443 new_x = wwin->frame_x;
444 new_width = wwin->frame->core->width;
445 }
446
447 if (directions & MAX_VERTICAL) {
448 new_height = usableArea.y2 - usableArea.y1;
449 if (HAS_BORDER(wwin))
450 new_height -= FRAME_BORDER_WIDTH * 2;
451 new_y = usableArea.y1;
452 if (WFLAGP(wwin, full_maximize)) {
453 new_y -= wwin->frame->top_width;
454 new_height += wwin->frame->bottom_width - 1;
455 }
456 } else if (shrink_v) {
457 new_y = wwin->old_geometry.y;
458 new_height = wwin->old_geometry.height;
459 } else {
460 new_y = wwin->frame_y;
461 new_height = wwin->frame->core->height;
462 }
463
464 if (!WFLAGP(wwin, full_maximize)) {
465 new_height -= wwin->frame->top_width + wwin->frame->bottom_width;
466 }
467
468 wWindowConstrainSize(wwin, &new_width, &new_height);
469
470 wWindowCropSize(wwin, usableArea.x2 - usableArea.x1,
471 usableArea.y2 - usableArea.y1, &new_width, &new_height);
472
473 wWindowConfigure(wwin, new_x, new_y, new_width, new_height);
474
475 WMPostNotificationName(WMNChangedState, wwin, "maximize");
476
477 wSoundPlay(WSOUND_MAXIMIZE);
478 }
479
480 void wUnmaximizeWindow(WWindow * wwin)
481 {
482 int x, y, w, h;
483
484 if (!wwin->flags.maximized)
485 return;
486
487 if (wwin->flags.shaded) {
488 wwin->flags.skip_next_animation = 1;
489 wUnshadeWindow(wwin);
490 }
491 x = ((wwin->flags.maximized & (MAX_HORIZONTAL|MAX_LEFTHALF|MAX_RIGHTHALF)) && wwin->old_geometry.x) ?
492 wwin->old_geometry.x : wwin->frame_x;
493 y = ((wwin->flags.maximized & MAX_VERTICAL) && wwin->old_geometry.y) ?
494 wwin->old_geometry.y : wwin->frame_y;
495 w = wwin->old_geometry.width ? wwin->old_geometry.width : wwin->client.width;
496 h = wwin->old_geometry.height ? wwin->old_geometry.height : wwin->client.height;
497
498 wwin->flags.maximized = 0;
499 wWindowConfigure(wwin, x, y, w, h);
500
501 WMPostNotificationName(WMNChangedState, wwin, "maximize");
502
503 wSoundPlay(WSOUND_UNMAXIMIZE);
504 }
505
506 void wFullscreenWindow(WWindow * wwin)
507 {
508 int head;
509 WMRect rect;
510
511 if (wwin->flags.fullscreen)
512 return;
513
514 wwin->flags.fullscreen = True;
515
516 wWindowConfigureBorders(wwin);
517
518 ChangeStackingLevel(wwin->frame->core, WMFullscreenLevel);
519
520 wwin->bfs_geometry.x = wwin->frame_x;
521 wwin->bfs_geometry.y = wwin->frame_y;
522 wwin->bfs_geometry.width = wwin->frame->core->width;
523 wwin->bfs_geometry.height = wwin->frame->core->height;
524
525 head = wGetHeadForWindow(wwin);
526 rect = wGetRectForHead(wwin->screen_ptr, head);
527 wWindowConfigure(wwin, rect.pos.x, rect.pos.y, rect.size.width, rect.size.height);
528
529 WMPostNotificationName(WMNChangedState, wwin, "fullscreen");
530 }
531
532 void wUnfullscreenWindow(WWindow * wwin)
533 {
534 if (!wwin->flags.fullscreen)
535 return;
536
537 wwin->flags.fullscreen = False;
538
539 if (wwin->frame->core->stacking->window_level == WMFullscreenLevel) {
540 if (WFLAGP(wwin, sunken)) {
541 ChangeStackingLevel(wwin->frame->core, WMSunkenLevel);
542 } else if (WFLAGP(wwin, floating)) {
543 ChangeStackingLevel(wwin->frame->core, WMFloatingLevel);
544 } else {
545 ChangeStackingLevel(wwin->frame->core, WMNormalLevel);
546 }
547 }
548
549 wWindowConfigure(wwin, wwin->bfs_geometry.x, wwin->bfs_geometry.y,
550 wwin->bfs_geometry.width, wwin->bfs_geometry.height);
551
552 wWindowConfigureBorders(wwin);
553 /*
554 // seems unnecessary, but also harmless (doesn't generate flicker) -Dan
555 wFrameWindowPaint(wwin->frame);
556 */
557
558 WMPostNotificationName(WMNChangedState, wwin, "fullscreen");
559 }
560
561 #ifdef ANIMATIONS
562 static void animateResizeFlip(WScreen * scr, int x, int y, int w, int h, int fx, int fy, int fw, int fh, int steps)
563 {
564 #define FRAMES (MINIATURIZE_ANIMATION_FRAMES_F)
565 float cx, cy, cw, ch;
566 float xstep, ystep, wstep, hstep;
567 XPoint points[5];
568 float dx, dch, midy;
569 float angle, final_angle, delta;
570
571 xstep = (float)(fx - x) / steps;
572 ystep = (float)(fy - y) / steps;
573 wstep = (float)(fw - w) / steps;
574 hstep = (float)(fh - h) / steps;
575
576 cx = (float)x;
577 cy = (float)y;
578 cw = (float)w;
579 ch = (float)h;
580
581 final_angle = 2 * WM_PI * MINIATURIZE_ANIMATION_TWIST_F;
582 delta = (float)(final_angle / FRAMES);
583 for (angle = 0;; angle += delta) {
584 if (angle > final_angle)
585 angle = final_angle;
586
587 dx = (cw / 10) - ((cw / 5) * sin(angle));
588 dch = (ch / 2) * cos(angle);
589 midy = cy + (ch / 2);
590
591 points[0].x = cx + dx;
592 points[0].y = midy - dch;
593 points[1].x = cx + cw - dx;
594 points[1].y = points[0].y;
595 points[2].x = cx + cw + dx;
596 points[2].y = midy + dch;
597 points[3].x = cx - dx;
598 points[3].y = points[2].y;
599 points[4].x = points[0].x;
600 points[4].y = points[0].y;
601
602 XGrabServer(dpy);
603 XDrawLines(dpy, scr->root_win, scr->frame_gc, points, 5, CoordModeOrigin);
604 XFlush(dpy);
605 #if (MINIATURIZE_ANIMATION_DELAY_F > 0)
606 wusleep(MINIATURIZE_ANIMATION_DELAY_F);
607 #else
608 wusleep(10);
609 #endif
610
611 XDrawLines(dpy, scr->root_win, scr->frame_gc, points, 5, CoordModeOrigin);
612 XUngrabServer(dpy);
613 cx += xstep;
614 cy += ystep;
615 cw += wstep;
616 ch += hstep;
617 if (angle >= final_angle)
618 break;
619
620 }
621 XFlush(dpy);
622 }
623
624 #undef FRAMES
625
626 static void
627 animateResizeTwist(WScreen * scr, int x, int y, int w, int h, int fx, int fy, int fw, int fh, int steps)
628 {
629 #define FRAMES (MINIATURIZE_ANIMATION_FRAMES_T)
630 float cx, cy, cw, ch;
631 float xstep, ystep, wstep, hstep;
632 XPoint points[5];
633 float angle, final_angle, a, d, delta;
634
635 x += w / 2;
636 y += h / 2;
637 fx += fw / 2;
638 fy += fh / 2;
639
640 xstep = (float)(fx - x) / steps;
641 ystep = (float)(fy - y) / steps;
642 wstep = (float)(fw - w) / steps;
643 hstep = (float)(fh - h) / steps;
644
645 cx = (float)x;
646 cy = (float)y;
647 cw = (float)w;
648 ch = (float)h;
649
650 final_angle = 2 * WM_PI * MINIATURIZE_ANIMATION_TWIST_T;
651 delta = (float)(final_angle / FRAMES);
652 for (angle = 0;; angle += delta) {
653 if (angle > final_angle)
654 angle = final_angle;
655
656 a = atan(ch / cw);
657 d = sqrt((cw / 2) * (cw / 2) + (ch / 2) * (ch / 2));
658
659 points[0].x = cx + cos(angle - a) * d;
660 points[0].y = cy + sin(angle - a) * d;
661 points[1].x = cx + cos(angle + a) * d;
662 points[1].y = cy + sin(angle + a) * d;
663 points[2].x = cx + cos(angle - a + WM_PI) * d;
664 points[2].y = cy + sin(angle - a + WM_PI) * d;
665 points[3].x = cx + cos(angle + a + WM_PI) * d;
666 points[3].y = cy + sin(angle + a + WM_PI) * d;
667 points[4].x = cx + cos(angle - a) * d;
668 points[4].y = cy + sin(angle - a) * d;
669 XGrabServer(dpy);
670 XDrawLines(dpy, scr->root_win, scr->frame_gc, points, 5, CoordModeOrigin);
671 XFlush(dpy);
672 #if (MINIATURIZE_ANIMATION_DELAY_T > 0)
673 wusleep(MINIATURIZE_ANIMATION_DELAY_T);
674 #else
675 wusleep(10);
676 #endif
677
678 XDrawLines(dpy, scr->root_win, scr->frame_gc, points, 5, CoordModeOrigin);
679 XUngrabServer(dpy);
680 cx += xstep;
681 cy += ystep;
682 cw += wstep;
683 ch += hstep;
684 if (angle >= final_angle)
685 break;
686
687 }
688 XFlush(dpy);
689 }
690
691 #undef FRAMES
692
693 static void animateResizeZoom(WScreen * scr, int x, int y, int w, int h, int fx, int fy, int fw, int fh, int steps)
694 {
695 #define FRAMES (MINIATURIZE_ANIMATION_FRAMES_Z)
696 float cx[FRAMES], cy[FRAMES], cw[FRAMES], ch[FRAMES];
697 float xstep, ystep, wstep, hstep;
698 int i, j;
699
700 xstep = (float)(fx - x) / steps;
701 ystep = (float)(fy - y) / steps;
702 wstep = (float)(fw - w) / steps;
703 hstep = (float)(fh - h) / steps;
704
705 for (j = 0; j < FRAMES; j++) {
706 cx[j] = (float)x;
707 cy[j] = (float)y;
708 cw[j] = (float)w;
709 ch[j] = (float)h;
710 }
711 XGrabServer(dpy);
712 for (i = 0; i < steps; i++) {
713 for (j = 0; j < FRAMES; j++) {
714 XDrawRectangle(dpy, scr->root_win, scr->frame_gc,
715 (int)cx[j], (int)cy[j], (int)cw[j], (int)ch[j]);
716 }
717 XFlush(dpy);
718 #if (MINIATURIZE_ANIMATION_DELAY_Z > 0)
719 wusleep(MINIATURIZE_ANIMATION_DELAY_Z);
720 #else
721 wusleep(10);
722 #endif
723 for (j = 0; j < FRAMES; j++) {
724 XDrawRectangle(dpy, scr->root_win, scr->frame_gc,
725 (int)cx[j], (int)cy[j], (int)cw[j], (int)ch[j]);
726 if (j < FRAMES - 1) {
727 cx[j] = cx[j + 1];
728 cy[j] = cy[j + 1];
729 cw[j] = cw[j + 1];
730 ch[j] = ch[j + 1];
731 } else {
732 cx[j] += xstep;
733 cy[j] += ystep;
734 cw[j] += wstep;
735 ch[j] += hstep;
736 }
737 }
738 }
739
740 for (j = 0; j < FRAMES; j++) {
741 XDrawRectangle(dpy, scr->root_win, scr->frame_gc, (int)cx[j], (int)cy[j], (int)cw[j], (int)ch[j]);
742 }
743 XFlush(dpy);
744 #if (MINIATURIZE_ANIMATION_DELAY_Z > 0)
745 wusleep(MINIATURIZE_ANIMATION_DELAY_Z);
746 #else
747 wusleep(10);
748 #endif
749 for (j = 0; j < FRAMES; j++) {
750 XDrawRectangle(dpy, scr->root_win, scr->frame_gc, (int)cx[j], (int)cy[j], (int)cw[j], (int)ch[j]);
751 }
752
753 XUngrabServer(dpy);
754 }
755
756 #undef FRAMES
757
758 void animateResize(WScreen * scr, int x, int y, int w, int h, int fx, int fy, int fw, int fh, int hiding)
759 {
760 int style = wPreferences.iconification_style; /* Catch the value */
761 int steps, k;
762
763 if (style == WIS_NONE)
764 return;
765
766 if (style == WIS_RANDOM) {
767 style = rand() % 3;
768 }
769
770 k = (hiding ? 2 : 3);
771
772 switch (style) {
773 case WIS_TWIST:
774 steps = (MINIATURIZE_ANIMATION_STEPS_T * k) / 3;
775 if (steps > 0)
776 animateResizeTwist(scr, x, y, w, h, fx, fy, fw, fh, steps);
777 break;
778 case WIS_FLIP:
779 steps = (MINIATURIZE_ANIMATION_STEPS_F * k) / 3;
780 if (steps > 0)
781 animateResizeFlip(scr, x, y, w, h, fx, fy, fw, fh, steps);
782 break;
783 case WIS_ZOOM:
784 default:
785 steps = (MINIATURIZE_ANIMATION_STEPS_Z * k) / 3;
786 if (steps > 0)
787 animateResizeZoom(scr, x, y, w, h, fx, fy, fw, fh, steps);
788 break;
789 }
790 }
791 #endif /* ANIMATIONS */
792
793 static void flushExpose()
794 {
795 XEvent tmpev;
796
797 while (XCheckTypedEvent(dpy, Expose, &tmpev))
798 WMHandleEvent(&tmpev);
799 XSync(dpy, 0);
800 }
801
802 static void unmapTransientsFor(WWindow * wwin)
803 {
804 WWindow *tmp;
805
806 tmp = wwin->screen_ptr->focused_window;
807 while (tmp) {
808 /* unmap the transients for this transient */
809 if (tmp != wwin && tmp->transient_for == wwin->client_win
810 && (tmp->flags.mapped || wwin->screen_ptr->flags.startup || tmp->flags.shaded)) {
811 unmapTransientsFor(tmp);
812 tmp->flags.miniaturized = 1;
813 if (!tmp->flags.shaded) {
814 wWindowUnmap(tmp);
815 } else {
816 XUnmapWindow(dpy, tmp->frame->core->window);
817 }
818 /*
819 if (!tmp->flags.shaded)
820 */
821 wClientSetState(tmp, IconicState, None);
822
823 WMPostNotificationName(WMNChangedState, tmp, "iconify-transient");
824 }
825 tmp = tmp->prev;
826 }
827 }
828
829 static void mapTransientsFor(WWindow * wwin)
830 {
831 WWindow *tmp;
832
833 tmp = wwin->screen_ptr->focused_window;
834 while (tmp) {
835 /* recursively map the transients for this transient */
836 if (tmp != wwin && tmp->transient_for == wwin->client_win && /*!tmp->flags.mapped */ tmp->flags.miniaturized
837 && tmp->icon == NULL) {
838 mapTransientsFor(tmp);
839 tmp->flags.miniaturized = 0;
840 if (!tmp->flags.shaded) {
841 wWindowMap(tmp);
842 } else {
843 XMapWindow(dpy, tmp->frame->core->window);
844 }
845 tmp->flags.semi_focused = 0;
846 /*
847 if (!tmp->flags.shaded)
848 */
849 wClientSetState(tmp, NormalState, None);
850
851 WMPostNotificationName(WMNChangedState, tmp, "iconify-transient");
852 }
853 tmp = tmp->prev;
854 }
855 }
856
857 #if 0
858 static void setupIconGrabs(WIcon * icon)
859 {
860 /* setup passive grabs on the icon */
861 XGrabButton(dpy, Button1, AnyModifier, icon->core->window, True,
862 ButtonPressMask, GrabModeSync, GrabModeAsync, None, None);
863 XGrabButton(dpy, Button2, AnyModifier, icon->core->window, True,
864 ButtonPressMask, GrabModeSync, GrabModeAsync, None, None);
865 XGrabButton(dpy, Button3, AnyModifier, icon->core->window, True,
866 ButtonPressMask, GrabModeSync, GrabModeAsync, None, None);
867 XSync(dpy, 0);
868 }
869 #endif
870
871 static WWindow *recursiveTransientFor(WWindow * wwin)
872 {
873 int i;
874
875 if (!wwin)
876 return None;
877
878 /* hackish way to detect transient_for cycle */
879 i = wwin->screen_ptr->window_count + 1;
880
881 while (wwin && wwin->transient_for != None && i > 0) {
882 wwin = wWindowFor(wwin->transient_for);
883 i--;
884 }
885 if (i == 0 && wwin) {
886 wwarning("%s has a severely broken WM_TRANSIENT_FOR hint.", wwin->frame->title);
887 return NULL;
888 }
889
890 return wwin;
891 }
892
893 #if 0
894 static void removeIconGrabs(WIcon * icon)
895 {
896 /* remove passive grabs on the icon */
897 XUngrabButton(dpy, Button1, AnyModifier, icon->core->window);
898 XUngrabButton(dpy, Button2, AnyModifier, icon->core->window);
899 XUngrabButton(dpy, Button3, AnyModifier, icon->core->window);
900 XSync(dpy, 0);
901 }
902 #endif
903
904 void wIconifyWindow(WWindow * wwin)
905 {
906 XWindowAttributes attribs;
907 int present;
908
909 if (!XGetWindowAttributes(dpy, wwin->client_win, &attribs)) {
910 /* the window doesn't exist anymore */
911 return;
912 }
913
914 if (wwin->flags.miniaturized) {
915 return;
916 }
917
918 if (wwin->transient_for != None && wwin->transient_for != wwin->screen_ptr->root_win) {
919 WWindow *owner = wWindowFor(wwin->transient_for);
920
921 if (owner && owner->flags.miniaturized)
922 return;
923 }
924
925 present = wwin->frame->workspace == wwin->screen_ptr->current_workspace;
926
927 /* if the window is in another workspace, simplify process */
928 if (present) {
929 /* icon creation may take a while */
930 XGrabPointer(dpy, wwin->screen_ptr->root_win, False,
931 ButtonMotionMask | ButtonReleaseMask, GrabModeAsync,
932 GrabModeAsync, None, None, CurrentTime);
933 }
934
935 if (!wPreferences.disable_miniwindows
936 #ifdef NETWM_HINTS
937 && !wwin->flags.net_handle_icon
938 #endif
939 ) {
940 if (!wwin->flags.icon_moved) {
941 PlaceIcon(wwin->screen_ptr, &wwin->icon_x, &wwin->icon_y, wGetHeadForWindow(wwin));
942 }
943 wwin->icon = wIconCreate(wwin);
944
945 wwin->icon->mapped = 1;
946 }
947
948 wwin->flags.miniaturized = 1;
949 wwin->flags.mapped = 0;
950
951 /* unmap transients */
952
953 unmapTransientsFor(wwin);
954
955 if (present) {
956 wSoundPlay(WSOUND_ICONIFY);
957
958 XUngrabPointer(dpy, CurrentTime);
959 wWindowUnmap(wwin);
960 /* let all Expose events arrive so that we can repaint
961 * something before the animation starts (and the server is grabbed) */
962 XSync(dpy, 0);
963
964 if (wPreferences.disable_miniwindows
965 #ifdef NETWM_HINTS
966 || wwin->flags.net_handle_icon
967 #endif
968 )
969 wClientSetState(wwin, IconicState, None);
970 else
971 wClientSetState(wwin, IconicState, wwin->icon->icon_win);
972
973 flushExpose();
974 #ifdef ANIMATIONS
975 if (!wwin->screen_ptr->flags.startup && !wwin->flags.skip_next_animation
976 && !wPreferences.no_animations) {
977 int ix, iy, iw, ih;
978
979 if (!wPreferences.disable_miniwindows
980 #ifdef NETWM_HINTS
981 && !wwin->flags.net_handle_icon
982 #endif
983 ) {
984 ix = wwin->icon_x;
985 iy = wwin->icon_y;
986 iw = wwin->icon->core->width;
987 ih = wwin->icon->core->height;
988 } else {
989 #ifdef NETWM_HINTS
990 if (wwin->flags.net_handle_icon) {
991 ix = wwin->icon_x;
992 iy = wwin->icon_y;
993 iw = wwin->icon_w;
994 ih = wwin->icon_h;
995 } else
996 #endif
997 {
998 ix = 0;
999 iy = 0;
1000 iw = wwin->screen_ptr->scr_width;
1001 ih = wwin->screen_ptr->scr_height;
1002 }
1003 }
1004 animateResize(wwin->screen_ptr, wwin->frame_x, wwin->frame_y,
1005 wwin->frame->core->width, wwin->frame->core->height, ix, iy, iw, ih, False);
1006 }
1007 #endif
1008 }
1009
1010 wwin->flags.skip_next_animation = 0;
1011
1012 if (!wPreferences.disable_miniwindows
1013 #ifdef NETWM_HINTS
1014 && !wwin->flags.net_handle_icon
1015 #endif
1016 ) {
1017
1018 if (wwin->screen_ptr->current_workspace == wwin->frame->workspace ||
1019 IS_OMNIPRESENT(wwin) || wPreferences.sticky_icons)
1020
1021 XMapWindow(dpy, wwin->icon->core->window);
1022
1023 AddToStackList(wwin->icon->core);
1024
1025 wLowerFrame(wwin->icon->core);
1026 }
1027
1028 if (present) {
1029 WWindow *owner = recursiveTransientFor(wwin->screen_ptr->focused_window);
1030
1031 /*
1032 * It doesn't seem to be working and causes button event hangup
1033 * when deiconifying a transient window.
1034 setupIconGrabs(wwin->icon);
1035 */
1036 if ((wwin->flags.focused || (owner && wwin->client_win == owner->client_win))
1037 && wPreferences.focus_mode == WKF_CLICK) {
1038 WWindow *tmp;
1039
1040 tmp = wwin->prev;
1041 while (tmp) {
1042 if (!WFLAGP(tmp, no_focusable)
1043 && !(tmp->flags.hidden || tmp->flags.miniaturized)
1044 && (wwin->frame->workspace == tmp->frame->workspace))
1045 break;
1046 tmp = tmp->prev;
1047 }
1048 wSetFocusTo(wwin->screen_ptr, tmp);
1049 } else if (wPreferences.focus_mode != WKF_CLICK) {
1050 wSetFocusTo(wwin->screen_ptr, NULL);
1051 }
1052 #ifdef ANIMATIONS
1053 if (!wwin->screen_ptr->flags.startup) {
1054 /* Catch up with events not processed while animation was running */
1055 Window clientwin = wwin->client_win;
1056
1057 ProcessPendingEvents();
1058
1059 /* the window can disappear while ProcessPendingEvents() runs */
1060 if (!wWindowFor(clientwin)) {
1061 return;
1062 }
1063 }
1064 #endif
1065 }
1066
1067 /* maybe we want to do this regardless of net_handle_icon
1068 * it seems to me we might break behaviour this way.
1069 */
1070 if (wwin->flags.selected && !wPreferences.disable_miniwindows
1071 #ifdef NETWM_HINTS
1072 && !wwin->flags.net_handle_icon
1073 #endif
1074 )
1075 wIconSelect(wwin->icon);
1076
1077 WMPostNotificationName(WMNChangedState, wwin, "iconify");
1078 }
1079
1080 void wDeiconifyWindow(WWindow * wwin)
1081 {
1082 #ifdef NETWM_HINTS
1083 /* we're hiding for show_desktop */
1084 int netwm_hidden = wwin->flags.net_show_desktop &&
1085 wwin->frame->workspace != wwin->screen_ptr->current_workspace;
1086 #else
1087 int netwm_hidden = False;
1088 #endif
1089
1090 if (!netwm_hidden)
1091 wWindowChangeWorkspace(wwin, wwin->screen_ptr->current_workspace);
1092
1093 if (!wwin->flags.miniaturized)
1094 return;
1095
1096 if (wwin->transient_for != None && wwin->transient_for != wwin->screen_ptr->root_win) {
1097 WWindow *owner = recursiveTransientFor(wwin);
1098
1099 if (owner && owner->flags.miniaturized) {
1100 wDeiconifyWindow(owner);
1101 wSetFocusTo(wwin->screen_ptr, wwin);
1102 wRaiseFrame(wwin->frame->core);
1103 return;
1104 }
1105 }
1106
1107 wwin->flags.miniaturized = 0;
1108
1109 if (!netwm_hidden && !wwin->flags.shaded) {
1110 wwin->flags.mapped = 1;
1111 }
1112
1113 if (!netwm_hidden || wPreferences.sticky_icons) {
1114 /* maybe we want to do this regardless of net_handle_icon
1115 * it seems to me we might break behaviour this way.
1116 */
1117 if (!wPreferences.disable_miniwindows
1118 #ifdef NETWM_HINTS
1119 && !wwin->flags.net_handle_icon
1120 #endif
1121 && wwin->icon != NULL) {
1122 if (wwin->icon->selected)
1123 wIconSelect(wwin->icon);
1124
1125 XUnmapWindow(dpy, wwin->icon->core->window);
1126 }
1127 }
1128
1129 if (!netwm_hidden)
1130 wSoundPlay(WSOUND_DEICONIFY);
1131
1132 /* if the window is in another workspace, do it silently */
1133 if (!netwm_hidden) {
1134 #ifdef ANIMATIONS
1135 if (!wwin->screen_ptr->flags.startup && !wPreferences.no_animations
1136 && !wwin->flags.skip_next_animation && wwin->icon != NULL) {
1137 int ix, iy, iw, ih;
1138
1139 if (!wPreferences.disable_miniwindows
1140 #ifdef NETWM_HINTS
1141 && !wwin->flags.net_handle_icon
1142 #endif
1143 ) {
1144 ix = wwin->icon_x;
1145 iy = wwin->icon_y;
1146 iw = wwin->icon->core->width;
1147 ih = wwin->icon->core->height;
1148 } else {
1149 #ifdef NETWM_HINTS
1150 if (wwin->flags.net_handle_icon) {
1151 ix = wwin->icon_x;
1152 iy = wwin->icon_y;
1153 iw = wwin->icon_w;
1154 ih = wwin->icon_h;
1155 } else
1156 #endif
1157 {
1158 ix = 0;
1159 iy = 0;
1160 iw = wwin->screen_ptr->scr_width;
1161 ih = wwin->screen_ptr->scr_height;
1162 }
1163 }
1164 animateResize(wwin->screen_ptr, ix, iy, iw, ih,
1165 wwin->frame_x, wwin->frame_y,
1166 wwin->frame->core->width, wwin->frame->core->height, False);
1167 }
1168 #endif /* ANIMATIONS */
1169 wwin->flags.skip_next_animation = 0;
1170 XGrabServer(dpy);
1171 if (!wwin->flags.shaded) {
1172 XMapWindow(dpy, wwin->client_win);
1173 }
1174 XMapWindow(dpy, wwin->frame->core->window);
1175 wRaiseFrame(wwin->frame->core);
1176 if (!wwin->flags.shaded) {
1177 wClientSetState(wwin, NormalState, None);
1178 }
1179 mapTransientsFor(wwin);
1180 }
1181
1182 if (!wPreferences.disable_miniwindows && wwin->icon != NULL
1183 #ifdef NETWM_HINTS
1184 && !wwin->flags.net_handle_icon
1185 #endif
1186 ) {
1187 RemoveFromStackList(wwin->icon->core);
1188 /* removeIconGrabs(wwin->icon); */
1189 wIconDestroy(wwin->icon);
1190 wwin->icon = NULL;
1191 }
1192
1193 if (!netwm_hidden) {
1194 XUngrabServer(dpy);
1195
1196 wSetFocusTo(wwin->screen_ptr, wwin);
1197
1198 #ifdef ANIMATIONS
1199 if (!wwin->screen_ptr->flags.startup) {
1200 /* Catch up with events not processed while animation was running */
1201 Window clientwin = wwin->client_win;
1202
1203 ProcessPendingEvents();
1204
1205 /* the window can disappear while ProcessPendingEvents() runs */
1206 if (!wWindowFor(clientwin)) {
1207 return;
1208 }
1209 }
1210 #endif
1211 }
1212
1213 if (wPreferences.auto_arrange_icons) {
1214 wArrangeIcons(wwin->screen_ptr, True);
1215 }
1216
1217 WMPostNotificationName(WMNChangedState, wwin, "iconify");
1218
1219 /* In case we were shaded and iconified, also unshade */
1220 if (!netwm_hidden)
1221 wUnshadeWindow(wwin);
1222 }
1223
1224 static void hideWindow(WIcon * icon, int icon_x, int icon_y, WWindow * wwin, int animate)
1225 {
1226 if (wwin->flags.miniaturized) {
1227 if (wwin->icon) {
1228 XUnmapWindow(dpy, wwin->icon->core->window);
1229 wwin->icon->mapped = 0;
1230 }
1231 wwin->flags.hidden = 1;
1232
1233 WMPostNotificationName(WMNChangedState, wwin, "hide");
1234 return;
1235 }
1236
1237 if (wwin->flags.inspector_open) {
1238 wHideInspectorForWindow(wwin);
1239 }
1240
1241 wwin->flags.hidden = 1;
1242 wWindowUnmap(wwin);
1243
1244 wClientSetState(wwin, IconicState, icon->icon_win);
1245 flushExpose();
1246 wSoundPlay(WSOUND_HIDE);
1247 #ifdef ANIMATIONS
1248 if (!wwin->screen_ptr->flags.startup && !wPreferences.no_animations &&
1249 !wwin->flags.skip_next_animation && animate) {
1250 animateResize(wwin->screen_ptr, wwin->frame_x, wwin->frame_y,
1251 wwin->frame->core->width, wwin->frame->core->height,
1252 icon_x, icon_y, icon->core->width, icon->core->height, True);
1253 }
1254 #endif
1255 wwin->flags.skip_next_animation = 0;
1256
1257 WMPostNotificationName(WMNChangedState, wwin, "hide");
1258 }
1259
1260 void wHideOtherApplications(WWindow * awin)
1261 {
1262 WWindow *wwin;
1263 WApplication *tapp;
1264
1265 if (!awin)
1266 return;
1267 wwin = awin->screen_ptr->focused_window;
1268
1269 while (wwin) {
1270 if (wwin != awin
1271 && wwin->frame->workspace == awin->screen_ptr->current_workspace
1272 && !(wwin->flags.miniaturized || wwin->flags.hidden)
1273 && !wwin->flags.internal_window
1274 && wGetWindowOfInspectorForWindow(wwin) != awin && !WFLAGP(wwin, no_hide_others)) {
1275
1276 if (wwin->main_window == None || WFLAGP(wwin, no_appicon)) {
1277 if (!WFLAGP(wwin, no_miniaturizable)) {
1278 wwin->flags.skip_next_animation = 1;
1279 wIconifyWindow(wwin);
1280 }
1281 } else if (wwin->main_window != None && awin->main_window != wwin->main_window) {
1282 tapp = wApplicationOf(wwin->main_window);
1283 if (tapp) {
1284 tapp->flags.skip_next_animation = 1;
1285 wHideApplication(tapp);
1286 } else {
1287 if (!WFLAGP(wwin, no_miniaturizable)) {
1288 wwin->flags.skip_next_animation = 1;
1289 wIconifyWindow(wwin);
1290 }
1291 }
1292 }
1293 }
1294 wwin = wwin->prev;
1295 }
1296 /*
1297 wSetFocusTo(awin->screen_ptr, awin);
1298 */
1299 }
1300
1301 void wHideApplication(WApplication * wapp)
1302 {
1303 WScreen *scr;
1304 WWindow *wlist;
1305 int hadfocus;
1306 int animate;
1307
1308 if (!wapp) {
1309 wwarning("trying to hide a non grouped window");
1310 return;
1311 }
1312 if (!wapp->main_window_desc) {
1313 wwarning("group leader not found for window group");
1314 return;
1315 }
1316 scr = wapp->main_window_desc->screen_ptr;
1317 hadfocus = 0;
1318 wlist = scr->focused_window;
1319 if (!wlist)
1320 return;
1321
1322 if (wlist->main_window == wapp->main_window)
1323 wapp->last_focused = wlist;
1324 else
1325 wapp->last_focused = NULL;
1326
1327 animate = !wapp->flags.skip_next_animation;
1328
1329 while (wlist) {
1330 if (wlist->main_window == wapp->main_window) {
1331 if (wlist->flags.focused) {
1332 hadfocus = 1;
1333 }
1334 if (wapp->app_icon) {
1335 hideWindow(wapp->app_icon->icon, wapp->app_icon->x_pos,
1336 wapp->app_icon->y_pos, wlist, animate);
1337 animate = False;
1338 }
1339 }
1340 wlist = wlist->prev;
1341 }
1342
1343 wapp->flags.skip_next_animation = 0;
1344
1345 if (hadfocus) {
1346 if (wPreferences.focus_mode == WKF_CLICK) {
1347 wlist = scr->focused_window;
1348 while (wlist) {
1349 if (!WFLAGP(wlist, no_focusable) && !wlist->flags.hidden
1350 && (wlist->flags.mapped || wlist->flags.shaded))
1351 break;
1352 wlist = wlist->prev;
1353 }
1354 wSetFocusTo(scr, wlist);
1355 } else {
1356 wSetFocusTo(scr, NULL);
1357 }
1358 }
1359
1360 wapp->flags.hidden = 1;
1361
1362 if (wPreferences.auto_arrange_icons) {
1363 wArrangeIcons(scr, True);
1364 }
1365 #ifdef HIDDENDOT
1366 if (wapp->app_icon)
1367 wAppIconPaint(wapp->app_icon);
1368 #endif
1369 }
1370
1371 static void unhideWindow(WIcon * icon, int icon_x, int icon_y, WWindow * wwin, int animate, int bringToCurrentWS)
1372 {
1373 if (bringToCurrentWS)
1374 wWindowChangeWorkspace(wwin, wwin->screen_ptr->current_workspace);
1375
1376 wwin->flags.hidden = 0;
1377
1378 wSoundPlay(WSOUND_UNHIDE);
1379 #ifdef ANIMATIONS
1380 if (!wwin->screen_ptr->flags.startup && !wPreferences.no_animations && animate) {
1381 animateResize(wwin->screen_ptr, icon_x, icon_y,
1382 icon->core->width, icon->core->height,
1383 wwin->frame_x, wwin->frame_y,
1384 wwin->frame->core->width, wwin->frame->core->height, True);
1385 }
1386 #endif
1387 wwin->flags.skip_next_animation = 0;
1388 if (wwin->screen_ptr->current_workspace == wwin->frame->workspace) {
1389 XMapWindow(dpy, wwin->client_win);
1390 XMapWindow(dpy, wwin->frame->core->window);
1391 wClientSetState(wwin, NormalState, None);
1392 wwin->flags.mapped = 1;
1393 wRaiseFrame(wwin->frame->core);
1394 }
1395 if (wwin->flags.inspector_open) {
1396 wUnhideInspectorForWindow(wwin);
1397 }
1398
1399 WMPostNotificationName(WMNChangedState, wwin, "hide");
1400 }
1401
1402 void wUnhideApplication(WApplication * wapp, Bool miniwindows, Bool bringToCurrentWS)
1403 {
1404 WScreen *scr;
1405 WWindow *wlist, *next;
1406 WWindow *focused = NULL;
1407 int animate;
1408
1409 if (!wapp)
1410 return;
1411
1412 scr = wapp->main_window_desc->screen_ptr;
1413 wlist = scr->focused_window;
1414 if (!wlist)
1415 return;
1416
1417 /* goto beginning of list */
1418 while (wlist->prev)
1419 wlist = wlist->prev;
1420
1421 animate = !wapp->flags.skip_next_animation;
1422
1423 while (wlist) {
1424 next = wlist->next;
1425
1426 if (wlist->main_window == wapp->main_window) {
1427 if (wlist->flags.focused)
1428 focused = wlist;
1429 else if (!focused || !focused->flags.focused)
1430 focused = wlist;
1431
1432 if (wlist->flags.miniaturized) {
1433 if ((bringToCurrentWS || wPreferences.sticky_icons ||
1434 wlist->frame->workspace == scr->current_workspace) && wlist->icon) {
1435 if (!wlist->icon->mapped) {
1436 int x, y;
1437
1438 PlaceIcon(scr, &x, &y, wGetHeadForWindow(wlist));
1439 if (wlist->icon_x != x || wlist->icon_y != y) {
1440 XMoveWindow(dpy, wlist->icon->core->window, x, y);
1441 }
1442 wlist->icon_x = x;
1443 wlist->icon_y = y;
1444 XMapWindow(dpy, wlist->icon->core->window);
1445 wlist->icon->mapped = 1;
1446 }
1447 wRaiseFrame(wlist->icon->core);
1448 }
1449 if (bringToCurrentWS)
1450 wWindowChangeWorkspace(wlist, scr->current_workspace);
1451 wlist->flags.hidden = 0;
1452 if (miniwindows && wlist->frame->workspace == scr->current_workspace) {
1453 wDeiconifyWindow(wlist);
1454 }
1455 WMPostNotificationName(WMNChangedState, wlist, "hide");
1456 } else if (wlist->flags.shaded) {
1457 if (bringToCurrentWS)
1458 wWindowChangeWorkspace(wlist, scr->current_workspace);
1459 wlist->flags.hidden = 0;
1460 if (wlist->frame->workspace == scr->current_workspace) {
1461 XMapWindow(dpy, wlist->frame->core->window);
1462 if (miniwindows) {
1463 wUnshadeWindow(wlist);
1464 wRaiseFrame(wlist->frame->core);
1465 }
1466 }
1467 WMPostNotificationName(WMNChangedState, wlist, "hide");
1468 } else if (wlist->flags.hidden) {
1469 unhideWindow(wapp->app_icon->icon, wapp->app_icon->x_pos,
1470 wapp->app_icon->y_pos, wlist, animate, bringToCurrentWS);
1471 animate = False;
1472 } else {
1473 if (bringToCurrentWS && wlist->frame->workspace != scr->current_workspace) {
1474 wWindowChangeWorkspace(wlist, scr->current_workspace);
1475 }
1476 wRaiseFrame(wlist->frame->core);
1477 }
1478 }
1479 wlist = next;
1480 }
1481
1482 wapp->flags.skip_next_animation = 0;
1483 wapp->flags.hidden = 0;
1484
1485 if (wapp->last_focused && wapp->last_focused->flags.mapped) {
1486 wRaiseFrame(wapp->last_focused->frame->core);
1487 wSetFocusTo(scr, wapp->last_focused);
1488 } else if (focused) {
1489 wSetFocusTo(scr, focused);
1490 }
1491 wapp->last_focused = NULL;
1492 if (wPreferences.auto_arrange_icons) {
1493 wArrangeIcons(scr, True);
1494 }
1495 #ifdef HIDDENDOT
1496 wAppIconPaint(wapp->app_icon);
1497 #endif
1498 }
1499
1500 void wShowAllWindows(WScreen * scr)
1501 {
1502 WWindow *wwin, *old_foc;
1503 WApplication *wapp;
1504
1505 old_foc = wwin = scr->focused_window;
1506 while (wwin) {
1507 if (!wwin->flags.internal_window &&
1508 (scr->current_workspace == wwin->frame->workspace || IS_OMNIPRESENT(wwin))) {
1509 if (wwin->flags.miniaturized) {
1510 wwin->flags.skip_next_animation = 1;
1511 wDeiconifyWindow(wwin);
1512 } else if (wwin->flags.hidden) {
1513 wapp = wApplicationOf(wwin->main_window);
1514 if (wapp) {
1515 wUnhideApplication(wapp, False, False);
1516 } else {
1517 wwin->flags.skip_next_animation = 1;
1518 wDeiconifyWindow(wwin);
1519 }
1520 }
1521 }
1522 wwin = wwin->prev;
1523 }
1524 wSetFocusTo(scr, old_foc);
1525 /*wRaiseFrame(old_foc->frame->core); */
1526 }
1527
1528 void wRefreshDesktop(WScreen * scr)
1529 {
1530 Window win;
1531 XSetWindowAttributes attr;
1532
1533 attr.backing_store = NotUseful;
1534 attr.save_under = False;
1535 win = XCreateWindow(dpy, scr->root_win, 0, 0, scr->scr_width,
1536 scr->scr_height, 0, CopyFromParent, CopyFromParent,
1537 (Visual *) CopyFromParent, CWBackingStore | CWSaveUnder, &attr);
1538 XMapRaised(dpy, win);
1539 XDestroyWindow(dpy, win);
1540 XFlush(dpy);
1541 }
1542
1543 void wArrangeIcons(WScreen * scr, Bool arrangeAll)
1544 {
1545 WWindow *wwin;
1546 WAppIcon *aicon;
1547
1548 int head;
1549 const int heads = wXineramaHeads(scr);
1550
1551 struct HeadVars {
1552 int pf; /* primary axis */
1553 int sf; /* secondary axis */
1554 int fullW;
1555 int fullH;
1556 int pi, si;
1557 int sx1, sx2, sy1, sy2; /* screen boundary */
1558 int sw, sh;
1559 int xo, yo;
1560 int xs, ys;
1561 } *vars;
1562
1563 int isize = wPreferences.icon_size;
1564
1565 vars = (struct HeadVars *)wmalloc(sizeof(struct HeadVars) * heads);
1566
1567 for (head = 0; head < heads; ++head) {
1568 #if 0
1569 WMRect rect = wGetRectForHead(scr, head);
1570 #else
1571 WArea area = wGetUsableAreaForHead(scr, head, NULL, False);
1572 WMRect rect = wmkrect(area.x1, area.y1, area.x2 - area.x1, area.y2 - area.y1);
1573 #endif
1574
1575 vars[head].pi = vars[head].si = 0;
1576 vars[head].sx1 = rect.pos.x;
1577 vars[head].sy1 = rect.pos.y;
1578 vars[head].sw = rect.size.width;
1579 vars[head].sh = rect.size.height;
1580 vars[head].sx2 = vars[head].sx1 + vars[head].sw;
1581 vars[head].sy2 = vars[head].sy1 + vars[head].sh;
1582
1583 #if 0
1584 if (scr->dock) {
1585 if (scr->dock->on_right_side)
1586 vars[head].sx2 -= isize + DOCK_EXTRA_SPACE;
1587 else
1588 vars[head].sx1 += isize + DOCK_EXTRA_SPACE;
1589 }
1590 #endif
1591
1592 vars[head].sw = isize * (vars[head].sw / isize);
1593 vars[head].sh = isize * (vars[head].sh / isize);
1594 vars[head].fullW = (vars[head].sx2 - vars[head].sx1) / isize;
1595 vars[head].fullH = (vars[head].sy2 - vars[head].sy1) / isize;
1596
1597 /* icon yard boundaries */
1598 if (wPreferences.icon_yard & IY_VERT) {
1599 vars[head].pf = vars[head].fullH;
1600 vars[head].sf = vars[head].fullW;
1601 } else {
1602 vars[head].pf = vars[head].fullW;
1603 vars[head].sf = vars[head].fullH;
1604 }
1605 if (wPreferences.icon_yard & IY_RIGHT) {
1606 vars[head].xo = vars[head].sx2 - isize;
1607 vars[head].xs = -1;
1608 } else {
1609 vars[head].xo = vars[head].sx1;
1610 vars[head].xs = 1;
1611 }
1612 if (wPreferences.icon_yard & IY_TOP) {
1613 vars[head].yo = vars[head].sy1;
1614 vars[head].ys = 1;
1615 } else {
1616 vars[head].yo = vars[head].sy2 - isize;
1617 vars[head].ys = -1;
1618 }
1619 }
1620
1621 #define X ((wPreferences.icon_yard & IY_VERT) \
1622 ? vars[head].xo + vars[head].xs*(vars[head].si*isize) \
1623 : vars[head].xo + vars[head].xs*(vars[head].pi*isize))
1624
1625 #define Y ((wPreferences.icon_yard & IY_VERT) \
1626 ? vars[head].yo + vars[head].ys*(vars[head].pi*isize) \
1627 : vars[head].yo + vars[head].ys*(vars[head].si*isize))
1628
1629 /* arrange application icons */
1630 aicon = scr->app_icon_list;
1631 /* reverse them to avoid unnecessarily sliding of icons */
1632 while (aicon && aicon->next)
1633 aicon = aicon->next;
1634
1635 while (aicon) {
1636 if (!aicon->docked) {
1637 /* CHECK: can icon be NULL here ? */
1638 /* The intention here is to place the AppIcon on the head that
1639 * contains most of the applications _main_ window. */
1640 head = wGetHeadForWindow(aicon->icon->owner);
1641
1642 if (aicon->x_pos != X || aicon->y_pos != Y) {
1643 #ifdef ANIMATIONS
1644 if (!wPreferences.no_animations) {
1645 SlideWindow(aicon->icon->core->window, aicon->x_pos, aicon->y_pos, X, Y);
1646 }
1647 #endif /* ANIMATIONS */
1648 }
1649 wAppIconMove(aicon, X, Y);
1650 vars[head].pi++;
1651 if (vars[head].pi >= vars[head].pf) {
1652 vars[head].pi = 0;
1653 vars[head].si++;
1654 }
1655 }
1656 aicon = aicon->prev;
1657 }
1658
1659 /* arrange miniwindows */
1660 wwin = scr->focused_window;
1661 /* reverse them to avoid unnecessarily shuffling */
1662 while (wwin && wwin->prev)
1663 wwin = wwin->prev;
1664
1665 while (wwin) {
1666 if (wwin->icon && wwin->flags.miniaturized && !wwin->flags.hidden &&
1667 (wwin->frame->workspace == scr->current_workspace ||
1668 IS_OMNIPRESENT(wwin) || wPreferences.sticky_icons)) {
1669
1670 head = wGetHeadForWindow(wwin);
1671
1672 if (arrangeAll || !wwin->flags.icon_moved) {
1673 if (wwin->icon_x != X || wwin->icon_y != Y) {
1674 #ifdef ANIMATIONS
1675 if (wPreferences.no_animations) {
1676 XMoveWindow(dpy, wwin->icon->core->window, X, Y);
1677 } else {
1678 SlideWindow(wwin->icon->core->window, wwin->icon_x,
1679 wwin->icon_y, X, Y);
1680 }
1681 #else
1682 XMoveWindow(dpy, wwin->icon->core->window, X, Y);
1683 #endif /* ANIMATIONS */
1684 }
1685 wwin->icon_x = X;
1686 wwin->icon_y = Y;
1687
1688 vars[head].pi++;
1689 if (vars[head].pi >= vars[head].pf) {
1690 vars[head].pi = 0;
1691 vars[head].si++;
1692 }
1693 }
1694 }
1695 if (arrangeAll) {
1696 wwin->flags.icon_moved = 0;
1697 }
1698 /* we reversed the order, so we use next */
1699 wwin = wwin->next;
1700 }
1701
1702 wfree(vars);
1703 }
1704
1705 #if 0
1706 void wArrangeIcons(WScreen * scr, Bool arrangeAll)
1707 {
1708 WWindow *wwin;
1709 WAppIcon *aicon;
1710 int pf; /* primary axis */
1711 int sf; /* secondary axis */
1712 int fullW;
1713 int fullH;
1714 int pi, si;
1715 int sx1, sx2, sy1, sy2; /* screen boundary */
1716 int sw, sh;
1717 int xo, yo;
1718 int xs, ys;
1719 int isize = wPreferences.icon_size;
1720
1721 /*
1722 * Find out screen boundaries.
1723 */
1724
1725 /*
1726 * Allows each head to have miniwindows
1727 */
1728 WMRect rect = wGetRectForHead(scr, wGetHeadForPointerLocation(scr));
1729
1730 sx1 = rect.pos.x;
1731 sy1 = rect.pos.y;
1732 sw = rect.size.width;
1733 sh = rect.size.height;
1734 sx2 = sx1 + sw;
1735 sy2 = sy1 + sh;
1736 if (scr->dock) {
1737 if (scr->dock->on_right_side)
1738 sx2 -= isize + DOCK_EXTRA_SPACE;
1739 else
1740 sx1 += isize + DOCK_EXTRA_SPACE;
1741 }
1742 #if 0
1743 sw = isize * (scr->scr_width / isize);
1744 sh = isize * (scr->scr_height / isize);
1745 #else
1746 sw = isize * (sw / isize);
1747 sh = isize * (sh / isize);
1748 #endif
1749 fullW = (sx2 - sx1) / isize;
1750 fullH = (sy2 - sy1) / isize;
1751
1752 /* icon yard boundaries */
1753 if (wPreferences.icon_yard & IY_VERT) {
1754 pf = fullH;
1755 sf = fullW;
1756 } else {
1757 pf = fullW;
1758 sf = fullH;
1759 }
1760 if (wPreferences.icon_yard & IY_RIGHT) {
1761 xo = sx2 - isize;
1762 xs = -1;
1763 } else {
1764 xo = sx1;
1765 xs = 1;
1766 }
1767 if (wPreferences.icon_yard & IY_TOP) {
1768 yo = sy1;
1769 ys = 1;
1770 } else {
1771 yo = sy2 - isize;
1772 ys = -1;
1773 }
1774
1775 /* arrange icons putting the most recently focused window
1776 * as the last icon */
1777 #define X ((wPreferences.icon_yard & IY_VERT) ? xo + xs*(si*isize)\
1778 : xo + xs*(pi*isize))
1779 #define Y ((wPreferences.icon_yard & IY_VERT) ? yo + ys*(pi*isize)\
1780 : yo + ys*(si*isize))
1781
1782 /* arrange application icons */
1783 aicon = scr->app_icon_list;
1784 /* reverse them to avoid unnecessarily sliding of icons */
1785 while (aicon && aicon->next)
1786 aicon = aicon->next;
1787
1788 pi = 0;
1789 si = 0;
1790 while (aicon) {
1791 if (!aicon->docked) {
1792 if (aicon->x_pos != X || aicon->y_pos != Y) {
1793 #ifdef ANIMATIONS
1794 if (!wPreferences.no_animations) {
1795 SlideWindow(aicon->icon->core->window, aicon->x_pos, aicon->y_pos, X, Y);
1796 }
1797 #endif /* ANIMATIONS */
1798 }
1799 wAppIconMove(aicon, X, Y);
1800 pi++;
1801 }
1802 /* we reversed the order so we use prev */
1803 aicon = aicon->prev;
1804 if (pi >= pf) {
1805 pi = 0;
1806 si++;
1807 }
1808 }
1809
1810 /* arrange miniwindows */
1811
1812 wwin = scr->focused_window;
1813 /* reverse them to avoid unnecessarily shuffling */
1814 while (wwin && wwin->prev)
1815 wwin = wwin->prev;
1816
1817 while (wwin) {
1818 if (wwin->icon && wwin->flags.miniaturized && !wwin->flags.hidden &&
1819 (wwin->frame->workspace == scr->current_workspace ||
1820 IS_OMNIPRESENT(wwin) || wPreferences.sticky_icons)) {
1821
1822 if (arrangeAll || !wwin->flags.icon_moved) {
1823 if (wwin->icon_x != X || wwin->icon_y != Y) {
1824 #ifdef ANIMATIONS
1825 if (wPreferences.no_animations) {
1826 XMoveWindow(dpy, wwin->icon->core->window, X, Y);
1827 } else {
1828 SlideWindow(wwin->icon->core->window, wwin->icon_x,
1829 wwin->icon_y, X, Y);
1830 }
1831 #else
1832 XMoveWindow(dpy, wwin->icon->core->window, X, Y);
1833 #endif /* ANIMATIONS */
1834 }
1835 wwin->icon_x = X;
1836 wwin->icon_y = Y;
1837 pi++;
1838 }
1839 }
1840 if (arrangeAll) {
1841 wwin->flags.icon_moved = 0;
1842 }
1843 /* we reversed the order, so we use next */
1844 wwin = wwin->next;
1845 if (pi >= pf) {
1846 pi = 0;
1847 si++;
1848 }
1849 }
1850 }
1851 #endif
1852
1853 void wSelectWindow(WWindow * wwin, Bool flag)
1854 {
1855 WScreen *scr = wwin->screen_ptr;
1856
1857 if (flag) {
1858 wwin->flags.selected = 1;
1859 XSetWindowBorder(dpy, wwin->frame->core->window, scr->white_pixel);
1860
1861 if (!HAS_BORDER(wwin)) {
1862 XSetWindowBorderWidth(dpy, wwin->frame->core->window, FRAME_BORDER_WIDTH);
1863 }
1864
1865 if (!scr->selected_windows)
1866 scr->selected_windows = WMCreateArray(4);
1867 WMAddToArray(scr->selected_windows, wwin);
1868 } else {
1869 wwin->flags.selected = 0;
1870 XSetWindowBorder(dpy, wwin->frame->core->window, scr->frame_border_pixel);
1871
1872 if (!HAS_BORDER(wwin)) {
1873 XSetWindowBorderWidth(dpy, wwin->frame->core->window, 0);
1874 }
1875
1876 if (scr->selected_windows) {
1877 WMRemoveFromArray(scr->selected_windows, wwin);
1878 }
1879 }
1880 }
1881
1882 void wMakeWindowVisible(WWindow * wwin)
1883 {
1884 if (wwin->frame->workspace != wwin->screen_ptr->current_workspace)
1885 wWorkspaceChange(wwin->screen_ptr, wwin->frame->workspace);
1886
1887 if (wwin->flags.shaded) {
1888 wUnshadeWindow(wwin);
1889 }
1890 if (wwin->flags.hidden) {
1891 WApplication *app;
1892
1893 app = wApplicationOf(wwin->main_window);
1894 if (app) {
1895 /* trick to get focus to this window */
1896 app->last_focused = wwin;
1897 wUnhideApplication(app, False, False);
1898 }
1899 }
1900 if (wwin->flags.miniaturized) {
1901 wDeiconifyWindow(wwin);
1902 } else {
1903 if (!WFLAGP(wwin, no_focusable))
1904 wSetFocusTo(wwin->screen_ptr, wwin);
1905 wRaiseFrame(wwin->frame->core);
1906 }
1907 }