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