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

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

All Implemented Interfaces:

IInputMode
```
public abstract class AbstractInputMode
extends Object
implements IInputMode
```
Abstract base class implementation of an IInputMode that can be used concurrently with other IInputMode implementations if its Exclusive property is true.
This class adds convenience methods for derived classes.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`AbstractInputMode()` Initializes a new instance of the `AbstractInputMode` class that is `Exclusive` by default.
`protected`	`AbstractInputMode(boolean exclusive)` Initializes a new instance of the `AbstractInputMode` class.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addCanceledListener(IEventHandler<InputModeEventArgs> canceledEvent)` Adds the given listener for the `Canceled` event that occurs after the call to `cancel()`.
`void`	`addInitializedListener(IEventHandler<InputModeEventArgs> initializedEvent)` Adds the given listener for the `Initialized` event that occurs after the call to `initialize()`.
`void`	`addInitializingListener(IEventHandler<InputModeEventArgs> initializingEvent)` Adds the given listener for the `Initializing` event that occurs before the call to `initialize()`.
`void`	`addStoppedListener(IEventHandler<InputModeEventArgs> stoppedEvent)` Adds the given listener for the `Stopped` event that occurs after the call to `stop()`.
`void`	`cancel()` Cancels the editing of this mode by first disabling and afterwards reenabling the installed `Controller`.
`protected boolean`	`canRequestMutex()` Determines whether this instance can request the mutex.
`protected IInputModeContext`	`createChildInputModeContext()` Creates an implementation of `IInputModeContext` that is specific to this mode.
`protected InputModeEventArgs`	`createInputModeEventArgs(IInputModeContext context)` Helper method that yields a suitably configured `InputModeEventArgs` for this input mode.
`protected ConcurrencyController`	`getController()` Returns the installed `Controller`.
`IInputModeContext`	`getInputModeContext()` Returns the context instance this mode is currently installed in or `null` if this instance is not installed.
`int`	`getPriority()` The priority of this input mode.
`protected boolean`	`hasMutex()` Determines whether this instance owns the input mutex.
`protected void`	`initialize()` Performs one-time initialization of this instance.
`void`	`install(IInputModeContext context, ConcurrencyController controller)` Installs this mode into a `CanvasControl` using the provided `IInputModeContext`.
`boolean`	`isActive()` Returns if this mode is active.
`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.
`boolean`	`isInstalled()` Returns whether this mode is currently installed so a call to `Canvas` will yield a non-`null` result.
`protected void`	`onCanceled(InputModeEventArgs eventArgs)` Event dispatch method that will dispatch the `Canceled` event.
`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`	`onInitialized(InputModeEventArgs eventArgs)` Event dispatch method that will dispatch the `Initialized` event.
`protected void`	`onInitializing(InputModeEventArgs eventArgs)` Event dispatch method that will dispatch the `Initializing` event.
`protected void`	`onMutexObtained()` Called when this instance obtains the mutex.
`protected void`	`onMutexReleased()` Called when this instance released the mutex.
`protected void`	`onStopped(InputModeEventArgs eventArgs)` Event dispatch method that will dispatch the `Stopped` event.
`protected void`	`releaseKeyboard()` Releases previously captured keyboard input.
`protected void`	`releaseMutex()` Releases the mutex that is currently owned by this instance.
`protected void`	`releasePointer()` Releases previously captured mouse and touch input.
`void`	`removeCanceledListener(IEventHandler<InputModeEventArgs> canceledEvent)` Removes the given listener for the `Canceled` event that occurs after the call to `cancel()`.
`void`	`removeInitializedListener(IEventHandler<InputModeEventArgs> initializedEvent)` Removes the given listener for the `Initialized` event that occurs after the call to `initialize()`.
`void`	`removeInitializingListener(IEventHandler<InputModeEventArgs> initializingEvent)` Removes the given listener for the `Initializing` event that occurs before the call to `initialize()`.
`void`	`removeStoppedListener(IEventHandler<InputModeEventArgs> stoppedEvent)` Removes the given listener for the `Stopped` event that occurs after the call to `stop()`.
`protected void`	`requestKeyboard()` Requests capturing of all keyboard input that happens in the `CanvasControl`.
`protected void`	`requestMutex()` Requests the mutex from the current `Controller`.
`protected void`	`requestPointer()` Requests capturing of all mouse and touch input that happens in the `CanvasControl`.
`void`	`setEnabled(boolean value)` Sets the enabled state of this input mode.
`void`	`setExclusive(boolean value)` Sets a value indicating whether this mode will be the only one running when it has the mutex.
`void`	`setPriority(int value)` The priority of this input mode.
`boolean`	`stop()` Tries to stop the editing.
`void`	`uninstall(IInputModeContext context)` Uninstalls this mode from the canvas.

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

