The graph canvas this input mode is installed into.

The context this input mode is installed into.

Used by clients to provide this instance with a ConcurrencyController.

Note that implementations may not depend on this property being set. The controller can be used to acquire and release an input mutex.

The ICanvasObject which is currently hovered over.

May be null if no object is hovered over.

Whether the input mode is enabled.

The default value is true.

The duration of the animation that is triggered when the mouse leaves a node.

The function that determines the interpolation between 0 and 1 for the animation that is triggered when the mouse leaves a node.

The duration of the animation that is triggered when the mouse enters a node.

The function that determines the interpolation between 0 and 1 for the animation that is triggered when the mouse enters a node.

The Sprite to draw the effect node on.

The Sprite is created by createOverlaySprite()

May be null if no effect is displayed.

Returns the cursor this mode would like to have displayed in the

To indicate that this mode does not have any preferences implementations should return null.

Wether to use the overlay as the node's hit area or to query the nodeStyles IBoundsProvider for the node bounds to determine whether the mouse is still hovering over the node.

Called by the client to unconditionally cancel all editing. This will be called prior to the uninstalling of this instance. In order to stop an active input mode manually, client code should use the following idiom:

	     if ( !mode.stop() ){
	       mode.cancel();
	     }
	     

Creates a new IDisplayObjectContext instance which is used by drawNodeStyle as context to render the node.

This context can be used by the node style renderer to draw the effect node differently.

Create an object that implements the animation effect triggered when the mouse leaves a node.

If this method is not overridden, it returns a listener that does nothing except hiding the overlay when the animation has ended.

Parameters

Create an object that implements the animation effect triggered when the mouse is moved over a node.

If this method is not overridden, it returns a listener that does nothing.

Parameters

Create the sprite that will be used to draw the hover effect.

This implementation creates a simple sprite and configures it to catch the mouse down events (and call overlayMouseDown()). Subclasses which do further configuration may create the sprite by calling this implementation (var sprite:Sprite = super.createOverlaySprite();).

Let the node.style draw itself on the current overlay.

Parameters

Draw the visual representation of the node during a hover effect. The normal appearance of the node can conveniently be drawn on the overlay using drawNodeStyle( INode ).

This method should also take care of the correct positioning of the overlay sprite.

Parameters

End the hovering.

Called when the mouse isn't hovering over the node anymore.

This implementation creates a new Tween with a listener created by createMouseOutTweenListener() and an easing function defined by mouseOutTweenEasingFunction. It also releases the mutex.

Find a canvas object that is hit at the given mouse hover coordinates.

This implementation detects canvas objects for nodes. Custom implementations may verify for other model items.

Parameters

Installs this mode into the given canvas.

Installation ususally means registering some event listeners on the canvasComponent or on canvasComponent.root.

When this instance gets uninstalled from the context the same context instance will be passed to it.

Implementations may hold a reference to the context instance and use it while they are being installed.

Parameters

Tests whether the mouse is currently over the canvas.

This method is asked by the handler for mouse events befor getHitObject is asked. If the hover effect should be available when the mouse is hovering over a (transparent) object which is not a child of the canvas (e.g. the overview component) this method can be overridden to return always true

Parameters

Called when mouse was pressed over the overlay sprite.

Implementations can use this callback to detect mouse clicks on the overlay.

This implementation stops the event from propagation. Otherwise, the canvas would handle the mouse clicks as if there was no overlay.

Parameters

Sets the user tag provider for a node styled with TemplateNodeStyle.

This method is called by drawNodeStyle when the hovered node is styled using TemplateNodeStyle. Its purpose is to ensure that the renderer for the dummy node gets the user tag for the original node.

This implementation copies the user tag of the original node by reference if the style's userTagProvider is of type TagOwnerUserTagProvider, otherwise it wraps the tag provider. This should work in most cases.

Parameters

Starts the hovering.

Called when the mouse hovers over a new node.

This implementation creates the overlaySprite using createOverlaySprite() and a new Tween with a listener created by createMouseOverTweenListener() and an easing function defined by mouseOverTweenEasingFunction. It also requests the mutex.

Parameters

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

Uninstalls this mode from the given canvas. This code should clean up all changes made to the canvas in the install method. After a mode has been uninstalled it can be installed again into the same or another canvas.

Parameters