?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

2069ee505cfe9ec0835b6bc7026bd5d4aafa0bf3
[wmaker-crm.git] / src / event.c
blob2069ee505cfe9ec0835b6bc7026bd5d4aafa0bf3
1 /* event.c- event loop and handling
2 *
3 * Window Maker window manager
4 *
5 * Copyright (c) 1997-2003 Alfredo K. Kojima
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20 * USA.
21 */
22
23 #include <sys/inotify.h>
24 #include "wconfig.h"
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <unistd.h>
29 #include <string.h>
30
31 #include <X11/Xlib.h>
32 #include <X11/Xutil.h>
33 #ifdef SHAPE
34 # include <X11/extensions/shape.h>
35 #endif
36 #ifdef XDND
37 #include "xdnd.h"
38 #endif
39
40 #ifdef KEEP_XKB_LOCK_STATUS
41 #include <X11/XKBlib.h>
42 #endif /* KEEP_XKB_LOCK_STATUS */
43
44 #include "WindowMaker.h"
45 #include "window.h"
46 #include "actions.h"
47 #include "client.h"
48 #include "funcs.h"
49 #include "keybind.h"
50 #include "application.h"
51 #include "stacking.h"
52 #include "defaults.h"
53 #include "workspace.h"
54 #include "dock.h"
55 #include "framewin.h"
56 #include "properties.h"
57 #include "balloon.h"
58 #include "xinerama.h"
59
60 #ifdef NETWM_HINTS
61 # include "wmspec.h"
62 #endif
63
64 /******** Global Variables **********/
65 extern XContext wWinContext;
66 extern XContext wVEdgeContext;
67
68 extern Cursor wCursor[WCUR_LAST];
69
70 extern WShortKey wKeyBindings[WKBD_LAST];
71 extern int wScreenCount;
72 extern Time LastTimestamp;
73 extern Time LastFocusChange;
74
75 extern WPreferences wPreferences;
76
77 #define MOD_MASK wPreferences.modifier_mask
78
79 extern Atom _XA_WM_COLORMAP_NOTIFY;
80
81 extern Atom _XA_WM_CHANGE_STATE;
82 extern Atom _XA_WM_DELETE_WINDOW;
83 extern Atom _XA_GNUSTEP_WM_ATTR;
84 extern Atom _XA_GNUSTEP_WM_MINIATURIZE_WINDOW;
85 extern Atom _XA_GNUSTEP_TITLEBAR_STATE;
86 extern Atom _XA_WINDOWMAKER_WM_FUNCTION;
87 extern Atom _XA_WINDOWMAKER_COMMAND;
88 extern Atom _XA_WM_IGNORE_FOCUS_EVENTS;
89
90 #ifdef SHAPE
91 extern Bool wShapeSupported;
92 extern int wShapeEventBase;
93 #endif
94
95 #ifdef KEEP_XKB_LOCK_STATUS
96 extern int wXkbEventBase;
97 #endif
98
99 /* special flags */
100 /*extern char WDelayedActionSet;*/
101
102 /************ Local stuff ***********/
103
104 static void saveTimestamp(XEvent *event);
105 static void handleColormapNotify(XEvent *event);
106 static void handleMapNotify(XEvent *event);
107 static void handleUnmapNotify(XEvent *event);
108 static void handleButtonPress(XEvent *event);
109 static void handleExpose(XEvent *event);
110 static void handleDestroyNotify(XEvent *event);
111 static void handleConfigureRequest(XEvent *event);
112 static void handleMapRequest(XEvent *event);
113 static void handlePropertyNotify(XEvent *event);
114 static void handleEnterNotify(XEvent *event);
115 static void handleLeaveNotify(XEvent *event);
116 static void handleExtensions(XEvent *event);
117 static void handleClientMessage(XEvent *event);
118 static void handleKeyPress(XEvent *event);
119 static void handleFocusIn(XEvent *event);
120 static void handleMotionNotify(XEvent *event);
121 static void handleVisibilityNotify(XEvent *event);
122
123 #ifdef SHAPE
124 static void handleShapeNotify(XEvent *event);
125 #endif
126
127 /* called from the signal handler */
128 void NotifyDeadProcess(pid_t pid, unsigned char status);
129
130 /* real dead process handler */
131 static void handleDeadProcess(void *foo);
132
133 typedef struct DeadProcesses {
134 pid_t pid;
135 unsigned char exit_status;
136 } DeadProcesses;
137
138 /* stack of dead processes */
139 static DeadProcesses deadProcesses[MAX_DEAD_PROCESSES];
140 static int deadProcessPtr = 0;
141
142 typedef struct DeathHandler {
143 WDeathHandler *callback;
144 pid_t pid;
145 void *client_data;
146 } DeathHandler;
147
148 static WMArray *deathHandlers = NULL;
149
150 WMagicNumber wAddDeathHandler(pid_t pid, WDeathHandler * callback, void *cdata)
151 {
152 DeathHandler *handler;
153
154 handler = malloc(sizeof(DeathHandler));
155 if (!handler)
156 return 0;
157
158 handler->pid = pid;
159 handler->callback = callback;
160 handler->client_data = cdata;
161
162 if (!deathHandlers)
163 deathHandlers = WMCreateArrayWithDestructor(8, wfree);
164
165 WMAddToArray(deathHandlers, handler);
166
167 return handler;
168 }
169
170 void wDeleteDeathHandler(WMagicNumber id)
171 {
172 DeathHandler *handler = (DeathHandler *) id;
173
174 if (!handler || !deathHandlers)
175 return;
176
177 /* array destructor will call wfree(handler) */
178 WMRemoveFromArray(deathHandlers, handler);
179 }
180
181 void DispatchEvent(XEvent * event)
182 {
183 if (deathHandlers)
184 handleDeadProcess(NULL);
185
186 if (WCHECK_STATE(WSTATE_NEED_EXIT)) {
187 WCHANGE_STATE(WSTATE_EXITING);
188 /* received SIGTERM */
189 /*
190 * WMHandleEvent() can't be called from anything
191 * executed inside here, or we can get in a infinite
192 * recursive loop.
193 */
194 Shutdown(WSExitMode);
195
196 } else if (WCHECK_STATE(WSTATE_NEED_RESTART)) {
197 WCHANGE_STATE(WSTATE_RESTARTING);
198
199 Shutdown(WSRestartPreparationMode);
200 /* received SIGHUP */
201 Restart(NULL, True);
202 } else if (WCHECK_STATE(WSTATE_NEED_REREAD)) {
203 WCHANGE_STATE(WSTATE_NORMAL);
204 wDefaultsCheckDomains();
205 }
206
207 /* for the case that all that is wanted to be dispatched is
208 * the stuff above */
209 if (!event)
210 return;
211
212 saveTimestamp(event);
213 switch (event->type) {
214 case MapRequest:
215 handleMapRequest(event);
216 break;
217
218 case KeyPress:
219 handleKeyPress(event);
220 break;
221
222 case MotionNotify:
223 handleMotionNotify(event);
224 break;
225
226 case ConfigureRequest:
227 handleConfigureRequest(event);
228 break;
229
230 case DestroyNotify:
231 handleDestroyNotify(event);
232 break;
233
234 case MapNotify:
235 handleMapNotify(event);
236 break;
237
238 case UnmapNotify:
239 handleUnmapNotify(event);
240 break;
241
242 case ButtonPress:
243 handleButtonPress(event);
244 break;
245
246 case Expose:
247 handleExpose(event);
248 break;
249
250 case PropertyNotify:
251 handlePropertyNotify(event);
252 break;
253
254 case EnterNotify:
255 handleEnterNotify(event);
256 break;
257
258 case LeaveNotify:
259 handleLeaveNotify(event);
260 break;
261
262 case ClientMessage:
263 handleClientMessage(event);
264 break;
265
266 case ColormapNotify:
267 handleColormapNotify(event);
268 break;
269
270 case MappingNotify:
271 if (event->xmapping.request == MappingKeyboard || event->xmapping.request == MappingModifier)
272 XRefreshKeyboardMapping(&event->xmapping);
273 break;
274
275 case FocusIn:
276 handleFocusIn(event);
277 break;
278
279 case VisibilityNotify:
280 handleVisibilityNotify(event);
281 break;
282 default:
283 handleExtensions(event);
284 break;
285 }
286 }
287
288 /*
289 *----------------------------------------------------------------------
290 * inotifyHandleEvents-
291 * Check for inotify events
292 *
293 * Returns:
294 * After reading events for the given file descriptor (fd) and
295 * watch descriptor (wd)
296 *
297 * Side effects:
298 * Calls wDefaultsCheckDomains if config database is updated
299 *----------------------------------------------------------------------
300 */
301
302 #define BUFF_SIZE ((sizeof(struct inotify_event) + 16)*512)
303 void inotifyHandleEvents(int fd, int wd)
304 {
305 extern void wDefaultsCheckDomains(void);
306 ssize_t eventQLength, i = 0;
307 char buff[BUFF_SIZE] = { 0 };
308 /* Check config only once per read of the event queue */
309 int oneShotFlag = 0;
310
311 /*
312 * Read off the queued events
313 * queue overflow is not checked (IN_Q_OVERFLOW). In practise this should
314 * not occur; the block is on Xevents, but a config file change will normally
315 * occur as a result of an Xevent - so the event queue should never have more than
316 * a few entries before a read().
317 */
318 eventQLength = read(fd, buff, BUFF_SIZE);
319
320 /* check what events occured */
321 /* Should really check wd here too, but for now we only have one watch! */
322 while (i < eventQLength) {
323 struct inotify_event *pevent = (struct inotify_event *)&buff[i];
324
325 /*
326 * see inotify.h for event types.
327 */
328 if (pevent->mask & IN_DELETE_SELF) {
329 wwarning(_("the defaults database has been deleted!"
330 " Restart Window Maker to create the database" " with the default settings"));
331 close(fd);
332 }
333 if (pevent->mask & IN_UNMOUNT) {
334 wwarning(_("the unit containing the defaults database has"
335 " been unmounted. Setting --static mode." " Any changes will not be saved."));
336 close(fd);
337 wPreferences.flags.noupdates = 1;
338 }
339 if ((pevent->mask & IN_MODIFY) && oneShotFlag == 0) {
340 fprintf(stdout, "wmaker: reading config files in defaults database.\n");
341 wDefaultsCheckDomains();
342 }
343
344 /* move to next event in the buffer */
345 i += sizeof(struct inotify_event) + pevent->len;
346 }
347 }
348
349 /*
350 *----------------------------------------------------------------------
351 * EventLoop-
352 * Processes X and internal events indefinitely.
353 *
354 * Returns:
355 * Never returns
356 *
357 * Side effects:
358 * The LastTimestamp global variable is updated.
359 * Calls inotifyGetEvents if defaults database changes.
360 *----------------------------------------------------------------------
361 */
362 void EventLoop(void)
363 {
364 XEvent event;
365 extern int inotifyFD;
366 extern int inotifyWD;
367 struct timeval time;
368 fd_set rfds;
369 int retVal = 0;
370
371 if (inotifyFD < 0 || inotifyWD < 0)
372 retVal = -1;
373
374 for (;;) {
375
376 WMNextEvent(dpy, &event); /* Blocks here */
377 WMHandleEvent(&event);
378
379 if (retVal != -1) {
380 time.tv_sec = 0;
381 time.tv_usec = 0;
382 FD_ZERO(&rfds);
383 FD_SET(inotifyFD, &rfds);
384
385 /* check for available read data from inotify - don't block! */
386 retVal = select(inotifyFD + 1, &rfds, NULL, NULL, &time);
387
388 if (retVal < 0) { /* an error has occured */
389 wwarning(_("select failed. The inotify instance will be closed."
390 " Changes to the defaults database will require"
391 " a restart to take effect."));
392 close(inotifyFD);
393 continue;
394 }
395 if (FD_ISSET(inotifyFD, &rfds))
396 inotifyHandleEvents(inotifyFD, inotifyWD);
397 }
398 }
399 }
400
401 /*
402 *----------------------------------------------------------------------
403 * ProcessPendingEvents --
404 * Processes the events that are currently pending (at the time
405 * this function is called) in the display's queue.
406 *
407 * Returns:
408 * After the pending events that were present at the function call
409 * are processed.
410 *
411 * Side effects:
412 * Many -- whatever handling events may involve.
413 *
414 *----------------------------------------------------------------------
415 */
416 void ProcessPendingEvents(void)
417 {
418 XEvent event;
419 int count;
420
421 XSync(dpy, False);
422
423 /* Take a snapshot of the event count in the queue */
424 count = XPending(dpy);
425
426 while (count > 0 && XPending(dpy)) {
427 WMNextEvent(dpy, &event);
428 WMHandleEvent(&event);
429 count--;
430 }
431 }
432
433 Bool IsDoubleClick(WScreen * scr, XEvent * event)
434 {
435 if ((scr->last_click_time > 0) &&
436 (event->xbutton.time - scr->last_click_time <= wPreferences.dblclick_time)
437 && (event->xbutton.button == scr->last_click_button)
438 && (event->xbutton.window == scr->last_click_window)) {
439
440 scr->flags.next_click_is_not_double = 1;
441 scr->last_click_time = 0;
442 scr->last_click_window = event->xbutton.window;
443
444 return True;
445 }
446 return False;
447 }
448
449 void NotifyDeadProcess(pid_t pid, unsigned char status)
450 {
451 if (deadProcessPtr >= MAX_DEAD_PROCESSES - 1) {
452 wwarning("stack overflow: too many dead processes");
453 return;
454 }
455 /* stack the process to be handled later,
456 * as this is called from the signal handler */
457 deadProcesses[deadProcessPtr].pid = pid;
458 deadProcesses[deadProcessPtr].exit_status = status;
459 deadProcessPtr++;
460 }
461
462 static void handleDeadProcess(void *foo)
463 {
464 DeathHandler *tmp;
465 int i;
466
467 for (i = 0; i < deadProcessPtr; i++) {
468 wWindowDeleteSavedStatesForPID(deadProcesses[i].pid);
469 }
470
471 if (!deathHandlers) {
472 deadProcessPtr = 0;
473 return;
474 }
475
476 /* get the pids on the queue and call handlers */
477 while (deadProcessPtr > 0) {
478 deadProcessPtr--;
479
480 for (i = WMGetArrayItemCount(deathHandlers) - 1; i >= 0; i--) {
481 tmp = WMGetFromArray(deathHandlers, i);
482 if (!tmp)
483 continue;
484
485 if (tmp->pid == deadProcesses[deadProcessPtr].pid) {
486 (*tmp->callback) (tmp->pid,
487 deadProcesses[deadProcessPtr].exit_status, tmp->client_data);
488 wDeleteDeathHandler(tmp);
489 }
490 }
491 }
492 }
493
494 static void saveTimestamp(XEvent * event)
495 {
496 /*
497 * Never save CurrentTime as LastTimestamp because CurrentTime
498 * it's not a real timestamp (it's the 0L constant)
499 */
500
501 switch (event->type) {
502 case ButtonRelease:
503 case ButtonPress:
504 LastTimestamp = event->xbutton.time;
505 break;
506 case KeyPress:
507 case KeyRelease:
508 LastTimestamp = event->xkey.time;
509 break;
510 case MotionNotify:
511 LastTimestamp = event->xmotion.time;
512 break;
513 case PropertyNotify:
514 LastTimestamp = event->xproperty.time;
515 break;
516 case EnterNotify:
517 case LeaveNotify:
518 LastTimestamp = event->xcrossing.time;
519 break;
520 case SelectionClear:
521 LastTimestamp = event->xselectionclear.time;
522 break;
523 case SelectionRequest:
524 LastTimestamp = event->xselectionrequest.time;
525 break;
526 case SelectionNotify:
527 LastTimestamp = event->xselection.time;
528 #ifdef XDND
529 wXDNDProcessSelection(event);
530 #endif
531 break;
532 }
533 }
534
535 static int matchWindow(void *item, void *cdata)
536 {
537 return (((WFakeGroupLeader *) item)->origLeader == (Window) cdata);
538 }
539
540 static void handleExtensions(XEvent * event)
541 {
542 #ifdef KEEP_XKB_LOCK_STATUS
543 XkbEvent *xkbevent;
544 xkbevent = (XkbEvent *) event;
545 #endif /*KEEP_XKB_LOCK_STATUS */
546 #ifdef SHAPE
547 if (wShapeSupported && event->type == (wShapeEventBase + ShapeNotify)) {
548 handleShapeNotify(event);
549 }
550 #endif
551 #ifdef KEEP_XKB_LOCK_STATUS
552 if (wPreferences.modelock && (xkbevent->type == wXkbEventBase)) {
553 handleXkbIndicatorStateNotify(event);
554 }
555 #endif /*KEEP_XKB_LOCK_STATUS */
556 }
557
558 static void handleMapRequest(XEvent * ev)
559 {
560 WWindow *wwin;
561 WScreen *scr = NULL;
562 Window window = ev->xmaprequest.window;
563
564 #ifdef DEBUG
565 printf("got map request for %x\n", (unsigned)window);
566 #endif
567 if ((wwin = wWindowFor(window))) {
568 if (wwin->flags.shaded) {
569 wUnshadeWindow(wwin);
570 }
571 /* deiconify window */
572 if (wwin->flags.miniaturized) {
573 wDeiconifyWindow(wwin);
574 } else if (wwin->flags.hidden) {
575 WApplication *wapp = wApplicationOf(wwin->main_window);
576 /* go to the last workspace that the user worked on the app */
577 if (wapp) {
578 wWorkspaceChange(wwin->screen_ptr, wapp->last_workspace);
579 }
580 wUnhideApplication(wapp, False, False);
581 }
582 return;
583 }
584
585 scr = wScreenForRootWindow(ev->xmaprequest.parent);
586
587 wwin = wManageWindow(scr, window);
588
589 /*
590 * This is to let the Dock know that the application it launched
591 * has already been mapped (eg: it has finished launching).
592 * It is not necessary for normally docked apps, but is needed for
593 * apps that were forcedly docked (like with dockit).
594 */
595 if (scr->last_dock) {
596 if (wwin && wwin->main_window != None && wwin->main_window != window)
597 wDockTrackWindowLaunch(scr->last_dock, wwin->main_window);
598 else
599 wDockTrackWindowLaunch(scr->last_dock, window);
600 }
601
602 if (wwin) {
603 wClientSetState(wwin, NormalState, None);
604 if (wwin->flags.maximized) {
605 wMaximizeWindow(wwin, wwin->flags.maximized);
606 }
607 if (wwin->flags.shaded) {
608 wwin->flags.shaded = 0;
609 wwin->flags.skip_next_animation = 1;
610 wShadeWindow(wwin);
611 }
612 if (wwin->flags.miniaturized) {
613 wwin->flags.miniaturized = 0;
614 wwin->flags.skip_next_animation = 1;
615 wIconifyWindow(wwin);
616 }
617 if (wwin->flags.fullscreen) {
618 wwin->flags.fullscreen = 0;
619 wFullscreenWindow(wwin);
620 }
621 if (wwin->flags.hidden) {
622 WApplication *wapp = wApplicationOf(wwin->main_window);
623
624 wwin->flags.hidden = 0;
625 wwin->flags.skip_next_animation = 1;
626 if (wapp) {
627 wHideApplication(wapp);
628 }
629 }
630 }
631 }
632
633 static void handleDestroyNotify(XEvent * event)
634 {
635 WWindow *wwin;
636 WApplication *app;
637 Window window = event->xdestroywindow.window;
638 WScreen *scr = wScreenForRootWindow(event->xdestroywindow.event);
639 int widx;
640
641 #ifdef DEBUG
642 printf("got destroy notify\n");
643 #endif
644 wwin = wWindowFor(window);
645 if (wwin) {
646 wUnmanageWindow(wwin, False, True);
647 }
648
649 if (scr != NULL) {
650 while ((widx = WMFindInArray(scr->fakeGroupLeaders, matchWindow, (void *)window)) != WANotFound) {
651 WFakeGroupLeader *fPtr;
652
653 fPtr = WMGetFromArray(scr->fakeGroupLeaders, widx);
654 if (fPtr->retainCount > 0) {
655 fPtr->retainCount--;
656 if (fPtr->retainCount == 0 && fPtr->leader != None) {
657 XDestroyWindow(dpy, fPtr->leader);
658 fPtr->leader = None;
659 XFlush(dpy);
660 }
661 }
662 fPtr->origLeader = None;
663 }
664 }
665
666 app = wApplicationOf(window);
667 if (app) {
668 if (window == app->main_window) {
669 app->refcount = 0;
670 wwin = app->main_window_desc->screen_ptr->focused_window;
671 while (wwin) {
672 if (wwin->main_window == window) {
673 wwin->main_window = None;
674 }
675 wwin = wwin->prev;
676 }
677 }
678 wApplicationDestroy(app);
679 }
680 }
681
682 static void handleExpose(XEvent * event)
683 {
684 WObjDescriptor *desc;
685 XEvent ev;
686
687 #ifdef DEBUG
688 printf("got expose\n");
689 #endif
690 while (XCheckTypedWindowEvent(dpy, event->xexpose.window, Expose, &ev)) ;
691
692 if (XFindContext(dpy, event->xexpose.window, wWinContext, (XPointer *) & desc) == XCNOENT) {
693 return;
694 }
695
696 if (desc->handle_expose) {
697 (*desc->handle_expose) (desc, event);
698 }
699 }
700
701 static void executeButtonAction(WScreen * scr, XEvent * event, int action)
702 {
703 switch (action) {
704 case WA_SELECT_WINDOWS:
705 wUnselectWindows(scr);
706 wSelectWindows(scr, event);
707 break;
708 case WA_OPEN_APPMENU:
709 OpenRootMenu(scr, event->xbutton.x_root, event->xbutton.y_root, False);
710 /* ugly hack */
711 if (scr->root_menu) {
712 if (scr->root_menu->brother->flags.mapped)
713 event->xbutton.window = scr->root_menu->brother->frame->core->window;
714 else
715 event->xbutton.window = scr->root_menu->frame->core->window;
716 }
717 break;
718 case WA_OPEN_WINLISTMENU:
719 OpenSwitchMenu(scr, event->xbutton.x_root, event->xbutton.y_root, False);
720 if (scr->switch_menu) {
721 if (scr->switch_menu->brother->flags.mapped)
722 event->xbutton.window = scr->switch_menu->brother->frame->core->window;
723 else
724 event->xbutton.window = scr->switch_menu->frame->core->window;
725 }
726 break;
727 default:
728 break;
729 }
730 }
731
732 /* bindable */
733 static void handleButtonPress(XEvent * event)
734 {
735 WObjDescriptor *desc;
736 WScreen *scr;
737
738 #ifdef DEBUG
739 printf("got button press\n");
740 #endif
741 scr = wScreenForRootWindow(event->xbutton.root);
742
743 #ifdef BALLOON_TEXT
744 wBalloonHide(scr);
745 #endif
746
747 if (event->xbutton.window == scr->root_win) {
748 if (event->xbutton.button == Button1 && wPreferences.mouse_button1 != WA_NONE) {
749 executeButtonAction(scr, event, wPreferences.mouse_button1);
750 } else if (event->xbutton.button == Button2 && wPreferences.mouse_button2 != WA_NONE) {
751 executeButtonAction(scr, event, wPreferences.mouse_button2);
752 } else if (event->xbutton.button == Button3 && wPreferences.mouse_button3 != WA_NONE) {
753 executeButtonAction(scr, event, wPreferences.mouse_button3);
754 } else if (event->xbutton.button == Button4 && wPreferences.mouse_wheel != WA_NONE) {
755 wWorkspaceRelativeChange(scr, 1);
756 } else if (event->xbutton.button == Button5 && wPreferences.mouse_wheel != WA_NONE) {
757 wWorkspaceRelativeChange(scr, -1);
758 }
759 }
760
761 desc = NULL;
762 if (XFindContext(dpy, event->xbutton.subwindow, wWinContext, (XPointer *) & desc) == XCNOENT) {
763 if (XFindContext(dpy, event->xbutton.window, wWinContext, (XPointer *) & desc) == XCNOENT) {
764 return;
765 }
766 }
767
768 if (desc->parent_type == WCLASS_WINDOW) {
769 XSync(dpy, 0);
770
771 if (event->xbutton.state & MOD_MASK) {
772 XAllowEvents(dpy, AsyncPointer, CurrentTime);
773 }
774
775 /* if (wPreferences.focus_mode == WKF_CLICK) { */
776 if (wPreferences.ignore_focus_click) {
777 XAllowEvents(dpy, AsyncPointer, CurrentTime);
778 }
779 XAllowEvents(dpy, ReplayPointer, CurrentTime);
780 /* } */
781 XSync(dpy, 0);
782 } else if (desc->parent_type == WCLASS_APPICON
783 || desc->parent_type == WCLASS_MINIWINDOW || desc->parent_type == WCLASS_DOCK_ICON) {
784 if (event->xbutton.state & MOD_MASK) {
785 XSync(dpy, 0);
786 XAllowEvents(dpy, AsyncPointer, CurrentTime);
787 XSync(dpy, 0);
788 }
789 }
790
791 if (desc->handle_mousedown != NULL) {
792 (*desc->handle_mousedown) (desc, event);
793 }
794
795 /* save double-click information */
796 if (scr->flags.next_click_is_not_double) {
797 scr->flags.next_click_is_not_double = 0;
798 } else {
799 scr->last_click_time = event->xbutton.time;
800 scr->last_click_button = event->xbutton.button;
801 scr->last_click_window = event->xbutton.window;
802 }
803 }
804
805 static void handleMapNotify(XEvent * event)
806 {
807 WWindow *wwin;
808 #ifdef DEBUG
809 printf("got map\n");
810 #endif
811 wwin = wWindowFor(event->xmap.event);
812 if (wwin && wwin->client_win == event->xmap.event) {
813 if (wwin->flags.miniaturized) {
814 wDeiconifyWindow(wwin);
815 } else {
816 XGrabServer(dpy);
817 wWindowMap(wwin);
818 wClientSetState(wwin, NormalState, None);
819 XUngrabServer(dpy);
820 }
821 }
822 }
823
824 static void handleUnmapNotify(XEvent * event)
825 {
826 WWindow *wwin;
827 XEvent ev;
828 Bool withdraw = False;
829 #ifdef DEBUG
830 printf("got unmap\n");
831 #endif
832 /* only process windows with StructureNotify selected
833 * (ignore SubstructureNotify) */
834 wwin = wWindowFor(event->xunmap.window);
835 if (!wwin)
836 return;
837
838 /* whether the event is a Withdrawal request */
839 if (event->xunmap.event == wwin->screen_ptr->root_win && event->xunmap.send_event)
840 withdraw = True;
841
842 if (wwin->client_win != event->xunmap.event && !withdraw)
843 return;
844
845 if (!wwin->flags.mapped && !withdraw
846 && wwin->frame->workspace == wwin->screen_ptr->current_workspace
847 && !wwin->flags.miniaturized && !wwin->flags.hidden)
848 return;
849
850 XGrabServer(dpy);
851 XUnmapWindow(dpy, wwin->frame->core->window);
852 wwin->flags.mapped = 0;
853 XSync(dpy, 0);
854 /* check if the window was destroyed */
855 if (XCheckTypedWindowEvent(dpy, wwin->client_win, DestroyNotify, &ev)) {
856 DispatchEvent(&ev);
857 } else {
858 Bool reparented = False;
859
860 if (XCheckTypedWindowEvent(dpy, wwin->client_win, ReparentNotify, &ev))
861 reparented = True;
862
863 /* withdraw window */
864 wwin->flags.mapped = 0;
865 if (!reparented)
866 wClientSetState(wwin, WithdrawnState, None);
867
868 /* if the window was reparented, do not reparent it back to the
869 * root window */
870 wUnmanageWindow(wwin, !reparented, False);
871 }
872 XUngrabServer(dpy);
873 }
874
875 static void handleConfigureRequest(XEvent * event)
876 {
877 WWindow *wwin;
878 #ifdef DEBUG
879 printf("got configure request\n");
880 #endif
881 if (!(wwin = wWindowFor(event->xconfigurerequest.window))) {
882 /*
883 * Configure request for unmapped window
884 */
885 wClientConfigure(NULL, &(event->xconfigurerequest));
886 } else {
887 wClientConfigure(wwin, &(event->xconfigurerequest));
888 }
889 }
890
891 static void handlePropertyNotify(XEvent * event)
892 {
893 WWindow *wwin;
894 WApplication *wapp;
895 Window jr;
896 int ji;
897 unsigned int ju;
898 WScreen *scr;
899 #ifdef DEBUG
900 printf("got property notify\n");
901 #endif
902
903 wwin = wWindowFor(event->xproperty.window);
904 if (wwin) {
905 if (!XGetGeometry(dpy, wwin->client_win, &jr, &ji, &ji, &ju, &ju, &ju, &ju)) {
906 return;
907 }
908 wClientCheckProperty(wwin, &event->xproperty);
909 }
910 wapp = wApplicationOf(event->xproperty.window);
911 if (wapp) {
912 wClientCheckProperty(wapp->main_window_desc, &event->xproperty);
913 }
914
915 scr = wScreenForWindow(event->xproperty.window);
916 }
917
918 static void handleClientMessage(XEvent * event)
919 {
920 WWindow *wwin;
921 WObjDescriptor *desc;
922 #ifdef DEBUG
923 printf("got client message\n");
924 #endif
925 /* handle transition from Normal to Iconic state */
926 if (event->xclient.message_type == _XA_WM_CHANGE_STATE
927 && event->xclient.format == 32 && event->xclient.data.l[0] == IconicState) {
928
929 wwin = wWindowFor(event->xclient.window);
930 if (!wwin)
931 return;
932 if (!wwin->flags.miniaturized)
933 wIconifyWindow(wwin);
934 } else if (event->xclient.message_type == _XA_WM_COLORMAP_NOTIFY && event->xclient.format == 32) {
935 WScreen *scr = wScreenSearchForRootWindow(event->xclient.window);
936
937 if (!scr)
938 return;
939
940 if (event->xclient.data.l[1] == 1) { /* starting */
941 wColormapAllowClientInstallation(scr, True);
942 } else { /* stopping */
943 wColormapAllowClientInstallation(scr, False);
944 }
945 } else if (event->xclient.message_type == _XA_WINDOWMAKER_COMMAND) {
946
947 wDefaultsCheckDomains();
948
949 } else if (event->xclient.message_type == _XA_WINDOWMAKER_WM_FUNCTION) {
950 WApplication *wapp;
951 int done = 0;
952 wapp = wApplicationOf(event->xclient.window);
953 if (wapp) {
954 switch (event->xclient.data.l[0]) {
955 case WMFHideOtherApplications:
956 wHideOtherApplications(wapp->main_window_desc);
957 done = 1;
958 break;
959
960 case WMFHideApplication:
961 wHideApplication(wapp);
962 done = 1;
963 break;
964 }
965 }
966 if (!done) {
967 wwin = wWindowFor(event->xclient.window);
968 if (wwin) {
969 switch (event->xclient.data.l[0]) {
970 case WMFHideOtherApplications:
971 wHideOtherApplications(wwin);
972 break;
973
974 case WMFHideApplication:
975 wHideApplication(wApplicationOf(wwin->main_window));
976 break;
977 }
978 }
979 }
980 } else if (event->xclient.message_type == _XA_GNUSTEP_WM_ATTR) {
981 wwin = wWindowFor(event->xclient.window);
982 if (!wwin)
983 return;
984 switch (event->xclient.data.l[0]) {
985 case GSWindowLevelAttr:
986 {
987 int level = (int)event->xclient.data.l[1];
988
989 if (WINDOW_LEVEL(wwin) != level) {
990 ChangeStackingLevel(wwin->frame->core, level);
991 }
992 }
993 break;
994 }
995 } else if (event->xclient.message_type == _XA_GNUSTEP_TITLEBAR_STATE) {
996 wwin = wWindowFor(event->xclient.window);
997 if (!wwin)
998 return;
999 switch (event->xclient.data.l[0]) {
1000 case WMTitleBarNormal:
1001 wFrameWindowChangeState(wwin->frame, WS_UNFOCUSED);
1002 break;
1003 case WMTitleBarMain:
1004 wFrameWindowChangeState(wwin->frame, WS_PFOCUSED);
1005 break;
1006 case WMTitleBarKey:
1007 wFrameWindowChangeState(wwin->frame, WS_FOCUSED);
1008 break;
1009 }
1010 } else if (event->xclient.message_type == _XA_WM_IGNORE_FOCUS_EVENTS) {
1011 WScreen *scr = wScreenSearchForRootWindow(event->xclient.window);
1012 if (!scr)
1013 return;
1014 scr->flags.ignore_focus_events = event->xclient.data.l[0] ? 1 : 0;
1015 #ifdef NETWM_HINTS
1016 } else if (wNETWMProcessClientMessage(&event->xclient)) {
1017 /* do nothing */
1018 #endif
1019 #ifdef XDND
1020 } else if (wXDNDProcessClientMessage(&event->xclient)) {
1021 /* do nothing */
1022 #endif /* XDND */
1023 } else {
1024 /*
1025 * Non-standard thing, but needed by OffiX DND.
1026 * For when the icon frame gets a ClientMessage
1027 * that should have gone to the icon_window.
1028 */
1029 if (XFindContext(dpy, event->xbutton.window, wWinContext, (XPointer *) & desc) != XCNOENT) {
1030 struct WIcon *icon = NULL;
1031
1032 if (desc->parent_type == WCLASS_MINIWINDOW) {
1033 icon = (WIcon *) desc->parent;
1034 } else if (desc->parent_type == WCLASS_DOCK_ICON || desc->parent_type == WCLASS_APPICON) {
1035 icon = ((WAppIcon *) desc->parent)->icon;
1036 }
1037 if (icon && (wwin = icon->owner)) {
1038 if (wwin->client_win != event->xclient.window) {
1039 event->xclient.window = wwin->client_win;
1040 XSendEvent(dpy, wwin->client_win, False, NoEventMask, event);
1041 }
1042 }
1043 }
1044 }
1045 }
1046
1047 static void raiseWindow(WScreen * scr)
1048 {
1049 WWindow *wwin;
1050
1051 scr->autoRaiseTimer = NULL;
1052
1053 wwin = wWindowFor(scr->autoRaiseWindow);
1054 if (!wwin)
1055 return;
1056
1057 if (!wwin->flags.destroyed && wwin->flags.focused) {
1058 wRaiseFrame(wwin->frame->core);
1059 /* this is needed or a race condition will occur */
1060 XSync(dpy, False);
1061 }
1062 }
1063
1064 static void handleEnterNotify(XEvent * event)
1065 {
1066 WWindow *wwin;
1067 WObjDescriptor *desc = NULL;
1068 #ifdef VIRTUAL_DESKTOP
1069 void (*vdHandler) (XEvent * event);
1070 #endif
1071 XEvent ev;
1072 WScreen *scr = wScreenForRootWindow(event->xcrossing.root);
1073 #ifdef DEBUG
1074 printf("got enter notify\n");
1075 #endif
1076
1077 #ifdef VIRTUAL_DESKTOP
1078 if (XFindContext(dpy, event->xcrossing.window, wVEdgeContext, (XPointer *) & vdHandler) != XCNOENT) {
1079 (*vdHandler) (event);
1080 }
1081 #endif
1082
1083 if (XCheckTypedWindowEvent(dpy, event->xcrossing.window, LeaveNotify, &ev)) {
1084 /* already left the window... */
1085 saveTimestamp(&ev);
1086 if (ev.xcrossing.mode == event->xcrossing.mode && ev.xcrossing.detail == event->xcrossing.detail) {
1087 return;
1088 }
1089 }
1090
1091 if (XFindContext(dpy, event->xcrossing.window, wWinContext, (XPointer *) & desc) != XCNOENT) {
1092 if (desc->handle_enternotify)
1093 (*desc->handle_enternotify) (desc, event);
1094 }
1095
1096 /* enter to window */
1097 wwin = wWindowFor(event->xcrossing.window);
1098 if (!wwin) {
1099 if (wPreferences.colormap_mode == WCM_POINTER) {
1100 wColormapInstallForWindow(scr, NULL);
1101 }
1102 if (scr->autoRaiseTimer && event->xcrossing.root == event->xcrossing.window) {
1103 WMDeleteTimerHandler(scr->autoRaiseTimer);
1104 scr->autoRaiseTimer = NULL;
1105 }
1106 } else {
1107 /* set auto raise timer even if in focus-follows-mouse mode
1108 * and the event is for the frame window, even if the window
1109 * has focus already. useful if you move the pointer from a focused
1110 * window to the root window and back pretty fast
1111 *
1112 * set focus if in focus-follows-mouse mode and the event
1113 * is for the frame window and window doesn't have focus yet */
1114 if (wPreferences.focus_mode == WKF_SLOPPY
1115 && wwin->frame->core->window == event->xcrossing.window && !scr->flags.doing_alt_tab) {
1116
1117 if (!wwin->flags.focused && !WFLAGP(wwin, no_focusable))
1118 wSetFocusTo(scr, wwin);
1119
1120 if (scr->autoRaiseTimer)
1121 WMDeleteTimerHandler(scr->autoRaiseTimer);
1122 scr->autoRaiseTimer = NULL;
1123
1124 if (wPreferences.raise_delay && !WFLAGP(wwin, no_focusable)) {
1125 scr->autoRaiseWindow = wwin->frame->core->window;
1126 scr->autoRaiseTimer
1127 = WMAddTimerHandler(wPreferences.raise_delay, (WMCallback *) raiseWindow, scr);
1128 }
1129 }
1130 /* Install colormap for window, if the colormap installation mode
1131 * is colormap_follows_mouse */
1132 if (wPreferences.colormap_mode == WCM_POINTER) {
1133 if (wwin->client_win == event->xcrossing.window)
1134 wColormapInstallForWindow(scr, wwin);
1135 else
1136 wColormapInstallForWindow(scr, NULL);
1137 }
1138 }
1139
1140 /* a little kluge to hide the clip balloon */
1141 if (!wPreferences.flags.noclip && scr->flags.clip_balloon_mapped) {
1142 if (!desc) {
1143 XUnmapWindow(dpy, scr->clip_balloon);
1144 scr->flags.clip_balloon_mapped = 0;
1145 } else {
1146 if (desc->parent_type != WCLASS_DOCK_ICON || scr->clip_icon != desc->parent) {
1147 XUnmapWindow(dpy, scr->clip_balloon);
1148 scr->flags.clip_balloon_mapped = 0;
1149 }
1150 }
1151 }
1152
1153 if (event->xcrossing.window == event->xcrossing.root
1154 && event->xcrossing.detail == NotifyNormal
1155 && event->xcrossing.detail != NotifyInferior && wPreferences.focus_mode != WKF_CLICK) {
1156
1157 wSetFocusTo(scr, scr->focused_window);
1158 }
1159 #ifdef BALLOON_TEXT
1160 wBalloonEnteredObject(scr, desc);
1161 #endif
1162 }
1163
1164 static void handleLeaveNotify(XEvent * event)
1165 {
1166 WObjDescriptor *desc = NULL;
1167
1168 if (XFindContext(dpy, event->xcrossing.window, wWinContext, (XPointer *) & desc) != XCNOENT) {
1169 if (desc->handle_leavenotify)
1170 (*desc->handle_leavenotify) (desc, event);
1171 }
1172 }
1173
1174 #ifdef SHAPE
1175 static void handleShapeNotify(XEvent * event)
1176 {
1177 XShapeEvent *shev = (XShapeEvent *) event;
1178 WWindow *wwin;
1179 XEvent ev;
1180 #ifdef DEBUG
1181 printf("got shape notify\n");
1182 #endif
1183 while (XCheckTypedWindowEvent(dpy, shev->window, event->type, &ev)) {
1184 XShapeEvent *sev = (XShapeEvent *) & ev;
1185
1186 if (sev->kind == ShapeBounding) {
1187 if (sev->shaped == shev->shaped) {
1188 *shev = *sev;
1189 } else {
1190 XPutBackEvent(dpy, &ev);
1191 break;
1192 }
1193 }
1194 }
1195
1196 wwin = wWindowFor(shev->window);
1197 if (!wwin || shev->kind != ShapeBounding)
1198 return;
1199
1200 if (!shev->shaped && wwin->flags.shaped) {
1201
1202 wwin->flags.shaped = 0;
1203 wWindowClearShape(wwin);
1204
1205 } else if (shev->shaped) {
1206
1207 wwin->flags.shaped = 1;
1208 wWindowSetShape(wwin);
1209 }
1210 }
1211 #endif /* SHAPE */
1212
1213 #ifdef KEEP_XKB_LOCK_STATUS
1214 /* please help ]d if you know what to do */
1215 handleXkbIndicatorStateNotify(XEvent * event)
1216 {
1217 WWindow *wwin;
1218 WScreen *scr;
1219 XkbStateRec staterec;
1220 int i;
1221
1222 for (i = 0; i < wScreenCount; i++) {
1223 scr = wScreenWithNumber(i);
1224 wwin = scr->focused_window;
1225 if (wwin && wwin->flags.focused) {
1226 XkbGetState(dpy, XkbUseCoreKbd, &staterec);
1227 if (wwin->frame->languagemode != staterec.group) {
1228 wwin->frame->last_languagemode = wwin->frame->languagemode;
1229 wwin->frame->languagemode = staterec.group;
1230 }
1231 #ifdef XKB_BUTTON_HINT
1232 if (wwin->frame->titlebar) {
1233 wFrameWindowPaint(wwin->frame);
1234 }
1235 #endif
1236 }
1237 }
1238 }
1239 #endif /*KEEP_XKB_LOCK_STATUS */
1240
1241 static void handleColormapNotify(XEvent * event)
1242 {
1243 WWindow *wwin;
1244 WScreen *scr;
1245 Bool reinstall = False;
1246
1247 wwin = wWindowFor(event->xcolormap.window);
1248 if (!wwin)
1249 return;
1250
1251 scr = wwin->screen_ptr;
1252
1253 do {
1254 if (wwin) {
1255 if (event->xcolormap.new) {
1256 XWindowAttributes attr;
1257
1258 XGetWindowAttributes(dpy, wwin->client_win, &attr);
1259
1260 if (wwin == scr->cmap_window && wwin->cmap_window_no == 0)
1261 scr->current_colormap = attr.colormap;
1262
1263 reinstall = True;
1264 } else if (event->xcolormap.state == ColormapUninstalled &&
1265 scr->current_colormap == event->xcolormap.colormap) {
1266
1267 /* some bastard app (like XV) removed our colormap */
1268 /*
1269 * can't enforce or things like xscreensaver wont work
1270 * reinstall = True;
1271 */
1272 } else if (event->xcolormap.state == ColormapInstalled &&
1273 scr->current_colormap == event->xcolormap.colormap) {
1274
1275 /* someone has put our colormap back */
1276 reinstall = False;
1277 }
1278 }
1279 } while (XCheckTypedEvent(dpy, ColormapNotify, event)
1280 && ((wwin = wWindowFor(event->xcolormap.window)) || 1));
1281
1282 if (reinstall && scr->current_colormap != None) {
1283 if (!scr->flags.colormap_stuff_blocked)
1284 XInstallColormap(dpy, scr->current_colormap);
1285 }
1286 }
1287
1288 static void handleFocusIn(XEvent * event)
1289 {
1290 WWindow *wwin;
1291
1292 /*
1293 * For applications that like stealing the focus.
1294 */
1295 while (XCheckTypedEvent(dpy, FocusIn, event)) ;
1296 saveTimestamp(event);
1297 if (event->xfocus.mode == NotifyUngrab
1298 || event->xfocus.mode == NotifyGrab || event->xfocus.detail > NotifyNonlinearVirtual) {
1299 return;
1300 }
1301
1302 wwin = wWindowFor(event->xfocus.window);
1303 if (wwin && !wwin->flags.focused) {
1304 if (wwin->flags.mapped)
1305 wSetFocusTo(wwin->screen_ptr, wwin);
1306 else
1307 wSetFocusTo(wwin->screen_ptr, NULL);
1308 } else if (!wwin) {
1309 WScreen *scr = wScreenForWindow(event->xfocus.window);
1310 if (scr)
1311 wSetFocusTo(scr, NULL);
1312 }
1313 }
1314
1315 static WWindow *windowUnderPointer(WScreen * scr)
1316 {
1317 unsigned int mask;
1318 int foo;
1319 Window bar, win;
1320
1321 if (XQueryPointer(dpy, scr->root_win, &bar, &win, &foo, &foo, &foo, &foo, &mask))
1322 return wWindowFor(win);
1323 return NULL;
1324 }
1325
1326 static int CheckFullScreenWindowFocused(WScreen * scr)
1327 {
1328 if (scr->focused_window && scr->focused_window->flags.fullscreen)
1329 return 1;
1330 else
1331 return 0;
1332 }
1333
1334 static void handleKeyPress(XEvent * event)
1335 {
1336 WScreen *scr = wScreenForRootWindow(event->xkey.root);
1337 WWindow *wwin = scr->focused_window;
1338 short i, widx;
1339 int modifiers;
1340 int command = -1;
1341 #ifdef KEEP_XKB_LOCK_STATUS
1342 XkbStateRec staterec;
1343 #endif /*KEEP_XKB_LOCK_STATUS */
1344
1345 /* ignore CapsLock */
1346 modifiers = event->xkey.state & ValidModMask;
1347
1348 for (i = 0; i < WKBD_LAST; i++) {
1349 if (wKeyBindings[i].keycode == 0)
1350 continue;
1351
1352 if (wKeyBindings[i].keycode == event->xkey.keycode && ( /*wKeyBindings[i].modifier==0
1353 || */ wKeyBindings[i].modifier ==
1354 modifiers)) {
1355 command = i;
1356 break;
1357 }
1358 }
1359
1360 if (command < 0) {
1361
1362 if (!wRootMenuPerformShortcut(event)) {
1363 static int dontLoop = 0;
1364
1365 if (dontLoop > 10) {
1366 wwarning("problem with key event processing code");
1367 return;
1368 }
1369 dontLoop++;
1370 /* if the focused window is an internal window, try redispatching
1371 * the event to the managed window, as it can be a WINGs window */
1372 if (wwin && wwin->flags.internal_window && wwin->client_leader != None) {
1373 /* client_leader contains the WINGs toplevel */
1374 event->xany.window = wwin->client_leader;
1375 WMHandleEvent(event);
1376 }
1377 dontLoop--;
1378 }
1379 return;
1380 }
1381 #define ISMAPPED(w) ((w) && !(w)->flags.miniaturized && ((w)->flags.mapped || (w)->flags.shaded))
1382 #define ISFOCUSED(w) ((w) && (w)->flags.focused)
1383
1384 switch (command) {
1385
1386 case WKBD_ROOTMENU:
1387 /*OpenRootMenu(scr, event->xkey.x_root, event->xkey.y_root, True); */
1388 if (!CheckFullScreenWindowFocused(scr)) {
1389 WMRect rect = wGetRectForHead(scr, wGetHeadForPointerLocation(scr));
1390 OpenRootMenu(scr, rect.pos.x + rect.size.width / 2, rect.pos.y + rect.size.height / 2,
1391 True);
1392 }
1393 break;
1394 case WKBD_WINDOWLIST:
1395 if (!CheckFullScreenWindowFocused(scr)) {
1396 WMRect rect = wGetRectForHead(scr, wGetHeadForPointerLocation(scr));
1397 OpenSwitchMenu(scr, rect.pos.x + rect.size.width / 2, rect.pos.y + rect.size.height / 2,
1398 True);
1399 }
1400 break;
1401
1402 case WKBD_WINDOWMENU:
1403 if (ISMAPPED(wwin) && ISFOCUSED(wwin))
1404 OpenWindowMenu(wwin, wwin->frame_x, wwin->frame_y + wwin->frame->top_width, True);
1405 break;
1406 case WKBD_MINIATURIZE:
1407 if (ISMAPPED(wwin) && ISFOCUSED(wwin)
1408 && !WFLAGP(wwin, no_miniaturizable)) {
1409 CloseWindowMenu(scr);
1410
1411 if (wwin->protocols.MINIATURIZE_WINDOW)
1412 wClientSendProtocol(wwin, _XA_GNUSTEP_WM_MINIATURIZE_WINDOW, event->xbutton.time);
1413 else {
1414 wIconifyWindow(wwin);
1415 }
1416 }
1417 break;
1418 case WKBD_HIDE:
1419 if (ISMAPPED(wwin) && ISFOCUSED(wwin)) {
1420 WApplication *wapp = wApplicationOf(wwin->main_window);
1421 CloseWindowMenu(scr);
1422
1423 if (wapp && !WFLAGP(wapp->main_window_desc, no_appicon)) {
1424 wHideApplication(wapp);
1425 }
1426 }
1427 break;
1428 case WKBD_HIDE_OTHERS:
1429 if (ISMAPPED(wwin) && ISFOCUSED(wwin)) {
1430 CloseWindowMenu(scr);
1431
1432 wHideOtherApplications(wwin);
1433 }
1434 break;
1435 case WKBD_MAXIMIZE:
1436 if (ISMAPPED(wwin) && ISFOCUSED(wwin) && IS_RESIZABLE(wwin)) {
1437 int newdir = (MAX_VERTICAL | MAX_HORIZONTAL);
1438
1439 CloseWindowMenu(scr);
1440
1441 if (wwin->flags.maximized == newdir) {
1442 wUnmaximizeWindow(wwin);
1443 } else {
1444 wMaximizeWindow(wwin, newdir | MAX_KEYBOARD);
1445 }
1446 }
1447 break;
1448 case WKBD_VMAXIMIZE:
1449 if (ISMAPPED(wwin) && ISFOCUSED(wwin) && IS_RESIZABLE(wwin)) {
1450 int newdir = (MAX_VERTICAL ^ wwin->flags.maximized);
1451
1452 CloseWindowMenu(scr);
1453
1454 if (newdir) {
1455 wMaximizeWindow(wwin, newdir | MAX_KEYBOARD);
1456 } else {
1457 wUnmaximizeWindow(wwin);
1458 }
1459 }
1460 break;
1461 case WKBD_HMAXIMIZE:
1462 if (ISMAPPED(wwin) && ISFOCUSED(wwin) && IS_RESIZABLE(wwin)) {
1463 int newdir = (MAX_HORIZONTAL ^ wwin->flags.maximized);
1464
1465 CloseWindowMenu(scr);
1466
1467 if (newdir) {
1468 wMaximizeWindow(wwin, newdir | MAX_KEYBOARD);
1469 } else {
1470 wUnmaximizeWindow(wwin);
1471 }
1472 }
1473 break;
1474 case WKBD_RAISE:
1475 if (ISMAPPED(wwin) && ISFOCUSED(wwin)) {
1476 CloseWindowMenu(scr);
1477
1478 wRaiseFrame(wwin->frame->core);
1479 }
1480 break;
1481 case WKBD_LOWER:
1482 if (ISMAPPED(wwin) && ISFOCUSED(wwin)) {
1483 CloseWindowMenu(scr);
1484
1485 wLowerFrame(wwin->frame->core);
1486 }
1487 break;
1488 case WKBD_RAISELOWER:
1489 /* raise or lower the window under the pointer, not the
1490 * focused one
1491 */
1492 wwin = windowUnderPointer(scr);
1493 if (wwin)
1494 wRaiseLowerFrame(wwin->frame->core);
1495 break;
1496 case WKBD_SHADE:
1497 if (ISMAPPED(wwin) && ISFOCUSED(wwin) && !WFLAGP(wwin, no_shadeable)) {
1498 if (wwin->flags.shaded)
1499 wUnshadeWindow(wwin);
1500 else
1501 wShadeWindow(wwin);
1502 }
1503 break;
1504 case WKBD_MOVERESIZE:
1505 if (ISMAPPED(wwin) && ISFOCUSED(wwin) && (IS_RESIZABLE(wwin) || IS_MOVABLE(wwin))) {
1506 CloseWindowMenu(scr);
1507
1508 wKeyboardMoveResizeWindow(wwin);
1509 }
1510 break;
1511 case WKBD_CLOSE:
1512 if (ISMAPPED(wwin) && ISFOCUSED(wwin) && !WFLAGP(wwin, no_closable)) {
1513 CloseWindowMenu(scr);
1514 if (wwin->protocols.DELETE_WINDOW)
1515 wClientSendProtocol(wwin, _XA_WM_DELETE_WINDOW, event->xkey.time);
1516 }
1517 break;
1518 case WKBD_SELECT:
1519 if (ISMAPPED(wwin) && ISFOCUSED(wwin)) {
1520 wSelectWindow(wwin, !wwin->flags.selected);
1521 }
1522 break;
1523 case WKBD_FOCUSNEXT:
1524 StartWindozeCycle(wwin, event, True);
1525 break;
1526
1527 case WKBD_FOCUSPREV:
1528 StartWindozeCycle(wwin, event, False);
1529 break;
1530
1531 case WKBD_WORKSPACE1 ... WKBD_WORKSPACE10:
1532 widx = command - WKBD_WORKSPACE1;
1533 i = (scr->current_workspace / 10) * 10 + widx;
1534 if (wPreferences.ws_advance || i < scr->workspace_count)
1535 wWorkspaceChange(scr, i);
1536 break;
1537
1538 case WKBD_NEXTWORKSPACE:
1539 wWorkspaceRelativeChange(scr, 1);
1540 break;
1541 case WKBD_PREVWORKSPACE:
1542 wWorkspaceRelativeChange(scr, -1);
1543 break;
1544
1545 case WKBD_WINDOW1:
1546 case WKBD_WINDOW2:
1547 case WKBD_WINDOW3:
1548 case WKBD_WINDOW4:
1549 case WKBD_WINDOW5:
1550 case WKBD_WINDOW6:
1551 case WKBD_WINDOW7:
1552 case WKBD_WINDOW8:
1553 case WKBD_WINDOW9:
1554 case WKBD_WINDOW10:
1555
1556 widx = command - WKBD_WINDOW1;
1557
1558 if (scr->shortcutWindows[widx]) {
1559 WMArray *list = scr->shortcutWindows[widx];
1560 int cw;
1561 int count = WMGetArrayItemCount(list);
1562 WWindow *twin;
1563 WMArrayIterator iter;
1564 WWindow *wwin;
1565
1566 wUnselectWindows(scr);
1567 cw = scr->current_workspace;
1568
1569 WM_ETARETI_ARRAY(list, wwin, iter) {
1570 if (count > 1)
1571 wWindowChangeWorkspace(wwin, cw);
1572
1573 wMakeWindowVisible(wwin);
1574
1575 if (count > 1)
1576 wSelectWindow(wwin, True);
1577 }
1578
1579 /* rotate the order of windows, to create a cycling effect */
1580 twin = WMGetFromArray(list, 0);
1581 WMDeleteFromArray(list, 0);
1582 WMAddToArray(list, twin);
1583
1584 } else if (wwin && ISMAPPED(wwin) && ISFOCUSED(wwin)) {
1585 if (scr->shortcutWindows[widx]) {
1586 WMFreeArray(scr->shortcutWindows[widx]);
1587 scr->shortcutWindows[widx] = NULL;
1588 }
1589
1590 if (wwin->flags.selected && scr->selected_windows) {
1591 scr->shortcutWindows[widx] = WMDuplicateArray(scr->selected_windows);
1592 /*WMRemoveFromArray(scr->shortcutWindows[index], wwin);
1593 WMInsertInArray(scr->shortcutWindows[index], 0, wwin); */
1594 } else {
1595 scr->shortcutWindows[widx] = WMCreateArray(4);
1596 WMAddToArray(scr->shortcutWindows[widx], wwin);
1597 }
1598
1599 wSelectWindow(wwin, !wwin->flags.selected);
1600 XFlush(dpy);
1601 wusleep(3000);
1602 wSelectWindow(wwin, !wwin->flags.selected);
1603 XFlush(dpy);
1604
1605 } else if (scr->selected_windows && WMGetArrayItemCount(scr->selected_windows)) {
1606
1607 if (wwin->flags.selected && scr->selected_windows) {
1608 if (scr->shortcutWindows[widx]) {
1609 WMFreeArray(scr->shortcutWindows[widx]);
1610 }
1611 scr->shortcutWindows[widx] = WMDuplicateArray(scr->selected_windows);
1612 }
1613 }
1614
1615 break;
1616
1617 case WKBD_SWITCH_SCREEN:
1618 if (wScreenCount > 1) {
1619 WScreen *scr2;
1620 int i;
1621
1622 /* find index of this screen */
1623 for (i = 0; i < wScreenCount; i++) {
1624 if (wScreenWithNumber(i) == scr)
1625 break;
1626 }
1627 i++;
1628 if (i >= wScreenCount) {
1629 i = 0;
1630 }
1631 scr2 = wScreenWithNumber(i);
1632
1633 if (scr2) {
1634 XWarpPointer(dpy, scr->root_win, scr2->root_win, 0, 0, 0, 0,
1635 scr2->scr_width / 2, scr2->scr_height / 2);
1636 }
1637 }
1638 break;
1639
1640 case WKBD_NEXTWSLAYER:
1641 case WKBD_PREVWSLAYER:
1642 {
1643 int row, column;
1644
1645 row = scr->current_workspace / 10;
1646 column = scr->current_workspace % 10;
1647
1648 if (command == WKBD_NEXTWSLAYER) {
1649 if ((row + 1) * 10 < scr->workspace_count)
1650 wWorkspaceChange(scr, column + (row + 1) * 10);
1651 } else {
1652 if (row > 0)
1653 wWorkspaceChange(scr, column + (row - 1) * 10);
1654 }
1655 }
1656 break;
1657 case WKBD_CLIPLOWER:
1658 if (!wPreferences.flags.noclip)
1659 wDockLower(scr->workspaces[scr->current_workspace]->clip);
1660 break;
1661 case WKBD_CLIPRAISE:
1662 if (!wPreferences.flags.noclip)
1663 wDockRaise(scr->workspaces[scr->current_workspace]->clip);
1664 break;
1665 case WKBD_CLIPRAISELOWER:
1666 if (!wPreferences.flags.noclip)
1667 wDockRaiseLower(scr->workspaces[scr->current_workspace]->clip);
1668 break;
1669 #ifdef KEEP_XKB_LOCK_STATUS
1670 case WKBD_TOGGLE:
1671 if (wPreferences.modelock) {
1672 /*toggle */
1673 wwin = scr->focused_window;
1674
1675 if (wwin && wwin->flags.mapped
1676 && wwin->frame->workspace == wwin->screen_ptr->current_workspace
1677 && !wwin->flags.miniaturized && !wwin->flags.hidden) {
1678 XkbGetState(dpy, XkbUseCoreKbd, &staterec);
1679
1680 wwin->frame->languagemode = wwin->frame->last_languagemode;
1681 wwin->frame->last_languagemode = staterec.group;
1682 XkbLockGroup(dpy, XkbUseCoreKbd, wwin->frame->languagemode);
1683
1684 }
1685 }
1686 break;
1687 #endif /* KEEP_XKB_LOCK_STATUS */
1688 #ifdef VIRTUAL_DESKTOP
1689 case WKBD_VDESK_LEFT:
1690 wWorkspaceKeyboardMoveDesktop(scr, VEC_LEFT);
1691 break;
1692
1693 case WKBD_VDESK_RIGHT:
1694 wWorkspaceKeyboardMoveDesktop(scr, VEC_RIGHT);
1695 break;
1696
1697 case WKBD_VDESK_UP:
1698 wWorkspaceKeyboardMoveDesktop(scr, VEC_UP);
1699 break;
1700
1701 case WKBD_VDESK_DOWN:
1702 wWorkspaceKeyboardMoveDesktop(scr, VEC_DOWN);
1703 break;
1704 #endif
1705
1706 }
1707 }
1708
1709 static void handleMotionNotify(XEvent * event)
1710 {
1711 WScreen *scr = wScreenForRootWindow(event->xmotion.root);
1712
1713 if (wPreferences.scrollable_menus) {
1714 WMPoint p = wmkpoint(event->xmotion.x_root, event->xmotion.y_root);
1715 WMRect rect = wGetRectForHead(scr, wGetHeadForPoint(scr, p));
1716
1717 if (scr->flags.jump_back_pending ||
1718 p.x <= (rect.pos.x + 1) ||
1719 p.x >= (rect.pos.x + rect.size.width - 2) ||
1720 p.y <= (rect.pos.y + 1) || p.y >= (rect.pos.y + rect.size.height - 2)) {
1721 WMenu *menu;
1722 #ifdef DEBUG
1723 printf("pointer at screen edge\n");
1724 #endif
1725 menu = wMenuUnderPointer(scr);
1726 if (menu != NULL)
1727 wMenuScroll(menu, event);
1728 }
1729 }
1730 }
1731
1732 static void handleVisibilityNotify(XEvent * event)
1733 {
1734 WWindow *wwin;
1735
1736 wwin = wWindowFor(event->xvisibility.window);
1737 if (!wwin)
1738 return;
1739 wwin->flags.obscured = (event->xvisibility.state == VisibilityFullyObscured);
1740 }
The Window Maker window manager