/*
* 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 Dmitry A. Durnev, Michael Danilov, Pavel Dolgov
*/
package java.awt;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.Dispatcher.MouseGrabManager;
import java.util.EventListener;
import org.apache.harmony.awt.wtk.NativeEvent;
import org.apache.harmony.awt.wtk.NativeWindow;
class MouseDispatcher {
// Fields for synthetic mouse click events generation
private static final int clickDelta = 5;
private final long[] lastPressTime = new long[] {0l, 0l, 0l};
private final Point[] lastPressPos = new Point[] {null, null, null};
private final boolean[] buttonPressed = new boolean[] {false, false, false};
private final int[] clickCount = new int[] {0, 0, 0};
// Fields for mouse entered/exited support
private Component lastUnderPointer = null;
private final Point lastScreenPos = new Point(-1, -1);
// Fields for redundant mouse moved/dragged filtering
private Component lastUnderMotion = null;
private Point lastLocalPos = new Point(-1, -1);
private final MouseGrabManager mouseGrabManager;
private final Toolkit toolkit;
static Point convertPoint(Component src, int x, int y, Component dest) {
Point srcPoint = getAbsLocation(src);
Point destPoint = getAbsLocation(dest);
return new Point(x + (srcPoint.x - destPoint.x),
y + (srcPoint.y - destPoint.y));
}
static Point convertPoint(Component src, Point p, Component dst) {
return convertPoint(src, p.x, p.y, dst);
}
private static Point getAbsLocation(Component comp) {
Point location = new Point(0, 0);
for (Component parent = comp; parent != null; parent = parent.parent) {
Point parentPos = (parent instanceof EmbeddedWindow ?
parent.getNativeWindow().getScreenPos() :
parent.getLocation());
location.translate(parentPos.x, parentPos.y);
if (parent instanceof Window) {
break;
}
}
return location;
}
MouseDispatcher(MouseGrabManager mouseGrabManager,
Toolkit toolkit) {
this.mouseGrabManager = mouseGrabManager;
this.toolkit = toolkit;
}
Point getPointerPos() {
return lastScreenPos;
}
boolean dispatch(Component src, NativeEvent event) {
int id = event.getEventId();
lastScreenPos.setLocation(event.getScreenPos());
checkMouseEnterExit(event.getInputModifiers(), event.getTime());
if (id == MouseEvent.MOUSE_WHEEL) {
dispatchWheelEvent(src, event);
} else if ((id != MouseEvent.MOUSE_ENTERED) &&
(id != MouseEvent.MOUSE_EXITED)) {
PointerInfo info = new PointerInfo(src, event.getLocalPos());
mouseGrabManager.preprocessEvent(event);
findEventSource(info);
if ((id == MouseEvent.MOUSE_PRESSED) ||
(id == MouseEvent.MOUSE_RELEASED)) {
dispatchButtonEvent(info, event);
} else if ((id == MouseEvent.MOUSE_MOVED) ||
(id == MouseEvent.MOUSE_DRAGGED)) {
dispatchMotionEvent(info, event);
}
}
return false;
}
private void checkMouseEnterExit(int modifiers, long when) {
PointerInfo info = findComponentUnderPointer();
Component curUnderPointer =
propagateEvent(info, AWTEvent.MOUSE_EVENT_MASK,
MouseListener.class, false).src;
if (curUnderPointer != lastUnderPointer) {
Point pos = info.position;
if ((lastUnderPointer != null) &&
lastUnderPointer.isMouseExitedExpected()) {
Point exitPos = convertPoint(null, lastScreenPos.x,
lastScreenPos.y, lastUnderPointer);
postMouseEnterExit(MouseEvent.MOUSE_EXITED, modifiers, when,
exitPos.x, exitPos.y, lastUnderPointer);
}
setCursor(curUnderPointer);
if (curUnderPointer != null) {
postMouseEnterExit(MouseEvent.MOUSE_ENTERED, modifiers, when,
pos.x, pos.y, curUnderPointer);
}
lastUnderPointer = curUnderPointer;
}
}
private void setCursor(Component comp) {
if (comp == null) {
return;
}
Component grabOwner = mouseGrabManager.getSyntheticGrabOwner();
Component cursorComp = ((grabOwner != null) &&
grabOwner.isShowing() ? grabOwner : comp);
cursorComp.setCursor();
}
private void postMouseEnterExit(int id, int mod, long when,
int x, int y, Component comp) {
if (comp.isIndirectlyEnabled()) {
toolkit.getSystemEventQueueImpl().postEvent(
new MouseEvent(comp, id, when, mod, x, y, 0, false));
comp.setMouseExitedExpected(id == MouseEvent.MOUSE_ENTERED);
} else {
comp.setMouseExitedExpected(false);
}
}
private PointerInfo findComponentUnderPointer() {
NativeWindow nativeWindow = toolkit.getWindowFactory().
getWindowFromPoint(lastScreenPos);
if (nativeWindow != null) {
Component comp = toolkit.getComponentById(nativeWindow.getId());
if (comp != null) {
Window window = comp.getWindowAncestor();
Point pointerPos = convertPoint(null, lastScreenPos.x,
lastScreenPos.y, window);
if (window.getClient().contains(pointerPos)) {
PointerInfo info = new PointerInfo(window, pointerPos);
fall2Child(info);
return info;
}
}
}
return new PointerInfo(null, null);
}
private void findEventSource(PointerInfo info) {
Component grabOwner = mouseGrabManager.getSyntheticGrabOwner();
if (grabOwner != null && grabOwner.isShowing()) {
info.position = convertPoint(info.src, info.position, grabOwner);
info.src = grabOwner;
} else {
rise2TopLevel(info);
fall2Child(info);
}
}
private void rise2TopLevel(PointerInfo info) {
while (!(info.src instanceof Window)) {
info.position.translate(info.src.x, info.src.y);
info.src = info.src.parent;
}
}
private void fall2Child(PointerInfo info) {
final Point pos = info.position;
final int x = pos.x;
final int y = pos.y;
for (Component child : ((Container) info.src).getComponents()) {
if (child.isShowing()) {
if (child.contains(x - child.x, y - child.y)) {
info.src = child;
pos.translate(-child.x, -child.y);
if (child instanceof Container) {
fall2Child(info);
}
return;
}
}
}
}
private void dispatchButtonEvent(PointerInfo info, NativeEvent event) {
int button = event.getMouseButton();
long time = event.getTime();
int id = event.getEventId();
int index = button - 1;
boolean clickRequired = false;
propagateEvent(info, AWTEvent.MOUSE_EVENT_MASK,
MouseListener.class, false);
if (id == MouseEvent.MOUSE_PRESSED) {
int clickInterval = toolkit.dispatcher.clickInterval;
mouseGrabManager.onMousePressed(info.src);
buttonPressed[index] = true;
clickCount[index] = (!deltaExceeded(index, info) &&
((time - lastPressTime[index]) <= clickInterval)) ?
clickCount[index] + 1 : 1;
lastPressTime[index] = time;
lastPressPos[index] = info.position;
} else {
mouseGrabManager.onMouseReleased(info.src);
// set cursor back on synthetic mouse grab end:
setCursor(findComponentUnderPointer().src);
if (buttonPressed[index]) {
buttonPressed[index] = false;
clickRequired = !deltaExceeded(index, info);
} else {
clickCount[index] = 0;
}
}
if (info.src.isIndirectlyEnabled()) {
final Point pos = info.position;
final int mod = event.getInputModifiers();
toolkit.getSystemEventQueueImpl().postEvent(
new MouseEvent(info.src, id, time, mod, pos.x,
pos.y, clickCount[index],
event.getTrigger(), button));
if (clickRequired) {
toolkit.getSystemEventQueueImpl().postEvent(
new MouseEvent(info.src,
MouseEvent.MOUSE_CLICKED,
time, mod, pos.x, pos.y,
clickCount[index], false,
button));
}
}
}
private boolean deltaExceeded(int index, PointerInfo info) {
final Point lastPos = lastPressPos[index];
if (lastPos == null) {
return true;
}
return ((Math.abs(lastPos.x - info.position.x) > clickDelta) ||
(Math.abs(lastPos.y - info.position.y) > clickDelta));
}
private void dispatchMotionEvent(PointerInfo info, NativeEvent event) {
propagateEvent(info, AWTEvent.MOUSE_MOTION_EVENT_MASK,
MouseMotionListener.class, false);
final Point pos = info.position;
if ((lastUnderMotion != info.src) ||
!lastLocalPos.equals(pos)) {
lastUnderMotion = info.src;
lastLocalPos = pos;
if (info.src.isIndirectlyEnabled()) {
toolkit.getSystemEventQueueImpl().postEvent(
new MouseEvent(info.src, event.getEventId(),
event.getTime(),
event.getInputModifiers(),
pos.x, pos.y, 0, false));
}
}
}
MouseWheelEvent createWheelEvent(Component src, NativeEvent event,
Point where) {
Integer scrollAmountProperty =
(Integer)toolkit.getDesktopProperty("awt.wheelScrollingSize"); //$NON-NLS-1$
int amount = 1;
int type = MouseWheelEvent.WHEEL_UNIT_SCROLL;
if (scrollAmountProperty != null) {
amount = scrollAmountProperty.intValue();
if (amount == -1) {
type = MouseWheelEvent.WHEEL_BLOCK_SCROLL;
amount = 1;
}
}
return new MouseWheelEvent(src, event.getEventId(),
event.getTime(), event.getInputModifiers(),
where.x, where.y, 0, false, type, amount,
event.getWheelRotation());
}
private void dispatchWheelEvent(Component src, NativeEvent event) {
PointerInfo info = findComponentUnderPointer();
if (info.src == null) {
info.src = src;
info.position = event.getLocalPos();
}
propagateEvent(info, AWTEvent.MOUSE_WHEEL_EVENT_MASK,
MouseWheelListener.class, true);
if ((info.src != null) && info.src.isIndirectlyEnabled()) {
toolkit.getSystemEventQueueImpl().postEvent(
createWheelEvent(info.src, event, info.position));
}
}
private PointerInfo propagateEvent(PointerInfo info, long mask,
Class<? extends EventListener> type, boolean pierceHW) {
Component src = info.src;
while ((src != null) &&
(src.isLightweight() || pierceHW) &&
!(src.isMouseEventEnabled(mask) ||
(src.getListeners(type).length > 0))) {
info.position.translate(src.x, src.y);
src = src.parent;
info.src = src;
}
return info;
}
Window findWindowAt(Point p) {
NativeWindow nativeWindow =
toolkit.getWindowFactory().getWindowFromPoint(p);
Window window = null;
if (nativeWindow != null) {
Component comp = toolkit.getComponentById(nativeWindow.getId());
if (comp != null) {
window = comp.getWindowAncestor();
}
}
return window;
}
private class PointerInfo {
Component src;
Point position;
PointerInfo(Component src, Point position) {
this.src = src;
this.position = position;
}
}
}