input | yFiles for HTML Docs

Classes

CanExecuteCommandArgs: Event argument used by can execute command handler to set whether the provided command can be executed.
ClickEventArgs: Event arguments used by clicked and handleClick.
ClickInputMode: An input mode that recognizes pointer clicks or taps.
CollectSnapReferencesEventArgs: Event arguments for the collect-snap-references event.
CollectSnapResultsEventArgs: Event arguments for the collect-snap-results event.
ConcurrencyController: A controller class that manages a single IInputMode implementation.
ConstrainedDragHandler: An implementation of the IDragHandler interface that can be used to constrain the movement of an existing instance.
ConstrainedHandle: An implementation of the IHandle interface that can be used to constrain the handle of an item.
ConstrainedPositionHandler: An implementation of the IPositionHandler interface that can be used to constrain the position of an item.
ConstrainedReshapeHandler: An implementation of the IReshapeHandler interface that can be used to constrain the reshaping of an existing instance conveniently.
ContextMenuInputMode: An implementation of the IInputMode interface that handles the display of a custom context menu when the user right-clicks on the CanvasComponent.
CreateBendInputMode: An IInputMode used for recognizing the gesture of creating IBends in an IGraph.
CreateEdgeInputMode: An IInputMode for interactively creating edges between nodes and edges in an IGraph displayed in a CanvasComponent or GraphComponent.
DropInputMode: An input mode which handles drag and drop related events on a CanvasComponent.
EdgeSnapReferenceProvider: An ISnapReferenceProvider implementation that can be used to add snap lines for orthogonally routed IEdges.
EditLabelHelper: An IEditLabelHelper implementation which provides a number of methods that can be overridden to change the default behavior.
EditLabelInputMode: Handles interactive editing and adding of labels.
EventRecognizers: Provides implementation singletons and utility methods for event recognizers.
ExecuteCommandArgs: The argument that is used by execute command handler to manage the execution of the given command.
FocusGuardInputMode: An IInputMode that can be added to a MultiplexingInputMode to suppress other modes from performing unwanted actions if the control has just become focused.
GraphEditorInputMode: A complex IInputMode that can be used in a GraphComponent to edit an IGraph instance.
GraphInputMode: Abstract base class for GraphViewerInputMode and GraphEditorInputMode.
GraphSnapContext: Concrete SnapContext implementation which handles snapping movement for IGraph items.
GraphViewerInputMode: An IInputMode implementation for use in a GraphComponent to assign to the inputMode property.
GridConstraintProvider: A simple integer-based implementation of IGridConstraintProvider<T>.
GroupPaddingProvider: An IGroupPaddingProvider that returns the same padding for each node.
GroupingNodePositionHandler: The IPositionHandler implementation used in the context of IGraphs where there is an active hierarchy.
HandleInputMode: An IInputMode implementation that can handle a collection of IHandles.
HandlesRenderTag: The render tag for rendering handles.
HandlesRenderer: An IObjectRenderer<HandlesRenderTag> that draws collections of IHandle instances in a CanvasComponent.
HoveredItemChangedEventArgs: Event argument class containing information about which IModelItem the mouse is currently hovering over.
InputModeBase: Abstract base class implementation of an IInputMode that can be used concurrently with other IInputMode implementations if its exclusive property is true.
InputModeContext: An implementation of the IInputModeContext for use within the scope of IInputModes.
InputModeEventArgs: Event argument base class that is used by events that are triggered by IInputMode implementations
InputModeItemChangedEventArgs: Event argument that is used by events that indicate deletion or change of an item which is triggered by IInputMode implementations.
InputModeItemEventArgs: Event argument that is used by events that indicate creation or change of an item which is triggered by IInputMode implementations.
ItemClickedEventArgs: Provides data for the item-clicked, item-double-clicked, item-left-clicked, item-left-double-clicked, item-right-clicked and item-right-double-clicked events.
ItemDropInputMode: A DropInputMode providing a preview of the dragged item.
ItemHoverInputMode: An input mode for use in a GraphComponent that fires events when the pointer enters or leaves the visualization of a graph item.
ItemsEventArgs: Event argument class that is used by events that are triggered by IInputMode implementations and affect various graph items.
KeyboardInputMode: An IInputMode that recognizes simple key events and invokes a registered action.
KeyboardInputModeBinding: A token returned by KeyboardInputMode's factory methods that can be used to remove the binding again.
LabelCandidateRenderTag: The render tag for rendering label candidates.
LabelDropInputMode: An ItemDropInputMode<T> specialized to the drag and drop of ILabels.
LabelEditingEventArgs: Event arguments for the query-label-adding and query-label-editing events, as well as the IEditLabelHelper interface.
LabelPositionHandler: An implementation of IPositionHandler that shows the various label position candidates and lets the user move a label to one of those candidate positions.
LabelSnapReferenceProvider: An implementation of the ISnapReferenceProvider interface that provides SnapReferences for ILabels.
LabelSnapResultProvider: The default implementation of ILabelSnapResultProvider that provides the snap results to the GraphSnapContext during dragging of labels.
LabelTextValidatingEventArgs: Event arguments for label text validation.
LassoPathFinishRegionRenderTag: The render tag for rendering the finish region of the lasso path.
LassoSelectionEventArgs: Event arguments used by LassoSelectionInputMode.
LassoSelectionInputMode: An IInputMode implementation that provides support for lasso selections through mouse or touch gestures.
MarqueeRenderTag: The render tag for rendering the marquee rectangle of MarqueeSelectionInputMode.
MarqueeSelectionEventArgs: Event arguments used by MarqueeSelectionInputMode.
MarqueeSelectionInputMode: An IInputMode implementation that provides support for marquee selections through mouse or touch gestures.
MoveInputMode: Generic IInputMode implementation that can be used to move something in the canvas using the mouse.
MoveViewportInputMode: An IInputMode implementation that can be used to pan or zoom the viewport of a CanvasComponent via mouse, stylus, and multitouch gestures.
MovementInfo: Used in the context of GraphSnapContext to describe the movement of entities during the edit process.
MultiplexingInputMode: A composite IInputMode implementation that additionally can deal with exclusive instances.
NavigationInputMode: An IInputMode that can navigate an IGraph displayed in a graphComponent.
NodeDropInputMode: An ItemDropInputMode<T> specialized to the drag and drop of INodes.
NodeReshapeHandleProvider: Default implementation of the IReshapeHandleProvider interface for nodes.
NodeReshapeHandlerHandle: The default IHandle implementation for nodes that uses IReshapeHandler for the actual reshaping.
NodeReshapeSnapResultProvider: The default implementation of the INodeReshapeSnapResultProvider interface.
NodeSizeConstraintProvider: An implementation of INodeSizeConstraintProvider which provides constant sizes.
NodeSnapReferenceProvider: An implementation of the ISnapReferenceProvider interface that provides SnapReferences for INodes.
NodeSnapResultProvider: The default implementation of the INodeSnapResultProvider interface.
OrthogonalEdgeDragHandler: This class can be used to keep the orthogonal edges attached to an INode orthogonal while the node is moved or reshaped interactively.
OrthogonalEdgeEditingContext: Used to interactively reshape orthogonal edge paths.
OrthogonalEdgeHelper: Default implementation of the IOrthogonalEdgeHelper.
OrthogonalSnapLine: An orthogonal snap line, in other words, one that is parallel to the x or y axis.
OverviewInputMode: An IInputMode that can be used for an overview CanvasComponent.
PopulateItemContextMenuEventArgs: A specialized subclass of PopulateContextMenuEventArgs that carries the item for which the context menu should be populated.
PortCandidate: An IPortCandidate implementation which can be used for candidates at existing ports as well as for candidates at a given location.
PortCandidateProviderBase: An abstract base implementation of the IPortCandidateProvider interface.
PortDropInputMode: An ItemDropInputMode<T> specialized to the drag and drop of IPorts.
PortLocationModelParameterHandle: An implementation of the IHandle that can be used to move an IPort interactively by assigning new IPortLocationModelParameters to the locationParameter
PortRelocationHandle: A sophisticated implementation of the IHandle interface that lets the user change an edge's source and targetPort.
PortRelocationHandleProvider: An implementation of an IHandleProvider that can be used for IEdges.
PortsHandleProvider: An implementation of an IHandleProvider that returns all handles in the lookup of the ports owned by the given owner.
QueryClosestHandleEventArgs: Event argument that can be used to query the IHandle that is closest to the given location in world coordinate space.
QueryItemToolTipEventArgs: A specialized subclass of QueryToolTipEventArgs that carries the item for which the tool tip is queried.
QueryPositionHandlerEventArgs: Event argument that is used to query the IPositionHandler that is used to move the items while dragging via MoveInputMode.
QueryToolTipEventArgs: Event argument that can be used to query the text to display when the mouse hovers over the given point in world coordinate space.
RectangleHandle: A more sophisticated IHandle implementation that modifies a rectangle.
RectangleReshapeHandleProvider: A simple implementation of an IReshapeHandleProvider that returns handles that modify an IMutableRectangle.
ReparentNodeHandler: The default IReparentNodeHandler implementation used by reparentNodeHandler.
ReparentStripeHandler: Default implementation of the IReparentStripeHandler interface.
ReparentStripeInputMode: Specialized input mode that is used to reparent a stripe inside an ITable structure.
ReparentStripePositionHandler: Customized IPositionHandler implementation that moves a stripe in the table hierarchy when the stripe is dragged.
ReshapeHandleProviderBase: Abstract base class implementation of the IReshapeHandleProvider interface that has properties to restrict the size and area of a reshapeable.
ReshapeHandlerHandle: A more sophisticated IHandle implementation that delegates to a IReshapeHandler.
ReshapeRectangleContext: Carries information about a reshape operation.
ResizeStripeInputMode: Specialized input mode that is used to resize a stripe by dragging one of its borders.
SelectionEventArgs: Event arguments that are used when modifying an IObservableCollection<T> in the context of IGraphSelections.
SnapCircle: A SnapCircle represents a circle in the world coordinate system to which other items snap during interactive movements.
SnapConstraint: Implementations of this class describe the constraint for a pointer location so that a SnapResult is considered to be snapped.
SnapContext: Manages interactive snapping of elements to other elements during drag operations like movements.
SnapGrid: A SnapReference to snap to locations on a grid.
SnapLine: A snap line is a line segment in the world coordinate system to which other items (lines or points) snap during interactive movements.
SnapReference: A snap reference represents a reference to which other items (lines or points) snap during interactive movements.
SnapResult: This is the base class used by the implementers of SnapContext to model the result of the pointer being snapped to a certain location.
SnapSize: A SnapReference to snap the width or height of an item to the size of other rectangles.
StripeDropInputMode: An ItemDropInputMode<T> specialized to the drag and drop of IStripes.
StripeHitTester: Support class that allows to iterate over hits on table elements or subregions of table elements.
StripeInputRenderTag: The render tag for rendering input visualizations for IStripes.
StripeLabelInputRenderTag: The render tag for rendering the selection of IStripe labels.
StripeSubregion: Further describes the result of a hit test on a stripe or table.
TableEditorInputMode: Input mode that can be used to interactively edit a table.
TableHitTestResult: Support class to describe hit test results in the context of TableEditorInputMode interactions.
TableItemClickedEventArgs: Provides data for the item-clicked, item-double-clicked, item-left-clicked, item-left-double-clicked, item-right-clicked and item-right-double-clicked events.
TableReshapeHandler: IReshapeHandler implementation that constrains node resizes so that minimum size constraints of an associated ITable are satisfied and which resizes the outer IStripes of such a table when the node is resized.
TextEditorInputMode: An IInputMode implementation that displays a textarea in the CanvasComponent to let the user edit a text.
TextEventArgs: Event arguments used by TextEditorInputMode.
ToolTipInputMode: An IInputMode that detects when the mouse hovers over the CanvasComponent and displays a tooltip.
WaitInputMode: An IInputMode implementation that can be used to block user interaction.

