Examples with DoublePoint edu.cmu.cs.hcii.cogtool.model.DoublePoint used on opensource projects

Example 1 with DoublePoint

use of edu.cmu.cs.hcii.cogtool.model.DoublePoint in project cogtool by cogtool.

the class FrameEditorUI method moveWidgetGroup.

// moveFrameElementGroup
/**
     * Assumes gw's model is a traversable widget but not a child widget.
     */
public void moveWidgetGroup(double offsetX, double offsetY, GraphicalTraversableWidget<?> gw) {
    // No easier way to do this (hard to make getTopHeader call generic)
    TraversableWidget groupWidget = null;
    if (gw instanceof GraphicalMenuWidget<?>) {
        groupWidget = ((AMenuWidget) gw.getModel()).getTopHeader();
    } else if ((gw instanceof GraphicalListItem) || (gw instanceof GraphicalGridButton)) {
        groupWidget = (TraversableWidget) gw.getModel();
    } else {
        return;
    }
    SimpleWidgetGroup headerGroup = groupWidget.getParentGroup();
    // Ensure top-left header doesn't scroll off-screen
    groupWidget = (TraversableWidget) headerGroup.get(0);
    DoublePoint p = groupWidget.getShape().getOrigin();
    // Prevent the ability to move a widget to an origin less than 0,0
    if (offsetX + p.x < 0.0) {
        offsetX = -p.x;
    }
    if (offsetY + p.y < 0.0) {
        offsetY = -p.y;
    }
    Point newOrigin = new Point(0, 0);
    int index = 1;
    int headerCount = headerGroup.size();
    do {
        newOrigin.setLocation(PrecisionUtilities.round(p.x + offsetX), PrecisionUtilities.round(p.y + offsetY));
        frameUI.getWidgetFigure(groupWidget).setLocation(newOrigin);
        // Stop when we've moved the last header!
        if (index >= headerCount) {
            break;
        }
        groupWidget = (TraversableWidget) headerGroup.get(index++);
        p = groupWidget.getShape().getOrigin();
    } while (true);
}

Example 2 with DoublePoint

use of edu.cmu.cs.hcii.cogtool.model.DoublePoint in project cogtool by cogtool.

the class FrameEditorMouseState method dynamicMoveWidgets.

/**
     * Utility to help with dynamic move of selected widgets.
     *
     * @param selectedWFs the set of selected graphical widget figures
     * @param currentScaledX scaled X location of the current mouse position
     * @param currentScaledY scaled Y location of the current mouse position
     * @author mlh/alex
     */
protected void dynamicMoveWidgets(Iterator<FrameEltSelnFig<?>> selectedFigs, double currentScaledX, double currentScaledY) {
    ui.hideNondynamicSupport(true);
    // Iterate through list of selected objects
    while (selectedFigs.hasNext()) {
        FrameEltSelnFig<?> fig = selectedFigs.next();
        // Determine movement amount from initial points.
        double offsetX = currentScaledX - scaledMouseDownX;
        double offsetY = currentScaledY - scaledMouseDownY;
        if (fig instanceof GraphicalChildWidget<?, ?>) {
            continue;
        } else if (fig instanceof FrameEltGroupHalo) {
            ui.moveFrameElementGroup(offsetX, offsetY, ((FrameEltGroupHalo) fig).getModel());
        } else if (fig instanceof GraphicalWidget<?>) {
            GraphicalWidget<?> gw = (GraphicalWidget<?>) fig;
            if ((gw instanceof GraphicalTraversableWidget<?>) && (gw.getModel().getParentGroup() != null)) {
                ui.moveWidgetGroup(offsetX, offsetY, (GraphicalTraversableWidget<?>) gw);
            } else {
                DoublePoint p = gw.getModel().getShape().getOrigin();
                double tempX = offsetX + p.x;
                double tempY = offsetY + p.y;
                // Prevent moving a widget to an origin less than 0.0,0.0
                if (tempX < 0.0) {
                    tempX = 0.0;
                }
                if (tempY < 0.0) {
                    tempY = 0.0;
                }
                // Temporarily move the widget origin to new location.
                ui.setGraphicalWidgetOrigin(tempX, tempY, gw);
            }
        }
    }
}

Example 3 with DoublePoint

use of edu.cmu.cs.hcii.cogtool.model.DoublePoint in project cogtool by cogtool.

the class FrameEditorMouseState method dealWithMouseReleased.

