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