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 #ifdef KEEP_XKB_LOCK_STATUS
1694         case WKBD_TOGGLE:
1695                 if (wPreferences.modelock) {
1696                         /*toggle */
1697                         wwin = scr->focused_window;
1698
1699                         if (wwin && wwin->flags.mapped
1700                             && wwin->frame->workspace == wwin->screen_ptr->current_workspace
1701                             && !wwin->flags.miniaturized && !wwin->flags.hidden) {
1702                                 XkbGetState(dpy, XkbUseCoreKbd, &staterec);
1703
1704                                 wwin->frame->languagemode = wwin->frame->last_languagemode;
1705                                 wwin->frame->last_languagemode = staterec.group;
1706                                 XkbLockGroup(dpy, XkbUseCoreKbd, wwin->frame->languagemode);
1707
1708                         }
1709                 }
1710                 break;
1711 #endif                          /* KEEP_XKB_LOCK_STATUS */
1712 #ifdef VIRTUAL_DESKTOP
1713         case WKBD_VDESK_LEFT:
1714                 wWorkspaceKeyboardMoveDesktop(scr, VEC_LEFT);
1715                 break;
1716
1717         case WKBD_VDESK_RIGHT:
1718                 wWorkspaceKeyboardMoveDesktop(scr, VEC_RIGHT);
1719                 break;
1720
1721         case WKBD_VDESK_UP:
1722                 wWorkspaceKeyboardMoveDesktop(scr, VEC_UP);
1723                 break;
1724
1725         case WKBD_VDESK_DOWN:
1726                 wWorkspaceKeyboardMoveDesktop(scr, VEC_DOWN);
1727                 break;
1728 #endif
1729
1730         }
1731 }
1732
1733 static void handleMotionNotify(XEvent * event)
1734 {
1735         WScreen *scr = wScreenForRootWindow(event->xmotion.root);
1736
1737         if (wPreferences.scrollable_menus) {
1738                 WMPoint p = wmkpoint(event->xmotion.x_root, event->xmotion.y_root);
1739                 WMRect rect = wGetRectForHead(scr, wGetHeadForPoint(scr, p));
1740
1741                 if (scr->flags.jump_back_pending ||
1742                     p.x <= (rect.pos.x + 1) ||
1743                     p.x >= (rect.pos.x + rect.size.width - 2) ||
1744                     p.y <= (rect.pos.y + 1) || p.y >= (rect.pos.y + rect.size.height - 2)) {
1745                         WMenu *menu;
1746 #ifdef DEBUG
1747                         printf("pointer at screen edge\n");
1748 #endif
1749                         menu = wMenuUnderPointer(scr);
1750                         if (menu != NULL)
1751                                 wMenuScroll(menu, event);
1752                 }
1753         }
1754 }
1755
1756 static void handleVisibilityNotify(XEvent * event)
1757 {
1758         WWindow *wwin;
1759
1760         wwin = wWindowFor(event->xvisibility.window);
1761         if (!wwin)
1762                 return;
1763         wwin->flags.obscured = (event->xvisibility.state == VisibilityFullyObscured);
1764 }