- Constructor Detail
  - AbstractInputMode
```
protected AbstractInputMode()
```
    Initializes a new instance of the AbstractInputMode class that is Exclusive by default.
  - AbstractInputMode
```
protected AbstractInputMode(boolean exclusive)
```
    Initializes a new instance of the AbstractInputMode class.
    
    Parameters:
    
    exclusive - Iff this mode should be Exclusive.
- Method Detail
  - addCanceledListener
```
public final void addCanceledListener(IEventHandler<InputModeEventArgs> canceledEvent)
```
    Adds the given listener for the Canceled event that occurs after the call to cancel().
    Clients can use this event to perform post cleanup steps of the instance shortly after the mode has been canceled.
    
    Parameters:
    
    canceledEvent - The listener to add.
    
    See Also:
    
    onCanceled(InputModeEventArgs), cancel(), stop(), addStoppedListener(IEventHandler), removeCanceledListener(IEventHandler)
  - addInitializedListener
```
public final void addInitializedListener(IEventHandler<InputModeEventArgs> initializedEvent)
```
    Adds the given listener for the Initialized event that occurs after the call to initialize().
    Clients can use this event to perform post configuration steps of the instance shortly after the initialization has been performed.
    
    Parameters:
    
    initializedEvent - The listener to add.
    
    See Also:
    
    install(IInputModeContext, ConcurrencyController), removeInitializedListener(IEventHandler)
  - addInitializingListener
```
public final void addInitializingListener(IEventHandler<InputModeEventArgs> initializingEvent)
```
    Adds the given listener for the Initializing event that occurs before the call to initialize().
    Clients can use this event to perform configuration of the instance shortly before the initialization begins.
    
    Parameters:
    
    initializingEvent - The listener to add.
    
    See Also:
    
    install(IInputModeContext, ConcurrencyController), removeInitializingListener(IEventHandler)
  - addStoppedListener
```
public final void addStoppedListener(IEventHandler<InputModeEventArgs> stoppedEvent)
```
    Adds the given listener for the Stopped event that occurs after the call to stop().
    Clients can use this event to perform post cleanup steps of the instance shortly after the mode has been stopped.
    
    Parameters:
    
    stoppedEvent - The listener to add.
    
    See Also:
    
    onStopped(InputModeEventArgs), cancel(), stop(), addCanceledListener(IEventHandler), removeStoppedListener(IEventHandler)
  - cancel
```
public void cancel()
```
    Cancels the editing of this mode by first disabling and afterwards reenabling the installed Controller.
    This implementation disables and reenables the Controller and fires the onCanceled(InputModeEventArgs) event afterwards. Classes that need to perform clean-up should override the onConcurrencyControllerDeactivated() method and invoke base.OnConcurrencyControllerDeactivated as the last statement.
    
    Specified by:
    
    cancel in interface IInputMode
    
    See Also:
    
    onCanceled(InputModeEventArgs), addCanceledListener(IEventHandler)
  - canRequestMutex
```
protected final boolean canRequestMutex()
```
    Determines whether this instance can request the mutex.
    This will return true, iff a Controller has been injected and the helper allows requesting the mutex.
    
    Returns:
    
    Whether a call to requestMutex() would currently succeed.
  - createChildInputModeContext
```
protected IInputModeContext createChildInputModeContext()
```
    Creates an implementation of IInputModeContext that is specific to this mode.
    This is needed for events that are triggered by this InputMode to signalize where the event is coming from. A common usage for this is for example in IHitTestable.isHit(IInputModeContext, com.yworks.yfiles.geometry.PointD) calls.
    
    The result can be given to IHitTestable.isHit(IInputModeContext, com.yworks.yfiles.geometry.PointD) or CanvasControl.hitElementsAt(IInputModeContext, com.yworks.yfiles.geometry.PointD, com.yworks.yfiles.view.ICanvasObjectGroup, java.util.function.Predicate) to let implementations of IHitTestable get access to the current IInputModeContext. This can be done by looking up IInputModeContext from the ICanvasContext's ILookup.lookup(Class) method or simply downcasting.
    
    Returns:
    
    A readily configured IInputModeContext.
    
    See Also:
    
    CanvasControl.hitElementsAt(IInputModeContext, com.yworks.yfiles.geometry.PointD, com.yworks.yfiles.view.ICanvasObjectGroup, java.util.function.Predicate), IHitTestable.isHit(IInputModeContext, com.yworks.yfiles.geometry.PointD), IInputModeContext
  - createInputModeEventArgs
```
protected InputModeEventArgs createInputModeEventArgs(IInputModeContext context)
```
    Helper method that yields a suitably configured InputModeEventArgs for this input mode.
    
    Parameters:
    
    context - An input mode context that is available in the InputModeEventArgs.
    Can be null in which case a new context for this instance is created automatically.
    
    Returns:
    
    An input mode event argument that is configured for this instance.
  - getController