/**
     * A mouse up event was called.
     * Checks for context selection, then performs actions as dictated
     * by the FSM.
     */
@Override
protected boolean dealWithMouseReleased(IFigure figure, int button, int x, int y, int state) {
    boolean goForward = super.dealWithMouseReleased(figure, button, x, y, state);
    // Clear any mouse drag timer, that may be running
    stopMouseDragTimer = true;
    if (goForward && isMouseDownValid) {
        // Record the mouse down position
        double zoom = ui.getZoom();
        // The current mouse down position (scaled)
        double currentScaledX = x / zoom;
        double currentScaledY = y / zoom;
        switch(getMouseState()) {
            case PotentialCreatingWidget:
            case PotentialMovingWidget:
            case PotentialResizingWidget:
                {
                    // Nothing to do; any action necessary was taken on "down".
                    break;
                }
            case PotentialReorderWidget:
            case PotentialMovingSelection:
                {
                    // Get whatever graphical widget under original down x,y
                    GraphicalWidget<?> wf = ui.widgetLocatedAtXY(mouseDownX, mouseDownY);
                    MoveHalo halo = null;
                    FrameElement data = null;
                    if (wf == null) {
                        halo = ui.moveHaloUnderXY(mouseDownX, mouseDownY);
                        if (halo != null) {
                            data = halo.getData();
                            if (data instanceof SimpleWidgetGroup) {
                                IWidget[] widgets = selection.getSelectedIWidgets();
                                SimpleWidgetGroup group = (SimpleWidgetGroup) data;
                                for (IWidget widget : widgets) {
                                    if (widget.getParentGroup() != group) {
                                        selection.deselectElement(widget);
                                    }
                                }
                                break;
                            }
                            if (data instanceof IWidget) {
                                wf = ui.frameUI.getWidgetFigure((IWidget) data);
                            }
                        }
                    }
                    if (wf != null) {
                        selection.setSelectedSelnFig(wf);
                    } else {
                        if (halo == null) {
                            halo = ui.moveHaloUnderXY(mouseDownX, mouseDownY);
                            if (halo != null) {
                                data = halo.getData();
                            }
                        }
                        if ((data != null) && (data instanceof FrameElementGroup)) {
                            selection.setSelectedSelnFig((FrameEltGroupHalo) halo);
                        }
                    }
                    break;
                }
            case PotentialTogglingSelection:
                {
                    // If mouse down on a widget, toggle selection.
                    GraphicalWidget<?> wf = ui.widgetLocatedAtXY(mouseDownX, mouseDownY);
                    MoveHalo halo = ui.moveHaloUnderXY(mouseDownX, mouseDownY);
                    FrameElement data = null;
                    if (halo != null) {
                        data = halo.getData();
                    }
                    if (wf == null) {
                        if (data instanceof IWidget) {
                            wf = ui.frameUI.getWidgetFigure((IWidget) data);
                        }
                    }
                    if (wf != null) {
                        // If the widget is already selected, unselect it.
                        if (selection.isSelectionFigureSelected(wf)) {
                            selection.deselectSelnFig(wf);
                        } else {
                            selection.selectSelnFig(wf);
                        }
                    } else if (data instanceof SimpleWidgetGroup) {
                        Iterator<IWidget> widgets = ((SimpleWidgetGroup) data).iterator();
                        while (widgets.hasNext()) {
                            IWidget w = widgets.next();
                            selection.deselectElement(w);
                        }
                    } else if ((halo instanceof FrameEltGroupHalo) && (data instanceof FrameElementGroup)) {
                        FrameEltGroupHalo groupHalo = (FrameEltGroupHalo) halo;
                        if (selection.isElementSelected(data)) {
                            selection.deselectSelnFig(groupHalo);
                        } else {
                            selection.selectSelnFig(groupHalo);
                        }
                    } else {
                        selection.deselectAll();
                    }
                    break;
                }
            // Move is complete, so apply changes to the model.
            case MovingWidgets:
                {
                    // Get selection, and use the difference between current
                    // and start location.
                    double moveByX = currentScaledX - scaledMouseDownX;
                    double moveByY = currentScaledY - scaledMouseDownY;
                    FrameEditorUI.MoveParameters prms = new FrameEditorUI.MoveParameters(moveByX, moveByY, selection);
                    ui.performAction(CogToolLID.MoveWidgets, prms);
                    break;
                }
            case ReorderWidget:
                {
                    boolean reorder = reorderWidget(x, y, reorderParms);
                    ui.clearUISupport(true);
                    isReordering = false;
                    if (reorder) {
                        ui.performAction(FrameEditorLID.Reorder, reorderParms);
                    } else {
                        selection.deselectElement(lastClickedWidget);
                    }
                    InteractionDrawingEditor editor = ui.getViewEditor();
                    editor.removeInteractionFigure(reorderFigure);
                    editor.removeInteractionFigure(dividerLine);
                    break;
                }
            // since the user may have flipped the orientation.
            case ResizingWidget:
                {
                    // Switch to quality mode rendering for graphical widgets
                    setWidgetFastRenderMode(false);
                    if (currentScaledX < 0.0) {
                        currentScaledX = 0.0;
                    }
                    if (currentScaledY < 0.0) {
                        currentScaledY = 0.0;
                    }
                    // Deal with any anchoring issues
                    if (ui.resizeHandlesUIFig.isTopLeftAnchored()) {
                        switch(currentResizeHandleType) {
                            case FrameEditorUI.TOP_RIGHT:
                                {
                                    // Cannot change Y position
                                    currentScaledY = initialResizeArea.y;
                                    break;
                                }
                            case FrameEditorUI.BOTTOM_LEFT:
                                {
                                    // Cannot change X position
                                    currentScaledX = initialResizeArea.x;
                                    break;
                                }
                            default:
                                {
                                    break;
                                }
                        }
                        // Cannot move left of top-left
                        if (currentScaledX < initialResizeArea.x) {
                            currentScaledX = initialResizeArea.x;
                        }
                        // Cannot move above of top-left
                        if (currentScaledY < initialResizeArea.y) {
                            currentScaledY = initialResizeArea.y;
                        }
                    }
                    double width = Math.abs(currentScaledX - mouseFixedResizeX);
                    double height = Math.abs(currentScaledY - mouseFixedResizeY);
                    FrameEditorUI.ResizeParameters prms = new FrameEditorUI.ResizeParameters(initialResizeArea.x, initialResizeArea.y, Math.min(currentScaledX, mouseFixedResizeX), Math.min(currentScaledY, mouseFixedResizeY), width / initialResizeArea.width, height / initialResizeArea.height, selection);
                    ui.performAction(CogToolLID.ResizeWidgets, prms);
                    break;
                }
            // Finished a mouse drag operation to create a new widget
            case CreatingWidget:
                {
                    if (currentScaledX < 0.0) {
                        currentScaledX = 0.0;
                    }
                    if (currentScaledY < 0.0) {
                        currentScaledY = 0.0;
                    }
                    double width = Math.abs(scaledMouseDownX - currentScaledX);
                    double height = Math.abs(scaledMouseDownY - currentScaledY);
                    double leftX = (scaledMouseDownX > currentScaledX) ? currentScaledX : scaledMouseDownX;
                    double topY = (scaledMouseDownY > currentScaledY) ? currentScaledY : scaledMouseDownY;
                    // Turn off the bounding box drawn.
                    ui.stopDrawingTemporaryFigure();
                    // Create a rectangle for the new region.
                    DoubleRectangle region = new DoubleRectangle(leftX, topY, width, height);
                    // width of 0. Probably this should be less then 2.
                    if ((region.width != 0.0) && (region.height != 0.0)) {
                        ui.performAction(CogToolLID.NewWidget, new FrameEditorUI.NewWidgetParameters(region, ui.getCurrentWidgetType(), ui.view.isAutomaticCreation()));
                    }
                    break;
                }
            // Finished a mouse drag operation to select a set of widgets
            case TogglingSelection:
                {
                    // Get the total area selected
                    double width = Math.abs(scaledMouseDownX - currentScaledX);
                    double height = Math.abs(scaledMouseDownY - currentScaledY);
                    // Get top left point.
                    double leftX = (scaledMouseDownX > currentScaledX) ? currentScaledX : scaledMouseDownX;
                    double topY = (scaledMouseDownY > currentScaledY) ? currentScaledY : scaledMouseDownY;
                    // Turn off the bounding box drawn.
                    ui.stopDrawingTemporaryFigure();
                    // Create the final region's area
                    DoubleRectangle region = new DoubleRectangle(leftX, topY, width, height);
                    // Loop through all figures and check for intersections
                    Iterator<GraphicalWidget<?>> gwFigures = ui.getFrameUI().getFigureListIterator();
                    while (gwFigures.hasNext()) {
                        GraphicalWidget<?> gw = gwFigures.next();
                        if (!(gw instanceof GraphicalChildWidget<?, ?>)) {
                            Rectangle bounds = gw.getBounds();
                            if (region.intersects(bounds.x, bounds.y, bounds.width, bounds.height)) {
                                // If the widget is already selected, deselect it.
                                if (selection.isSelectionFigureSelected(gw)) {
                                    selection.deselectSelnFig(gw);
                                } else {
                                    selection.selectSelnFig(gw);
                                }
                            }
                        }
                    }
                    break;
                }
            case PotentialInsertDuplicateWidget:
            case PotentialDuplicatingWidget:
                {
                    GraphicalWidget<?> widgetFig = ui.widgetLocatedAtXY(mouseDownX, mouseDownY);
                    selection.setSelectedSelnFig(widgetFig);
                    break;
                }
            case DuplicatingWidgets:
                {
                    double dx = currentScaledX - scaledMouseDownX;
                    double dy = currentScaledY - scaledMouseDownY;
                    // Remove all the rectangle figures from the display, clear the list
                    clearRectFigures();
                    ui.performAction(FrameEditorLID.Duplicate, new FrameEditorUI.DuplicateParameters(dx, dy, selection));
                    break;
                }
            case InsertDuplicateWidget:
                {
                    double dx = currentScaledX - scaledMouseDownX;
                    double dy = currentScaledY - scaledMouseDownY;
                    isReordering = false;
                    if (reorderWidget(x, y, insertDuplicateParms)) {
                        insertDuplicateParms.moveByX = dx;
                        insertDuplicateParms.moveByY = dy;
                        ui.performAction(FrameEditorLID.InsertDuplicate, insertDuplicateParms);
                    } else {
                        selection.deselectElement(lastClickedWidget);
                    }
                    InteractionDrawingEditor editor = ui.getViewEditor();
                    editor.removeInteractionFigure(reorderFigure);
                    editor.removeInteractionFigure(dividerLine);
                    break;
                }
            case PotentialMovingGridButtons:
                {
                    if (movedGridButtons != null) {
                        movedGridButtons = NO_GRID_BUTTONS;
                    }
                    break;
                }
            case MovingGridButtons:
                {
                    // Get selection, and use the difference between current
                    // and start location.
                    double moveByX;
                    double moveByY;
                    GraphicalWidget<?> gw = ui.getPotentialFigureOwner();
                    GridButton gb = (GridButton) gw.getModel();
                    DoublePoint start = gb.getShape().getOrigin();
                    if (moveIsVertical) {
                        moveByX = 0.0;
                        if (currentScaledY < minY) {
                            moveByY = (minY - start.y);
                        } else {
                            moveByY = currentScaledY - scaledMouseDownY;
                        }
                    } else {
                        moveByY = 0.0;
                        if (currentScaledX < minX) {
                            moveByX = (minX - start.x);
                        } else {
                            moveByX = currentScaledX - scaledMouseDownX;
                        }
                    }
                    if ((moveByX != 0.0) || (moveByY != 0.0)) {
                        FrameEditorUI.MoveParameters prms = new FrameEditorUI.MoveParameters(moveByX, moveByY, selection, false);
                        ui.performAction(CogToolLID.MoveWidgets, prms);
                    }
                    break;
                }
        }
        // Clear the values used.
        lastClickedWidget = null;
        isMouseDownValid = false;
        setMouseState(MouseUp);
    }
    cleanup();
    return goForward;
}

