From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/gnu/awt/xlib/XEventLoop.java | 274 +++++++++++++++++++++++++++++++++++ 1 file changed, 274 insertions(+) create mode 100644 libjava/gnu/awt/xlib/XEventLoop.java (limited to 'libjava/gnu/awt/xlib/XEventLoop.java') diff --git a/libjava/gnu/awt/xlib/XEventLoop.java b/libjava/gnu/awt/xlib/XEventLoop.java new file mode 100644 index 000000000..d0c46a804 --- /dev/null +++ b/libjava/gnu/awt/xlib/XEventLoop.java @@ -0,0 +1,274 @@ +package gnu.awt.xlib; + +/* Copyright (C) 2000 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +import java.awt.*; + +import gnu.awt.LightweightRedirector; +import gnu.gcj.xlib.Display; +import gnu.gcj.xlib.XAnyEvent; +import gnu.gcj.xlib.XExposeEvent; +import gnu.gcj.xlib.XButtonEvent; +import gnu.gcj.xlib.XConfigureEvent; +import java.awt.event.PaintEvent; +import java.awt.event.InputEvent; +import java.awt.event.MouseEvent; +import java.util.Vector; + +public class XEventLoop implements Runnable +{ + Display display; + EventQueue queue; + XAnyEvent anyEvent; + private Thread eventLoopThread; + + LightweightRedirector lightweightRedirector = new LightweightRedirector(); + + public XEventLoop(Display display, EventQueue queue) + { + this.display = display; + this.queue = queue; + + anyEvent = new XAnyEvent(display); + eventLoopThread = new Thread(this, "AWT thread for XEventLoop"); + eventLoopThread.start(); + } + + public void run () + { + // FIXME: do we need an interrupt mechanism for window shutdown? + while (true) + postNextEvent (true); + } + + /** If there's an event available, post it. + * @return true if an event was posted + */ + boolean postNextEvent(boolean block) + { + AWTEvent evt = getNextEvent(block); + if (evt != null) + queue.postEvent(evt); + return evt != null; + } + + /** Get the next event. + * @param block If true, block until an event becomes available + */ + public AWTEvent getNextEvent(boolean block) + { + // ASSERT: + if (isIdle()) + throw new Error("should not be idle"); + + AWTEvent event = null; + if (loadNextEvent(block)) + { + event = createEvent(); + event = lightweightRedirector.redirect(event); + } + return event; + } + + boolean loadNextEvent(boolean block) + { + boolean gotEvent = false; + try + { + setIdle(true); + + /* The code below will result in an XFlush(). However, + while we are waiting for events after calling XFlush(), + new X requests issued on other threads will not + automatically be flushed. This can lead to a deadlock + since XFlush() will not be called before after the + processing of the next event, and new events arriving + might be dependent on the delivery of the X + requests. + + Code that issues X requests should therefore call + flushIfIdle() after they're done, to ensure that the + requests are delivered in a timely manner. XFlush is not + run if event processing is underway, since we are assured + that the event loop execution will return to this point, + where requests are flushed again, before waiting for new + events. + + Alternatively, do the work on the AWT thread, since the + XEventQueue knows how to flush the display when it runs out + of events. */ + + //display.flush(); // implicit? + gotEvent = anyEvent.loadNext(block); + } + catch (RuntimeException re) + { + System.err.println("Exception thrown on event thread:" + re); + } + finally + { + setIdle(false); + } + return gotEvent; + } + + /** + * @returns an AWT event created based on the current XEvent. + * Returns null if the current XEvent does not map to any perticular + * AWT event. + */ + + AWTEvent createEvent () + { + int type = anyEvent.getType (); + // Ignore some events without further processing + switch (type) + { + // ignore "no expose" events, which are generated whenever a pixmap + // is copied to copied to a window which is entirely unobscured + case XAnyEvent.TYPE_NO_EXPOSE: + case XAnyEvent.TYPE_UNMAP_NOTIFY: // ignore for now + case XAnyEvent.TYPE_MAP_NOTIFY: // ignore for now + case XAnyEvent.TYPE_REPARENT_NOTIFY: // ignore for now + return null; + default: + break; // continue processing events not in ignore list + } + /* avoid attempting to get client data before client data has + been set. */ + Object peer; + synchronized (this) + { + peer = anyEvent.getWindow ().getClientData (); + } + + Component source = null; + + // Try to identify source component + + if (peer instanceof XCanvasPeer) + { + source = ((XCanvasPeer) peer).getComponent (); + } + + if (source == null) + { + String msg = "unable to locate source for event (" + + anyEvent + "): peer=" + peer; + throw new RuntimeException (msg); + } + + /* if a mapping from anyEvent to AWTEvent is possible, construct a + new AWTEvent and return it. */ + + switch (type) + { + case XAnyEvent.TYPE_EXPOSE: + return createPaintEvent (source); + case XAnyEvent.TYPE_BUTTON_PRESS: + case XAnyEvent.TYPE_BUTTON_RELEASE: + return createMouseEvent (type, source); + case XAnyEvent.TYPE_CONFIGURE_NOTIFY: + configureNotify (peer); + return null; + + default: + String msg = "Do not know how to handle event (" + anyEvent + ")"; + throw new RuntimeException (msg); + } + } + + AWTEvent createPaintEvent(Component src) + { + XExposeEvent expose = new XExposeEvent(anyEvent); + PaintEvent pe = new PaintEvent(src, PaintEvent.PAINT, + expose.getBounds()); + return pe; + } + + AWTEvent createMouseEvent(int type, Component src) + { + XButtonEvent buttonEvt = new XButtonEvent(anyEvent); + + int modifiers = 0; //buttonToModifierMap[buttonEvt.button]; + + /* Warning: this makes assumptions on the contents of + X.h... Button1 = 1, Button2 = 2, etc... */ + switch (buttonEvt.button) + { + case 1: + modifiers = InputEvent.BUTTON1_DOWN_MASK; + break; + case 2: + modifiers = InputEvent.BUTTON2_DOWN_MASK; + break; + case 3: + modifiers = InputEvent.BUTTON2_DOWN_MASK; + break; + } + + int state = buttonEvt.state; + + // remap bits from state to modifiers: + + if ((state & XButtonEvent.MASK_SHIFT) != 0) + modifiers |= InputEvent.SHIFT_MASK; + + + if ((state & XButtonEvent.MASK_CONTROL) != 0) + modifiers |= InputEvent.CTRL_MASK; + + + /* FIXME: we need additional X code to properly map MODn states to + input modifiers */ + + int clickCount = 1; // FIXME... Can't get this from X. + boolean popupTrigger = false; // FIXME: look up policy somewhere + + int x = buttonEvt.x; + int y = buttonEvt.y; + + int id = (type == XAnyEvent.TYPE_BUTTON_PRESS) ? + MouseEvent.MOUSE_PRESSED : + MouseEvent.MOUSE_RELEASED; + + MouseEvent me = new MouseEvent(src, + id, + buttonEvt.time, modifiers, + buttonEvt.x, buttonEvt.y, + clickCount, popupTrigger); + return me; + } + + void configureNotify(Object peerObj) + { + XConfigureEvent configEvent = new XConfigureEvent(anyEvent); + XFramePeer peer = (XFramePeer) peerObj; + + peer.configureNotify(configEvent); + } + + public void flushIfIdle() + { + if (isIdle()) + display.flush(); + } + + volatile boolean idle = false; + + final synchronized void setIdle(boolean idle) + { + this.idle = idle; + } + + final synchronized boolean isIdle() + { + return idle; + } +} -- cgit v1.2.3