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