otk/eventdispatcher.cc

   1 // -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 2; -*-
   2
   3 #ifdef HAVE_CONFIG_H
   4 # include "../config.h"
   5 #endif
   6
   7 #include "eventdispatcher.hh"
   8 #include "display.hh"
   9 #include <iostream>
  10
  11 namespace otk {
  12
  13 EventDispatcher::EventDispatcher()
  14   : _fallback(0), _master(0)
  15 {
  16 }
  17
  18 EventDispatcher::~EventDispatcher()
  19 {
  20 }
  21
  22 void EventDispatcher::clearAllHandlers(void)
  23 {
  24   _map.clear();
  25 }
  26
  27 void EventDispatcher::registerHandler(Window id, EventHandler *handler)
  28 {
  29   _map.insert(std::pair<Window, EventHandler*>(id, handler));
  30 }
  31
  32 void EventDispatcher::clearHandler(Window id)
  33 {
  34   _map.erase(id);
  35 }
  36
  37 void EventDispatcher::dispatchEvents(void)
  38 {
  39   XEvent e;
  40
  41   while (XPending(**display)) {
  42     XNextEvent(**display, &e);
  43
  44 #if 0//defined(DEBUG)
  45     printf("Event %d window %lx\n", e.type, e.xany.window);
  46 #endif
  47
  48     if (e.type == FocusIn || e.type == FocusOut) {
  49       // focus events are a beast all their own.. yuk, hate, etc.
  50       dispatchFocus(e);
  51     } else {
  52       Window win;
  53
  54       // pick a window
  55       switch (e.type) {
  56       case UnmapNotify:
  57         win = e.xunmap.window;
  58         break;
  59       case DestroyNotify:
  60         win = e.xdestroywindow.window;
  61         break;
  62       case ConfigureRequest:
  63         win = e.xconfigurerequest.window;
  64         break;
  65       default:
  66         win = e.xany.window;
  67       }
  68
  69       // grab the lasttime and hack up the modifiers
  70       switch (e.type) {
  71       case ButtonPress:
  72       case ButtonRelease:
  73         _lasttime = e.xbutton.time;
  74         e.xbutton.state &= ~(LockMask | display->numLockMask() |
  75                              display->scrollLockMask());
  76         break;
  77       case KeyPress:
  78         e.xkey.state &= ~(LockMask | display->numLockMask() |
  79                           display->scrollLockMask());
  80         break;
  81       case MotionNotify:
  82         _lasttime = e.xmotion.time;
  83         e.xmotion.state &= ~(LockMask | display->numLockMask() |
  84                              display->scrollLockMask());
  85         break;
  86       case PropertyNotify:
  87         _lasttime = e.xproperty.time;
  88         break;
  89       case EnterNotify:
  90       case LeaveNotify:
  91         _lasttime = e.xcrossing.time;
  92         break;
  93       }
  94
  95       dispatch(win, e);
  96     }
  97   }
  98 }
  99
 100 void EventDispatcher::dispatchFocus(const XEvent &e)
 101 {
 102   // ignore focus changes from grabs
 103   if (e.xfocus.mode == NotifyGrab) // ||
 104       // From Metacity, from WindowMaker, ignore all funky pointer root events
 105       // its commented out cuz I don't think we need this at all. If problems
 106       // arise we can look into it
 107       //e.xfocus.detail > NotifyNonlinearVirtual)
 108     return;
 109
 110   if (e.type == FocusIn) {
 111     //printf("Got FocusIn!\n");
 112
 113     // send a FocusIn to whatever was just focused
 114     dispatch(e.xfocus.window, e);
 115     //printf("Sent FocusIn 0x%lx\n", e.xfocus.window);
 116
 117   } else if (e.type == FocusOut) {
 118     //printf("Got FocusOut!\n");
 119
 120     // FocusOut events just make us look for FocusIn events. They are ignored
 121     // otherwise.
 122     XEvent fi;
 123     if (XCheckTypedEvent(**display, FocusIn, &fi)) {
 124       //printf("Found FocusIn\n");
 125       dispatchFocus(fi);
 126       // dont unfocus the window we just focused!
 127       if (fi.xfocus.window == e.xfocus.window)
 128         return;
 129     }
 130
 131     dispatch(e.xfocus.window, e);
 132     //printf("Sent FocusOut 0x%lx\n", e.xfocus.window);
 133   }
 134 }
 135
 136 void EventDispatcher::dispatch(Window win, const XEvent &e)
 137 {
 138   EventHandler *handler = 0;
 139   EventMap::iterator it;
 140
 141   // master gets everything first
 142   if (_master)
 143     _master->handle(e);
 144
 145   // find handler for the chosen window
 146   it = _map.find(win);
 147
 148   if (it != _map.end()) {
 149     // if we found a handler
 150     handler = it->second;
 151   } else if (e.type == ConfigureRequest) {
 152     // unhandled configure requests must be used to configure the window
 153     // directly
 154     XWindowChanges xwc;
 155
 156     xwc.x = e.xconfigurerequest.x;
 157     xwc.y = e.xconfigurerequest.y;
 158     xwc.width = e.xconfigurerequest.width;
 159     xwc.height = e.xconfigurerequest.height;
 160     xwc.border_width = e.xconfigurerequest.border_width;
 161     xwc.sibling = e.xconfigurerequest.above;
 162     xwc.stack_mode = e.xconfigurerequest.detail;
 163
 164     XConfigureWindow(**display, e.xconfigurerequest.window,
 165                      e.xconfigurerequest.value_mask, &xwc);
 166   } else {
 167     // grab a falback if it exists
 168     handler = _fallback;
 169   }
 170
 171   if (handler)
 172     handler->handle(e);
 173 }
 174
 175 EventHandler *EventDispatcher::findHandler(Window win)
 176 {
 177   EventMap::iterator it = _map.find(win);
 178   if (it != _map.end())
 179     return it->second;
 180   return 0;
 181 }
 182
 183 }