src/event.c

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