Interfaces

IBendCreator: Callback interface for instances that can create bends for an edge and graph.
IBendGridConstraintProvider: This is a flagging interface for instances of IGridConstraintProvider<T> that can snap coordinates of IBends to a grid.
IBendSelectionTester: Interface that can be used to find bends at specific locations in the canvas.
IBendSnapResultProvider: Interface that is used by the GraphSnapContext for bends to collect a number of SnapResults during the move/edit operation.
IClickListener: A simple interface that can be used to react to clicks on regions of INodeStyles etc.
IContainsBendTester: An interface that checks for containment of an IBend in 2D coordinate space.
IDragHandler: Interface for an object that can be used to drag something displayed in a CanvasComponent
IEdgePortHandleProvider: An interface for classes that can yield IHandle implementations for the source and target ends of an IEdge.
IEdgeReconnectionPortCandidateProvider: This interface can be used to query IPortCandidates for a specific existing IEdge
IEdgeSnapResultProvider: Interface for classes that help during snapping of parts of edges.
IEditLabelHelper: Helper interface to handle interactive label editing.
IGridConstraintProvider: Interface for classes that can snap coordinates of items of a specific type to a grid.
IGroupPaddingProvider: Implementations of this interface yield the padding for a group node around its child nodes when calculating the group node's size.
IHandle: Interface for a handle that represents a draggable, point-like structure.
IHandleProvider: Interface for an object that provides a number of IHandle implementations.
IHitTestable: Interface that is implemented for elements that can be hit or picked in a coordinate system.
IHitTester: An interface that can enumerate hits in an IGraph of a given type for a certain position in world coordinates.
IInputMode: Interface implemented by input modes to handle user input in a CanvasComponent instance.
IInputModeContext: The interface for the context object that is passed to IInputMode instances during install and uninstall and IDragHandler implementations like IPositionHandler and IHandle to provide additional context for the implementations.
ILabelGridConstraintProvider: This is a flagging interface for instances of IGridConstraintProvider<T> that can snap coordinates of ILabels to a grid.
ILabelOwnerGridConstraintProvider: This is a flagging interface for instances of IGridConstraintProvider<T> that can snap coordinates of ILabelOwners to a grid.
ILabelSnapResultProvider: Provides the snap results to the GraphSnapContext during dragging of labels.
ILassoTestable: Interface that is used to test whether a rendered item is deemed to be inside a lasso selection path.
IMarqueeTestable: Interface that is used to test whether a rendered item is deemed to be inside a rectangular marquee selection.
IModelItemCollector: An interface that allows input modes to collect IModelItems for various purposes.
INodeGridConstraintProvider: This is a flagging interface for instances of IGridConstraintProvider<T> that can snap coordinates of INodes to a grid.
INodeReshapeSnapResultProvider: Interface for an implementation which evaluates a list of given SnapLines for a node which is resized and adds a set of SnapResults for sizes to which this node can potentially snap.
INodeSizeConstraintProvider: An interface used by implementations that provide various size constraints for INodes.
INodeSnapResultProvider: Interface that is used by the GraphSnapContext for nodes to collect a number of SnapResults during the move/edit operation.
IOrthogonalEdgeHelper: An interface which provides methods that handle orthogonal editing of individual edges and can be decorated to the ILookup of IEdges.
IPortCandidate: An interface for possible IPort candidates used by IPortCandidateProvider and the like.
IPortCandidateProvider: This interface is used to provide IPortCandidates for a specific IPortOwner.
IPortGridConstraintProvider: This is a flagging interface for instances of IGridConstraintProvider<T> that can snap coordinates of IPorts to a grid.
IPortSelectionTester: Interface that can be used to find ports at specific locations in the canvas.
IPortSnapResultProvider: Interface that is used by the GraphSnapContext for port to collect a number of SnapResults during the move/edit operation.
IPositionHandler: Interface for an object that can handle the position of an item displayed in a CanvasComponent.
IReparentNodeHandler: Interface used for implementations that recognize, approve, and disapprove node reparenting gestures, as well as actually perform the reparenting.
IReparentStripeHandler: Interface used for implementations that recognize, approve, and disapprove stripe reparenting gestures, as well as actually perform the reparenting.
IReshapeHandleProvider: A specialized version of the IHandleProvider interface that can be used to query IHandle implementations for resizing an object.
IReshapeHandler: Interface for an object that can be interactively reshaped in a CanvasComponent
ISnapReferenceProvider: Queried by the GraphSnapContext to add SnapReferences to its collections during the initialization phase.
IStripeHitTestHelper: Helper interface that allows to bundle IHitTestable implementations for the main regions of a IStripe instance.
IStripeInputRenderer: This interface allows to change the visualization of stripes for different input gestures.
IStripeLabelInputRenderer: This interface allows to change the visualization of stripe labels for different input gestures.

