1 /*******************************************************************************
2 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
4 * All rights reserved. This program and the accompanying materials
5 * are made available under the terms of the Eclipse Public License v1.0
6 * which accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * VTT Technical Research Centre of Finland - initial API and implementation
11 *******************************************************************************/
12 package org.simantics.g2d.diagram.impl;
14 import java.awt.Color;
15 import java.awt.geom.AffineTransform;
16 import java.awt.geom.Point2D;
17 import java.awt.geom.Rectangle2D;
18 import java.util.Comparator;
19 import java.util.List;
21 import java.util.concurrent.atomic.AtomicBoolean;
23 import org.simantics.g2d.canvas.Hints;
24 import org.simantics.g2d.canvas.ICanvasContext;
25 import org.simantics.g2d.canvas.ICanvasParticipant;
26 import org.simantics.g2d.canvas.IContentContext;
27 import org.simantics.g2d.canvas.IMouseCaptureContext;
28 import org.simantics.g2d.canvas.IMouseCursorContext;
29 import org.simantics.g2d.canvas.impl.MouseCaptureContext;
30 import org.simantics.g2d.canvas.impl.MouseCursorContext;
31 import org.simantics.g2d.canvas.impl.PaintableContextImpl;
32 import org.simantics.g2d.chassis.ITooltipProvider;
33 import org.simantics.g2d.diagram.DiagramClass;
34 import org.simantics.g2d.diagram.DiagramHints;
35 import org.simantics.g2d.diagram.IDiagram;
36 import org.simantics.g2d.diagram.participant.DiagramParticipant;
37 import org.simantics.g2d.diagram.participant.ElementInteractor;
38 import org.simantics.g2d.diagram.participant.ElementPainter;
39 import org.simantics.g2d.diagram.participant.Selection;
40 import org.simantics.g2d.diagram.participant.TerminalPainter;
41 import org.simantics.g2d.diagram.participant.ZOrderHandler;
42 import org.simantics.g2d.diagram.participant.pointertool.PointerInteractor;
43 import org.simantics.g2d.element.IElement;
44 import org.simantics.g2d.multileveldiagram.TransitionFunction;
45 import org.simantics.g2d.multileveldiagram.ZoomTransitionParticipant;
46 import org.simantics.g2d.participant.BackgroundPainter;
47 import org.simantics.g2d.participant.CanvasGrab;
48 import org.simantics.g2d.participant.GridPainter;
49 import org.simantics.g2d.participant.HandPainter;
50 import org.simantics.g2d.participant.KeyToCommand;
51 import org.simantics.g2d.participant.KeyUtil;
52 import org.simantics.g2d.participant.MouseUtil;
53 import org.simantics.g2d.participant.PointerPainter;
54 import org.simantics.g2d.participant.RulerPainter;
55 import org.simantics.g2d.participant.SubCanvas;
56 import org.simantics.g2d.participant.SymbolUtil;
57 import org.simantics.g2d.participant.TimeParticipant;
58 import org.simantics.g2d.participant.TransformUtil;
59 import org.simantics.g2d.scenegraph.SceneGraphConstants;
60 import org.simantics.scenegraph.g2d.G2DParentNode;
61 import org.simantics.scenegraph.g2d.G2DSceneGraph;
62 import org.simantics.scenegraph.g2d.events.Event;
63 import org.simantics.scenegraph.g2d.events.EventHandlerStack;
64 import org.simantics.scenegraph.g2d.events.EventQueue;
65 import org.simantics.scenegraph.g2d.events.IEventHandlerStack;
66 import org.simantics.scenegraph.g2d.events.IEventQueue;
67 import org.simantics.scenegraph.g2d.events.MouseEvent;
68 import org.simantics.scenegraph.g2d.events.MouseEventCoalescer;
69 import org.simantics.scenegraph.g2d.events.EventHandlerReflection.EventHandler;
70 import org.simantics.scenegraph.g2d.events.IEventQueue.IEventQueueListener;
71 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseButtonEvent;
72 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseButtonPressedEvent;
73 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseButtonReleasedEvent;
74 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseClickEvent;
75 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseDoubleClickedEvent;
76 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseDragBegin;
77 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseEnterEvent;
78 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseExitEvent;
79 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseMovedEvent;
80 import org.simantics.scenegraph.g2d.events.MouseEvent.MouseWheelMovedEvent;
81 import org.simantics.scenegraph.g2d.events.command.CommandKeyBinding;
82 import org.simantics.utils.datastructures.context.Context;
83 import org.simantics.utils.datastructures.context.IContext;
84 import org.simantics.utils.datastructures.context.IContextListener;
85 import org.simantics.utils.datastructures.hints.HintContext;
86 import org.simantics.utils.datastructures.hints.HintStack;
87 import org.simantics.utils.datastructures.hints.IHintContext;
88 import org.simantics.utils.datastructures.hints.IHintListener;
89 import org.simantics.utils.datastructures.hints.IHintStack;
90 import org.simantics.utils.threads.IThreadWorkQueue;
91 import org.simantics.utils.threads.ThreadUtils;
94 * Creates subcanvas on top of parent canvas. Size and position of the subcanvas
97 * Beware: every CanvasParticipant that handles mouseEvents must be replaced
98 * since mouse coordinates must be translated. Currently Implemented
99 * participants: - MouseUtil - ElementInteractor
101 * @author Marko Luukkainen <marko.luukkainen@vtt.fi>
103 * TODO: CanvasContext implementation needs to implement scene graph methods too
105 public class ElementDiagram implements IDiagram {
106 private final ICanvasContext ctx;
108 private final ICanvasContext parentCtx;
110 private IDiagram diagram;
112 private final SubCanvas subCanvas;
114 private Rectangle2D canvasRect = new Rectangle2D.Double(0, 0, 200, 200);
116 private int canvasPosX = 100;
118 private int canvasPosY = 100;
120 public ElementDiagram(ICanvasContext parentCtx) {
121 this.parentCtx = parentCtx;
122 ctx = createCanvas(parentCtx.getThreadAccess(),parentCtx.getSceneGraph());
123 ICanvasParticipant mouseUtil = ctx.getSingleItem(MouseUtil.class);
124 if (mouseUtil != null) {
125 ctx.remove(mouseUtil);
126 ctx.add(new ElementDiagramMouseUtil());
127 // ctx.add(new MouseUtil());
129 ICanvasParticipant elementInteractor = ctx.getSingleItem(ElementInteractor.class);
130 if (elementInteractor != null) {
131 ctx.remove(elementInteractor);
132 ctx.add(new ElementDiagramElementInteractor());
134 diagram = createDiagram();
135 ctx.getDefaultHintContext().setHint(DiagramHints.KEY_DIAGRAM, diagram);
136 subCanvas = new SubCanvas(ctx, 10000, Integer.MAX_VALUE - 100, 10000);
137 parentCtx.add(subCanvas);
140 public void setSize(int x, int y, int width, int height) {
143 canvasRect = new Rectangle2D.Double(0, 0, width, height);
144 getCanvas().getCanvasNode().setTransform(new AffineTransform(1,0,0,1,x,y));
148 public Rectangle2D getSize() {
153 * Override this for custom functionality
157 public IDiagram createDiagram() {
158 IDiagram d = Diagram.spawnNew(DiagramClass.DEFAULT);
163 * Override this for custom functionality
168 public ICanvasContext createCanvas(IThreadWorkQueue thread, G2DSceneGraph sg) {
169 return createDefaultCanvas(thread,sg);
172 public void setDiagram(IDiagram diagram) {
173 this.diagram = diagram;
174 ctx.getDefaultHintContext().setHint(DiagramHints.KEY_DIAGRAM, diagram);
177 public ICanvasContext getCanvas() {
181 public ICanvasContext getParentCanvas() {
185 public SubCanvas getSubCanvas() {
189 public IDiagram getDiagram() {
194 public void addElement(IElement element) {
195 diagram.addElement(element);
199 public void removeElement(IElement element) {
200 diagram.removeElement(element);
204 public void addCompositionListener(CompositionListener listener) {
205 diagram.addCompositionListener(listener);
209 public void addCompositionVetoListener(CompositionVetoListener listener) {
210 diagram.addCompositionVetoListener(listener);
214 public void addHintListener(IHintListener listener) {
215 diagram.addHintListener(listener);
219 public void addHintListener(IThreadWorkQueue threadAccess, IHintListener listener) {
220 diagram.addHintListener(threadAccess, listener);
224 public void addKeyHintListener(IThreadWorkQueue threadAccess, Key key, IHintListener listener) {
225 diagram.addKeyHintListener(threadAccess, key, listener);
229 public void addKeyHintListener(Key key, IHintListener listener) {
230 diagram.addKeyHintListener(key, listener);
234 public boolean bringToTop(IElement e) {
235 return diagram.bringToTop(e);
239 public boolean bringUp(IElement e) {
240 return diagram.bringUp(e);
244 public void destroy() {
249 public void dispose() {
254 public DiagramClass getDiagramClass() {
255 return diagram.getDiagramClass();
259 public boolean containsElement(IElement element) {
260 return diagram.containsElement(element);
264 public List<IElement> getElements() {
265 return diagram.getElements();
269 public void sort(Comparator<IElement> comparator) {
270 diagram.sort(comparator);
274 public List<IElement> getSnapshot() {
275 return diagram.getSnapshot();
279 public void clearWithoutNotification() {
280 diagram.clearWithoutNotification();
284 public boolean containsHint(Key key) {
285 return diagram.containsHint(key);
289 public <E> E getHint(Key key) {
290 return diagram.getHint(key);
294 public Map<Key, Object> getHints() {
295 return diagram.getHints();
299 public Map<Key, Object> getHintsUnsafe() {
300 return diagram.getHintsUnsafe();
304 public <E extends Key> Map<E, Object> getHintsOfClass(Class<E> clazz) {
305 return diagram.getHintsOfClass(clazz);
309 public boolean moveTo(IElement e, int position) {
310 return diagram.moveTo(e, position);
314 public void removeCompositionListener(CompositionListener listener) {
315 diagram.removeCompositionListener(listener);
319 public void removeCompositionVetoListener(CompositionVetoListener listener) {
320 diagram.removeCompositionVetoListener(listener);
324 public <E> E removeHint(Key key) {
325 return diagram.removeHint(key);
329 public void removeHintListener(IHintListener listener) {
330 diagram.removeHintListener(listener);
334 public void removeHintListener(IThreadWorkQueue threadAccess, IHintListener listener) {
335 diagram.removeHintListener(threadAccess, listener);
339 public void removeKeyHintListener(IThreadWorkQueue threadAccess, Key key, IHintListener listener) {
340 diagram.removeKeyHintListener(threadAccess, key, listener);
344 public void removeKeyHintListener(Key key, IHintListener listener) {
345 diagram.removeKeyHintListener(key, listener);
349 public boolean sendDown(IElement e) {
350 return diagram.sendDown(e);
354 public boolean sendToBottom(IElement e) {
355 return diagram.sendToBottom(e);
359 public void setHint(Key key, Object value) {
360 diagram.setHint(key, value);
364 public void setHints(Map<Key, Object> hints) {
365 diagram.setHints(hints);
368 public ICanvasContext createDefaultCanvas(IThreadWorkQueue thread, G2DSceneGraph sg) {
369 // Create canvas context and a layer of interactors
370 ICanvasContext canvasContext = new ElementDiagramCanvasContext(thread,sg);
371 IHintContext h = canvasContext.getDefaultHintContext();
373 //canvasContext.add(new PanZoomRotateHandler()); // Must be before
376 // Support & Util Participants
377 canvasContext.add(new TransformUtil());
378 canvasContext.add(new MouseUtil());
379 canvasContext.add(new KeyUtil());
380 canvasContext.add(new CanvasGrab());
381 canvasContext.add(new SymbolUtil());
382 canvasContext.add(new TimeParticipant());
384 // Debug participant(s)
385 // canvasContext.add( new PointerPainter() );
386 canvasContext.add(new HandPainter());
387 h.setHint(PointerPainter.KEY_PAINT_POINTER, true);
389 // Pan & Zoom & Rotate
390 // canvasContext.add( new MousePanZoomInteractor() );
391 // canvasContext.add( new MultitouchPanZoomRotateInteractor() );
392 // canvasContext.add( new OrientationRestorer() );
394 // Grid & Ruler & Background
395 canvasContext.add(new GridPainter());
396 canvasContext.add(new RulerPainter());
397 canvasContext.add(new BackgroundPainter());
398 h.setHint(Hints.KEY_GRID_COLOR, new Color(0.9f, 0.9f, 0.9f));
399 h.setHint(Hints.KEY_BACKGROUND_COLOR, Color.LIGHT_GRAY);
402 canvasContext.add(new KeyToCommand(CommandKeyBinding.DEFAULT_BINDINGS));
404 // //// Diagram Participants //////
405 canvasContext.add(new PointerInteractor());
406 canvasContext.add(new ElementInteractor());
407 canvasContext.add(new Selection());
408 canvasContext.add(new DiagramParticipant());
409 canvasContext.add(new ElementPainter());
410 canvasContext.add(new TerminalPainter(true, true, false, true));
411 //canvasContext.add(new ElementHeartbeater());
412 canvasContext.add(new ZOrderHandler());
413 canvasContext.add(new ZoomTransitionParticipant(TransitionFunction.SIGMOID));
414 h.setHint(Hints.KEY_TOOL, Hints.PANTOOL);
416 return canvasContext;
419 public class ElementDiagramCanvasContext extends Context<ICanvasParticipant> implements ICanvasContext {
421 protected HintStack hintStack = new HintStack();
423 protected HintContext bottomHintContext = new HintContext();
425 protected IEventHandlerStack eventHandlerStack = null;
427 protected boolean eventHandlingOrdered = false;
429 protected EventQueue eventQueue = null;
431 protected IContentContext paintableCtx = new PaintableContextImpl();
433 protected final IThreadWorkQueue thread;
435 protected IMouseCaptureContext mouseCaptureCtx = new MouseCaptureContext();
437 protected IMouseCursorContext mouseCursorCtx = new MouseCursorContext();
439 protected G2DSceneGraph sg;
440 protected G2DParentNode canvasNode = null;
442 protected ITooltipProvider tooltip;
446 * @param thread context thread, or null if sync policy not used
448 public ElementDiagramCanvasContext(IThreadWorkQueue thread, G2DSceneGraph sg) {
449 super(ICanvasParticipant.class);
451 throw new IllegalArgumentException("null");
452 this.thread = thread;
453 eventHandlerStack = new EventHandlerStack(thread);
454 eventQueue = new EventQueue(eventHandlerStack);
455 hintStack.addHintContext(bottomHintContext, Integer.MIN_VALUE);
460 canvasNode = sg.addNode("elementd" + SceneGraphConstants.NAVIGATION_NODE_NAME , G2DParentNode.class); // Add dummy parent node
461 canvasNode.setZIndex(1000);
463 this.addContextListener(thread, new IContextListener<ICanvasParticipant>() {
465 public void itemAdded(IContext<ICanvasParticipant> sender, ICanvasParticipant item) {
466 item.addedToContext(ElementDiagramCanvasContext.this);
470 public void itemRemoved(IContext<ICanvasParticipant> sender, ICanvasParticipant item) {
471 item.removedFromContext(ElementDiagramCanvasContext.this);
475 eventQueue.addEventCoalesceler(MouseEventCoalescer.INSTANCE);
476 // Order event handling if events are added to the queue
477 eventQueue.addQueueListener(new IEventQueueListener() {
479 public void onEventAdded(IEventQueue queue, Event e, int index) {
484 public void onQueueEmpty(IEventQueue queue) {
489 public IHintStack getHintStack() {
494 private final Runnable eventHandling = new Runnable() {
497 eventHandlingOrdered = false;
498 eventQueue.handleEvents();
502 synchronized void asyncHandleEvents() {
503 if (eventHandlingOrdered)
505 eventHandlingOrdered = true;
506 ThreadUtils.asyncExec(thread, eventHandling);
509 synchronized void syncHandleEvents() {
510 if (eventHandlingOrdered)
512 eventHandlingOrdered = true;
513 ThreadUtils.syncExec(thread, eventHandling);
517 public IEventHandlerStack getEventHandlerStack() {
519 return eventHandlerStack;
523 public IThreadWorkQueue getThreadAccess() {
524 // assertNotDisposed();
529 protected void doDispose() {
530 ThreadUtils.syncExec(getThreadAccess(), new Runnable() {
535 // HN: added to decrease memory leaks
537 // Makes sure that scene graph nodes free their resources!
546 public IHintContext getDefaultHintContext() {
547 return bottomHintContext;
551 public IMouseCursorContext getMouseCursorContext() {
552 return mouseCursorCtx;
556 public void setMouseCursorContext(IMouseCursorContext ctx) {
557 this.mouseCursorCtx = ctx;
561 public IMouseCaptureContext getMouseCaptureContext() {
562 return mouseCaptureCtx;
566 public void setMouseCaptureContext(IMouseCaptureContext mctx) {
567 this.mouseCaptureCtx = mctx;
571 public IEventQueue getEventQueue() {
576 public IContentContext getContentContext() {
581 public void setContentContext(IContentContext ctx) {
582 this.paintableCtx = ctx;
586 public G2DSceneGraph getSceneGraph() {
591 public G2DParentNode getCanvasNode() {
596 public void setCanvasNode(G2DParentNode node) {
597 throw new RuntimeException("Cannot set canvasNode");
601 protected final AtomicBoolean locked = new AtomicBoolean(false);
604 public boolean isLocked() {
605 return this.locked.get();
609 public void setLocked(boolean locked) {
610 boolean previous = this.locked.getAndSet(locked);
611 if (!locked && previous != locked) {
612 // The context was unlocked!
613 getContentContext().setDirty();
618 public ITooltipProvider getTooltipProvider() {
623 public void setTooltipProvider(ITooltipProvider tooltipProvider) {
624 this.tooltip = tooltipProvider;
629 public class ElementDiagramMouseUtil extends MouseUtil {
632 @EventHandler(priority = Integer.MAX_VALUE)
633 public boolean handleMouseEvent(MouseEvent e) {
634 MouseEvent ne = createMouseEvent(e);
636 return handleMouseEvent2(ne);
641 * Copy-pasted MouseUtil.handleMouseEvent with one modification;
642 * Generating MouseClickEvents has been removed, because it created
643 * duplicated events (with incorrect coordinates).
648 public boolean handleMouseEvent2(MouseEvent e) {
649 assertDependencies();
650 if (e instanceof MouseEnterEvent) {
651 Point2D canvasPosition = util.controlToCanvas(e.controlPosition, null);
653 MouseInfo mi = new MouseInfo(e.mouseId, e.controlPosition, canvasPosition, e.buttons);
654 miceInfo.put(e.mouseId, mi);
655 } else if (e instanceof MouseExitEvent) {
656 miceInfo.remove(e.mouseId);
657 } else if (e instanceof MouseMovedEvent) {
658 Point2D canvasPosition = util.controlToCanvas(e.controlPosition, null);
659 double deltaDistance = 0;
660 MouseInfo mi = miceInfo.get(e.mouseId);
662 mi = new MouseInfo(e.mouseId, e.controlPosition, canvasPosition, 0/*e.buttons*/);
663 miceInfo.put(e.mouseId, mi);
665 deltaDistance = e.controlPosition.distance(mi.controlPosition);
666 mi.controlPosition = e.controlPosition;
667 mi.canvasPosition = canvasPosition;
670 if (deltaDistance > 0)
671 mi.addDistanceForButtons(deltaDistance);
673 // Send mouse drag events.
674 for (ButtonInfo bi : mi.buttonPressInfo.values()) {
677 if (bi.deltaMotion <= profile.movementTolerance)
682 MouseDragBegin db = new MouseDragBegin(this, e.time, e.mouseId, e.buttons, e.stateMask, bi.button,
683 bi.canvasPosition, bi.controlPosition, e.controlPosition, e.screenPosition);
684 getContext().getEventQueue().queueFirst(db);
687 } else if (e instanceof MouseButtonPressedEvent) {
688 Point2D canvasPosition = util.controlToCanvas(e.controlPosition, null);
689 MouseButtonPressedEvent me = (MouseButtonPressedEvent) e;
690 MouseInfo mi = miceInfo.get(e.mouseId);
692 mi = new MouseInfo(e.mouseId, e.controlPosition, canvasPosition, e.buttons);
693 miceInfo.put(e.mouseId, mi);
695 mi.controlPosition = e.controlPosition;
696 mi.canvasPosition = canvasPosition;
698 mi.setButtonPressed(me.button, e.stateMask, e.controlPosition, canvasPosition, e.time);
699 } else if (e instanceof MouseButtonReleasedEvent) {
700 MouseButtonReleasedEvent me = (MouseButtonReleasedEvent) e;
701 Point2D canvasPosition = util.controlToCanvas(me.controlPosition, null);
702 MouseInfo mi = miceInfo.get(me.mouseId);
704 mi = new MouseInfo(e.mouseId, me.controlPosition, canvasPosition, 0/*me.buttons*/);
705 miceInfo.put(me.mouseId, mi);
707 mi.controlPosition = me.controlPosition;
708 mi.canvasPosition = canvasPosition;
710 ButtonInfo bi = mi.releaseButton(me.button, me.time);
714 if (me.holdTime > profile.clickHoldTimeTolerance)
716 if (bi.deltaMotion > profile.movementTolerance)
720 long timeSinceLastClick = me.time - bi.lastClickEventTime;
721 bi.lastClickEventTime = me.time;
723 // reset click counter
724 if (timeSinceLastClick > profile.consecutiveToleranceTime)
734 public class ElementDiagramElementInteractor extends ElementInteractor {
736 @EventHandler(priority = INTERACTOR_PRIORITY)
737 public boolean handleMouseEvent(MouseEvent me) {
738 MouseEvent ne = createMouseEvent(me);
740 return super.handleMouseEvent(ne);
745 public MouseEvent createMouseEvent(MouseEvent e) {
746 MouseEvent newEvent = null;
747 double x = e.controlPosition.getX();
748 double y = e.controlPosition.getY();
749 Point2D newPos = new Point2D.Double(x - canvasPosX, y - canvasPosY);
751 if (!canvasRect.contains(newPos))
752 return new MouseExitEvent(e.context, e.time, e.mouseId, e.buttons, e.stateMask, newPos, e.screenPosition);
753 if (e instanceof MouseButtonPressedEvent) {
754 newEvent = new MouseButtonPressedEvent(e.context, e.time, e.mouseId, e.buttons, e.stateMask,
755 ((MouseButtonEvent) e).button, newPos, e.screenPosition);
756 } else if (e instanceof MouseButtonReleasedEvent) {
757 newEvent = new MouseButtonReleasedEvent(e.context, e.time, e.mouseId, e.buttons, e.stateMask,
758 ((MouseButtonEvent) e).button, ((MouseButtonReleasedEvent) e).holdTime, newPos, e.screenPosition);
759 } else if (e instanceof MouseDoubleClickedEvent) {
760 newEvent = new MouseDoubleClickedEvent(e.context, e.time, e.mouseId, e.buttons, e.stateMask,
761 ((MouseButtonEvent) e).button, newPos, e.screenPosition);
762 } else if (e instanceof MouseClickEvent) {
763 newEvent = new MouseClickEvent(e.context, e.time, e.mouseId, e.buttons, e.stateMask,
764 ((MouseButtonEvent) e).button, ((MouseClickEvent) e).clickCount, newPos, e.screenPosition);
765 } else if (e instanceof MouseDragBegin) {
766 newEvent = new MouseDragBegin(e.context, e.time, e.mouseId, e.buttons, e.stateMask,
767 ((MouseButtonEvent) e).button, ((MouseDragBegin) e).startCanvasPos,
768 ((MouseDragBegin) e).startControlPos, newPos, e.screenPosition);
769 } else if (e instanceof MouseEnterEvent) {
770 newEvent = new MouseEnterEvent(e.context, e.time, e.mouseId, e.buttons, e.stateMask, newPos,
772 } else if (e instanceof MouseExitEvent) {
773 newEvent = new MouseExitEvent(e.context, e.time, e.mouseId, e.buttons, e.stateMask, newPos,
775 } else if (e instanceof MouseMovedEvent) {
776 newEvent = new MouseMovedEvent(e.context, e.time, e.mouseId, e.buttons, e.stateMask, newPos,
778 } else if (e instanceof MouseWheelMovedEvent) {
779 newEvent = new MouseWheelMovedEvent(e.context, e.time, e.mouseId, e.buttons, e.stateMask, newPos,
780 e.screenPosition, ((MouseWheelMovedEvent) e).scrollType, ((MouseWheelMovedEvent) e).scrollAmount,
781 ((MouseWheelMovedEvent) e).wheelRotation);
783 throw new Error("Unknow event " + e.getClass() + " " + e);
785 // System.out.println(newPos + " " + newEvent + " "+ e);