libjava/gnu/awt/xlib/XEventLoop.java

   1 package gnu.awt.xlib;
   2
   3 /* Copyright (C) 2000  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 import java.awt.*;
  12
  13 import gnu.awt.LightweightRedirector;
  14 import gnu.gcj.xlib.Display;
  15 import gnu.gcj.xlib.XAnyEvent;
  16 import gnu.gcj.xlib.XExposeEvent;
  17 import gnu.gcj.xlib.XButtonEvent;
  18 import gnu.gcj.xlib.XConfigureEvent;
  19 import java.awt.event.PaintEvent;
  20 import java.awt.event.InputEvent;
  21 import java.awt.event.MouseEvent;
  22 import java.util.Vector;
  23
  24 public class XEventLoop implements Runnable
  25 {
  26   Display display;
  27   EventQueue queue;
  28   XAnyEvent anyEvent;
  29   Thread eventLoopThread;
  30
  31   LightweightRedirector lightweightRedirector = new LightweightRedirector();
  32
  33   public XEventLoop(Display display, EventQueue queue)
  34   {
  35     this.display = display;
  36     this.queue = queue;
  37
  38     anyEvent = new XAnyEvent(display);
  39     eventLoopThread = new Thread(this, "AWT thread for XEventLoop");
  40     eventLoopThread.start();
  41   }
  42
  43   public void run()
  44   {
  45     while (true)
  46       postNextEvent();
  47   }
  48
  49   void postNextEvent()
  50   {
  51     AWTEvent evt = getNextEvent();
  52     queue.postEvent(evt);
  53   }
  54
  55   /** get next event. Will block until events become available. */
  56
  57   public AWTEvent getNextEvent()
  58   {
  59     // ASSERT:
  60     if (isIdle())
  61       throw new Error("should not be idle");
  62
  63     AWTEvent event = null;
  64     while (event == null)
  65       {
  66         loadNextEvent();
  67         event = createEvent();
  68       }
  69
  70     event = lightweightRedirector.redirect(event);
  71
  72     return event;
  73   }
  74
  75   void loadNextEvent()
  76   {
  77     try
  78       {
  79         setIdle(true);
  80
  81         /* The code below will result in an XFlush(). However,
  82            while we are waiting for events after calling XFlush(),
  83            new X requests issued on other threads will not
  84            automatically be flushed. This can lead to a deadlock
  85            since XFlush() will not be called before after the
  86            processing of the next event, and new events arriving
  87            might be dependent on the delivery of the X
  88            requests.
  89
  90            Code that issues X requests should therefore call
  91            flushIfIdle() after they're done, to ensure that the
  92            requests are delivered in a timely manner.  XFlush is not
  93            run if event processing is underway, since we are assured
  94            that the event loop execution will return to this point,
  95            where requests are flushed again, before waiting for new
  96            events.
  97
  98            Alternatively, do the work on the AWT thread, since the
  99            XEventQueue knows how to flush the display when it runs out
 100            of events. */
 101
 102         //display.flush(); // implicit?
 103         anyEvent.loadNext();
 104       }
 105     catch (RuntimeException re)
 106       {
 107         System.err.println("Exception thrown on event thread:" + re);
 108       }
 109     finally
 110       {
 111         setIdle(false);
 112       }
 113   }
 114
 115   /**
 116    * @returns an AWT event created based on the current XEvent.
 117    * Returns null if the current XEvent does not map to any perticular
 118    * AWT event.
 119    */
 120
 121   AWTEvent createEvent ()
 122   {
 123     int type = anyEvent.getType ();
 124     // Ignore some events without further processing
 125     switch (type)
 126     {
 127       // ignore "no expose" events, which are generated whenever a  pixmap
 128       // is copied to copied to a window which is entirely unobscured
 129       case XAnyEvent.TYPE_NO_EXPOSE:
 130       case XAnyEvent.TYPE_UNMAP_NOTIFY:     // ignore for now
 131       case XAnyEvent.TYPE_MAP_NOTIFY:       // ignore for now
 132       case XAnyEvent.TYPE_REPARENT_NOTIFY:  // ignore for now
 133         return null;
 134       default:
 135         break;  // continue processing events not in ignore list
 136     }
 137     /* avoid attempting to get client data before client data has
 138        been set. */
 139     Object peer;
 140     synchronized (this)
 141     {
 142       peer = anyEvent.getWindow ().getClientData ();
 143     }
 144
 145     Component source = null;
 146
 147     // Try to identify source component
 148
 149     if (peer instanceof XCanvasPeer)
 150     {
 151       source = ((XCanvasPeer) peer).getComponent ();
 152     }
 153
 154     if (source == null)
 155     {
 156       String msg = "unable to locate source for event (" +
 157       anyEvent + "): peer=" + peer;
 158       throw new RuntimeException (msg);
 159     }
 160
 161     /* if a mapping from anyEvent to AWTEvent is possible, construct a
 162        new AWTEvent and return it. */
 163
 164     switch (type)
 165     {
 166       case XAnyEvent.TYPE_EXPOSE:
 167         return createPaintEvent (source);
 168       case XAnyEvent.TYPE_BUTTON_PRESS:
 169       case XAnyEvent.TYPE_BUTTON_RELEASE:
 170         return createMouseEvent (type, source);
 171       case XAnyEvent.TYPE_CONFIGURE_NOTIFY:
 172         configureNotify (peer);
 173         return null;
 174
 175       default:
 176         String msg = "Do no know how to handle event (" + anyEvent + ")";
 177         throw new RuntimeException (msg);
 178     }
 179   }
 180
 181   AWTEvent createPaintEvent(Component src)
 182   {
 183     XExposeEvent expose = new XExposeEvent(anyEvent);
 184     PaintEvent pe = new PaintEvent(src, PaintEvent.PAINT,
 185                                    expose.getBounds());
 186     return pe;
 187   }
 188
 189   AWTEvent createMouseEvent(int type, Component src)
 190   {
 191     XButtonEvent buttonEvt = new XButtonEvent(anyEvent);
 192
 193     int modifiers = 0; //buttonToModifierMap[buttonEvt.button];
 194
 195     /* Warning: this makes assumptions on the contents of
 196        X.h... Button1 = 1, Button2 = 2, etc... */
 197     switch (buttonEvt.button)
 198       {
 199       case 1:
 200         modifiers = InputEvent.BUTTON1_MASK;
 201         break;
 202       case 2:
 203         modifiers = InputEvent.BUTTON2_MASK;
 204         break;
 205       case 3:
 206         modifiers = InputEvent.BUTTON2_MASK;
 207         break;
 208       }
 209
 210     int state = buttonEvt.state;
 211
 212     // remap bits from state to modifiers:
 213
 214     if ((state & XButtonEvent.MASK_SHIFT) != 0)
 215       modifiers |= InputEvent.SHIFT_MASK;
 216
 217
 218     if ((state & XButtonEvent.MASK_CONTROL) != 0)
 219       modifiers |= InputEvent.CTRL_MASK;
 220
 221
 222     /* FIXME: we need additional X code to properly map MODn states to
 223        input modifiers */
 224
 225     int clickCount = 1; // FIXME... Can't get this from X.
 226     boolean popupTrigger = false; // FIXME: look up policy somewhere
 227
 228     int x = buttonEvt.x;
 229     int y = buttonEvt.y;
 230
 231     int id = (type == XAnyEvent.TYPE_BUTTON_PRESS) ?
 232       MouseEvent.MOUSE_PRESSED :
 233       MouseEvent.MOUSE_RELEASED;
 234
 235     MouseEvent me = new MouseEvent(src,
 236                                    id,
 237                                    buttonEvt.time, modifiers,
 238                                    buttonEvt.x, buttonEvt.y,
 239                                    clickCount, popupTrigger);
 240     return me;
 241   }
 242
 243   void configureNotify(Object peerObj)
 244   {
 245     XConfigureEvent configEvent = new XConfigureEvent(anyEvent);
 246     XFramePeer peer = (XFramePeer)  peerObj;
 247
 248     peer.configureNotify(configEvent);
 249   }
 250
 251   public void flushIfIdle()
 252   {
 253     if (isIdle())
 254       display.flush();
 255   }
 256
 257   volatile boolean idle = false;
 258
 259   final synchronized void setIdle(boolean idle)
 260   {
 261     this.idle = idle;
 262   }
 263
 264   final synchronized boolean isIdle()
 265   {
 266     return idle;
 267   }
 268 }