MoveInputMode (yFiles-for-JavaFX-Complete-3.0 API)

java.lang.Object
- com.yworks.yfiles.view.input.MoveInputMode

All Implemented Interfaces:

IInputMode

Direct Known Subclasses:

MoveLabelInputMode, ReparentStripeInputMode
```
public class MoveInputMode
extends Object
implements IInputMode
```
Generic IInputMode implementation that can be used to move something in the canvas using the mouse.
This implementation uses the HitTestable to determine where the user can begin dragging the selection. It will then use the PositionHandler to delegate the actual work of moving the elements to.

This mode is Exclusive by default.

Constructor Summary

Constructors
Constructor and Description

MoveInputMode()
Initializes a new instance of the MoveInputMode class.

Constructors
Constructor and Description
`MoveInputMode()` Initializes a new instance of the `MoveInputMode` class.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addDragCanceledListener(IEventHandler<InputModeEventArgs> dragCanceledEvent)` Adds the given listener for the `DragCanceled` event that occurs when the drag has been canceled.
`void`	`addDragCancelingListener(IEventHandler<InputModeEventArgs> dragCancelingEvent)` Adds the given listener for the `DragCanceling` event that occurs before the drag will be canceled.
`void`	`addDragFinishedListener(IEventHandler<InputModeEventArgs> dragFinishedEvent)` Adds the given listener for the `DragFinished` event that occurs once the drag has been finished.
`void`	`addDragFinishingListener(IEventHandler<InputModeEventArgs> dragFinishingEvent)` Adds the given listener for the `DragFinishing` event that occurs before the drag will be finished.
`void`	`addDraggedListener(IEventHandler<InputModeEventArgs> draggedEvent)` Adds the given listener for the `Dragged` event that occurs at the end of every drag.
`void`	`addDraggingListener(IEventHandler<InputModeEventArgs> draggingEvent)` Adds the given listener for the `Dragging` event that occurs at the start of every drag.
`void`	`addDragStartedListener(IEventHandler<InputModeEventArgs> dragStartedEvent)` Adds the given listener for the `DragStarted` event that occurs once the drag is initialized and has started.
`void`	`addDragStartingListener(IEventHandler<InputModeEventArgs> dragStartingEvent)` Adds the given listener for the `DragStarting` event that occurs once the drag is starting.
`void`	`addQueryPositionHandlerListener(IEventHandler<QueryPositionHandlerEventArgs> queryPositionHandlerEvent)` Adds the given listener for the `QueryPositionHandler` event that occurs when a drag is recognized for the `MoveInputMode`.
`protected void`	`arm()` Callback that is called when this mode is "armed".
`void`	`cancel()` Cancels the editing of this mode.
`protected IInputModeContext`	`createPositionHandlerInputModeContext()` Creates an `IInputModeContext` for use with the `IPositionHandler` interface for the upcoming drag operation.
`protected void`	`disarm()` Callback that is called when this mode is "disarmed".
`void`	`doStartDrag(PointD location)` Simulates the start of a drag and puts the state machine into the dragging state.
`IEnumerable<IModelItem>`	`getAffectedItems()` Gets an immutable snapshot of the `IModelItem`s affected by the currently `active` gesture.
`IEventRecognizer`	`getCancelRecognizer()` Gets the "cancel" recognizer.
`protected ConcurrencyController`	`getController()` Returns the installed `Controller`.
`IEventRecognizer`	`getDisableSnappingRecognizer()` Gets event recognizer that recognizes when the user temporarily disables snapping.
`IEventRecognizer`	`getDraggedRecognizer()` Gets the "dragged" recognizer.
`IEventRecognizer`	`getDraggedRecognizerTouch()` Gets the "dragged" recognizer for touch events.
`IEventRecognizer`	`getEnableSnappingRecognizer()` Gets event recognizer that recognizes when the user reenables temporarily disabled snapping.
`IHitTestable`	`getHitTestable()` Gets the `IHitTestable` that will be used by this mode to determine where the user may start dragging.
`IEventRecognizer`	`getHoverRecognizer()` Gets the "hovering" state recognizer.
`PointD`	`getInitialLocation()` Returns the initial position where the dragging was initiated.
`IInputModeContext`	`getInputModeContext()` Returns the context instance this mode is currently installed in or `null` if this instance is not installed.
`Cursor`	`getMoveCursor()` Gets the cursor to use during the move.
`IPositionHandler`	`getPositionHandler()` Gets the `IPositionHandler` that will be used as fallback to handle that actual movement of the elements during the drag.
`IEventRecognizer`	`getPressedRecognizer()` Gets the "pressed" state recognizer.
`IEventRecognizer`	`getPressedRecognizerTouch()` Gets the "pressed" recognizer for touch events.
`int`	`getPriority()` The priority of this input mode.
`IEventRecognizer`	`getReleasedRecognizer()` Gets the "released" recognizer.
`IEventRecognizer`	`getReleasedRecognizerTouch()` Gets the "released" recognizer for touch events.
`SnapContext`	`getSnapContext()` The `SnapContext` which manages snapping model items to certain coordinates (for instance, other items).
`void`	`install(IInputModeContext context, ConcurrencyController controller)` Installs this mode into the given context that is provided by the canvas.
`boolean`	`isDragging()` Gets a value indicating whether a drag operation is currently in progress.
`boolean`	`isEnabled()` Gets the enabled state of this input mode.
`boolean`	`isExclusive()` Gets a value indicating whether this mode will be the only one running when it has the mutex.
`protected boolean`	`isValidStartLocation(PointD location)` Determines whether the given location is a valid start location for the move gesture.
`protected void`	`onCanceled()` Called after `cancel()` has been called.
`protected void`	`onConcurrencyControllerActivated()` Called after the `Active` property of the installed `ConcurrencyController` has been set to `true`.
`protected void`	`onConcurrencyControllerDeactivated()` Called after the `Active` property of the installed `ConcurrencyController` has been set to `false`.
`protected void`	`onDragCanceled(InputModeEventArgs inputModeEventArgs)` Triggers the `DragCanceled` event.
`protected void`	`onDragCanceling(InputModeEventArgs inputModeEventArgs)` Triggers the `DragCanceling` event.
`protected void`	`onDragFinished(InputModeEventArgs inputModeEventArgs)` Callback triggered once the drag has been finalized.
`protected void`	`onDragFinishing(InputModeEventArgs inputModeEventArgs)` Callback triggered before the drag will be finalized.
`protected void`	`onDragged(InputModeEventArgs inputModeEventArgs)` Callback triggered at the end of each drag.
`protected void`	`onDragging(InputModeEventArgs inputModeEventArgs)` Callback triggered at the start of each drag.
`protected void`	`onDragStarted(InputModeEventArgs inputModeEventArgs)` Triggers the `DragStarted` event.
`protected void`	`onDragStarting(InputModeEventArgs inputModeEventArgs)` Triggers the `DragStarting` event.
`protected void`	`onQueryPositionHandler(QueryPositionHandlerEventArgs args)` Raises the `QueryPositionHandler` event.
`protected void`	`onStopped()` Called after `stop()` has been called.
`void`	`removeDragCanceledListener(IEventHandler<InputModeEventArgs> dragCanceledEvent)` Removes the given listener for the `DragCanceled` event that occurs when the drag has been canceled.
`void`	`removeDragCancelingListener(IEventHandler<InputModeEventArgs> dragCancelingEvent)` Removes the given listener for the `DragCanceling` event that occurs before the drag will be canceled.
`void`	`removeDragFinishedListener(IEventHandler<InputModeEventArgs> dragFinishedEvent)` Removes the given listener for the `DragFinished` event that occurs once the drag has been finished.
`void`	`removeDragFinishingListener(IEventHandler<InputModeEventArgs> dragFinishingEvent)` Removes the given listener for the `DragFinishing` event that occurs before the drag will be finished.
`void`	`removeDraggedListener(IEventHandler<InputModeEventArgs> draggedEvent)` Removes the given listener for the `Dragged` event that occurs at the end of every drag.
`void`	`removeDraggingListener(IEventHandler<InputModeEventArgs> draggingEvent)` Removes the given listener for the `Dragging` event that occurs at the start of every drag.
`void`	`removeDragStartedListener(IEventHandler<InputModeEventArgs> dragStartedEvent)` Removes the given listener for the `DragStarted` event that occurs once the drag is initialized and has started.
`void`	`removeDragStartingListener(IEventHandler<InputModeEventArgs> dragStartingEvent)` Removes the given listener for the `DragStarting` event that occurs once the drag is starting.
`void`	`removeQueryPositionHandlerListener(IEventHandler<QueryPositionHandlerEventArgs> queryPositionHandlerEvent)` Removes the given listener for the `QueryPositionHandler` event that occurs when a drag is recognized for the `MoveInputMode`.
`void`	`setCancelRecognizer(IEventRecognizer value)` Sets the "cancel" recognizer.
`void`	`setDisableSnappingRecognizer(IEventRecognizer value)` Sets event recognizer that recognizes when the user temporarily disables snapping.
`void`	`setDraggedRecognizer(IEventRecognizer value)` Sets the "dragged" recognizer.
`void`	`setDraggedRecognizerTouch(IEventRecognizer value)` Sets the "dragged" recognizer for touch events.
`void`	`setEnabled(boolean value)` Sets the enabled state of this input mode.
`void`	`setEnableSnappingRecognizer(IEventRecognizer value)` Sets event recognizer that recognizes when the user reenables temporarily disabled snapping.
`void`	`setExclusive(boolean value)` Sets a value indicating whether this mode will be the only one running when it has the mutex.
`void`	`setHitTestable(IHitTestable value)` Sets the `IHitTestable` that will be used by this mode to determine where the user may start dragging.
`void`	`setHoverRecognizer(IEventRecognizer value)` Sets the "hovering" state recognizer.
`void`	`setMoveCursor(Cursor value)` Sets the cursor to use during the move.
`void`	`setPositionHandler(IPositionHandler value)` Sets the `IPositionHandler` that will be used as fallback to handle that actual movement of the elements during the drag.
`void`	`setPressedRecognizer(IEventRecognizer value)` Sets the "pressed" state recognizer.
`void`	`setPressedRecognizerTouch(IEventRecognizer value)` Sets the "pressed" recognizer for touch events.
`void`	`setPriority(int value)` The priority of this input mode.
`void`	`setReleasedRecognizer(IEventRecognizer value)` Sets the "released" recognizer.
`void`	`setReleasedRecognizerTouch(IEventRecognizer value)` Sets the "released" recognizer for touch events.
`void`	`setSnapContext(SnapContext value)` The `SnapContext` which manages snapping model items to certain coordinates (for instance, other items).
`boolean`	`stop()` Called by the client in order to stop a current editing progress.
`void`	`uninstall(IInputModeContext context)` Uninstalls this mode from the given context.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - MoveInputMode
```
public MoveInputMode()
```
    Initializes a new instance of the MoveInputMode class.
- Method Detail
  - addDragCanceledListener
```
public final void addDragCanceledListener(IEventHandler<InputModeEventArgs> dragCanceledEvent)
```
    Adds the given listener for the DragCanceled event that occurs when the drag has been canceled.
    
    Parameters:
    
    dragCanceledEvent - The listener to add.
    
    See Also:
    
    removeDragCanceledListener(IEventHandler)
  - addDragCancelingListener
```
public final void addDragCancelingListener(IEventHandler<InputModeEventArgs> dragCancelingEvent)
```
    Adds the given listener for the DragCanceling event that occurs before the drag will be canceled.
    
    Parameters:
    
    dragCancelingEvent - The listener to add.
    
    See Also:
    
    removeDragCancelingListener(IEventHandler)
  - addDragFinishedListener
```
public final void addDragFinishedListener(IEventHandler<InputModeEventArgs> dragFinishedEvent)
```
    Adds the given listener for the DragFinished event that occurs once the drag has been finished.
    
    Parameters:
    
    dragFinishedEvent - The listener to add.
    
    See Also:
    
    removeDragFinishedListener(IEventHandler)
  - addDragFinishingListener
```
public final void addDragFinishingListener(IEventHandler<InputModeEventArgs> dragFinishingEvent)
```
    Adds the given listener for the DragFinishing event that occurs before the drag will be finished.
    
    Parameters:
    
    dragFinishingEvent - The listener to add.
    
    See Also:
    
    removeDragFinishingListener(IEventHandler)
  - addDraggedListener
```
public final void addDraggedListener(IEventHandler<InputModeEventArgs> draggedEvent)
```
    Adds the given listener for the Dragged event that occurs at the end of every drag.
    
    Parameters:
    
    draggedEvent - The listener to add.
    
    See Also:
    
    removeDraggedListener(IEventHandler)
  - addDraggingListener
```
public final void addDraggingListener(IEventHandler<InputModeEventArgs> draggingEvent)
```
    Adds the given listener for the Dragging event that occurs at the start of every drag.
    
    Parameters:
    
    draggingEvent - The listener to add.
    
    See Also:
    
    removeDraggingListener(IEventHandler)
  - addDragStartedListener
```
public final void addDragStartedListener(IEventHandler<InputModeEventArgs> dragStartedEvent)
```
    Adds the given listener for the DragStarted event that occurs once the drag is initialized and has started.
    
    Parameters:
    
    dragStartedEvent - The listener to add.
    
    See Also:
    
    removeDragStartedListener(IEventHandler)
  - addDragStartingListener
```
public final void addDragStartingListener(IEventHandler<InputModeEventArgs> dragStartingEvent)
```
    Adds the given listener for the DragStarting event that occurs once the drag is starting.
    
    Parameters:
    
    dragStartingEvent - The listener to add.
    
    See Also:
    
    removeDragStartingListener(IEventHandler)
  - addQueryPositionHandlerListener
```
public final void addQueryPositionHandlerListener(IEventHandler<QueryPositionHandlerEventArgs> queryPositionHandlerEvent)
```
    Adds the given listener for the QueryPositionHandler event that occurs when a drag is recognized for the MoveInputMode.
    If the event args are Handled, the IPositionHandler that is carried with the event args is used to actually move the items. Otherwise the pre-set PositionHandler property is used.
    
    Parameters:
    
    queryPositionHandlerEvent - The listener to add.
    
    See Also:
    
    removeQueryPositionHandlerListener(IEventHandler)
  - arm
```
protected void arm()
```
    Callback that is called when this mode is "armed".
    This happens when the mouse hovers over the item(s) to move. This implementation sets the mouse cursor to MoveCursor.
  - cancel
```
public void cancel()
```
    Cancels the editing of this mode.
    This implementation releases the mutex if it is currently owned by this instance and calls onCanceled().
    
    Specified by:
    
    cancel in interface IInputMode
    
    See Also:
    
    onCanceled()
  - createPositionHandlerInputModeContext
```
protected IInputModeContext createPositionHandlerInputModeContext()
```
    Creates an IInputModeContext for use with the IPositionHandler interface for the upcoming drag operation.
    
    Returns:
    
    An instance of IInputModeContext.
  - disarm
```
protected void disarm()
```
    Callback that is called when this mode is "disarmed".
    This happens when the mouse stops hovering over the item(s). This implementation resets the mouse cursor again.
  - doStartDrag
```
public void doStartDrag(PointD location)
```
    Simulates the start of a drag and puts the state machine into the dragging state.
    Subsequent moves of input devices will behave as if the dragging has been successfully initiated at location.
    
    Parameters:
    
    location - The location where the drag had been initialized.
  - getAffectedItems
```
public final IEnumerable<IModelItem> getAffectedItems()
```
    Gets an immutable snapshot of the IModelItems affected by the currently active gesture.
    When the gesture is starting and the PositionHandler is initialized, the implementation can register the affected item(s) through the IModelItemCollector instance that is bound to the context available via its ILookup.lookup(Class).
    
    Client code can register with the DragStarted event, as well as the DragFinished event to get notified of the elements that may be or have been affected respectively by this input mode.
    
    Returns:
    
    A snapshot of the current collection of the items that are affected by the move operation.
  - getCancelRecognizer
```
public final IEventRecognizer getCancelRecognizer()
```
    Gets the "cancel" recognizer.
    This recognizer recognizes a cancel action during the move.
    
    Returns:
    
    The "cancel" recognizer.
    
    See Also:
    
    setCancelRecognizer(IEventRecognizer)
  - getController
```
protected final ConcurrencyController getController()
```
    Returns the installed Controller.
    
    Returns:
    
    The Controller.
  - getDisableSnappingRecognizer
```
public final IEventRecognizer getDisableSnappingRecognizer()
```
    Gets event recognizer that recognizes when the user temporarily disables snapping.
    
    Returns:
    
    The instance to use for disabling snapping. The default is IEventRecognizer.SHORTCUT_DOWN
    
    See Also:
    
    getEnableSnappingRecognizer(), setDisableSnappingRecognizer(IEventRecognizer)
  - getDraggedRecognizer
```
public final IEventRecognizer getDraggedRecognizer()
```
    Gets the "dragged" recognizer.
    This recognizer instance determines when the user is moving the selection
    
    Returns:
    
    The "dragged" recognizer.
    
    See Also:
    
    setDraggedRecognizer(IEventRecognizer)
  - getDraggedRecognizerTouch
```
public final IEventRecognizer getDraggedRecognizerTouch()
```
    Gets the "dragged" recognizer for touch events.
    This recognizer instance determines when the user is moving the selection
    
    Returns:
    
    The "dragged" recognizer specifically for touch events.
    
    See Also:
    
    setDraggedRecognizerTouch(IEventRecognizer)
  - getEnableSnappingRecognizer
```
public final IEventRecognizer getEnableSnappingRecognizer()
```
    Gets event recognizer that recognizes when the user reenables temporarily disabled snapping.
    
    Returns:
    
    The instance to use for reenabling snapping. The default is IEventRecognizer.SHORTCUT_UP
    
    See Also:
    
    setEnableSnappingRecognizer(IEventRecognizer)
  - getHitTestable
```
public final IHitTestable getHitTestable()
```
    Gets the IHitTestable that will be used by this mode to determine where the user may start dragging.
    
    Returns:
    
    The HitTestable.
    
    See Also:
    
    setHitTestable(IHitTestable)
  - getHoverRecognizer
```
public final IEventRecognizer getHoverRecognizer()
```
    Gets the "hovering" state recognizer.
    This recognizer instance will be used to determine whether the user is hovering over an item where pressing can initialize a move operation. The default implementation uses the isValidStartLocation(PointD) method to determine whether the mode can be initialized, here.
    
    Returns:
    
    The "hover" recognizer.
    
    See Also:
    
    setHoverRecognizer(IEventRecognizer)
  - getInitialLocation
```
public final PointD getInitialLocation()
```
    Returns the initial position where the dragging was initiated.
    
    Returns:
    
    The InitialLocation.
  - getInputModeContext
```
public final IInputModeContext getInputModeContext()
```
    Description copied from interface: IInputMode
    
    Returns the context instance this mode is currently installed in or null if this instance is not installed.
    Note that this instance should not be passed down to subordinate modes or instances. Instead a corresponding context that has this instance set as the ParentInputMode should be used.
    
    Specified by:
    
    getInputModeContext in interface IInputMode
    
    Returns:
    
    The InputModeContext.
  - getMoveCursor
```
public final Cursor getMoveCursor()
```
    Gets the cursor to use during the move.
    
    Returns:
    
    The MoveCursor.
    
    See Also:
    
    setMoveCursor(Cursor)
  - getPositionHandler
```
public final IPositionHandler getPositionHandler()
```
    Gets the IPositionHandler that will be used as fallback to handle that actual movement of the elements during the drag.
    Note that the IPositionHandler retrieved by the QueryPositionHandler event has priority before this property. Only if the event is not Handled this property is used.
    
    Returns:
    
    The PositionHandler.
    
    See Also:
    
    setPositionHandler(IPositionHandler)
  - getPressedRecognizer
```
public final IEventRecognizer getPressedRecognizer()
```
    Gets the "pressed" state recognizer.
    This recognizer instance will be used to determine when the user begins to move the selection.
    
    Returns:
    
    The "pressed" recognizer.
    
    See Also:
    
    setPressedRecognizer(IEventRecognizer)
  - getPressedRecognizerTouch
```
public final IEventRecognizer getPressedRecognizerTouch()
```
    Gets the "pressed" recognizer for touch events.
    This recognizer instance determines when the user begins the move selection operation.
    
    Returns:
    
    The "pressed" recognizer specifically for touch events.
    
    See Also:
    
    setPressedRecognizerTouch(IEventRecognizer)
  - getPriority
```
public final int getPriority()
```
    Description copied from interface: IInputMode
    
    The priority of this input mode.
    The priority will influence the order in which the modes will be installed into the canvas control. The lower the priority value, the earlier it will be installed. If two modes are installed using the same priority value, the first one will be installed earlier.
    
    Specified by:
    
    getPriority in interface IInputMode
    
    Returns:
    
    The Priority.
  - getReleasedRecognizer
```
public final IEventRecognizer getReleasedRecognizer()
```
    Gets the "released" recognizer.
    This instance determines when the user has finished the move.
    
    Returns:
    
    The "released" recognizer.
    
    See Also:
    
    setReleasedRecognizer(IEventRecognizer)
  - getReleasedRecognizerTouch
```
public final IEventRecognizer getReleasedRecognizerTouch()
```
    Gets the "released" recognizer for touch events.
    This instance determines when the user has finished the move using touch.
    
    Returns:
    
    The "released" recognizer specifically for touch events.
    
    See Also:
    
    setReleasedRecognizerTouch(IEventRecognizer)
  - getSnapContext
```
public final SnapContext getSnapContext()
```
    The SnapContext which manages snapping model items to certain coordinates (for instance, other items).
    If set to null (the default) this input mode tries to obtain the SnapContext from the IInputModeContext. To explicitly disable snapping, a SnapContext implementation that does nothing has to be set to this instance.
    
    Returns:
    
    The SnapContext.
    
    See Also:
    
    setSnapContext(SnapContext)
  - install
```
public void install(IInputModeContext context,
                    ConcurrencyController controller)