```
protected final ConcurrencyController getController()
```
    Returns the installed Controller.
    
    Returns:
    
    The Controller.
    
    See Also:
    
    requestMutex(), releaseMutex(), hasMutex(), canRequestMutex()
  - getInputModeContext
```
public final IInputModeContext getInputModeContext()
```
    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. One such instance can be obtained through helper method createChildInputModeContext().
    
    Specified by:
    
    getInputModeContext in interface IInputMode
    
    Returns:
    
    The InputModeContext.
  - 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.
  - hasMutex
```
protected final boolean hasMutex()
```
    Determines whether this instance owns the input mutex.
    If no Controller had been associated with this instance upon the call to requestMutex() this method will return false.
    
    Returns:
    
    Whether this instance has the input mutex.
  - initialize
```
protected void initialize()
```
    Performs one-time initialization of this instance.
    This method should not be invoked by subclasses. This will be done automatically upon first installation of this mode.
    
    This code will be executed only once per instance. The Canvas property and InputModeContext property will be null when this code is executed. This method should not be used to install this mode into a specific canvas. Subclasses should always call base.Initialize() first.
    
    See Also:
    
    install(IInputModeContext, ConcurrencyController)
  - install
```
public void install(IInputModeContext context,
                    ConcurrencyController controller)
```
    Installs this mode into a CanvasControl using the provided IInputModeContext.
    Subclasses should override this method and callbase.Install(context), first. One-time initialization should be performed in the initialize() method. This implementation will call the initialize() method the first time this mode gets installed. The initialization will be surrounded by calls to onInitializing(InputModeEventArgs) and onInitialized(InputModeEventArgs) to trigger the corresponding events.
    
    Specified by:
    
    install in interface IInputMode
    
    Parameters:
    
    context - the context to install this mode into
    
    controller - The Controller for this mode.
    
    See Also:
    
    getCanvas(), getInputModeContext(), CanvasControl.getInputMode()
  - isActive
```
public final boolean isActive()
```
    Returns if this mode is active.
    This mode is active if a Controller is installed and is Active.
    
    Returns:
    
    The Active.
  - 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)
  - isInstalled
```
public final boolean isInstalled()
```
    Returns whether this mode is currently installed so a call to Canvas will yield a non-null result.
    
    Returns:
    
    The Installed.
    
    See Also:
    
    install(IInputModeContext, ConcurrencyController)
  - onCanceled
```
protected void onCanceled(InputModeEventArgs eventArgs)
```
    Event dispatch method that will dispatch the Canceled event.
    This method is called by subclasses when the editing process has been cancel()ed.
    
    Parameters:
    
    eventArgs - The event arguments.
    
    See Also:
    
    initialize()
  - 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.
  - onInitialized
```
protected void onInitialized(InputModeEventArgs eventArgs)
```
    Event dispatch method that will dispatch the Initialized event.
    This method will be called by install(IInputModeContext, ConcurrencyController) for the first installation directly after initialize() has returned.
    
    Parameters:
    
    eventArgs - The event arguments.
    
    See Also:
    
    initialize()
  - onInitializing
```
protected void onInitializing(InputModeEventArgs eventArgs)
```
    Event dispatch method that will dispatch the Initializing event.
    This method will be called by install(IInputModeContext, ConcurrencyController) for the first installation directly before initialize() is invoked.
    
    Parameters:
    
    eventArgs - The event arguments.
    
    See Also:
    
    initialize()
  - onMutexObtained
```
protected void onMutexObtained()
```
    Called when this instance obtains the mutex.
    If no Controller had been associated with this instance upon the call to requestMutex() this method will not be called.
  - onMutexReleased
```
protected void onMutexReleased()
```
    Called when this instance released the mutex.
    If no Controller had been associated with this instance upon the call to requestMutex() this method will not be called.
  - onStopped
```
protected void onStopped(InputModeEventArgs eventArgs)
```
    Event dispatch method that will dispatch the Stopped event.
    This method will be called by stop() or can be called by subclasses during a stop() operation.
    
    Parameters:
    
    eventArgs - The event arguments.
    
    See Also:
    
    stop(), addStoppedListener(IEventHandler)
  - releaseKeyboard
```
protected void releaseKeyboard()
```
    Releases previously captured keyboard input.
  - releaseMutex
```
protected final void releaseMutex()
```
    Releases the mutex that is currently owned by this instance.
    This will trigger the onMutexReleased() method if this instance previously owned the mutex.
  - releasePointer
```
protected void releasePointer()
```
    Releases previously captured mouse and touch input.
  - removeCanceledListener
