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