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     return;
 105
 106   if (e.type == FocusIn) {
 107     //printf("Got FocusIn!\n");
 108
 109     // send a FocusIn to whatever was just focused
 110     dispatch(e.xfocus.window, e);
 111     //printf("Sent FocusIn 0x%lx\n", e.xfocus.window);
 112
 113   } else if (e.type == FocusOut) {
 114     //printf("Got FocusOut!\n");
 115
 116     // FocusOut events just make us look for FocusIn events. They are ignored
 117     // otherwise.
 118     XEvent fi;
 119     if (XCheckTypedEvent(**display, FocusIn, &fi)) {
 120       //printf("Found FocusIn\n");
 121       dispatchFocus(fi);
 122       // dont unfocus the window we just focused!
 123       if (fi.xfocus.window == e.xfocus.window)
 124         return;
 125     }
 126
 127     dispatch(e.xfocus.window, e);
 128     //printf("Sent FocusOut 0x%lx\n", e.xfocus.window);
 129   }
 130 }
 131
 132 void EventDispatcher::dispatch(Window win, const XEvent &e)
 133 {
 134   EventHandler *handler = 0;
 135   EventMap::iterator it;
 136
 137   // master gets everything first
 138   if (_master)
 139     _master->handle(e);
 140
 141   // find handler for the chosen window
 142   it = _map.find(win);
 143
 144   if (it != _map.end()) {
 145     // if we found a handler
 146     handler = it->second;
 147   } else if (e.type == ConfigureRequest) {
 148     // unhandled configure requests must be used to configure the window
 149     // directly
 150     XWindowChanges xwc;
 151
 152     xwc.x = e.xconfigurerequest.x;
 153     xwc.y = e.xconfigurerequest.y;
 154     xwc.width = e.xconfigurerequest.width;
 155     xwc.height = e.xconfigurerequest.height;
 156     xwc.border_width = e.xconfigurerequest.border_width;
 157     xwc.sibling = e.xconfigurerequest.above;
 158     xwc.stack_mode = e.xconfigurerequest.detail;
 159
 160     XConfigureWindow(**display, e.xconfigurerequest.window,
 161                      e.xconfigurerequest.value_mask, &xwc);
 162   } else {
 163     // grab a falback if it exists
 164     handler = _fallback;
 165   }
 166
 167   if (handler)
 168     handler->handle(e);
 169 }
 170
 171 EventHandler *EventDispatcher::findHandler(Window win)
 172 {
 173   EventMap::iterator it = _map.find(win);
 174   if (it != _map.end())
 175     return it->second;
 176   return 0;
 177 }
 178
 179 }