```
public final void removeCanceledListener(IEventHandler<InputModeEventArgs> canceledEvent)
```
    Removes the given listener for the Canceled event that occurs after the call to cancel().
    Clients can use this event to perform post cleanup steps of the instance shortly after the mode has been canceled.
    
    Parameters:
    
    canceledEvent - The listener to remove.
    
    See Also:
    
    onCanceled(InputModeEventArgs), cancel(), stop(), addStoppedListener(IEventHandler), addCanceledListener(IEventHandler)
  - removeInitializedListener
```
public final void removeInitializedListener(IEventHandler<InputModeEventArgs> initializedEvent)
```
    Removes the given listener for the Initialized event that occurs after the call to initialize().
    Clients can use this event to perform post configuration steps of the instance shortly after the initialization has been performed.
    
    Parameters:
    
    initializedEvent - The listener to remove.
    
    See Also:
    
    install(IInputModeContext, ConcurrencyController), addInitializedListener(IEventHandler)
  - removeInitializingListener
```
public final void removeInitializingListener(IEventHandler<InputModeEventArgs> initializingEvent)
```
    Removes the given listener for the Initializing event that occurs before the call to initialize().
    Clients can use this event to perform configuration of the instance shortly before the initialization begins.
    
    Parameters:
    
    initializingEvent - The listener to remove.
    
    See Also:
    
    install(IInputModeContext, ConcurrencyController), addInitializingListener(IEventHandler)
  - removeStoppedListener
```
public final void removeStoppedListener(IEventHandler<InputModeEventArgs> stoppedEvent)
```
    Removes the given listener for the Stopped event that occurs after the call to stop().
    Clients can use this event to perform post cleanup steps of the instance shortly after the mode has been stopped.
    
    Parameters:
    
    stoppedEvent - The listener to remove.
    
    See Also:
    
    onStopped(InputModeEventArgs), cancel(), stop(), addCanceledListener(IEventHandler), addStoppedListener(IEventHandler)
  - requestKeyboard
```
protected void requestKeyboard()
```
    Requests capturing of all keyboard input that happens in the CanvasControl.
    This sets the AllKeyboardInputCapturingEnabled property to true, which will prevent visuals inside the canvas from stealing key strokes.
    
    See Also:
    
    releaseKeyboard()
  - requestMutex
```
protected final void requestMutex()
```
    Requests the mutex from the current Controller.
    This implementation will call the onMutexObtained() method if the mutex has been successfully obtained. If the mutex cannot be obtained this method will trigger an exception.
    
    Throws:
    
    RuntimeException - If the mutex could not be obtained.
  - requestPointer
```
protected void requestPointer()
```
    Requests capturing of all mouse and touch input that happens in the CanvasControl.
    This sets the AllPointerInputCapturingEnabled property to true, which will prevent visuals inside the canvas from stealing mouse input.
    
    See Also:
    
    releasePointer()
  - 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()
  - 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()
  - 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()
  - stop
```
public boolean stop()
```
    Tries to stop the editing.
    This implementation returns if this instance does not currently have the input mutex.
    
    This implementation calls onStopped(InputModeEventArgs). Subclasses that want to prevent a stop or need to do special clean up should do this here if the base class implementation of stop() returns true. A typical implementation should follow this idiom if it wants to stop:
    
    and if it doesn't want to stop simply return false immediately.
    
    Calling this method raises the Stopped event.
    
    Specified by:
    
    stop in interface IInputMode
    
    Returns:
    
    true iff this instance does not own the mutex.
    
    See Also:
    
    onStopped(InputModeEventArgs)
  - uninstall
```
public void uninstall(IInputModeContext context)
```
    Uninstalls this mode from the canvas.
    Subclasses should always call base.Uninstall(context) as the last statement.
    
    Specified by:
    
    uninstall in interface IInputMode
    
    Parameters:
    
    context - The context to remove this mode from. This is the same instance that has been passed to install(IInputModeContext, ConcurrencyController).

Class AbstractInputMode

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AbstractInputMode

AbstractInputMode

Method Detail

addCanceledListener

addInitializedListener

addInitializingListener

addStoppedListener

cancel

canRequestMutex

createChildInputModeContext

createInputModeEventArgs

getController

getInputModeContext

getPriority

hasMutex

initialize

install

isActive

isEnabled

isExclusive

isInstalled

onCanceled

onConcurrencyControllerActivated

onConcurrencyControllerDeactivated

onInitialized

onInitializing

onMutexObtained

onMutexReleased

onStopped

releaseKeyboard

releaseMutex

releasePointer

removeCanceledListener

removeInitializedListener

removeInitializingListener

removeStoppedListener

requestKeyboard

requestMutex

requestPointer

setEnabled

setExclusive

setPriority

stop

uninstall