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