Example 4 with DoublePoint

use of edu.cmu.cs.hcii.cogtool.model.DoublePoint in project cogtool by cogtool.

the class DesignEditorMouseState method updateDynamicMove.

protected void updateDynamicMove(int x, int y, boolean updateModel) {
    double zoom = ui.getZoom();
    double dx = (x / zoom) - scaledMouseDownX;
    double dy = (y / zoom) - scaledMouseDownY;
    Iterator<DesignEditorFrame> frameFigs = selection.getSelectedFrameFigures();
    while (frameFigs.hasNext()) {
        DesignEditorFrame frameFig = frameFigs.next();
        DoublePoint frameOrigin = frameFig.getFrame().getFrameOrigin();
        double newX = frameOrigin.x + dx;
        double newY = frameOrigin.y + dy;
        // Prevent the frame from moving past 0,0
        if (newX < 0) {
            newX = 0;
        }
        if (newY < 0) {
            newY = 0;
        }
        ui.setFigureOrigin(frameFig, newX, newY);
    }
    ui.performRepaintUpdates();
    if (updateModel) {
        ui.performAction(DesignEditorLID.MoveFrames, new DesignEditorUI.MoveParameters(dx, dy, selection));
    }
}

Example 5 with DoublePoint

use of edu.cmu.cs.hcii.cogtool.model.DoublePoint in project cogtool by cogtool.

