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