protected void processMouseEvent(final MouseEvent e) {
if (e.isPopupTrigger() && e.getComponent().isShowing()) {
super.processMouseEvent(e);
return;
}
if (UIUtil.isCloseClick(e)) {
myDecorator.fireHiddenSide();
return;
}
if (e.getButton() == MouseEvent.BUTTON1) {
if (MouseEvent.MOUSE_PRESSED == e.getID()) {
myPressedPoint = e.getPoint();
myPressedWhenSelected = isSelected();
myDragCancelled = false;
} else if (MouseEvent.MOUSE_RELEASED == e.getID()) {
finishDragging();
myPressedPoint = null;
myDragButtonImage = null;
}
}
super.processMouseEvent(e);
}
/**
* Converts the specified mouse event's screen point from WebView coordinates to Windows
* coordinates, and returns a new event who's screen point is in Windows coordinates, with the
* origin at the upper left corner of the WebView window.
*
* @param e The event to convert.
* @return A new mouse event in the Windows coordinate system.
*/
protected MouseEvent convertToWindows(MouseEvent e) {
int x = e.getX();
int y = e.getY();
// Translate OpenGL screen coordinates to Windows by moving the Y origin from the lower left
// corner to
// the upper left corner and flipping the direction of the Y axis.
y = this.frameSize.height - y;
if (e instanceof MouseWheelEvent) {
return new MouseWheelEvent(
(Component) e.getSource(),
e.getID(),
e.getWhen(),
e.getModifiers(),
x,
y,
e.getClickCount(),
e.isPopupTrigger(),
((MouseWheelEvent) e).getScrollType(),
((MouseWheelEvent) e).getScrollAmount(),
((MouseWheelEvent) e).getWheelRotation());
} else {
return new MouseEvent(
(Component) e.getSource(),
e.getID(),
e.getWhen(),
e.getModifiers(),
x,
y,
e.getClickCount(),
e.isPopupTrigger(),
e.getButton());
}
}
protected void processMouseMotionEvent(MouseEvent e) {
MouseEvent transformedEvent = transformMouseEvent(e);
if (mouseEnteredComponent == null) {
mouseEnteredComponent = mouseCurrentComponent;
}
switch (e.getID()) {
case MouseEvent.MOUSE_MOVED:
if (mouseCurrentComponent != mouseEnteredComponent) {
dispatchMouseEvent(
createEnterExitEvent(mouseEnteredComponent, MouseEvent.MOUSE_EXITED, e));
dispatchMouseEvent(
createEnterExitEvent(mouseCurrentComponent, MouseEvent.MOUSE_ENTERED, e));
}
break;
case MouseEvent.MOUSE_DRAGGED:
if (mouseDraggedComponent == null) {
mouseDraggedComponent = mouseEnteredComponent;
}
if (mouseEnteredComponent == mouseDraggedComponent
&& mouseCurrentComponent != mouseDraggedComponent) {
dispatchMouseEvent(
createEnterExitEvent(mouseDraggedComponent, MouseEvent.MOUSE_EXITED, e));
} else if (mouseEnteredComponent != mouseDraggedComponent
&& mouseCurrentComponent == mouseDraggedComponent) {
dispatchMouseEvent(
createEnterExitEvent(mouseDraggedComponent, MouseEvent.MOUSE_ENTERED, e));
}
if (mouseDraggedComponent != null) {
transformedEvent.setSource(mouseDraggedComponent);
}
break;
}
mouseEnteredComponent = mouseCurrentComponent;
// dispatch MouseMotionEvent
MouseMotionListener[] mouseMotionListeners =
transformedEvent.getComponent().getMouseMotionListeners();
for (MouseMotionListener listener : mouseMotionListeners) {
// skip all ToolTipManager's related listeners
if (!listener.getClass().getName().startsWith("javax.swing.ToolTipManager")) {
switch (transformedEvent.getID()) {
case MouseEvent.MOUSE_MOVED:
listener.mouseMoved(transformedEvent);
break;
case MouseEvent.MOUSE_DRAGGED:
listener.mouseDragged(transformedEvent);
break;
default:
throw new AssertionError();
}
}
}
super.processMouseMotionEvent(e);
}
private void dispatchMouseEvent(MouseEvent event) {
MouseListener[] mouseListeners = event.getComponent().getMouseListeners();
for (MouseListener listener : mouseListeners) {
// skip all ToolTipManager's related listeners
if (!listener.getClass().getName().startsWith("javax.swing.ToolTipManager")) {
switch (event.getID()) {
case MouseEvent.MOUSE_PRESSED:
listener.mousePressed(event);
break;
case MouseEvent.MOUSE_RELEASED:
listener.mouseReleased(event);
break;
case MouseEvent.MOUSE_CLICKED:
listener.mouseClicked(event);
break;
case MouseEvent.MOUSE_EXITED:
listener.mouseExited(event);
break;
case MouseEvent.MOUSE_ENTERED:
listener.mouseEntered(event);
break;
default:
throw new AssertionError();
}
}
}
}
public void processFolderPanelMouseEvent(MouseEvent mouseevent) {
switch (mouseevent.getID()) {
case 501:
if (mouseevent.getClickCount() == 2 && !dragged) {
visitDocument(mouseevent.isShiftDown());
return;
}
// fall through
case 502:
ListItem listitem = hotCanvas.getSelectedItem();
if (listitem != null && (listitem instanceof Bookmark)) {
Bookmark bookmark = (Bookmark) listitem;
Webmark webmark = bookmark.getWebmark();
String s = webmark.getURL();
frm.setMessage(s);
} else {
frm.setMessage("");
}
redispatchEvent(mouseevent);
dragged = false;
return;
case 506:
redispatchEvent(mouseevent);
dragged = true;
return;
default:
return;
}
}
/**
* Called to process events. Mouse events will be rewritten to indicate the position in the
* document clicked, instead of the position of the panel.
*
* @param event to process.
*/
protected void processEvent(AWTEvent event) {
try {
if (event instanceof MouseEvent) {
final Point scrollPosition = getScrollPosition();
if (scrollPosition != null) {
final MouseEvent mouseEvent = (MouseEvent) event;
event =
new MouseEvent(
(Component) mouseEvent.getSource(),
mouseEvent.getID(),
mouseEvent.getWhen(),
mouseEvent.getModifiers(),
mouseEvent.getX() + scrollPosition.x,
mouseEvent.getY() + scrollPosition.y,
mouseEvent.getClickCount(),
mouseEvent.isPopupTrigger());
}
}
} catch (final Throwable exp) {
exp.printStackTrace(DjVuOptions.err);
System.gc();
}
super.processEvent(event);
}
protected void processMouseEvent(MouseEvent e) {
MouseEvent transformedEvent = transformMouseEvent(e);
switch (e.getID()) {
case MouseEvent.MOUSE_ENTERED:
if (mouseDraggedComponent == null || mouseCurrentComponent == mouseDraggedComponent) {
dispatchMouseEvent(transformedEvent);
}
break;
case MouseEvent.MOUSE_EXITED:
if (mouseEnteredComponent != null) {
dispatchMouseEvent(
createEnterExitEvent(mouseEnteredComponent, MouseEvent.MOUSE_EXITED, e));
mouseEnteredComponent = null;
}
break;
case MouseEvent.MOUSE_RELEASED:
if (mouseDraggedComponent != null && e.getButton() == MouseEvent.BUTTON1) {
transformedEvent.setSource(mouseDraggedComponent);
mouseDraggedComponent = null;
}
dispatchMouseEvent(transformedEvent);
break;
default:
dispatchMouseEvent(transformedEvent);
}
super.processMouseEvent(e);
}
/**
* Propagates certain mouse events, such as MOUSE_CLICKED, MOUSE_RELEASED etc. to the deepest
* component.
*
* @param e The MouseEvent to be propagated.
*/
protected void propagateMouseListenerEvent(MouseEvent e) {
if (POPUP_IS_MODAL == false) {
Component deepestComponent = getDeepestComponent(e.getPoint());
if (deepestComponent != null) {
MouseListener[] mouseListeners = deepestComponent.getMouseListeners();
int eventID;
// Get the event type
eventID = e.getID();
Point pt = e.getPoint();
Point convertedPt = SwingUtilities.convertPoint(glassPane, e.getPoint(), deepestComponent);
MouseEvent evt =
new MouseEvent(
deepestComponent,
e.getID(),
System.currentTimeMillis(),
e.getModifiers(),
convertedPt.x,
convertedPt.y,
e.getClickCount(),
e.isPopupTrigger(),
e.getButton());
// Distibute the event to the component's listeners.
for (int i = 0; i < mouseListeners.length; i++) {
// Forward the appropriate mouse event
if (eventID == MouseEvent.MOUSE_PRESSED) {
mouseListeners[i].mousePressed(evt);
} else if (eventID == MouseEvent.MOUSE_RELEASED) {
mouseListeners[i].mouseReleased(evt);
} else if (eventID == MouseEvent.MOUSE_CLICKED) {
mouseListeners[i].mouseClicked(evt);
}
}
}
}
}
protected void propagateMouseMotionListenerEvents(MouseEvent e) {
if (FORWARD_MOUSE_MOTION_EVENTS == true) {
// Get the correct component
Component deepestComponent = getDeepestComponent(e.getPoint());
if (deepestComponent != null) {
// Distribute the event to the components listeners
MouseMotionListener[] mouseMotionListeners = deepestComponent.getMouseMotionListeners();
// Get the event type
int eventID = e.getID();
Point pt = e.getPoint();
Point convertedPt = SwingUtilities.convertPoint(glassPane, e.getPoint(), deepestComponent);
MouseEvent evt =
new MouseEvent(
deepestComponent,
e.getID(),
System.currentTimeMillis(),
e.getModifiers(),
convertedPt.x,
convertedPt.y,
e.getClickCount(),
e.isPopupTrigger(),
e.getButton());
for (int i = 0; i < mouseMotionListeners.length; i++) {
if (eventID == MouseEvent.MOUSE_MOVED) {
mouseMotionListeners[i].mouseMoved(e);
} else if (eventID == MouseEvent.MOUSE_DRAGGED) {
mouseMotionListeners[i].mouseDragged(e);
}
}
}
}
}
void forwardEventToParent(MouseEvent e) {
getParent()
.dispatchEvent(
new MouseEvent(
getParent(),
e.getID(),
e.getWhen(),
e.getModifiers(),
e.getX(),
e.getY(),
e.getXOnScreen(),
e.getYOnScreen(),
e.getClickCount(),
e.isPopupTrigger(),
MouseEvent.NOBUTTON));
}
public void processMouseEvent(
JMenuItem item, MouseEvent e, MenuElement path[], MenuSelectionManager manager) {
Point p = e.getPoint();
if (p.x >= 0 && p.x < item.getWidth() && p.y >= 0 && p.y < item.getHeight()) {
if (e.getID() == MouseEvent.MOUSE_RELEASED) {
manager.clearSelectedPath();
item.doClick(0);
item.setArmed(false);
} else manager.setSelectedPath(path);
} else if (item.getModel().isArmed()) {
MenuElement newPath[] = new MenuElement[path.length - 1];
int i, c;
for (i = 0, c = path.length - 1; i < c; i++) newPath[i] = path[i];
manager.setSelectedPath(newPath);
}
}
private void dispatchEvent(MouseEvent me) {
if (rect != null && rect.contains(me.getX(), me.getY())) {
Point pt = me.getPoint();
pt.translate(-offset, 0);
comp.setBounds(rect);
comp.dispatchEvent(
new MouseEvent(
comp,
me.getID(),
me.getWhen(),
me.getModifiers(),
pt.x,
pt.y,
me.getClickCount(),
me.isPopupTrigger(),
me.getButton()));
if (!comp.isValid()) container.repaint();
}
}
/**
* @param aEvent
* @param aStartPoint
*/
protected void handleZoomRegion(final MouseEvent aEvent, final Point aStartPoint) {
// For now, disabled by default as it isn't 100% working yet...
if (Boolean.FALSE.equals(Boolean.valueOf(System.getProperty("zoomregionenabled", "false")))) {
return;
}
final JComponent source = (JComponent) aEvent.getComponent();
final boolean dragging = (aEvent.getID() == MouseEvent.MOUSE_DRAGGED);
final GhostGlassPane glassPane =
(GhostGlassPane) SwingUtilities.getRootPane(source).getGlassPane();
Rectangle viewRect;
final JScrollPane scrollPane =
SwingComponentUtils.getAncestorOfClass(JScrollPane.class, source);
if (scrollPane != null) {
final JViewport viewport = scrollPane.getViewport();
viewRect = SwingUtilities.convertRectangle(viewport, viewport.getVisibleRect(), glassPane);
} else {
viewRect = SwingUtilities.convertRectangle(source, source.getVisibleRect(), glassPane);
}
final Point start = SwingUtilities.convertPoint(source, aStartPoint, glassPane);
final Point current = SwingUtilities.convertPoint(source, aEvent.getPoint(), glassPane);
if (dragging) {
if (!glassPane.isVisible()) {
glassPane.setVisible(true);
glassPane.setRenderer(new RubberBandRenderer(), start, current, viewRect);
} else {
glassPane.updateRenderer(start, current, viewRect);
}
glassPane.repaintPartially();
} else
/* if ( !dragging ) */
{
// Fire off a signal to the zoom controller to do its job...
this.controller.getZoomController().zoomRegion(aStartPoint, aEvent.getPoint());
glassPane.setVisible(false);
}
}
/**
* Re-dispatches glass pane mouse events only in case they occur on the security panel.
*
* @param glassPane the glass pane
* @param e the mouse event in question
*/
private void redispatchMouseEvent(Component glassPane, MouseEvent e) {
Point glassPanePoint = e.getPoint();
Point securityPanelPoint =
SwingUtilities.convertPoint(glassPane, glassPanePoint, securityPanel);
Component component;
Point componentPoint;
if (securityPanelPoint.y > 0) {
component = securityPanel;
componentPoint = securityPanelPoint;
} else {
Container contentPane =
callRenderer.getCallContainer().getCallWindow().getFrame().getContentPane();
Point containerPoint = SwingUtilities.convertPoint(glassPane, glassPanePoint, contentPane);
component =
SwingUtilities.getDeepestComponentAt(contentPane, containerPoint.x, containerPoint.y);
componentPoint = SwingUtilities.convertPoint(contentPane, glassPanePoint, component);
}
if (component != null)
component.dispatchEvent(
new MouseEvent(
component,
e.getID(),
e.getWhen(),
e.getModifiers(),
componentPoint.x,
componentPoint.y,
e.getClickCount(),
e.isPopupTrigger()));
e.consume();
}
/**
* When a MenuElement receives an event from a MouseListener, it should never process the event
* directly. Instead all MenuElements should call this method with the event.
*
* @param event a MouseEvent object
*/
public void processMouseEvent(MouseEvent event) {
int screenX, screenY;
Point p;
int i, c, j, d;
Component mc;
Rectangle r2;
int cWidth, cHeight;
MenuElement menuElement;
MenuElement subElements[];
MenuElement path[];
Vector<MenuElement> tmp;
int selectionSize;
p = event.getPoint();
Component source = event.getComponent();
if ((source != null) && !source.isShowing()) {
// This can happen if a mouseReleased removes the
// containing component -- bug 4146684
return;
}
int type = event.getID();
int modifiers = event.getModifiers();
// 4188027: drag enter/exit added in JDK 1.1.7A, JDK1.2
if ((type == MouseEvent.MOUSE_ENTERED || type == MouseEvent.MOUSE_EXITED)
&& ((modifiers
& (InputEvent.BUTTON1_MASK | InputEvent.BUTTON2_MASK | InputEvent.BUTTON3_MASK))
!= 0)) {
return;
}
if (source != null) {
SwingUtilities.convertPointToScreen(p, source);
}
screenX = p.x;
screenY = p.y;
tmp = (Vector<MenuElement>) selection.clone();
selectionSize = tmp.size();
boolean success = false;
for (i = selectionSize - 1; i >= 0 && success == false; i--) {
menuElement = (MenuElement) tmp.elementAt(i);
subElements = menuElement.getSubElements();
path = null;
for (j = 0, d = subElements.length; j < d && success == false; j++) {
if (subElements[j] == null) continue;
mc = subElements[j].getComponent();
if (!mc.isShowing()) continue;
if (mc instanceof JComponent) {
cWidth = mc.getWidth();
cHeight = mc.getHeight();
} else {
r2 = mc.getBounds();
cWidth = r2.width;
cHeight = r2.height;
}
p.x = screenX;
p.y = screenY;
SwingUtilities.convertPointFromScreen(p, mc);
/**
* Send the event to visible menu element if menu element currently in the selected path or
* contains the event location
*/
if ((p.x >= 0 && p.x < cWidth && p.y >= 0 && p.y < cHeight)) {
int k;
if (path == null) {
path = new MenuElement[i + 2];
for (k = 0; k <= i; k++) path[k] = (MenuElement) tmp.elementAt(k);
}
path[i + 1] = subElements[j];
MenuElement currentSelection[] = getSelectedPath();
// Enter/exit detection -- needs tuning...
if (currentSelection[currentSelection.length - 1] != path[i + 1]
&& (currentSelection.length < 2
|| currentSelection[currentSelection.length - 2] != path[i + 1])) {
Component oldMC = currentSelection[currentSelection.length - 1].getComponent();
MouseEvent exitEvent =
new MouseEvent(
oldMC,
MouseEvent.MOUSE_EXITED,
event.getWhen(),
event.getModifiers(),
p.x,
p.y,
event.getXOnScreen(),
event.getYOnScreen(),
event.getClickCount(),
event.isPopupTrigger(),
MouseEvent.NOBUTTON);
currentSelection[currentSelection.length - 1].processMouseEvent(exitEvent, path, this);
MouseEvent enterEvent =
new MouseEvent(
mc,
MouseEvent.MOUSE_ENTERED,
event.getWhen(),
event.getModifiers(),
p.x,
p.y,
event.getXOnScreen(),
event.getYOnScreen(),
event.getClickCount(),
event.isPopupTrigger(),
MouseEvent.NOBUTTON);
subElements[j].processMouseEvent(enterEvent, path, this);
}
MouseEvent mouseEvent =
new MouseEvent(
mc,
event.getID(),
event.getWhen(),
event.getModifiers(),
p.x,
p.y,
event.getXOnScreen(),
event.getYOnScreen(),
event.getClickCount(),
event.isPopupTrigger(),
MouseEvent.NOBUTTON);
subElements[j].processMouseEvent(mouseEvent, path, this);
success = true;
event.consume();
}
}
}
}
/** Handles the event when the mouse is pressed or released */
public void processMouseEvent(MouseEvent e) {
if (e.getID() == MouseEvent.MOUSE_PRESSED && parent.dtype == CONST.TIMELINES) {
message = handleMsgDlg(e);
if (!message) handleEventDlg(e);
} else super.processMouseEvent(e);
}
/** Handles the event when the mouse is moved */
public void processMouseMotionEvent(MouseEvent e) {
if (e.getID() == MouseEvent.MOUSE_MOVED) {
adjustTimeField(e.getX());
adjustElTimeField();
} else super.processMouseMotionEvent(e);
}
public void mouseWheelMoved(MouseWheelEvent e) {
if (enabled && !readOnly) {
if (timer != null && timer.isRunning()) {
timer.stop();
}
if (enableMouseWheel) {
int count = 1;
MouseWheelEvent e2;
long lastEventTime = e.getWhen();
int steps = 0;
int r;
// This cycle is to determine multiple clicks like double wheel, triple wheel event etc.
// We go through the vector of events and check whether there are events corresponding to
// multiple events.
for (int i = 0; i < events.size() && events.get(i) instanceof MouseWheelEvent; i++) {
e2 = (MouseWheelEvent) events.get(i);
// The events are considered to be a multiple click when:
// 1. Coordinates are equal
// 2. Modifiers are equal
// 3. Both events are wheel up or down
// 4. Delay between two subsequent clicks is lower than given number of miliseconds
r = e2.getWheelRotation();
if (e2.getX() == e.getX()
&& e2.getY() == e.getY()
&& e2.getModifiers() == e.getModifiers()
&& (lastEventTime - e2.getWhen() < mouseMultiDelay)
&& e2.getID() == e.getID()
&& ((r > 0 && e.getWheelRotation() > 0) || (r < 0 && e.getWheelRotation() < 0))) {
count++;
lastEventTime = e2.getWhen();
steps += Math.abs(r);
} else {
break;
}
}
steps += Math.abs(e.getWheelRotation());
// Generate the command string
String s =
"Mouse "
+ (e.getWheelRotation() > 0
? MouseCommand.MOUSE_WHEEL_DOWN
: MouseCommand.MOUSE_WHEEL_UP);
// Insert modifiers if there are any
String modifiers = parser.modifiersToString(e.getModifiers());
if (modifiers.length() > 0) {
s += " " + MouseCommand.PARAM_MODIFIER + "=" + modifiers;
}
// Generate the count parameter
if (count > 1) {
s += " " + MouseCommand.PARAM_COUNT + "=" + Math.abs(steps);
}
// This will determine whether this event is preceded by a mouse move command with the same
// coordinates.
// It will be replaced if yes.
boolean replaceLastMove = false;
if (enableMouseMoves) {
if (events.size() > 0 && events.get(events.size() - 1) instanceof MouseEvent) {
MouseEvent me = (MouseEvent) events.get(events.size() - 1);
if (me.getID() == MouseEvent.MOUSE_MOVED
&& e.getX() == me.getX()
&& e.getY() == me.getY()) {
replaceLastMove = true;
}
}
}
// Generate coordinates
s += " " + MouseCommand.PARAM_TO + "=" + parser.pointToString(e.getPoint());
// Insert the command to the current editor
insertLine(s, count > 1 || replaceLastMove, true, false);
dragInProgress = false;
}
insertEvent(e);
}
}
/**
* This method gets called when user performs a mouse click. It decodes whether it is a single
* click or part of a multiple click (double click, triple click etc.) and inserts appropriate
* command to the current editor.
*
* @param e a MouseEvent describing the mouse click.
*/
public void mouseClicked(MouseEvent e) {
if (enabled && !readOnly) {
if (timer != null && timer.isRunning()) {
timer.stop();
}
if (enableMouseClicks) {
int count = 1;
MouseEvent e2;
long lastEventTime = e.getWhen();
// This cycle is to determine multiple clicks like double click, triple click etc.
// We go through the vector of events and check whether there are events corresponding to
// multiple clicks.
for (int i = 0; i < events.size() && events.get(i) instanceof MouseEvent; i++) {
e2 = (MouseEvent) events.get(i);
// The events are considered to be a multiple click when:
// 1. Coordinates are equal
// 2. Modifiers are equal
// 3. Button is equal
// 4. Delay between two subsequent clicks is lower than given number of miliseconds
if (e2.getX() == e.getX()
&& e2.getY() == e.getY()
&& e2.getModifiers() == e.getModifiers()
&& (lastEventTime - e2.getWhen() < mouseMultiDelay)
&& e.getButton() == e2.getButton()
&& e2.getID() == e.getID()) {
count++;
lastEventTime = e2.getWhen();
} else {
break;
}
}
// Generate the command string
String s = "Mouse " + MouseCommand.MOUSE_CLICK;
// Insert the button identifier if other than left button was pressed
if (e.getButton() != MouseEvent.BUTTON1) {
s += " " + MouseCommand.PARAM_BUTTON_SHORT + "=" + parser.buttonToString(e.getButton());
}
// Insert modifiers if there are any
String modifiers = parser.modifiersToString(e.getModifiers());
if (modifiers.length() > 0) {
s += " " + MouseCommand.PARAM_MODIFIER + "=" + modifiers;
}
// Generate the count parameter
if (count > 1) {
s += " " + MouseCommand.PARAM_COUNT + "=" + count;
}
// This will determine whether this click is preceded by a mouse
// move command with the same coordinates.
// It will be replaced if yes.
boolean replaceLastMove = false;
// if (enableMouseMoves) {
// if (events.size() > 0 && events.get(events.size() - 1) instanceof
// MouseEvent) {
// MouseEvent me = (MouseEvent) events.get(events.size() - 1);
// if (me.getID() == MouseEvent.MOUSE_MOVED && e.getX() == me.getX()
// && e.getY() == me.getY()) {
// replaceLastMove = true;
// }
// }
// }
// Generate coordinates
s += " " + MouseCommand.PARAM_TO + "=" + parser.pointToString(e.getPoint());
// Insert the command to the current editor
insertLine(s, count > 1 || replaceLastMove, true, false);
dragInProgress = false;
}
insertEvent(e);
}
}
private MouseEvent transformMouseEvent(MouseEvent event) {
if (event == null) {
throw new IllegalArgumentException("MouseEvent is null");
}
MouseEvent newEvent;
if (event instanceof MouseWheelEvent) {
MouseWheelEvent mouseWheelEvent = (MouseWheelEvent) event;
newEvent =
new MouseWheelEvent(
mouseWheelEvent.getComponent(),
mouseWheelEvent.getID(),
mouseWheelEvent.getWhen(),
mouseWheelEvent.getModifiers(),
mouseWheelEvent.getX(),
mouseWheelEvent.getY(),
mouseWheelEvent.getClickCount(),
mouseWheelEvent.isPopupTrigger(),
mouseWheelEvent.getScrollType(),
mouseWheelEvent.getScrollAmount(),
mouseWheelEvent.getWheelRotation());
} else {
newEvent =
new MouseEvent(
event.getComponent(),
event.getID(),
event.getWhen(),
event.getModifiers(),
event.getX(),
event.getY(),
event.getClickCount(),
event.isPopupTrigger(),
event.getButton());
}
if (view != null && at.getDeterminant() != 0) {
Rectangle viewBounds = getTransformedSize();
Insets insets = JXTransformer.this.getInsets();
int xgap = (getWidth() - (viewBounds.width + insets.left + insets.right)) / 2;
int ygap = (getHeight() - (viewBounds.height + insets.top + insets.bottom)) / 2;
double x = newEvent.getX() + viewBounds.getX() - insets.left;
double y = newEvent.getY() + viewBounds.getY() - insets.top;
Point2D p = new Point2D.Double(x - xgap, y - ygap);
Point2D tp;
try {
tp = at.inverseTransform(p, null);
} catch (NoninvertibleTransformException ex) {
// can't happen, we check it before
throw new AssertionError("NoninvertibleTransformException");
}
// Use transformed coordinates to get the current component
mouseCurrentComponent =
SwingUtilities.getDeepestComponentAt(view, (int) tp.getX(), (int) tp.getY());
if (mouseCurrentComponent == null) {
mouseCurrentComponent = JXTransformer.this;
}
Component tempComponent = mouseCurrentComponent;
if (mouseDraggedComponent != null) {
tempComponent = mouseDraggedComponent;
}
Point point =
SwingUtilities.convertPoint(view, (int) tp.getX(), (int) tp.getY(), tempComponent);
newEvent.setSource(tempComponent);
newEvent.translatePoint(point.x - event.getX(), point.y - event.getY());
}
return newEvent;
}
