/*
============================================================================
The Apache Software License, Version 1.1
============================================================================
Copyright (C) 1999-2003 The Apache Software Foundation. All rights reserved.
Redistribution and use in source and binary forms, with or without modifica-
tion, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. The end-user documentation included with the redistribution, if any, must
include the following acknowledgment: "This product includes software
developed by the Apache Software Foundation (http://www.apache.org/)."
Alternately, this acknowledgment may appear in the software itself, if
and wherever such third-party acknowledgments normally appear.
4. The names "Batik" and "Apache Software Foundation" must not be
used to endorse or promote products derived from this software without
prior written permission. For written permission, please contact
apache@apache.org.
5. Products derived from this software may not be called "Apache", nor may
"Apache" appear in their name, without prior written permission of the
Apache Software Foundation.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
DING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
This software consists of voluntary contributions made by many individuals
on behalf of the Apache Software Foundation. For more information on the
Apache Software Foundation, please see <http://www.apache.org/>.
*/
package org.apache.batik.gvt.event;
import java.awt.Point;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.lang.reflect.Array;
import java.util.EventListener;
import java.util.EventObject;
import java.util.LinkedList;
import java.util.List;
import javax.swing.event.EventListenerList;
import org.apache.batik.gvt.GraphicsNode;
import org.apache.batik.gvt.TextNode;
/**
* An EventDispatcher implementation based on AWT events.
*
* <p>Mouse events are dispatched to their "containing" node (the
* GraphicsNode corresponding to the mouse event coordinate). Searches
* for containment are performed from the EventDispatcher's "root"
* node.</p>
*
* @author <a href="bill.haneman@ireland.sun.com>Bill Haneman</a>
* @author <a href="cjolif@ilog.fr>Christophe Jolif</a>
* @author <a href="tkormann@ilog.fr>Thierry Kormann</a>
* @version $Id: AWTEventDispatcher.java,v 1.20 2003/09/11 10:40:24 deweese Exp $
*/
public class AWTEventDispatcher implements EventDispatcher,
MouseListener,
MouseMotionListener,
KeyListener {
/**
* The root GraphicsNode as determined by setRootNode().
*/
protected GraphicsNode root;
/**
* The base AffineTransform for InputEvent-to-GraphicsNodeEvent
* coordinates as determined by setBaseTransform().
*/
protected AffineTransform baseTransform;
/**
* The global listener list.
*/
protected EventListenerList glisteners;
/**
* The lastest node which has been targeted by an event.
*/
protected GraphicsNode lastHit;
/**
* A dummy graphics node to dispacth "deselect" mouse events to. ie.
* when the mouse is clicked outside any nodes.
*/
protected GraphicsNode dummyNode = new TextNode();
/**
* The current GraphicsNode targeted by an key events.
*/
protected GraphicsNode currentKeyEventTarget;
/**
* These are used to queue events while a rendering event
* is in progress.
*/
protected List eventQueue = new LinkedList();
protected boolean eventDispatchEnabled = true;
protected int eventQueueMaxSize = MAX_QUEUE_SIZE;
/**
* default max size of the event queue.
*/
final static int MAX_QUEUE_SIZE = 10;
private int nodeIncrementEventID = KeyEvent.KEY_PRESSED;
private int nodeIncrementEventCode = KeyEvent.VK_TAB;
private int nodeIncrementEventModifiers = 0;
private int nodeDecrementEventID = KeyEvent.KEY_PRESSED;
private int nodeDecrementEventCode = KeyEvent.VK_TAB;
private int nodeDecrementEventModifiers = InputEvent.SHIFT_MASK;
/**
* Constructs a new event dispatcher.
*/
public AWTEventDispatcher() {
}
/**
* Sets the root node for MouseEvent dispatch containment searches
* and field selections.
* @param root the root node
*/
public void setRootNode(GraphicsNode root) {
if (this.root != root)
eventQueue.clear(); // new root so clear 'old' events.
this.root = root;
}
/**
* Returns the root node for MouseEvent dispatch containment
* searches and field selections.
*/
public GraphicsNode getRootNode() {
return root;
}
/**
* Sets the base transform applied to MouseEvent coordinates prior
* to dispatch.
* @param t the affine transform
*/
public void setBaseTransform(AffineTransform t) {
if ((baseTransform != t) &&
((baseTransform == null) || (!baseTransform.equals(t))))
// new Display transform so events are not where user
// thinks they were.
eventQueue.clear();
baseTransform = t;
}
/**
* Returns the base transform applied to MouseEvent coordinates prior
* to dispatch.
*/
public AffineTransform getBaseTransform() {
return new AffineTransform(baseTransform);
}
//
// AWT listeners wrapper
//
/**
* Dispatches the specified AWT mouse event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeMouseEvent.
* @param evt the mouse event to propagate
*/
public void mousePressed(MouseEvent evt) {
dispatchEvent(evt);
}
/**
* Dispatches the specified AWT mouse event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeMouseEvent.
* @param evt the mouse event to propagate
*/
public void mouseReleased(MouseEvent evt) {
dispatchEvent(evt);
}
/**
* Dispatches the specified AWT mouse event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeMouseEvent.
* @param evt the mouse event to propagate
*/
public void mouseEntered(MouseEvent evt) {
dispatchEvent(evt);
}
/**
* Dispatches the specified AWT mouse event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeMouseEvent.
* @param evt the mouse event to propagate
*/
public void mouseExited(MouseEvent evt) {
dispatchEvent(evt);
}
/**
* Dispatches the specified AWT mouse event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeMouseEvent.
* @param evt the mouse event to propagate
*/
public void mouseClicked(MouseEvent evt) {
dispatchEvent(evt);
}
/**
* Dispatches the specified AWT mouse event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeMouseEvent.
* @param evt the mouse event to propagate
*/
public void mouseMoved(MouseEvent evt) {
dispatchEvent(evt);
}
/**
* Dispatches the specified AWT mouse event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeMouseEvent.
* @param evt the mouse event to propagate
*/
public void mouseDragged(MouseEvent evt) {
dispatchEvent(evt);
}
/**
* Dispatches the specified AWT key event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeKeyEvent.
* @param evt the key event to propagate
*/
public void keyPressed(KeyEvent evt) {
dispatchEvent(evt);
}
/**
* Dispatches the specified AWT key event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeKeyEvent.
* @param evt the key event to propagate
*/
public void keyReleased(KeyEvent evt) {
dispatchEvent(evt);
}
/**
* Dispatches the specified AWT key event down to the GVT tree.
* The mouse event is mutated to a GraphicsNodeKeyEvent.
* @param evt the key event to propagate
*/
public void keyTyped(KeyEvent evt) {
dispatchEvent(evt);
}
//
// Global GVT listeners support
//
/**
* Adds the specified 'global' GraphicsNodeMouseListener which is
* notified of all MouseEvents dispatched.
* @param l the listener to add
*/
public void addGraphicsNodeMouseListener(GraphicsNodeMouseListener l) {
if (glisteners == null) {
glisteners = new EventListenerList();
}
glisteners.add(GraphicsNodeMouseListener.class, l);
}
/**
* Removes the specified 'global' GraphicsNodeMouseListener which is
* notified of all MouseEvents dispatched.
* @param l the listener to remove
*/
public void removeGraphicsNodeMouseListener(GraphicsNodeMouseListener l) {
if (glisteners != null) {
glisteners.remove(GraphicsNodeMouseListener.class, l);
}
}
/**
* Adds the specified 'global' GraphicsNodeKeyListener which is
* notified of all KeyEvents dispatched.
* @param l the listener to add
*/
public void addGraphicsNodeKeyListener(GraphicsNodeKeyListener l) {
if (glisteners == null) {
glisteners = new EventListenerList();
}
glisteners.add(GraphicsNodeKeyListener.class, l);
}
/**
* Removes the specified 'global' GraphicsNodeKeyListener which is
* notified of all KeyEvents dispatched.
* @param l the listener to remove
*/
public void removeGraphicsNodeKeyListener(GraphicsNodeKeyListener l) {
if (glisteners != null) {
glisteners.remove(GraphicsNodeKeyListener.class, l);
}
}
/**
* Returns an array of listeners that were added to this event
* dispatcher and of the specified type.
* @param listenerType the type of the listeners to return
*/
public EventListener [] getListeners(Class listenerType) {
Object array =
Array.newInstance(listenerType,
glisteners.getListenerCount(listenerType));
Object[] pairElements = glisteners.getListenerList();
for (int i = 0, j = 0;i < pairElements.length-1; i+=2) {
if (pairElements[i].equals(listenerType)) {
Array.set(array, j, pairElements[i+1]);
++j;
}
}
return (EventListener[]) array;
}
//
// Event dispatch implementation
//
public void setEventDispatchEnabled(boolean b) {
eventDispatchEnabled = b;
if (eventDispatchEnabled) {
// Dispatch any queued events.
while (eventQueue.size() > 0) {
EventObject evt = (EventObject)eventQueue.remove(0);
dispatchEvent(evt);
}
}
}
public void setEventQueueMaxSize(int n) {
eventQueueMaxSize = n;
if (n == 0) eventQueue.clear();
while(eventQueue.size() > eventQueueMaxSize)
eventQueue.remove(0);
}
/**
* Dispatches the specified AWT event.
* @param evt the event to dispatch
*/
public void dispatchEvent(EventObject evt) {
if (root == null) // No root do not store anything.
return;
if (!eventDispatchEnabled) {
if (eventQueueMaxSize > 0) {
eventQueue.add(evt);
while (eventQueue.size() > eventQueueMaxSize)
// Limit how many events we queue - don't want
// user waiting forever for them to clear.
eventQueue.remove(0);
}
return;
}
if (evt instanceof MouseEvent) {
dispatchMouseEvent((MouseEvent) evt);
} else if (evt instanceof KeyEvent) {
InputEvent e = (InputEvent)evt;
if (isNodeIncrementEvent(e)) {
incrementKeyTarget();
} else if (isNodeDecrementEvent(e)) {
decrementKeyTarget();
} else {
dispatchKeyEvent((KeyEvent) evt);
}
}
}
/**
* Dispatches the specified AWT key event.
* @param evt the key event to dispatch
*/
protected void dispatchKeyEvent(KeyEvent evt) {
currentKeyEventTarget = lastHit;
if (currentKeyEventTarget != null) {
processKeyEvent
(new GraphicsNodeKeyEvent(currentKeyEventTarget,
evt.getID(),
evt.getWhen(),
evt.getModifiers(),
evt.getKeyCode(),
evt.getKeyChar()));
}
}
/**
* Dispatches the specified AWT mouse event.
* @param evt the mouse event to dispatch
*/
protected void dispatchMouseEvent(MouseEvent evt) {
GraphicsNodeMouseEvent gvtevt;
Point2D p = new Point2D.Float(evt.getX(), evt.getY());
Point2D gnp = p;
if (baseTransform != null) {
gnp = baseTransform.transform(p, null);
}
GraphicsNode node = root.nodeHitAt(gnp);
// If the receiving node has changed, send a notification
// check if we enter a new node
Point screenPos;
if (!evt.getComponent().isShowing()) {
screenPos = new Point(0,0);
} else {
screenPos = evt.getComponent().getLocationOnScreen();
screenPos.x += evt.getX();
screenPos.y += evt.getY();
}
if (lastHit != node) {
// post an MOUSE_EXITED
if (lastHit != null) {
gvtevt = new GraphicsNodeMouseEvent(lastHit,
MouseEvent.
MOUSE_EXITED,
evt.getWhen(),
evt.getModifiers(),
(float)gnp.getX(),
(float)gnp.getY(),
(int)Math.floor(p.getX()),
(int)Math.floor(p.getY()),
screenPos.x,
screenPos.y,
evt.getClickCount(),
node);
processMouseEvent(gvtevt);
// lastHit.processMouseEvent(gvtevt);
}
// post an MOUSE_ENTERED
if (node != null) {
gvtevt = new GraphicsNodeMouseEvent(node,
MouseEvent.
MOUSE_ENTERED,
evt.getWhen(),
evt.
getModifiers(),
(float)gnp.getX(),
(float)gnp.getY(),
(int)Math.floor(p.getX()),
(int)Math.floor(p.getY()),
screenPos.x,
screenPos.y,
evt.getClickCount(),
lastHit);
processMouseEvent(gvtevt);
// node.processMouseEvent(gvtevt);
}
}
// In all cases, dispatch the original event
if (node != null) {
gvtevt = new GraphicsNodeMouseEvent(node,
evt.getID(),
evt.getWhen(),
evt.getModifiers(),
(float)gnp.getX(),
(float)gnp.getY(),
(int)Math.floor(p.getX()),
(int)Math.floor(p.getY()),
screenPos.x,
screenPos.y,
evt.getClickCount(),
null);
// node.processMouseEvent(gvtevt);
processMouseEvent(gvtevt);
} else if (node == null && evt.getID() == MouseEvent.MOUSE_CLICKED
&& evt.getClickCount() == 1) {
// this is a deselect event, dispatch it to dummy node
gvtevt = new GraphicsNodeMouseEvent(dummyNode,
evt.getID(),
evt.getWhen(),
evt.getModifiers(),
(float)gnp.getX(),
(float)gnp.getY(),
(int)Math.floor(p.getX()),
(int)Math.floor(p.getY()),
screenPos.x,
screenPos.y,
evt.getClickCount(),
null);
processMouseEvent(gvtevt);
}
lastHit = node;
}
/**
* Processes the specified event by firing the 'global' listeners
* attached to this event dispatcher.
* @param evt the event to process
*/
protected void processMouseEvent(GraphicsNodeMouseEvent evt) {
if (glisteners != null) {
GraphicsNodeMouseListener[] listeners =
(GraphicsNodeMouseListener[])
getListeners(GraphicsNodeMouseListener.class);
switch (evt.getID()) {
case GraphicsNodeMouseEvent.MOUSE_MOVED:
for (int i = 0; i < listeners.length; i++) {
listeners[i].mouseMoved(evt);
}
break;
case GraphicsNodeMouseEvent.MOUSE_DRAGGED:
for (int i = 0; i < listeners.length; i++) {
listeners[i].mouseDragged(evt);
}
break;
case GraphicsNodeMouseEvent.MOUSE_ENTERED:
for (int i = 0; i < listeners.length; i++) {
listeners[i].mouseEntered(evt);
}
break;
case GraphicsNodeMouseEvent.MOUSE_EXITED:
for (int i = 0; i < listeners.length; i++) {
listeners[i].mouseExited(evt);
}
break;
case GraphicsNodeMouseEvent.MOUSE_CLICKED:
for (int i = 0; i < listeners.length; i++) {
listeners[i].mouseClicked(evt);
}
break;
case GraphicsNodeMouseEvent.MOUSE_PRESSED:
for (int i = 0; i < listeners.length; i++) {
listeners[i].mousePressed(evt);
}
break;
case GraphicsNodeMouseEvent.MOUSE_RELEASED:
for (int i = 0; i < listeners.length; i++) {
listeners[i].mouseReleased(evt);
}
break;
default:
throw new Error("Unknown Mouse Event type: "+evt.getID());
}
}
}
/**
* Dispatches a graphics node key event to by firing the 'global'
* listeners attached to this event dispatcher.
*
* @param evt the evt to dispatch
*/
public void processKeyEvent(GraphicsNodeKeyEvent evt) {
if ((glisteners != null)) {
GraphicsNodeKeyListener[] listeners =
(GraphicsNodeKeyListener[])
getListeners(GraphicsNodeKeyListener.class);
switch (evt.getID()) {
case GraphicsNodeKeyEvent.KEY_PRESSED:
for (int i=0; i<listeners.length; ++i) {
listeners[i].keyPressed(evt);
}
break;
case GraphicsNodeKeyEvent.KEY_RELEASED:
for (int i=0; i<listeners.length; ++i) {
listeners[i].keyReleased(evt);
}
break;
case GraphicsNodeKeyEvent.KEY_TYPED:
for (int i=0; i<listeners.length; ++i) {
listeners[i].keyTyped(evt);
}
break;
default:
throw new Error("Unknown Key Event type: "+evt.getID());
}
}
evt.consume();
}
private void incrementKeyTarget() {
// <!> FIXME TODO: Not implemented.
throw new Error("Increment not implemented.");
}
private void decrementKeyTarget() {
// <!> FIXME TODO: Not implemented.
throw new Error("Decrement not implemented.");
}
/**
* Associates all InputEvents of type <tt>e.getID()</tt>
* with "incrementing" of the currently selected GraphicsNode.
*/
public void setNodeIncrementEvent(InputEvent e) {
nodeIncrementEventID = e.getID();
if (e instanceof KeyEvent) {
nodeIncrementEventCode = ((KeyEvent) e).getKeyCode();
}
nodeIncrementEventModifiers = e.getModifiers();
}
/**
* Associates all InputEvents of type <tt>e.getID()</tt>
* with "decrementing" of the currently selected GraphicsNode.
* The notion of "currently selected" GraphicsNode is used
* for dispatching KeyEvents.
*/
public void setNodeDecrementEvent(InputEvent e) {
nodeDecrementEventID = e.getID();
if (e instanceof KeyEvent) {
nodeDecrementEventCode = ((KeyEvent) e).getKeyCode();
}
nodeDecrementEventModifiers = e.getModifiers();
}
/**
* Returns true if the input event e is a node increment event,
* false otherwise.
* @param e the input event
*/
protected boolean isNodeIncrementEvent(InputEvent e) {
// TODO: Improve code readability!
return ((e.getID() == nodeIncrementEventID) &&
((e instanceof KeyEvent) ?
(((KeyEvent) e).getKeyCode() == nodeIncrementEventCode) : true) &&
((e.getModifiers() & nodeIncrementEventModifiers) != 0));
}
/**
* Returns true if the input event e is a node decrement event,
* false otherwise.
*/
protected boolean isNodeDecrementEvent(InputEvent e) {
// TODO: Improve code readability!
return ((e.getID() == nodeDecrementEventID) &&
((e instanceof KeyEvent) ?
( ((KeyEvent) e).getKeyCode() == nodeDecrementEventCode) : true) &&
((e.getModifiers() & nodeDecrementEventModifiers) != 0 ));
}
}