/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Michael Danilov, Dmitry A. Durnev
* @version $Revision$
*/
package java.awt;
import java.awt.event.ComponentEvent;
import java.awt.event.FocusEvent;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.PaintEvent;
import java.awt.event.WindowEvent;
import org.apache.harmony.awt.internal.nls.Messages;
import org.apache.harmony.awt.wtk.NativeEvent;
import org.apache.harmony.awt.wtk.NativeWindow;
/**
* Helper package-private class for managing lightweight components &
* dispatching events from heavyweight source
*/
class Dispatcher {
//???AWT: final PopupDispatcher popupDispatcher = new PopupDispatcher();
//???AWT: final FocusDispatcher focusDispatcher;
final MouseGrabManager mouseGrabManager = new MouseGrabManager();
final MouseDispatcher mouseDispatcher;
private final ComponentDispatcher componentDispatcher = new ComponentDispatcher();
private final KeyDispatcher keyDispatcher = new KeyDispatcher();
private final Toolkit toolkit;
int clickInterval = 250;
/**
* @param toolkit - AWT toolkit
*/
Dispatcher(Toolkit toolkit) {
this.toolkit = toolkit;
//???AWT: focusDispatcher = new FocusDispatcher(toolkit);
mouseDispatcher = new MouseDispatcher(mouseGrabManager, toolkit);
}
/**
* Dispatch native event: produce appropriate AWT events,
* update component's fields when needed
* @param event - native event to dispatch
* @return - true means default processing by OS is not needed
*/
public boolean onEvent(NativeEvent event) {
int eventId = event.getEventId();
if (eventId == NativeEvent.ID_CREATED) {
return toolkit.onWindowCreated(event.getWindowId());
} else if (eventId == NativeEvent.ID_MOUSE_GRAB_CANCELED) {
return mouseGrabManager.onGrabCanceled();
//???AWT
// } else if (popupDispatcher.onEvent(event)) {
// return false;
} else {
Component src = toolkit.getComponentById(event.getWindowId());
if (src != null) {
if (((eventId >= ComponentEvent.COMPONENT_FIRST) && (eventId <= ComponentEvent.COMPONENT_LAST))
|| ((eventId >= WindowEvent.WINDOW_FIRST) && (eventId <= WindowEvent.WINDOW_LAST))
|| (eventId == NativeEvent.ID_INSETS_CHANGED)
|| (eventId == NativeEvent.ID_BOUNDS_CHANGED)
|| (eventId == NativeEvent.ID_THEME_CHANGED)) {
return componentDispatcher.dispatch(src, event);
} else if ((eventId >= MouseEvent.MOUSE_FIRST)
&& (eventId <= MouseEvent.MOUSE_LAST)) {
return mouseDispatcher.dispatch(src, event);
} else if (eventId == PaintEvent.PAINT) {
//???AWT: src.redrawManager.addPaintRegion(src, event.getClipRects());
return true;
}
}
if ((eventId >= FocusEvent.FOCUS_FIRST)
&& (eventId <= FocusEvent.FOCUS_LAST)) {
//???AWT: return focusDispatcher.dispatch(src, event);
return false;
} else if ((eventId >= KeyEvent.KEY_FIRST)
&& (eventId <= KeyEvent.KEY_LAST)) {
return keyDispatcher.dispatch(src, event);
}
}
return false;
}
/**
* The dispatcher of native events that affect
* component's state or bounds
*/
final class ComponentDispatcher {
/**
* Handle native event that affects component's state or bounds
* @param src - the component updated by the event
* @param event - the native event
* @return - as in Dispatcher.onEvent()
* @see Dispatcher#onEvent(NativeEvent)
*/
boolean dispatch(Component src, NativeEvent event) {
int id = event.getEventId();
if ((id == NativeEvent.ID_INSETS_CHANGED)
|| (id == NativeEvent.ID_THEME_CHANGED)) {
return dispatchInsets(event, src);
} else if ((id >= WindowEvent.WINDOW_FIRST)
&& (id <= WindowEvent.WINDOW_LAST)) {
return dispatchWindow(event, src);
} else {
return dispatchPureComponent(event, src);
}
}
/**
* Handle the change of top-level window's native decorations
* @param event - the native event
* @param src - the component updated by the event
* @return - as in Dispatcher.onEvent()
* @see Dispatcher#onEvent(NativeEvent)
*/
boolean dispatchInsets(NativeEvent event, Component src) {
//???AWT
/*
if (src instanceof Window) {
((Window) src).setNativeInsets(event.getInsets());
}
*/
return false;
}
/**
* Handle the change of top-level window's state
* @param event - the native event
* @param src - the component updated by the event
* @return - as in Dispatcher.onEvent()
* @see Dispatcher#onEvent(NativeEvent)
*/
boolean dispatchWindow(NativeEvent event, Component src) {
//???AWT
/*
Window window = (Window) src;
int id = event.getEventId();
if (id == WindowEvent.WINDOW_CLOSING) {
toolkit.getSystemEventQueueImpl().postEvent(
new WindowEvent(window, WindowEvent.WINDOW_CLOSING));
return true;
} else if (id == WindowEvent.WINDOW_STATE_CHANGED) {
if (window instanceof Frame) {
((Frame) window)
.updateExtendedState(event.getWindowState());
}
}
*/
return false;
}
/**
* Handle the change of component's size and/or position
* @param event - the native event
* @param src - the component updated by the event
* @return - as in Dispatcher.onEvent()
* @see Dispatcher#onEvent(NativeEvent)
*/
private boolean dispatchPureComponent(NativeEvent event, Component src) {
Rectangle rect = event.getWindowRect();
Point loc = rect.getLocation();
int mask;
switch (event.getEventId()) {
case NativeEvent.ID_BOUNDS_CHANGED:
mask = 0;
break;
case ComponentEvent.COMPONENT_MOVED:
mask = NativeWindow.BOUNDS_NOSIZE;
break;
case ComponentEvent.COMPONENT_RESIZED:
mask = NativeWindow.BOUNDS_NOMOVE;
break;
default:
// awt.12E=Unknown component event id.
throw new RuntimeException(Messages.getString("awt.12E")); //$NON-NLS-1$
}
//???AWT
/*
if (!(src instanceof Window)) {
Component compTo = src.getParent();
Component compFrom = src.getHWAncestor();
if ((compTo != null) && (compFrom != null)) {
loc = MouseDispatcher.convertPoint(compFrom, loc, compTo);
}
} else {
int windowState = event.getWindowState();
if ((windowState >= 0) && (src instanceof Frame)) {
((Frame) src).updateExtendedState(windowState);
}
}
src.setBounds(loc.x, loc.y, rect.width, rect.height, mask, false);
*/
return false;
}
}
/**
* The dispatcher of the keyboard events
*/
final class KeyDispatcher {
/**
* Handle the keyboard event using the KeyboardFocusManager
* @param src - the component receiving the event
* @param event - the native event
* @return - as in Dispatcher.onEvent()
* @see Dispatcher#onEvent(NativeEvent)
*/
boolean dispatch(Component src, NativeEvent event) {
int id = event.getEventId();
int modifiers = event.getInputModifiers();
int location = event.getKeyLocation();
int code = event.getVKey();
StringBuffer chars = event.getKeyChars();
int charsLength = chars.length();
long time = event.getTime();
char keyChar = event.getLastChar();
//???AWT
/*
if (src == null) {
//retarget focus proxy key events to focusOwner:
Window focusProxyOwner = toolkit.getFocusProxyOwnerById(event
.getWindowId());
if (focusProxyOwner == null) {
return false;
}
src = KeyboardFocusManager.actualFocusOwner;
}
*/
EventQueue eventQueue = toolkit.getSystemEventQueueImpl();
if (src != null) {
eventQueue.postEvent(new KeyEvent(src, id, time, modifiers,
code, keyChar, location));
// KEY_TYPED goes after KEY_PRESSED
if (id == KeyEvent.KEY_PRESSED) {
for (int i = 0; i < charsLength; i++) {
keyChar = chars.charAt(i);
if (keyChar != KeyEvent.CHAR_UNDEFINED) {
eventQueue.postEvent(new KeyEvent(src,
KeyEvent.KEY_TYPED, time, modifiers,
KeyEvent.VK_UNDEFINED, keyChar,
KeyEvent.KEY_LOCATION_UNKNOWN));
}
}
}
}
return false;
}
}
/**
* Retargets the mouse events to the grab owner when mouse is grabbed,
* grab and ungrab mouse when mouse buttons are pressed and released
*/
static final class MouseGrabManager {
/**
* The top-level window holding the mouse grab
* that was explicitly started by startGrab() method
*/
//???AWT: private Window nativeGrabOwner = null;
/**
* The component that owns the synthetic
* mouse grab while at least one of the
* mouse buttons is pressed
*/
private Component syntheticGrabOwner = null;
/**
* Previous value of syntheticGrabOwner
*/
private Component lastSyntheticGrabOwner = null;
/**
* Number of mouse buttons currently pressed
*/
private int syntheticGrabDepth = 0;
/**
* The callback to be called when the explicit mouse grab ends
*/
private Runnable whenCanceled;
/**
* Explicitly start the mouse grab
* @param grabWindow - the window that will own the grab
* @param whenCanceled - the callback to call when the grab ends.
* This parameter can be null
*/
//???AWT
/*
void startGrab(Window grabWindow, Runnable whenCanceled) {
if (nativeGrabOwner != null) {
// awt.12F=Attempt to start nested mouse grab
throw new RuntimeException(Messages.getString("awt.12F")); //$NON-NLS-1$
}
NativeWindow win = grabWindow.getNativeWindow();
if (win == null) {
// awt.130=Attempt to grab mouse in not displayable window
throw new RuntimeException(Messages.getString("awt.130")); //$NON-NLS-1$
}
nativeGrabOwner = grabWindow;
this.whenCanceled = whenCanceled;
win.grabMouse();
}
*/
/**
* Ends the explicit mouse grab. If the non-null callback was provided
* in the startGrab() method, this callback is called
*/
void endGrab() {
//???AWT
/*
if (nativeGrabOwner == null) {
return;
}
Window grabWindow = nativeGrabOwner;
nativeGrabOwner = null;
NativeWindow win = grabWindow.getNativeWindow();
if (win != null) {
win.ungrabMouse();
if (whenCanceled != null) {
whenCanceled.run();
whenCanceled = null;
}
}
*/
}
/**
* Ends both explicit and synthetic grans
* @return - always returns false
*/
boolean onGrabCanceled() {
endGrab();
resetSyntheticGrab();
return false;
}
/**
* Starts the synthetic mouse grab, increases the counter
* of currently pressed mouse buttons
* @param source - the component where mouse press event occured
* @return - the component that owns the synthetic grab
*/
Component onMousePressed(Component source) {
if (syntheticGrabDepth == 0) {
syntheticGrabOwner = source;
lastSyntheticGrabOwner = source;
}
syntheticGrabDepth++;
return syntheticGrabOwner;
}
/**
* Decreases the counter of currently pressed mouse buttons,
* ends the synthetic mouse grab, when this counter becomes zero
* @param source - the component where mouse press event occured
* @return - the component that owns the synthetic grab,
* or source parameter if mouse grab was released
*/
Component onMouseReleased(Component source) {
Component ret = source;
//???AWT
/*
if (syntheticGrabOwner != null && nativeGrabOwner == null) {
ret = syntheticGrabOwner;
}
*/
syntheticGrabDepth--;
if (syntheticGrabDepth <= 0) {
resetSyntheticGrab();
lastSyntheticGrabOwner = null;
}
return ret;
}
/**
* Update the state of synthetic ouse gram
* when the mouse is moved/dragged
* @param event - the native event
*/
void preprocessEvent(NativeEvent event) {
int id = event.getEventId();
switch (id) {
case MouseEvent.MOUSE_MOVED:
if (syntheticGrabOwner != null) {
syntheticGrabOwner = null;
syntheticGrabDepth = 0;
}
if (lastSyntheticGrabOwner != null) {
lastSyntheticGrabOwner = null;
}
case MouseEvent.MOUSE_DRAGGED:
if (syntheticGrabOwner == null
&& lastSyntheticGrabOwner != null) {
syntheticGrabOwner = lastSyntheticGrabOwner;
syntheticGrabDepth = 0;
int mask = event.getInputModifiers();
syntheticGrabDepth += (mask & InputEvent.BUTTON1_DOWN_MASK) != 0 ? 1
: 0;
syntheticGrabDepth += (mask & InputEvent.BUTTON2_DOWN_MASK) != 0 ? 1
: 0;
syntheticGrabDepth += (mask & InputEvent.BUTTON3_DOWN_MASK) != 0 ? 1
: 0;
}
}
}
/**
* @return the component that currently owns the synthetic grab
*/
Component getSyntheticGrabOwner() {
return syntheticGrabOwner;
}
/**
* ends synthetic grab
*/
private void resetSyntheticGrab() {
syntheticGrabOwner = null;
syntheticGrabDepth = 0;
}
}
/**
* Dispatches native events related to the pop-up boxes
* (the non-component windows such as menus and drop lists)
*/
// final class PopupDispatcher {
//
// private PopupBox activePopup;
//
// private PopupBox underCursor;
//
// private final MouseGrab grab = new MouseGrab();
//
// /**
// * Handles the mouse grab for pop-up boxes
// */
// private final class MouseGrab {
// private int depth;
//
// private PopupBox owner;
//
// private final Point start = new Point();
//
// /**
// * Starts the grab when mouse is pressed
// * @param src - the pop-up box where mouse event has occured
// * @param where - the mouse pointer location
// * @return - the grab owner
// */
// PopupBox mousePressed(PopupBox src, Point where) {
// if (depth == 0) {
// owner = src;
// start.setLocation(where);
// }
// depth++;
// return owner;
// }
//
// /**
// * Ends the grab when all mousebuttons are released
// * @param src - the pop-up box where mouse event has occured
// * @param where - the mouse pointer location
// * @return - the grab owner, or src parameter if the grab has ended
// */
// PopupBox mouseReleased(PopupBox src, Point where) {
// PopupBox ret = (owner != null) ? owner : src;
// if (depth == 0) {
// return ret;
// }
// depth--;
// if (depth == 0) {
// PopupBox tgt = owner;
// owner = null;
// if (tgt != null && src == null) {
// Point a = new Point(start);
// Point b = new Point(where);
// Point pos = tgt.getScreenLocation();
// a.translate(-pos.x, -pos.y);
// b.translate(-pos.x, -pos.y);
// if (tgt.closeOnUngrab(a, b)) {
// return null;
// }
// }
// }
// return ret;
// }
//
// /**
// * Set the grab owner to null
// */
// void reset() {
// depth = 0;
// owner = null;
// start.setLocation(0, 0);
// }
//
// /**
// * @return - the pop-up box currently owning the grab
// */
// public PopupBox getOwner() {
// return owner;
// }
// }
//
// /**
// * Call the mouse event handler of the pop-up box
// * @param src - the pop-up box where the mouse event occured
// * @param eventId - the event ID, one of MouseEvent.MOUSE_* constants
// * @param where - the mouse pointer location
// * @param event - native event
// */
// private void mouseEvent(PopupBox src, int eventId, Point where,
// NativeEvent event) {
// Point pos = src.getScreenLocation();
// pos.setLocation(where.x - pos.x, where.y - pos.y);
//
// src.onMouseEvent(eventId, pos, event.getMouseButton(), event
// .getTime(), event.getInputModifiers(), event
// .getWheelRotation());
// }
//
// /**
// * Handle the native event targeted by a pop-up box. This could be
// * paint event, mouse or keyboard event.
// * @param event - the native event
// * @return - false if the event was handled and doesn't
// * need the further processing; true when the further
// * processing is needed
// */
// boolean onEvent(NativeEvent event) {
// PopupBox src = toolkit.getPopupBoxById(event.getWindowId());
// int id = event.getEventId();
//
// if ((id == PaintEvent.PAINT)) {
// if (src != null) {
// src.paint(event.getClipRects());
// return true;
// }
// Component c = toolkit.getComponentById(event.getWindowId());
// if ((c != null) && (c instanceof Frame)) {
// ((Frame) c).paintMenuBar(event.getClipRects());
// }
// return false;
// }
//
// if ((id >= MouseEvent.MOUSE_FIRST) && (id <= MouseEvent.MOUSE_LAST)) {
// Point where = event.getScreenPos();
//
// if (src != underCursor) {
// if (underCursor != null) {
// mouseEvent(underCursor, MouseEvent.MOUSE_EXITED, where,
// event);
// }
// underCursor = src;
// if (underCursor != null) {
// mouseEvent(underCursor, MouseEvent.MOUSE_ENTERED,
// where, event);
// underCursor.setDefaultCursor();
// }
// }
// if (id == MouseEvent.MOUSE_EXITED) {
// underCursor = null;
// }
//
// if ((activePopup == null) && (src == null || !src.isMenuBar())) {
// return false;
// }
//
// if (id == MouseEvent.MOUSE_PRESSED) {
// src = grab.mousePressed(src, where);
// } else if (id == MouseEvent.MOUSE_RELEASED) {
// src = grab.mouseReleased(src, where);
// } else if (src == null) {
// src = grab.getOwner();
// }
//
// PopupBox wasActive = activePopup;
//
// if (src != null) {
// mouseEvent(src, id, where, event);
// return src.isMenu() || src.contains(where);
// }
//
// if (wasActive != null && activePopup == null) {
// return wasActive.isMenu();
// }
//
// if ((id == MouseEvent.MOUSE_PRESSED)
// || (id == MouseEvent.MOUSE_RELEASED)) {
// boolean isMenu = activePopup.isMenu();
// deactivateAll();
// return !isMenu;
// }
// return true;
// }
//
// if (activePopup == null) {
// return false;
// }
//
// if ((id >= KeyEvent.KEY_FIRST) && (id <= KeyEvent.KEY_LAST)) {
// boolean isMenu = activePopup.isMenu();
// activePopup.dispatchKeyEvent(id, event.getVKey(), event
// .getTime(), event.getInputModifiers());
//
// return isMenu;
// }
//
// return false;
// }
//
// /**
// * Remember the pop-up as active and grab the mouse on it
// * @param popup - the pop-up box to activate
// */
// void activate(final PopupBox popup) {
// if (activePopup == null) {
//
// activePopup = popup;
// mouseGrabManager.startGrab(popup.getOwner(), new Runnable() {
// public void run() {
// deactivate(popup);
// }
// });
// }
// }
//
// /**
// * Deactivate the currently active pop-up box
// */
// void deactivateAll() {
// deactivate(activePopup);
// }
//
// /**
// * Deactivate the pop-up box, end the mouse grab
// */
// void deactivate(PopupBox popup) {
// grab.reset();
//
// if (activePopup != null && activePopup == popup) {
// activePopup = null;
// mouseGrabManager.endGrab();
// popup.hide();
// underCursor = null;
// }
// }
//
// /**
// * Check that the pop-up box is currently active
// * @param popup - the pop-up box to check
// * @return - true if active
// */
// boolean isActive(PopupBox popup) {
// return (popup == activePopup) && (popup != null);
// }
// }
}