Enums

AdjustContentBoundsPolicy: Policy to determine how the contentBounds of the GraphComponent should be recalculated after interactive graph changes.
ClickReportingPolicy: Policy to determine how click events are raised in response to pointer clicks.
Command: The Commands class exposes a standard set of IGraph-related editing and navigation constants.
EdgeDirectionPolicy: Used by CreateEdgeInputMode to determine the direction in which edges get created.
EdgeSegmentDirection: Defines the direction of an edge segment
GridSnapTypes: The values of this enum describe to which grid elements an object shall snap.
GridSnappableItems: An enumeration that specifies which items will be snapped to a grid by the GraphSnapContext.
HandlePositions: The possible positions of a rectangle IHandles.
HandleType: Describes the type of IHandle.
InertiaPolicies: Flaggable enumeration used by inertia to determine when to use inertia moving.
LabelEditingAction: Used by IEditLabelHelper to determine the kind of action to handle.
LassoPathState: The state of the lasso path of the current lasso selection.
MoveFocusDirection: Enumeration used by NavigationInputMode to determine the direction of the search for items to navigate to.
MoveTypes: Describes the type of movement of a point during an edit in the context of GraphSnapContext.
NodeAlignmentPolicy: Enumeration used by NavigationInputMode to determine which point (if any) of a group or folder node should be kept fixed when toggling the group node state.
OrthogonalEdgeEditingPolicy: Enumeration defining different policies to enable or disable some aspects of creation or editing of orthogonal edges.
PortCandidateValidity: Enumeration for the different possible validity states.
ReshapePolicy: The policy constant used by NodeReshapeHandleProvider and ReshapeHandlerHandle.
SegmentOrientation: Enumeration for possible orientations of a segment in a (partially) orthogonal edge routing.
SelectionPolicy: Policies for changing the selection state with a selection gesture.
ShowPortCandidates: Defines whether to show the visualization of start and end port candidates during interactive edge creation.
SnapLineOrientation: The orientation used by orthogonal snap lines.
SnapLineSnapTypes: The type a snap line may be snapped to.
SnapPanningBehaviors: Flaggable enumeration to determine to which axis touch panning should snap to.
SnapPolicy: The policy constants used by IGridConstraintProvider<T>
SnapReferenceVisualizationType: Enumeration of snap reference visualization types.
SnappableItems: An enumeration that specifies which items will be snapped by the GraphSnapContext.
StripeReparentPolicy: Enumeration for the possible results of a reparent gesture.
StripeSubregionTypes: Enumeration that specifies the various hot spot regions of an IStripe instance.
StripeVisualizationType: Enumeration constants for the various visualization types used in conjunction with IStripeInputRenderer
TextBoxPlacementPolicy: Describe what policy to use when the editorContainer would be located outside of the current viewport
Visualization: Enumeration with different options on how to handle previews during a gesture.