```
    Installs this mode into the given context that is provided by the canvas.
    In general a mode can only be installed into a single canvas at all times.
    
    This method is called to initialize this instance. Subclasses should override this method to register the corresponding event handler delegates for the various input events they need to register with.
    
    Overriding implementations should call the base implementation, first.
    
    Specified by:
    
    install in interface IInputMode
    
    Parameters:
    
    context - The context that this instance shall be installed into. The same instance will be passed to this instance during IInputMode.uninstall(IInputModeContext). A reference to the context may be kept and queried during the time the mode is installed.
    
    controller - The Controller for this mode.
    
    See Also:
    
    IInputMode.uninstall(IInputModeContext)
  - isDragging
```
public final boolean isDragging()
```
    Gets a value indicating whether a drag operation is currently in progress.
    
    Returns:
    
    The IsDragging.
  - isEnabled
```
public boolean isEnabled()
```
    Gets the enabled state of this input mode.
    Clients can use this property to disable or reenable this instance. This will set the Enabled property of the installed Controller so a disabled instance should never try to acquire the input mutex.
    
    Returns:
    
    The Enabled.
    
    See Also:
    
    setEnabled(boolean)
  - isExclusive
```
public final boolean isExclusive()
```
    Gets a value indicating whether this mode will be the only one running when it has the mutex.
    The value of this property will be delegated to the Exclusive property of the Controller.
    
    If this mode is marked as exclusive and has the mutex, all other modes added to the same MultiplexingInputMode will be deactivated. Otherwise it will always run concurrently with all other modes.
    
    Returns:
    
    The Exclusive.
    
    See Also:
    
    setExclusive(boolean)
  - isValidStartLocation
```
protected boolean isValidStartLocation(PointD location)
```
    Determines whether the given location is a valid start location for the move gesture.
    This implementation delegates to the HitTestable. During this callback it is possible to reset or reconfigure the PositionHandler.
    
    Parameters:
    
    location - The location in the world coordinate system.
    
    Returns:
    
    true if at the given location it is valid to start the move gesture; otherwise, false.
  - onCanceled
```
protected void onCanceled()
```
    Called after cancel() has been called.
    Can be overridden in subclasses to perform additional actions after the mode has been canceled.
    
    This implementation does nothing.
  - onConcurrencyControllerActivated
```
protected void onConcurrencyControllerActivated()
```
    Called after the Active property of the installed ConcurrencyController has been set to true.
    Can be overridden in subclasses to perform additional actions after the mode has been activated.
    
    Overriding implementations should call the base implementation.
  - onConcurrencyControllerDeactivated
```
protected void onConcurrencyControllerDeactivated()
```
    Called after the Active property of the installed ConcurrencyController has been set to false.
    Can be overridden in subclasses to perform additional actions after the mode has been deactivated.
    
    Overriding implementations should call the base implementation.
  - onDragCanceled
```
protected void onDragCanceled(InputModeEventArgs inputModeEventArgs)
```
    Triggers the DragCanceled event.
    
    Parameters:
    
    inputModeEventArgs - The event argument that contains context information.
  - onDragCanceling
```
protected void onDragCanceling(InputModeEventArgs inputModeEventArgs)
```
    Triggers the DragCanceling event.
    
    Parameters:
    
    inputModeEventArgs - The event argument that contains context information.
  - onDragFinished
```
protected void onDragFinished(InputModeEventArgs inputModeEventArgs)
```
    Callback triggered once the drag has been finalized.
    This method triggers the DragFinished event.
    
    Parameters:
    
    inputModeEventArgs - The event argument that contains context information.
  - onDragFinishing
```
protected void onDragFinishing(InputModeEventArgs inputModeEventArgs)
```
    Callback triggered before the drag will be finalized.
    This method triggers the DragFinishing event.
    
    Parameters:
    
    inputModeEventArgs - The event argument that contains context information.
  - onDragged
```
protected void onDragged(InputModeEventArgs inputModeEventArgs)
```
    Callback triggered at the end of each drag.
    This method triggers the Dragged event.
    
    Parameters:
    
    inputModeEventArgs - The event argument that contains context information.
  - onDragging
```
protected void onDragging(InputModeEventArgs inputModeEventArgs)
```
    Callback triggered at the start of each drag.
    This method triggers the Dragging event.
    
    Parameters:
    
    inputModeEventArgs - The event argument that contains context information.
  - onDragStarted
```
protected void onDragStarted(InputModeEventArgs inputModeEventArgs)
```
    Triggers the DragStarted event.
    
    Parameters:
    
    inputModeEventArgs - The event argument that contains context information.
  - onDragStarting
```
protected void onDragStarting(InputModeEventArgs inputModeEventArgs)
```
    Triggers the DragStarting event.
    
    Parameters:
    
    inputModeEventArgs - The event argument that contains context information.
  - onQueryPositionHandler
```
protected void onQueryPositionHandler(QueryPositionHandlerEventArgs args)
```
    Raises the QueryPositionHandler event.
    
    Parameters:
    
    args - The QueryPositionHandlerEventArgs instance containing the event data.
  - onStopped
```
protected void onStopped()
```
    Called after stop() has been called.
    Can be overridden in subclasses to perform additional actions after the mode has been stopped.
    
    This implementation does nothing.
  - removeDragCanceledListener
```
public final void removeDragCanceledListener(IEventHandler<InputModeEventArgs> dragCanceledEvent)
```
    Removes the given listener for the DragCanceled event that occurs when the drag has been canceled.
    
    Parameters:
    
    dragCanceledEvent - The listener to remove.
    
    See Also:
    
    addDragCanceledListener(IEventHandler)
  - removeDragCancelingListener
```
public final void removeDragCancelingListener(IEventHandler<InputModeEventArgs> dragCancelingEvent)
```
    Removes the given listener for the DragCanceling event that occurs before the drag will be canceled.
    
    Parameters:
    
    dragCancelingEvent - The listener to remove.
    
    See Also:
    
    addDragCancelingListener(IEventHandler)
  - removeDragFinishedListener
```
public final void removeDragFinishedListener(IEventHandler<InputModeEventArgs> dragFinishedEvent)
```
    Removes the given listener for the DragFinished event that occurs once the drag has been finished.
    
    Parameters:
    
    dragFinishedEvent - The listener to remove.
    
    See Also:
    
    addDragFinishedListener(IEventHandler)
  - removeDragFinishingListener
```
public final void removeDragFinishingListener(IEventHandler<InputModeEventArgs> dragFinishingEvent)
```
    Removes the given listener for the DragFinishing event that occurs before the drag will be finished.
    
    Parameters:
    
    dragFinishingEvent - The listener to remove.
    
    See Also:
    
    addDragFinishingListener(IEventHandler)
  - removeDraggedListener
```
public final void removeDraggedListener(IEventHandler<InputModeEventArgs> draggedEvent)
```
    Removes the given listener for the Dragged event that occurs at the end of every drag.
    
    Parameters:
    
    draggedEvent - The listener to remove.
    
    See Also:
    
    addDraggedListener(IEventHandler)
  - removeDraggingListener
```
public final void removeDraggingListener(IEventHandler<InputModeEventArgs> draggingEvent)
```
    Removes the given listener for the Dragging event that occurs at the start of every drag.
    
    Parameters:
    
    draggingEvent - The listener to remove.
    
    See Also:
    
    addDraggingListener(IEventHandler)
  - removeDragStartedListener
```
public final void removeDragStartedListener(IEventHandler<InputModeEventArgs> dragStartedEvent)
```
    Removes the given listener for the DragStarted event that occurs once the drag is initialized and has started.
    
    Parameters:
    
    dragStartedEvent - The listener to remove.
    
    See Also:
    
    addDragStartedListener(IEventHandler)
  - removeDragStartingListener
```
public final void removeDragStartingListener(IEventHandler<InputModeEventArgs> dragStartingEvent)
```
    Removes the given listener for the DragStarting event that occurs once the drag is starting.
    
    Parameters:
    
    dragStartingEvent - The listener to remove.
    
    See Also:
    
    addDragStartingListener(IEventHandler)
  - removeQueryPositionHandlerListener
```
public final void removeQueryPositionHandlerListener(IEventHandler<QueryPositionHandlerEventArgs> queryPositionHandlerEvent)
```
    Removes the given listener for the QueryPositionHandler event that occurs when a drag is recognized for the MoveInputMode.
    If the event args are Handled, the IPositionHandler that is carried with the event args is used to actually move the items. Otherwise the pre-set PositionHandler property is used.
    
    Parameters:
    
    queryPositionHandlerEvent - The listener to remove.
    
    See Also:
    
    addQueryPositionHandlerListener(IEventHandler)
  - setCancelRecognizer
```
public final void setCancelRecognizer(IEventRecognizer value)
```
    Sets the "cancel" recognizer.
    This recognizer recognizes a cancel action during the move.
    
    Parameters:
    
    value - The "cancel" recognizer.
    
    See Also:
    
    getCancelRecognizer()
  - setDisableSnappingRecognizer
```
public final void setDisableSnappingRecognizer(IEventRecognizer value)
```
    Sets event recognizer that recognizes when the user temporarily disables snapping.
    
    Parameters:
    
    value - The instance to use for disabling snapping. The default is IEventRecognizer.SHORTCUT_DOWN
    
    See Also:
    
    getEnableSnappingRecognizer(), getDisableSnappingRecognizer()
  - setDraggedRecognizer
```
public final void setDraggedRecognizer(IEventRecognizer value)
```
    Sets the "dragged" recognizer.
    This recognizer instance determines when the user is moving the selection
    
    Parameters:
    
    value - The "dragged" recognizer.
    
    See Also:
    
    getDraggedRecognizer()
  - setDraggedRecognizerTouch
```
public final void setDraggedRecognizerTouch(IEventRecognizer value)
```
    Sets the "dragged" recognizer for touch events.
    This recognizer instance determines when the user is moving the selection
    
    Parameters:
    
    value - The "dragged" recognizer specifically for touch events.
    
    See Also:
    
    getDraggedRecognizerTouch()
  - setEnabled
```
public void setEnabled(boolean value)
```
    Sets the enabled state of this input mode.
    Clients can use this property to disable or reenable this instance. This will set the Enabled property of the installed Controller so a disabled instance should never try to acquire the input mutex.
    
    Parameters:
    
    value - The Enabled to set.
    
    See Also:
    
    isEnabled()
  - setEnableSnappingRecognizer
```
public final void setEnableSnappingRecognizer(IEventRecognizer value)
```
    Sets event recognizer that recognizes when the user reenables temporarily disabled snapping.
    
    Parameters:
    
    value - The instance to use for reenabling snapping. The default is IEventRecognizer.SHORTCUT_UP
    
    See Also:
    
    getEnableSnappingRecognizer()
  - setExclusive
```
public final void setExclusive(boolean value)
```
    Sets a value indicating whether this mode will be the only one running when it has the mutex.
    The value of this property will be delegated to the Exclusive property of the Controller.
    
    If this mode is marked as exclusive and has the mutex, all other modes added to the same MultiplexingInputMode will be deactivated. Otherwise it will always run concurrently with all other modes.
    
    Parameters:
    
    value - The Exclusive to set.
    
    See Also:
    
    isExclusive()
  - setHitTestable
```
public final void setHitTestable(IHitTestable value)
```
    Sets the IHitTestable that will be used by this mode to determine where the user may start dragging.
    
    Parameters:
    
    value - The HitTestable to set.
    
    See Also:
    
    getHitTestable()
  - setHoverRecognizer
```
public final void setHoverRecognizer(IEventRecognizer value)
```
    Sets the "hovering" state recognizer.
    This recognizer instance will be used to determine whether the user is hovering over an item where pressing can initialize a move operation. The default implementation uses the isValidStartLocation(PointD) method to determine whether the mode can be initialized, here.
    
    Parameters:
    
    value - The "hover" recognizer.
    
    See Also:
    
    getHoverRecognizer()
  - setMoveCursor
```
public final void setMoveCursor(Cursor value)
```
    Sets the cursor to use during the move.
    
    Parameters:
    
    value - The MoveCursor to set.
    
    See Also:
    
    getMoveCursor()
  - setPositionHandler
```
public final void setPositionHandler(IPositionHandler value)
```
    Sets the IPositionHandler that will be used as fallback to handle that actual movement of the elements during the drag.
    Note that the IPositionHandler retrieved by the QueryPositionHandler event has priority before this property. Only if the event is not Handled this property is used.
    
    Parameters:
    
    value - The PositionHandler to set.
    
    See Also:
    
    getPositionHandler()
  - setPressedRecognizer
```
public final void setPressedRecognizer(IEventRecognizer value)
```
    Sets the "pressed" state recognizer.
    This recognizer instance will be used to determine when the user begins to move the selection.
    
    Parameters:
    
    value - The "pressed" recognizer.
    
    See Also:
    
    getPressedRecognizer()
  - setPressedRecognizerTouch
```
public final void setPressedRecognizerTouch(IEventRecognizer value)
```
    Sets the "pressed" recognizer for touch events.
    This recognizer instance determines when the user begins the move selection operation.
    
    Parameters:
    
    value - The "pressed" recognizer specifically for touch events.
    
    See Also:
    
    getPressedRecognizerTouch()
  - setPriority
```
public final void setPriority(int value)
```
    The priority of this input mode.
    The priority will influence the order in which the modes will be installed into the canvas control. The lower the priority value, the earlier it will be installed. If two modes are installed using the same priority value, the first one will be installed earlier.
    
    Parameters:
    
    value - The Priority to set.
    
    See Also:
    
    getPriority()
  - setReleasedRecognizer
```
public final void setReleasedRecognizer(IEventRecognizer value)
```
    Sets the "released" recognizer.
    This instance determines when the user has finished the move.
    
    Parameters:
    
    value - The "released" recognizer.
    
    See Also:
    
    getReleasedRecognizer()
  - setReleasedRecognizerTouch
```
public final void setReleasedRecognizerTouch(IEventRecognizer value)
```
    Sets the "released" recognizer for touch events.
    This instance determines when the user has finished the move using touch.
    
    Parameters:
    
    value - The "released" recognizer specifically for touch events.
    
    See Also:
    
    getReleasedRecognizerTouch()
  - setSnapContext
```
public final void setSnapContext(SnapContext value)
```
    The SnapContext which manages snapping model items to certain coordinates (for instance, other items).
    If set to null (the default) this input mode tries to obtain the SnapContext from the IInputModeContext. To explicitly disable snapping, a SnapContext implementation that does nothing has to be set to this instance.
    
    Parameters:
    
    value - The SnapContext to set.
    
    See Also:
    
    getSnapContext()
  - stop
```
public boolean stop()
```
    Description copied from interface: IInputMode
    
    Called by the client in order to stop a current editing progress.
    This should stop the current edit, if one is in progress and possibly commit all of the changes. If stopping is not possible, this method can return false
    
    Specified by:
    
    stop in interface IInputMode
    
    Returns:
    
    true if and only if the editing has been stopped or there was no edit in progress
    
    See Also:
    
    IInputMode.cancel()
  - uninstall
```
public void uninstall(IInputModeContext context)
```
    Uninstalls this mode from the given context.
    This code should clean up all changes made to the canvas in the IInputMode.install(IInputModeContext, ConcurrencyController) method. After a mode has been uninstalled it can be installed again into the same or another canvas.
    
    Overriding implementations should call the base implementation after their own code.
    
    Specified by:
    
    uninstall in interface IInputMode
    
    Parameters:
    
    context - The context to deregister from. This is the same instance that had been passed to IInputMode.install(IInputModeContext, ConcurrencyController) during installation.

Class MoveInputMode

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MoveInputMode

Method Detail

addDragCanceledListener

addDragCancelingListener

addDragFinishedListener

addDragFinishingListener

addDraggedListener

addDraggingListener

addDragStartedListener

addDragStartingListener

addQueryPositionHandlerListener

arm

cancel

createPositionHandlerInputModeContext

disarm

doStartDrag

getAffectedItems

getCancelRecognizer

getController

getDisableSnappingRecognizer

getDraggedRecognizer

getDraggedRecognizerTouch

getEnableSnappingRecognizer

getHitTestable

getHoverRecognizer

getInitialLocation

getInputModeContext

getMoveCursor

getPositionHandler

getPressedRecognizer

getPressedRecognizerTouch

getPriority

getReleasedRecognizer

getReleasedRecognizerTouch

getSnapContext

install

isDragging

isEnabled

isExclusive

isValidStartLocation

onCanceled

onConcurrencyControllerActivated

onConcurrencyControllerDeactivated

onDragCanceled

onDragCanceling

onDragFinished

onDragFinishing

onDragged

onDragging

onDragStarted

onDragStarting

onQueryPositionHandler

onStopped

removeDragCanceledListener

removeDragCancelingListener

removeDragFinishedListener

removeDragFinishingListener

removeDraggedListener

removeDraggingListener

removeDragStartedListener

removeDragStartingListener

removeQueryPositionHandlerListener

setCancelRecognizer

setDisableSnappingRecognizer

setDraggedRecognizer

setDraggedRecognizerTouch

setEnabled

setEnableSnappingRecognizer

setExclusive

setHitTestable

setHoverRecognizer

setMoveCursor

setPositionHandler

setPressedRecognizer

setPressedRecognizerTouch