the class FrameEditorMouseState method dealWithMouseDragged.

/**
     * Parameterized mouse drags so they can be scaled programatically.
     *
     * Handles mouse drags: moves the viewable area as needed
     *
     * @param figure ignored
     * @param mouseX the location the mouse is pointing to
     * @param mouseY the location the mouse is pointing to
     * @param button the buttons pressed
     * @param state the modifiers being held down
     */
@Override
protected boolean dealWithMouseDragged(IFigure figure, int button, int mouseX, int mouseY, int state) {
    boolean goForward = super.dealWithMouseDragged(figure, button, mouseX, mouseY, state);
    if (goForward && isMouseDownValid) {
        // Get the StandardEditor for handling visuals & scrolling
        StandardDrawingEditor editor = ui.getViewEditor();
        // Update VIEW to ensure mouse point is visible.
        // If outside of the visible canvas, up-click should cancel!
        stopMouseDragTimer = true;
        stopDynamic = editor.movePointNearEdge(mouseX, mouseY, updateDelta);
        double zoom = ui.getZoom();
        // The current mouse down position (scaled)
        double currentScaledX = mouseX / zoom;
        double currentScaledY = mouseY / zoom;
        Iterator<FrameEltSelnFig<?>> selectedEltFigs = selection.getSelectedFigures();
        InteractionFigure drawLayer = ui.getViewEditor().getInteractionFigure();
        // Else this is a new widget
        switch(getMouseState()) {
            // Perform move-related states
            case PotentialMovingWidget:
            case PotentialMovingSelection:
                {
                    if (withinHysteresis(mouseX, mouseY)) {
                        return true;
                    }
                    ui.hideNondynamicSupport(false);
                    prevCursor = drawLayer.getCursor();
                    drawLayer.setCursor(SELECT_CURSOR);
                    setMouseState(MovingWidgets);
                // fall through!
                }
            case MovingWidgets:
                {
                    dynamicMoveWidgets(selectedEltFigs, currentScaledX, currentScaledY);
                    ui.repaintEditor();
                    break;
                }
            case PotentialReorderWidget:
                {
                    if (withinHysteresis(mouseX, mouseY)) {
                        return true;
                    }
                    prevCursor = drawLayer.getCursor();
                    ui.hideNondynamicSupport(false, false);
                    setUpReorderFigures();
                    prevCursor = drawLayer.getCursor();
                    drawLayer.setCursor(SELECT_CURSOR);
                    setMouseState(ReorderWidget);
                // fall through!
                }
            case ReorderWidget:
                {
                    dynamicReorderWidget(mouseX, mouseY, false);
                    break;
                }
            case PotentialResizingWidget:
                {
                    if (withinHysteresis(mouseX, mouseY)) {
                        return true;
                    }
                    ui.hideNondynamicSupport(true);
                    // Iterate through selected widgets XYZZY openChildren in a loop???
                    while (selectedEltFigs.hasNext()) {
                        FrameEltSelnFig<?> gw = selectedEltFigs.next();
                        if (gw instanceof GraphicalTraversableWidget<?>) {
                            if (gw instanceof GraphicalChildWidget<?, ?>) {
                                ((GraphicalChildWidget<?, ?>) gw).getParentFigure().openChildren();
                            }
                        }
                    }
                    setMouseState(ResizingWidget);
                // fall through!
                }
            // Perform a drag resize of selected widget
            case ResizingWidget:
                {
                    dynamicResizeWidgets(selectedEltFigs, currentScaledX, currentScaledY);
                    ui.repaintEditor();
                    break;
                }
            // Create a new widget
            case PotentialCreatingWidget:
                {
                    if (withinHysteresis(mouseX, mouseY)) {
                        return true;
                    }
                    setMouseState(CreatingWidget);
                // fall through!
                }
            case CreatingWidget:
                {
                    redrawTemporaryWidget(currentScaledX, currentScaledY, false);
                    break;
                }
            // Sweeping a region for toggling selection
            case PotentialTogglingSelection:
                {
                    if (withinHysteresis(mouseX, mouseY)) {
                        return true;
                    }
                    setMouseState(TogglingSelection);
                // fall through!
                }
            case TogglingSelection:
                {
                    redrawTemporaryWidget(currentScaledX, currentScaledY, true);
                    break;
                }
            case PotentialDuplicatingWidget:
                {
                    if (withinHysteresis(mouseX, mouseY)) {
                        return true;
                    }
                    ui.hideNondynamicSupport(false, false);
                    duplicatingDynamic = new ArrayList<RectangleFigure>();
                    Iterator<FrameEltSelnFig<?>> selectedFigs = selection.getSelectedFigures();
                    while (selectedFigs.hasNext()) {
                        FrameEltSelnFig<?> currFig = selectedFigs.next();
                        if (currFig instanceof FrameEltGroupHalo) {
                            showSelectionArea(new RectangleFigure(), currFig.getBounds());
                        } else if (!(currFig instanceof GraphicalChildWidget<?, ?>)) {
                            Rectangle widgetBds = new Rectangle(currFig.getBounds());
                            // Must scale widget figure's bounds to zoom factor
                            widgetBds.height = PrecisionUtilities.round(widgetBds.height * zoom);
                            widgetBds.width = PrecisionUtilities.round(widgetBds.width * zoom);
                            widgetBds.x = PrecisionUtilities.round(widgetBds.x * zoom);
                            widgetBds.y = PrecisionUtilities.round(widgetBds.y * zoom);
                            //display the new rectangle object
                            showSelectionArea(new RectangleFigure(), widgetBds);
                        }
                    }
                    setMouseState(DuplicatingWidgets);
                // fall through!
                }
            case DuplicatingWidgets:
                {
                    updateDynamicDuplicate(mouseX, mouseY);
                    break;
                }
            case PotentialInsertDuplicateWidget:
                {
                    if (withinHysteresis(mouseX, mouseY)) {
                        return true;
                    }
                    ui.hideNondynamicSupport(false, false);
                    prevCursor = drawLayer.getCursor();
                    setUpReorderFigures();
                    prevCursor = drawLayer.getCursor();
                    drawLayer.setCursor(DRAW_CURSOR);
                    setMouseState(InsertDuplicateWidget);
                // fall through!
                }
            case InsertDuplicateWidget:
                {
                    dynamicReorderWidget(mouseX, mouseY, true);
                    break;
                }
            case PotentialMovingGridButtons:
                {
                    if (withinHysteresis(mouseX, mouseY)) {
                        return true;
                    }
                    GraphicalWidget<?> gw = ui.getPotentialFigureOwner();
                    GridButton owner = (GridButton) gw.getModel();
                    DoublePoint start = owner.getShape().getOrigin();
                    GridButtonGroup gbg = (GridButtonGroup) owner.getParentGroup();
                    movedGridButtons = gbg.getMovedButtons(moveIsVertical, start.x, start.y);
                    minX = start.x - owner.getHorizSpace();
                    minY = start.y - owner.getVertSpace();
                    prevCursor = drawLayer.getCursor();
                    if (moveIsVertical) {
                        drawLayer.setCursor(MOVE_VERT_CURSOR);
                    } else {
                        drawLayer.setCursor(MOVE_HORIZ_CURSOR);
                    }
                    setMouseState(MovingGridButtons);
                // fall through!
                }
            case MovingGridButtons:
                {
                    dynamicMoveGridButtons(currentScaledX, currentScaledY);
                    break;
                }
        }
        // Repeating timer for causing events to repeat.
        if ((updateDelta.x != 0) || (updateDelta.y != 0)) {
            if (rootFigure == null) {
                rootFigure = ui.getViewEditor().getInteractionFigure();
            }
            stopMouseDragTimer = false;
            // Determine the new point the mouse "moved" too.
            mouseDragTask.setNextMousePosition(mouseX + updateDelta.x, mouseY + updateDelta.y, button, state);
            // Queue the event for 0.1 sec.
            WindowUtil.GLOBAL_DISPLAY.timerExec(100, mouseDragTask);
        }
    }
    lastX = mouseX;
    lastY = mouseY;
    updateDynamic();
    return goForward;
}