FilteredGraphWrapper

Show usages

An IGraph that contains a live subgraph of another IGraph.

Inheritance Hierarchy

GraphWrapperBase

FilteredGraphWrapper

Implemented Interfaces

IGraph

ILookup

ITagOwner

Remarks

FilteredGraphWrapper is a decorator for another IGraph instance and can be used to retain only a subset of nodes and edges of the original graph. The properties nodePredicate and edgePredicate control which nodes and edges are retained in the filtered graph. Edges adjacent to filtered nodes are also filtered automatically (as their source or target would not be in the graph anyway).

Using FilteredGraphWrapper is the recommended way to hide nodes and edges by including only those that satisfy the specified predicates.

Note that FilteredGraphWrapper has to listen to events raised by the wrapped graph to keep itself updated, so dispose should be called if this instance is not used anymore. Otherwise, the wrapped graph may be kept alive for longer than necessary.

Ports at IEdges (i.e. edge-to-edge connections) are not fully supported.

Related Programming Samples

Organization Chart: An interactive viewer for organization charts with adaptive styles and automatic layout.
Collapsible Trees: Shows interactive collapsing and expanding of subtrees of a graph.

Type Details

yFiles module: view

Constructors

FilteredGraphWrapper

(graph: IGraph, nodePredicate: function(INode):boolean, edgePredicate?: function(IEdge):boolean)

Creates a new graph instance that wraps the original graph and uses the predicates to determine which nodes and edges should be contained in the graph.

Remarks

Note that this instance will register listeners with the graph, so dispose should be called if this instance is not used any more.

Parameters

options - Object
A map of options to pass to the method.

graph - IGraph

The graph to wrap

nodePredicate - function(INode):boolean

The predicate that determines which nodes to keep.

Signature Details

function(obj: INode) : boolean

Represents the method that defines a set of criteria and determines whether the specified object meets those criteria.

Parameters

obj - INode: The object to compare against the criteria defined within the method represented by this delegate.

Returns

boolean: true if obj meets the criteria defined within the method represented by this delegate; otherwise, false.

edgePredicate - function(IEdge):boolean

The optional predicate that determines which edges to keep. If omitted, all edges are kept, unless connected to filtered nodes.

Signature Details

function(obj: IEdge) : boolean

Represents the method that defines a set of criteria and determines whether the specified object meets those criteria.

Parameters

obj - IEdge: The object to compare against the criteria defined within the method represented by this delegate.

Returns

boolean: true if obj meets the criteria defined within the method represented by this delegate; otherwise, false.

Throws

Exception({ name: 'ArgumentError' }): if graph, nodePredicate, or edgePredicate is null.

Properties

bends

: IEnumerable<IBend>

Gets a live view of all bends contained in this IGraph.

Overrides

IGraph.bends

decorator

: GraphDecorator

Gets a GraphDecorator instance for use with this graph.

Overrides

IGraph.decorator

edgeDefaults

: IEdgeDefaults

Gets or sets the defaults for edges.

Remarks

The settings that are obtained from the instance influence newly created elements only. Setting different defaults afterward does not influence existing elements.

Implements

IGraph

edgeLabels

: IEnumerable<ILabel>

Gets a live view of all edge labels contained in this IGraph.

Overrides

IGraph.edgeLabels

edgePredicate

: function(IEdge):boolean

Gets or sets the predicate function for the edges.

Remarks

Note that setting a new predicate requires calling edgePredicateChanged. If both nodePredicate and edgePredicate are changed, it is recommended to call nodePredicateChanged and edgePredicateChanged after both values are changed.

Signature Details

function(obj: IEdge) : boolean

Represents the method that defines a set of criteria and determines whether the specified object meets those criteria.

Parameters

obj - IEdge: The object to compare against the criteria defined within the method represented by this delegate.

Returns

boolean: true if obj meets the criteria defined within the method represented by this delegate; otherwise, false.

edges

: IListEnumerable<IEdge>

Gets a view of the edges contained in this graph.

Remarks

This is a live view of the edges that always represents the current state of the graph. The same reference will be returned for each invocation.

Note that even though edges can be accessed via index, the underlying graph structure in the default IGraph implementation is a linked list and indexed access can be slow. In those cases it is recommended to store the edges in your own list, if possible. This is not necessary for the first or last element or when iterating over the edges via a foreach loop.

Overrides

IGraph.edges

foldingView

: IFoldingView?

Gets the IFoldingView instance associated with this IGraph or null if none is associated with it.

Remarks

This convenience method uses the lookup of the IGraph to obtain the IFoldingView.

Overrides

IGraph.foldingView

groupingSupport

: GroupingSupport

Creates a GroupingSupport instance for the graph.

Remarks

GroupingSupport provides less frequently used methods for grouped graphs, such as methods for analyzing and walking the grouping hierarchy.

Overrides

IGraph.groupingSupport

groupNodeDefaults

: INodeDefaults

Gets or sets the defaults for group nodes.

Remarks

The settings that are obtained from the instance influence newly created elements only. Setting different defaults afterwards does not influence existing elements.

Implements

IGraph

labels

: IListEnumerable<ILabel>

Gets a view of the labels contained in this graph.

Remarks

This is a live view of the labels that always represents the current state of the graph. The same reference will be returned for each invocation.

Note that even though labels can be accessed via index, the underlying graph structure in the default IGraph implementation is a linked list and indexed access can be slow. In those cases it is recommended to store the labels in your own list, if possible. This is not necessary for the first or last element or when iterating over the labels via a foreach loop.

Overrides

IGraph.labels

nodeDefaults

: INodeDefaults

Gets or sets the defaults for normal nodes.

Remarks

The settings that are obtained from the instance influence newly created elements only. Setting different defaults afterwards does not influence existing elements.

Implements

IGraph

nodeLabels

: IEnumerable<ILabel>

Gets a live view of all node labels contained in this IGraph.

Overrides

IGraph.nodeLabels

nodePredicate

: function(INode):boolean

Gets or sets the predicate function for the nodes.

Remarks

Note that setting a new predicate requires calling nodePredicateChanged. If both nodePredicate and edgePredicate are changed, it is recommended to call nodePredicateChanged and edgePredicateChanged after both values are changed.

Signature Details

function(obj: INode) : boolean

Represents the method that defines a set of criteria and determines whether the specified object meets those criteria.

Parameters

obj - INode: The object to compare against the criteria defined within the method represented by this delegate.

Returns

boolean: true if obj meets the criteria defined within the method represented by this delegate; otherwise, false.

nodes

: IListEnumerable<INode>

Gets a view of the nodes contained in this graph.

Remarks

This is a live view of the nodes that always represents the current state of the graph. The same reference will be returned for each invocation.

Note that even though nodes can be accessed via index, the underlying graph structure in the default IGraph implementation is a linked list and indexed access can be slow. In those cases it is recommended to store the nodes in your own list, if possible. This is not necessary for the first or last element or when iterating over the nodes via a foreach loop.

Overrides

IGraph.nodes

portLabels

: IEnumerable<ILabel>

Gets a live view of all port labels contained in this IGraph.

Overrides

IGraph.portLabels

ports

: IListEnumerable<IPort>

Gets a view of the ports contained in this graph.

Remarks

This is a live view of the ports that always represents the current state of the graph. The same reference will be returned for each invocation.

Note that even though ports can be accessed via index, the underlying graph structure in the default IGraph implementation is a linked list and indexed access can be slow. In those cases it is recommended to store the ports in your own list, if possible. This is not necessary for the first or last element or when iterating over the ports via a foreach loop.

Overrides

IGraph.ports

undoEngine

: UndoEngine?

Gets the UndoEngine instance associated with this IGraph or null if none is associated with it.

Remarks

This convenience method uses the lookup of the IGraph to obtain the UndoEngine.

Overrides

IGraph.undoEngine

undoEngineEnabled

: boolean

Gets or sets whether or not the UndoEngine used for this instance should be enabled.

Overrides

IGraph.undoEngineEnabled

wrappedGraph

: IGraph?

Gets the graph that has been wrapped by this instance.

Property Value

The graph this instance is decorating.

Defined in

GraphWrapperBase

Methods

addBend

(edge: IEdge, location: Point, index?: number) : IBend

Adds a bend at the given index to the given edge using the coordinates provided.

Remarks

The added instance will be returned.

To retrieve the current bends of an edge, use bends

Parameters

options - Object
A map of options to pass to the method.

edge - IEdge: The edge to which the bend will be added.
location - Point: The coordinates to use for the newly created bend. To change the location after the bend has been added, use setBendLocation.
index - number: The index for the newly added bend; A negative value (which is the default) indicates that the bend should be appended to the end of the list of bends.

Returns

↪IBend: A newly created live bend

Throws

Exception({ name: 'ArgumentError' }): edge is not in this graph, or location contains one or more NaN values.

Implements

IGraph

addBends

(edge: IEdge, locations: IEnumerable<Point>)

Adds bends with the given locations to the end of the bend list of the given edge.

Parameters

options - Object
A map of options to pass to the method.

edge - IEdge: The edge to add the bends to.
locations - IEnumerable<Point>: The locations of the bends.

Throws

Exception({ name: 'ArgumentError' }): edge is not in this graph.
Exception({ name: 'ArgumentError' }): locations contains one or more NaN values.

Overrides

IGraph.addBends

addEventHandlers

(graph: IGraph)

Adds event handlers that propagate graph events from graph to listeners on this instance.

Parameters

options - Object
A map of options to pass to the method.

graph - IGraph: The graph for which event propagators should be created

Overrides

GraphWrapperBase.addEventHandlers

addLabel

(owner: ILabelOwner, text: string, layoutParameter?: ILabelModelParameter, style?: ILabelStyle, preferredSize?: Size, tag?: ILabel['tag']) : ILabel

Add a label to the given node or edge using the text as the initial label text and label model parameter, style, and tag.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

owner - ILabelOwner: The node, edge, or port to add the label to. Note that the owner cannot be changed after the label has been added.
text - string: The initial text of the label. To change the text after the label has been added, use setLabelText.
layoutParameter - ILabelModelParameter: The label model parameter instance to use. If omitted the default parameter will be set. To change the parameter after the label has been added, use setLabelLayoutParameter.
style - ILabelStyle: The style to use for the label. If omitted the default style will be set. To change the style after the label has been added, use setStyle.
preferredSize - Size: The initial values to use for the preferredSize. If omitted size will be determined automatically. To change the preferred size after the label has been added, use setLabelPreferredSize.
tag - ILabel['tag']: The initial tag to assign.

Returns

↪ILabel: The newly created label.

Throws

Exception({ name: 'ArgumentError' }): owner is not in this graph or preferredSize contains one or more NaN values.

Implements

IGraph

addPort

(owner: IPortOwner, locationParameter?: IPortLocationModelParameter, style?: IPortStyle, tag?: IPort['tag']) : IPort

Add a port to the given port owner using the location model parameter, style, and tag.

Remarks

The locationParameter determines the location of the port.

An implementation may throw a NotSupportedError if the type of the owner instance does not support adding ports.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

owner - IPortOwner: the owner to add the port instance to.
locationParameter - IPortLocationModelParameter: the parameter to use for the port to determine its location. If omitted, the default parameter will be set. To change the parameter after the port has been added, use setPortLocationParameter.
style - IPortStyle: the style to initially assign to the style property. If omitted, the default style will be set, e.g. VOID_PORT_STYLE. To change the style after the port has been added, use setStyle.
tag - IPort['tag']: the initial tag to assign.

Returns

↪IPort: the newly created port

Throws

Exception({ name: 'NotSupportedError' }): If this instance cannot add a port to owner.
Exception({ name: 'ArgumentError' }): owner is not in this graph.

Implements

IGraph

addPortAt

(owner: IPortOwner, location: Point, style?: IPortStyle, tag?: IPort['tag']) : IPort

Add a port to the given port owner using the absolute coordinates as the new initial position of the port anchor.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

owner - IPortOwner: The owner to add the port instance to.
location - Point: The location to use for the port to determine its location. This is passed to the createDefaultPortLocationParameter method to determine the initial IPortLocationModelParameter to use.
style - IPortStyle: The style to initially assign to the style property, e.g. VOID_PORT_STYLE.
tag - IPort['tag']: The initial tag to assign.

Returns

↪IPort: The newly created port

Throws

Exception({ name: 'NotSupportedError' }): If this instance cannot add a port to owner.
Exception({ name: 'ArgumentError' }): owner is not in this graph.
Exception({ name: 'ArgumentError' }): location contains one or more NaN values.

Overrides

IGraph.addPortAt

addRelativePort

(node: INode, relativeLocation: Point) : IPort

Adds a new port to the graph at the node using a location that is relative to the center of the node.

Remarks

The port style for the newly-created port is taken from the graph's defaults. The location parameter is determined by delegating to addPortAt.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The owner of the port.
relativeLocation - Point: The offset of the port relative to the center of the layout.

Returns

↪IPort: The newly added port instance.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph.
Exception({ name: 'ArgumentError' }): relativeLocation contains one or more NaN values.

Overrides

IGraph.addRelativePort

addUndoUnit

(undoName: string, redoName: string, undo: function():void, redo: function():void)

Uses the UndoEngine from the IGraph's ILookup to add a unit.

Parameters

options - Object
A map of options to pass to the method.

undoName - string

The name of the undo operation.

redoName - string

The name of the redo operation.

undo - function():void

The undo action.

Signature Details

function()

Encapsulates a method that has no parameters and does not return a value.

Parameters

redo - function():void

The redo action.

Signature Details

function()

Encapsulates a method that has no parameters and does not return a value.

Parameters

Overrides

IGraph.addUndoUnit

adjustGroupNodeLayout

(groupNode: INode)

Method to adjust the size of a group node.

Remarks

This will resize the group node bounds such that the node requires the least amount of space. If the node does not have any children, its bounds will be left unchanged. This will also respect any INodeSizeConstraintProviders for INodes that are available in the lookup of the groupNode.

Parameters

options - Object
A map of options to pass to the method.

groupNode - INode: The group node to adjust the size of.

Throws

Exception({ name: 'ArgumentError' }): groupNode is not in this graph.

Examples

How to create create a group node with children

// create a group node
const group = graph.createGroupNode()
// add some child nodes
graph.createNode(group, new Rect(10, 10, 30, 30))
graph.createNode(group, new Rect(50, 10, 30, 30))
graph.createNode(group, new Rect(50, 50, 30, 30))
// adjust the group node's layout to include all its children
graph.adjustGroupNodeLayout(group)

AdjustGroupNodeLayout only affects the node it is called for. To properly adjust all of its ancestors, too, one has to adjust all of them from the given node to the root:

for (const nodeToAdjust of graph.groupingSupport.getAncestors(
  innermostGroup,
)) {
  graph.adjustGroupNodeLayout(nodeToAdjust)
}

Overrides

IGraph.adjustGroupNodeLayout

adjustLabelPreferredSize

(label: ILabel)

Adjusts the preferredSize property of a label to fit the suggested size of its ILabelStyleRenderer.

Remarks

This implementation uses the style's renderer for the label to determine the preferred rendering size. This is useful after the label's content or style have been changed.

Parameters

options - Object
A map of options to pass to the method.

label - ILabel: The label to adjust the size for.

Overrides

IGraph.adjustLabelPreferredSize

applyLayout

(layout: ILayoutAlgorithm, layoutData?: LayoutData<INode,IEdge,ILabel,ILabel>, stopDuration?: TimeSpan, cancelDuration?: TimeSpan, portAdjustmentPolicies?: ItemMapping<IPort,PortAdjustmentPolicy>, portPlacementPolicies?: ItemMapping<IPort,PortPlacementPolicy>, portLabelPolicies?: ItemMapping<ILabel,PortLabelPolicy>, anchoredItems?: ItemMapping<IModelItem,LayoutAnchoringPolicy>, labelPlacementPolicies?: ItemMapping<ILabel,LabelPlacementPolicy>, nodeComparator?: function(INode, INode):number, edgeComparator?: function(IEdge, IEdge):number)

Runs an ILayoutAlgorithm synchronously on the given graph.

Remarks

For more control over how to apply a layout use LayoutExecutor.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

layout - ILayoutAlgorithm

The layout.

layoutData - LayoutData<INode,IEdge,ILabel,ILabel>

The layout data.

stopDuration - TimeSpan

the maximum runtime for the layout calculation before it is automatically stopped.

cancelDuration - TimeSpan

the maximum runtime for the layout calculation before it is automatically canceled.

portAdjustmentPolicies - ItemMapping<IPort,PortAdjustmentPolicy>

The policy that specifies how port locations should be adjusted after a layout has been calculated.

portPlacementPolicies - ItemMapping<IPort,PortPlacementPolicy>

The policy that specifies how ports should be placed by the layout algorithm.

portLabelPolicies - ItemMapping<ILabel,PortLabelPolicy>

Sets how ILabels at IPorts should be treated by the layout algorithm.

anchoredItems - ItemMapping<IModelItem,LayoutAnchoringPolicy>

Specifies which part of the items should be used to anchor the graph during layout.

labelPlacementPolicies - ItemMapping<ILabel,LabelPlacementPolicy>

Sets how ILabels should be placed by the layout algorithm.

nodeComparator - function(INode, INode):number

A comparison function that normalizes the order of the nodes for the layout calculation to ensure the same order for multiple layout invocations.

Signature Details

function(x: INode, y: INode) : number

Encapsulates a method that compares two objects.

Parameters

x - INode: The first object to compare.
y - INode: The second object to compare.

Returns

number: An integer value which is <0 if x is less than y, 0 if x is equal to y, or >0 if x is greater than y

edgeComparator - function(IEdge, IEdge):number

A comparison function that normalizes the order of the edges for the layout calculation to ensure the same order for multiple layout invocations.

Signature Details

function(x: IEdge, y: IEdge) : number

Encapsulates a method that compares two objects.

Parameters

x - IEdge: The first object to compare.
y - IEdge: The second object to compare.

Returns

number: An integer value which is <0 if x is less than y, 0 if x is equal to y, or >0 if x is greater than y

Overrides

IGraph.applyLayout

beginEdit

<T>(undoName: string, redoName: string, items: IEnumerable<T>, provider?: function(T):IMementoSupport) : ICompoundEdit

Starts an ICompoundEdit that uses the memento design pattern to record changes to the items in the given items collection.

Remarks

This method uses the IMementoSupport returned by the provider to record the state of an item at the beginning of the edit and when commit is called to create an IUndoUnit that can revert the item to the recorded state and back. If no provider is given, this method uses the IMementoSupport returned by the lookup implementation of the items to record the state of an item at the beginning of the edit and when commit is called to create an IUndoUnit that can revert the item to the recorded state and back.

Calling this method will immediately enqueue an IUndoUnit into the undo queue. Subsequent additions to the queue will be added after the created instance, even if they are added to the queue before the commit method has been called.

Type Parameters

T: The type of the items that will be modified subsequently.

Parameters

options - Object
A map of options to pass to the method.

undoName - string

The undoName of the IUndoUnit that will be placed into the undo queue after commit has been called.

redoName - string

The redoName of the IUndoUnit that will be placed into the undo queue after commit has been called.

items - IEnumerable<T>

The items that will be changed after this call and before the call to commit.

provider - function(T):IMementoSupport

The provider for the IMementoSupport of the items. if the provider returns null for a given item, changes to this item are not being recorded.

Signature Details

function(item: T) : IMementoSupport

A function that is used to retrieve an IMementoSupport for any given object.

Parameters

item - T: The item to provide the for.

Returns

IMementoSupport

Returns

↪ICompoundEdit: An implementation of the ICompoundEdit interface whose commit or cancel methods need to be called after the items have been modified.

Examples

The following is an example implementation of an item that is being managed using IMementoSupport:

A sample business object that implements ILookup to return IMementoSupport

class Employee extends BaseClass<ILookup>(ILookup) implements ILookup {
  _name: string
  position: string
  age: number

  constructor(name: string, position: string, age: number) {
    super()
    this._name = name
    this.position = position
    this.age = age
  }

  get name(): string {
    return this._name
  }

  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
  lookup<T extends any>(type: Constructor<any>): T | null {
    if (type === IMementoSupport) {
      return new EmployeeMementoSupport() as T
    }
    return null
  }
}

A collection of items from this type can then be watched using the following code snippet:

Using an ICompoundEdit

const edit = graph.beginEdit(
  undoName,
  redoName,
  listWithMyEmployeesToWatch,
)

// changes to the employees are done here

if (!success) {
  // if we don't want the changes to be done after all, then we need to cancel the edit
  edit.cancel()
}

Alternatively, when using a specific provider, consider the following examples. The following is an example implementation of an item that is being managed using IMementoSupport:

A sample business object

class SimpleEmployee {
  private readonly _name: string
  position: string
  age: number

  constructor(name: string, position: string, age: number) {
    this._name = name
    this.position = position
    this.age = age
  }

  get name(): string {
    return this._name
  }
}

A collection of items from this type can then be watched using the following code snippet, using the provider to return an appropriate IMementoSupport implementation:

Using an ICompoundEdit

const edit = graph.beginEdit(
  undoName,
  redoName,
  listWithMyEmployeesToWatch,
  (item) => new EmployeeMementoSupport(),
)

// changes to the employees are done here

if (!success) {
  // if we don't want the changes to be done after all, then we need to cancel the edit
  edit.cancel()
}

Implementing the IMementoSupport interface is quite unrestrained, the type of the state returned by getState method can by anything as long as the applyState and stateEquals methods can deal with it:

Sample implementation of IMementoSupport

class EmployeeMementoSupport
  extends BaseClass<IMementoSupport>(IMementoSupport)
  implements IMementoSupport
{
  getState(subject: any): EmployeeState | null {
    if (subject instanceof Employee) {
      return new EmployeeState(subject.position, subject.age)
    }
    return null
  }

  applyState(subject: any, state: any): void {
    if (subject instanceof Employee && state instanceof EmployeeState) {
      subject.position = state.position
      subject.age = state.age
    }
  }

  stateEquals(state1: any, state2: any): boolean {
    if (
      state1 instanceof EmployeeState &&
      state2 instanceof EmployeeState
    ) {
      return (
        state1.position === state2.position && state1.age === state2.age
      )
    }
    return state1 === state2
  }
}

class EmployeeState {
  _position: string
  _age: number

  constructor(position: string, age: number) {
    this._position = position
    this._age = age
  }

  get position(): string {
    return this._position
  }

  get age(): number {
    return this._age
  }
}

In summary, use this concept when you want to track the state of items during certain operations for undo/redo. This is efficient if it's easier to handle an item's state than the changes to the item themselves. If you want to focus on the changes or on certain events, you should use custom IUndoUnit

Overrides

IGraph.beginEdit(string,string,yfiles.collections.IEnumerable,yfiles.graph.MementoSupportProvider)

beginEdit

(undoName: string, redoName: string) : ICompoundEdit

Starts an ICompoundEdit that records graph changes and custom undo units in a single compound unit.

Remarks

This method can be used to bracket several undo units. All edits added to the queue after this call and before a call to cancel or commit will be placed into the queue as a single block.

Client code needs to make sure that either the cancel or commit method is called on the returned instance.

Parameters

options - Object
A map of options to pass to the method.

undoName - string: The undo name for the compound edit.
redoName - string: The redo name for the compound edit.

Returns

↪ICompoundEdit: The handle to stop the recording by calling cancel or commit on it.

Overrides

IGraph.beginEdit(string,string)

calculateLabelPreferredSize

(owner: ILabelOwner, text: string, layoutParameter?: ILabelModelParameter, style?: ILabelStyle, tag?: ILabel['tag']) : Size

Calculates the preferred size of a label with the given properties.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

owner - ILabelOwner: The item that will own the label.
text - string: The text.
layoutParameter - ILabelModelParameter: The label model parameter.
style - ILabelStyle: The label style.
tag - ILabel['tag']: The tag for the label.

Returns

↪Size: The size as calculated by the ILabelStyleRenderer.

Overrides

IGraph.calculateLabelPreferredSize

clear

()

Clears the graph, removing all items in proper order.

Overrides

IGraph.clear

clearBends

(owner: IEdge)

Removes all bends from the given edge.

Remarks

The edge must be part of this graph at the time of the invocation. This will trigger the corresponding events.

Parameters

options - Object
A map of options to pass to the method.

owner - IEdge: the edge whose bends will be removed

Throws

Exception({ name: 'ArgumentError' }): owner is not in this graph.

Overrides

IGraph.clearBends

clearLabels

(labelOwner: ILabelOwner)

Removes all labels from the given ILabelOwner, which can be an INode, IEdge, or IPort.

Remarks

The owner must be part of this graph at the time of the invocation. This will trigger the corresponding events.

Parameters

options - Object
A map of options to pass to the method.

labelOwner - ILabelOwner: the owner whose labels will be removed

Throws

Exception({ name: 'ArgumentError' }): labelOwner is not in this graph.

Overrides

IGraph.clearLabels

clearPorts

(portOwner: IPortOwner)

Removes all ports from the given IPortOwner, which can be an INode or an IEdge.

Remarks

The owner must be part of this graph at the time of the invocation. This will trigger the corresponding events.

Parameters

options - Object
A map of options to pass to the method.

portOwner - IPortOwner: the owner whose ports will be removed

Throws

Exception({ name: 'ArgumentError' }): portOwner is not in this graph.

Overrides

IGraph.clearPorts

contains

(item: IModelItem) : boolean

Determines whether this graph contains the specified item.

Parameters

options - Object
A map of options to pass to the method.

item - IModelItem: The item.

Returns

↪boolean: true if this graph contains the specified item; otherwise, false.

Overrides

IGraph.contains

createCompositeLayoutData

(items: LayoutData<INode,IEdge,ILabel,ILabel>…) : CompositeLayoutData<INode,IEdge,ILabel,ILabel>

Returns an instance of CompositeLayoutData<TNode,TEdge,TNodeLabel,TEdgeLabel> that combines the given layout data instances.

Remarks

The generic type arguments of the created layout data are compatible with instances of IGraph, but the layout data is not bound to a specific graph instance. Therefore, the created layout data still has to be passed as an argument of applyLayout in order to be applied.

Parameters

options - Object
A map of options to pass to the method.

items - LayoutData<INode,IEdge,ILabel,ILabel>: the layout data instances that should be combined into the created CompositeLayoutData<TNode,TEdge,TNodeLabel,TEdgeLabel>

Returns

↪CompositeLayoutData<INode,IEdge,ILabel,ILabel>: an instance of CompositeLayoutData<TNode,TEdge,TNodeLabel,TEdgeLabel> that combines the given layout data instances.

This method is not available unless the module view-layout-bridge is loaded. Either load the module 'view-layout-bridge' explicitly or ensure that the LayoutExecutor type is available at runtime.

Overrides

IGraph.createCompositeLayoutData

createDefaultLabelLayoutParameter

(owner: ILabelOwner) : ILabelModelParameter

Creates the label layout parameter for a given ILabelOwner.

Remarks

This implementation uses the label defaults for the graph to obtain the parameter instance.

Parameters

options - Object
A map of options to pass to the method.

owner - ILabelOwner: The item that is the owner of the label in question.

Returns

↪ILabelModelParameter: The default label layout parameter to use for newly created labels at the item.

Overrides

IGraph.createDefaultLabelLayoutParameter

createDefaultPortLocationParameter

(owner: IPortOwner, location?: Point) : IPortLocationModelParameter

Creates a location model parameter for a newly created IPort at the owner that matches the location.

Remarks

If location is null, this method uses the port defaults for the owner to obtain the location parameter.

Parameters

options - Object
A map of options to pass to the method.

owner - IPortOwner: The owner of the port.
location - Point: The location in the world coordinate system where the port should be added.

Returns

↪IPortLocationModelParameter: Either a location model parameter that matches the location, or the default parameter to use for the IPortOwner as returned by getLocationParameterInstance.

Throws

Exception({ name: 'ArgumentError' }): location contains one or more NaN values.

Overrides

IGraph.createDefaultPortLocationParameter

createEdge

(sourcePort: IPort, targetPort: IPort, style?: IEdgeStyle, tag?: IEdge['tag']) : IEdge

Creates and returns an edge that connects to the given port instances.

Remarks

The ports must be part of this graph at the time of the invocation. The edge will be a part of this graph after the method returns. This will trigger the corresponding events.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

sourcePort - IPort: The source port the created edge will connect to. To change the source port after the edge has been created, use setEdgePorts.
targetPort - IPort: The target port the created edge will connect to. To change the target port after the edge has been created, use setEdgePorts.
style - IEdgeStyle: The style instance that will be assigned to the newly created instance. This is done by reference. If omitted the default style will be set. To change the style after the edge has been created, use setStyle.
tag - IEdge['tag']: The initial value of the tag that will be assigned to the new edge.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
bends - Point[]: An array of bends to add to the newly created edge. Each item will be passed to the addBend method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
bends - Point[]: An array of bends to add to the newly created edge. Each item will be passed to the addBend method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
bends - Point[]: An array of bends to add to the newly created edge. Each item will be passed to the addBend method.

Returns

↪IEdge: the newly created edge instance

Implements

IGraph

createEdge

(source: INode, target: INode, style?: IEdgeStyle, tag?: IEdge['tag']) : IEdge

Creates and returns an edge that connects to the given node instances using the given style instance.

Remarks

The nodes must be part of this graph at the time of the invocation, and an implementation can choose the IPort instances to which the edge will be connected. The edge will be a part of this graph after the method returns. This will trigger the corresponding events.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

source - INode: The source node the created edge will connect to. It is up to the implementation to decide which port to use at the given node. An implementation may create a new port of the edge. To change the source port after the edge has been created, use setEdgePorts.
target - INode: The target node the created edge will connect to. It is up to the implementation to decide which port to use at the given node. An implementation may create a new port of the edge. To change the target port after the edge has been created, use setEdgePorts.
style - IEdgeStyle: The style instance that will be assigned to the newly created instance. This is done by reference. If omitted the default style will be set. To change the style after the edge has been created, use setStyle.
tag - IEdge['tag']: The initial value of the tag that will be assigned to the new edge.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
bends - Point[]: An array of bends to add to the newly created edge. Each item will be passed to the addBend method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
bends - Point[]: An array of bends to add to the newly created edge. Each item will be passed to the addBend method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
bends - Point[]: An array of bends to add to the newly created edge. Each item will be passed to the addBend method.

Returns

↪IEdge: the newly created edge instance

Implements

IGraph

createGenericLayoutData

() : GenericLayoutData<INode,IEdge,ILabel,ILabel>

Returns an instance of LayoutData<TNode,TEdge,TNodeLabel,TEdgeLabel> that can be used to easily associate custom item-specific data with an IGraph.

Remarks

Returns

↪GenericLayoutData<INode,IEdge,ILabel,ILabel>: an instance of GenericLayoutData<TNode,TEdge,TNodeLabel,TEdgeLabel> that can be used to easily associate custom item-specific data with a graph.

This method is not available unless the module view-layout-bridge is loaded. Either load the module 'view-layout-bridge' explicitly or ensure that the LayoutExecutor type is available at runtime.

Overrides

IGraph.createGenericLayoutData

createGroupNode

(parent?: INode, layout?: Rect, style?: INodeStyle, tag?: INode['tag']) : INode

Creates a new group node using the provided style and layout as a child of parent.

Remarks

The group node will be a direct descendant of parent.

To create group nodes interactively use the GraphEditorInputMode as input mode and enable the grouping operations.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

parent - INode: The node to use as the parent in the grouping hierarchy or null if the new node should become a top-level node. To change the parent after the group node has been created, use setParent.
layout - Rect: The initial layout to use for the new node. If omitted the node will be placed with its top left corner at 0,0 and the default size. To change the layout after the group node has been created, use setNodeLayout.
style - INodeStyle: The style to use for the new node. If omitted the default style will be set. To change the style after the group node has been created, use setStyle.
tag - INode['tag']: The tag to assign to the INode.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
children - Rect[]: An array of nodes to create as child nodes of this group node. Each item will be passed to the createNode method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
children - Rect[]: An array of nodes to create as child nodes of this group node. Each item will be passed to the createNode method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
children - Rect[]: An array of nodes to create as child nodes of this group node. Each item will be passed to the createNode method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
children - Rect[]: An array of nodes to create as child nodes of this group node. Each item will be passed to the createNode method.

Returns

↪INode: The newly created group node.

Throws

Exception({ name: 'ArgumentError' }): The layout contains one or more NaN values.

Overrides

IGraph.createGroupNode

createNode

(parent?: INode, layout?: Rect, style?: INodeStyle, tag?: INode['tag']) : INode

Creates a new ordinary node as a direct descendant of parent using the given layout and style.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

parent - INode: The node to use as the parent in the grouping hierarchy or null if the new node should become a top-level node. To change the parent after the group node has been created, use setParent.
layout - Rect: The layout to use initially. The values will be copied to the node's layout field. If omitted the default size will be set and the node's top left corner will be placed at 0,0. To change the layout after the group node has been created, use setNodeLayout.
style - INodeStyle: The style instance that will be assigned to the newly created instance. This is done by reference. If omitted the default style will be set.
tag - INode['tag']: The tag to assign to the INode.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.

Returns

↪INode: The newly created node.

Throws

Exception({ name: 'ArgumentError' }): parent is not in this graph, or layout contains one or more NaN values.

Overrides

IGraph.createNode

createNode

(layout: Rect, style?: INodeStyle, tag?: INode['tag']) : INode

Creates and returns a node using the specified values for the initial geometry, style, and tag.

Remarks

The node will be a part of this graph after the method returns. This will trigger the corresponding events.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

layout - Rect: The layout to use initially. The values will be copied to the node's layout field. To change the layout after the node has been created, use setNodeLayout.
style - INodeStyle: The style instance that will be assigned to the newly created instance. This is done by reference. If omitted the default style will be set. To change the style after the node has been added, use setStyle.
tag - INode['tag']: The initial value of the tag that will be assigned to the new node.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.

Returns

↪INode: A newly created node instance

Throws

Exception({ name: 'ArgumentError' }): layout contains one or more NaN values.

Implements

IGraph

createNodeAt

(location: Point, style?: INodeStyle, tag?: INode['tag']) : INode

Creates and returns a node using the specified initial center location and style, as well as the tag.

Remarks

The node will be a part of this graph after the method returns. This will trigger the corresponding events.

ParametersOptions Overload

options - Object
A map of options to pass to the method.

location - Point: the initial coordinates of the center of the node's layout property
style - INodeStyle: The style instance that will be assigned to the newly created instance. This is done by reference.
tag - INode['tag']: The initial value of the tag that will be assigned to the new node.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.

Returns

↪INode: A newly created node instance

Throws

Exception({ name: 'ArgumentError' }): location contains one or more NaN values.

Overrides

IGraph.createNodeAt

degree

(owner: IPortOwner) : number

Calculates the number of edges at the given IPortOwner for this graph.

Remarks

Note that an edge that is both incoming and outgoing will be counted twice.

Parameters

options - Object
A map of options to pass to the method.

owner - IPortOwner: The port owner to count the degree of.

Returns

↪number: The number of edges that are incident to the port owner.

Throws

Exception({ name: 'ArgumentError' }): owner is not in this graph.

Overrides

IGraph.degree(yfiles.graph.IPortOwner)

degree

(port: IPort) : number

Calculates the number of edges at the given IPort for this graph.

Remarks

Note that an edge that is both incoming and outgoing will be counted twice.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: The port owner to count the degree of.

Returns

↪number: The number of edges that are incident to the port.

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph.

Overrides

IGraph.degree(yfiles.graph.IPort)

dispose

()

Clears the internal state of this instance and released memory and bound listeners.

Remarks

After this instance has been disposed of, it will not work as expected anymore. This implementation removes all event handlers from the wrappedGraph and releases the reference.

Overrides

GraphWrapperBase.dispose

edgePredicateChanged

(edge: IEdge)

Should be called by the client when the edgePredicate has changed for the specified edge.

Parameters

options - Object
A map of options to pass to the method.

edge - IEdge: The edge for which the edgePredicate has changed.

edgePredicateChanged

()

Should be called by the client if the edgePredicate changed for the edge in the graph.

edgesAt

(port: IPort, type?: AdjacencyTypes) : IListEnumerable<IEdge>

Returns an IListEnumerable<T> for the incoming, the outgoing, or all edges adjacent to the given port, depending on type.

Remarks

If the given type is ALL, adjacent self-loops will appear twice in the returned enumerable. For INCOMING or OUTGOING, self-loops will only appear once.

Note that even though edges can be accessed via index, the underlying graph structure in the default IGraph implementation is a linked list and indexed access can be slow. In those cases, it is recommended to store the edges in your own list, if possible. This is not necessary for the first or last element or when iterating over the adjacent edges via a foreach loop.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: The port to check. The returned edges will have this port as a sourcePort or targetPort.
type - AdjacencyTypes: The type of adjacency to consider. Default is ALL, which includes both incoming and outgoing edges.

Returns

↪IListEnumerable<IEdge>: An enumeration of all adjacent edges of the given type (incoming, outgoing, or both).

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph.

Overrides

IGraph.edgesAt

edgesAt

(owner: IPortOwner, type?: AdjacencyTypes) : IListEnumerable<IEdge>

Returns an IListEnumerable<T> for the incoming, the outgoing, or all edges adjacent to the given port owner, depending on type.

Remarks

If the given type is ALL, adjacent self-loops will appear twice in the returned enumerable. For INCOMING or OUTGOING, self-loops will only appear once.

Note that even though edges can be accessed via index, the underlying graph structure in the default IGraph implementation is a linked list and indexed access can be slow. In those cases, it is recommended to store the edges in your own list, if possible. This is not necessary for the first or last element or when iterating over the adjacent edges via a foreach loop.

Parameters

options - Object
A map of options to pass to the method.

owner - IPortOwner: The port to check. The returned edges will have one of the ports at this owner as a sourcePort or targetPort.
type - AdjacencyTypes: The type of adjacency to consider. Default is ALL, which includes both incoming and outgoing edges.

Returns

↪IListEnumerable<IEdge>: An enumeration of all adjacent edges of the given type (incoming, outgoing, or both).

Throws

Exception({ name: 'ArgumentError' }): owner is not in this graph.

Overrides

IGraph.edgesAt

getChildren

(node: INode) : IListEnumerable<INode>

Returns an enumerable over the children of the provided node.

Remarks

This method returns the direct children, i.e. all nodes that have node as their parent. To get all descendants method getDescendants can be used.

To make a node a child of node, use setParent or create the node directly as a child with createNode

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node for which to return the children or null if the top-level nodes should be returned.

Returns

↪IListEnumerable<INode>: All nodes that have node as their parent.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph.

Overrides

IGraph.getChildren

getEdge

(from: IPortOwner, to: IPortOwner) : IEdge

Finds an edge that connects from and to in the given graph.

Parameters

options - Object
A map of options to pass to the method.

from - IPortOwner: The sourcePort owner of the edge to find.
to - IPortOwner: The targetPort owner of the edge to find.

Returns

↪IEdge?: An edge that satisfies the constraints or null, if none was found.

Throws

Exception({ name: 'ArgumentError' }): from or to are not in this graph.

Overrides

IGraph.getEdge(yfiles.graph.IPortOwner,yfiles.graph.IPortOwner)

getEdge

(sourcePort: IPort, targetPort: IPort) : IEdge

Finds an edge that connects sourcePort and targetPort in the given graph.

Parameters

options - Object
A map of options to pass to the method.

sourcePort - IPort: The sourcePort of the edge to find.
targetPort - IPort: The targetPort of the edge to find.

Returns

↪IEdge?: An edge that satisfies the constraints or null, if none was found.

Throws

Exception({ name: 'ArgumentError' }): sourcePort or targetPort are not in this graph.

Overrides

IGraph.getEdge(yfiles.graph.IPort,yfiles.graph.IPort)

getEdgesBetween

(source: IPortOwner, target: IPortOwner, directed?: boolean) : IEnumerable<IEdge>

Returns the edges between the specified source and target owners.

Remarks

By default, only directed edges are returned. To retrieve all edges (both incoming and outgoing), set directed to false.

Parameters

options - Object
A map of options to pass to the method.

source - IPortOwner: The owner from which the edges start.
target - IPortOwner: The owner at which the edges end.
directed - boolean: Specifies whether to return only directed edges (default) or all edges regardless of direction.

Returns

↪IEnumerable<IEdge>: An enumerable collection of edges connecting the source to the target.

Overrides

IGraph.getEdgesBetween(yfiles.graph.IPortOwner,yfiles.graph.IPortOwner,boolean)

getEdgesBetween

(sourcePort: IPort, targetPort: IPort, directed?: boolean) : IEnumerable<IEdge>

Returns the edges between the specified source and target ports.

Remarks

By default, only directed edges are returned. To retrieve all edges (both incoming and outgoing), set directed to false.

Parameters

options - Object
A map of options to pass to the method.

sourcePort - IPort: The port from which the edges start.
targetPort - IPort: The port at which the edges end.
directed - boolean: Specifies whether to return only directed edges (default) or all edges regardless of direction.

Returns

↪IEnumerable<IEdge>: An enumerable collection of edges connecting the sourcePort to the targetPort.

Overrides

IGraph.getEdgesBetween(yfiles.graph.IPort,yfiles.graph.IPort,boolean)

getLabelDefaults

(owner: ILabelOwner) : ILabelDefaults

Gets the ILabelDefaults for a given ILabelOwner in the context of the graph.

Parameters

options - Object
A map of options to pass to the method.

owner - ILabelOwner: The item that the label defaults are returned for. If this is a group node, the groupNodeDefaults's label defaults will be returned, otherwise the nodeDefaults or edgeDefaults labels will be returned.

Returns

↪ILabelDefaults: Appropriate ILabelDefaults for the provided owner.

Overrides

IGraph.getLabelDefaults

getParent

(node: INode) : INode

Returns the parent node of the node or null if node is a top-level node.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node to retrieve the parent node for.

Returns

↪INode?: The parent node in this hierarchy or null if node is a top-level node.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph.

Overrides

IGraph.getParent

getPortDefaults

(owner: IPortOwner) : IPortDefaults

Gets the IPortDefaults for a given IPortOwner in the context of the graph.

Parameters

options - Object
A map of options to pass to the method.

owner - IPortOwner: The item that the label defaults are returned for. If this is a group node, the groupNodeDefaults's port defaults will be returned, otherwise the nodeDefaults or edgeDefaults ports will be returned.

Returns

↪IPortDefaults: Appropriate IPortDefaults for the provided owner.

Overrides

IGraph.getPortDefaults

groupNodes

(parent: INode, children: IEnumerable<INode>)

Groups the nodes in children into the provided group node.

Remarks

The parent needs to be a group node at the time of the invocation. This operation is basically the same as calling setParent for each node in children whose parent is not part of the set.

How to create add multiple children to a group node

// create some nodes
const children = []
for (let i = 0; i < 5; i++) {
  children.push(graph.createNode())
}
// create a group node
const parent = graph.createGroupNode()
// add the nodes as children to the group
graph.groupNodes(parent, children)
// adjust the group node's layout to include all its children
graph.adjustGroupNodeLayout(parent)

ParametersOptions Overload

options - Object
A map of options to pass to the method.

parent - INode: The node to use as the parent in the grouping hierarchy.
children - IEnumerable<INode>: The children to group into the group node.

Throws

Exception({ name: 'ArgumentError' }): parent or one of children is not in this graph.

Overrides

IGraph.groupNodes(yfiles.graph.INode,yfiles.collections.IEnumerable)

groupNodes

(children: IEnumerable<INode>, style?: INodeStyle, tag?: any) : INode

Groups the nodes in children into a newly created group node.

Remarks

The group node will be created at the common ancestor level of all nodes in children.

How to create a new group node with multiple children

// create some nodes
const children = []
for (let i = 0; i < 5; i++) {
  children.push(graph.createNode())
}
// create a group node and add the given nodes as children
const group = graph.groupNodes(children)
// adjust the group node's layout to include all its children
graph.adjustGroupNodeLayout(group)

ParametersOptions Overload

options - Object
A map of options to pass to the method.

children - IEnumerable<INode>: The children to group into the new group node.
style - INodeStyle: The style for the new group node
tag - any: The group node's tag
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.
labels - string[]: An array of labels to add to the newly created node. Each item will be passed to the addLabel method.
ports - IPortLocationModelParameter[]: An array of ports to add to the newly created node. Each item will be passed to the addPort method.

Returns

↪INode: The newly created group node.

Throws

Exception({ name: 'ArgumentError' }): One of children is not in this graph.

Overrides

IGraph.groupNodes(yfiles.collections.IEnumerable,yfiles.styles.INodeStyle,any)

inDegree

(owner: IPortOwner) : number

Calculates the number of incoming edges at the given IPortOwner for this graph.

Parameters

options - Object
A map of options to pass to the method.

owner - IPortOwner: The port owner to count the incoming edges of.

Returns

↪number: The number of edges that have the port owner as their target port's owner.

Throws

Exception({ name: 'ArgumentError' }): owner is not in this graph.

Overrides

IGraph.inDegree(yfiles.graph.IPortOwner)

inDegree

(port: IPort) : number

Calculates the number of incoming edges at the given IPort for this graph.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: The port to count the incoming edges of.

Returns

↪number: The number of edges that have the port as their target port.

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph.

Overrides

IGraph.inDegree(yfiles.graph.IPort)

inEdgesAt

(owner: IPortOwner) : IListEnumerable<IEdge>

Returns the incoming edges at the given owner.

Remarks

This method delegates to edgesAt using INCOMING.

Parameters

options - Object
A map of options to pass to the method.

owner - IPortOwner: The owner of the edges.

Returns

↪IListEnumerable<IEdge>: An enumerable for the edges.

Throws

Exception({ name: 'ArgumentError' }): owner is not in this graph.

Overrides

IGraph.inEdgesAt(yfiles.graph.IPortOwner)

inEdgesAt

(port: IPort) : IListEnumerable<IEdge>

Returns the incoming edges at the given port.

Remarks

This method delegates to edgesAt using INCOMING.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: The port of the edges.

Returns

↪IListEnumerable<IEdge>: An enumerable for the edges.

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph.

Overrides

IGraph.inEdgesAt(yfiles.graph.IPort)

invalidateDisplays

()

Causes the displays-invalidated event to be triggered.

Remarks

This method may be called by client code to invalidate all views of the graph that have registered with the displays-invalidated event. Views that need to be informed if non-structural changes have been made to the graph should register with the corresponding event.

Implements

IGraph

isGroupNode

(node: INode) : boolean

Returns whether the given node is a group node.

Remarks

Group nodes are nodes which can have children. They may have children but do not necessarily have to.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node to check.

Returns

↪boolean: Whether the node is considered a group node.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph.

Overrides

IGraph.isGroupNode

lookup

<T>(type: Constructor<T>) : T

Returns an instance that implements the given type or null.

Remarks

Typically, this method will be called to obtain a different view or aspect of the current instance. This is quite similar to casting or using a super type or interface of this instance, but is not limited to inheritance or compile-time constraints. An instance implementing this method is not required to return non-null implementations for the types, nor does it have to return the same instance any time. Also, it depends on the type and context whether the instance returned stays up to date or needs to be re-obtained for further use.

Type Parameters

T

Parameters

options - Object
A map of options to pass to the method.

type - Constructor<T>: the type for which an instance shall be returned

Returns

↪T?: an instance that is assignable to the type or null

Implements

ILookup

neighbors

(node: INode) : IEnumerable<INode>

Enumerates the neighbors of a given INode.

Remarks

Neighbors are calculated by going through all ports and inspecting the edges at these ports, collecting the opposites.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node.

Returns

↪IEnumerable<INode>: An enumerable over all neighbors.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph.

Overrides

IGraph.neighbors

nodePredicateChanged

(node: INode)

Should be called by the client when the nodePredicate has changed for the specified node.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node for which the nodePredicate has changed.

nodePredicateChanged

()

Should be called by the client if the nodePredicate changed for the nodes in the graph.

onBendAdded

(evt: ItemEventArgs<IBend>)

Raises the bend-added event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemEventArgs<IBend>: The parameters for the event

Defined in

GraphWrapperBase

onBendLocationChanged

(bend: IBend, oldLocation: Point)

Raises the bend-location-changed event

Parameters

options - Object
A map of options to pass to the method.

bend - IBend: The bend whose location changed
oldLocation - Point: The bend location before the change

Defined in

GraphWrapperBase

onBendRemoved

(evt: BendEventArgs)

Raises the bend-removed event.

Parameters

options - Object
A map of options to pass to the method.

evt - BendEventArgs: The parameters for the event

Defined in

GraphWrapperBase

onBendTagChanged

(evt: ItemChangedEventArgs<IBend,any>)

Raises the bend-tag-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<IBend,any>: The parameters for the event.

Defined in

GraphWrapperBase

onEdgeCreated

(evt: ItemEventArgs<IEdge>)

Raises the edge-created event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemEventArgs<IEdge>: The parameters for the event

Defined in

GraphWrapperBase

onEdgePortsChanged

(evt: EdgeEventArgs)

Raises the edge-ports-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - EdgeEventArgs: The parameters for the event.

Defined in

GraphWrapperBase

onEdgeRemoved

(evt: EdgeEventArgs)

Raises the edge-removed event.

Parameters

options - Object
A map of options to pass to the method.

evt - EdgeEventArgs: The parameters for the event.

Defined in

GraphWrapperBase

onEdgeStyleChanged

(evt: ItemChangedEventArgs<IEdge,IEdgeStyle>)

Raises the edge-style-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<IEdge,IEdgeStyle>: The parameters for the event.

Defined in

GraphWrapperBase

onEdgeTagChanged

(evt: ItemChangedEventArgs<IEdge,any>)

Raises the edge-tag-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<IEdge,any>: The parameters for the event

Defined in

GraphWrapperBase

onGraphChanged

(oldGraph: IGraph, newGraph: IGraph)

Called when the wrappedGraph property value changes and after initialization of the field.

Remarks

Delegates to addEventHandlers for newGraph and to removeEventHandlers for oldGraph.

Parameters

options - Object
A map of options to pass to the method.

oldGraph - IGraph: the old value, which may be null the first time
newGraph - IGraph: the new value

Overrides

GraphWrapperBase.onGraphChanged

onGraphTagChanged

(evt: ItemChangedEventArgs<IGraph,any>)

Raises the graph-tag-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<IGraph,any>: The parameters for the event.

Defined in

GraphWrapperBase

onInvalidateDisplays

(evt: EventArgs)

Raises the displays-invalidated event

Parameters

options - Object
A map of options to pass to the method.

evt - EventArgs: The parameters for the event

Defined in

GraphWrapperBase

onIsGroupNodeChanged

(evt: NodeEventArgs)

Dispatches the is-group-node-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - NodeEventArgs: The event args to dispatch.

Defined in

GraphWrapperBase

onLabelAdded

(evt: ItemEventArgs<ILabel>)

Raises the label-added event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemEventArgs<ILabel>: The parameters for the event.

Defined in

GraphWrapperBase

onLabelLayoutParameterChanged

(evt: ItemChangedEventArgs<ILabel,ILabelModelParameter>)

Raises the label-layout-parameter-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<ILabel,ILabelModelParameter>: The parameters for the event.

Defined in

GraphWrapperBase

onLabelPreferredSizeChanged

(evt: ItemChangedEventArgs<ILabel,Size>)

Raises the label-preferred-size-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<ILabel,Size>: The parameters for the event.

Defined in

GraphWrapperBase

onLabelRemoved

(evt: LabelEventArgs)

Raises the label-removed event.

Parameters

options - Object
A map of options to pass to the method.

evt - LabelEventArgs: The parameters for the event.

Defined in

GraphWrapperBase

onLabelStyleChanged

(evt: ItemChangedEventArgs<ILabel,ILabelStyle>)

Raises the label-style-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<ILabel,ILabelStyle>: The parameters for the event.

Defined in

GraphWrapperBase

onLabelTagChanged

(evt: ItemChangedEventArgs<ILabel,any>)

Raises the label-tag-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<ILabel,any>: The parameters for the event

Defined in

GraphWrapperBase

onLabelTextChanged

(evt: ItemChangedEventArgs<ILabel,string>)

Raises the label-text-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<ILabel,string>: The parameters for the event.

Defined in

GraphWrapperBase

onNodeCreated

(evt: ItemEventArgs<INode>)

Raises the node-created event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemEventArgs<INode>: The parameters for the event

Defined in

GraphWrapperBase

onNodeLayoutChanged

(node: INode, oldLayout: Rect)

Raises the node-layout-changed event.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node whose layout changed.
oldLayout - Rect: The node layout before the change.

Defined in

GraphWrapperBase

onNodeRemoved

(evt: NodeEventArgs)

Raises the node-removed event.

Parameters

options - Object
A map of options to pass to the method.

evt - NodeEventArgs: The parameters for the event.

Overrides

GraphWrapperBase.onNodeRemoved

onNodeStyleChanged

(evt: ItemChangedEventArgs<INode,INodeStyle>)

Raises the node-style-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<INode,INodeStyle>: The parameters for the event

Defined in

GraphWrapperBase

onNodeTagChanged

(evt: ItemChangedEventArgs<INode,any>)

Raises the node-tag-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<INode,any>: The parameters for the event.

Defined in

GraphWrapperBase

onParentChanged

(evt: NodeEventArgs)

Dispatches the parent-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - NodeEventArgs: The event args to dispatch.

Defined in

GraphWrapperBase

onPortAdded

(evt: ItemEventArgs<IPort>)

Raises the port-added event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemEventArgs<IPort>: The parameters for the event.

Defined in

GraphWrapperBase

onPortLocationParameterChanged

(evt: ItemChangedEventArgs<IPort,IPortLocationModelParameter>)

Raises the port-location-parameter-changed event

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<IPort,IPortLocationModelParameter>: The parameters for the event

Defined in

GraphWrapperBase

onPortRemoved

(evt: PortEventArgs)

Raises the port-removed event.

Parameters

options - Object
A map of options to pass to the method.

evt - PortEventArgs: The parameters for the event.

Defined in

GraphWrapperBase

onPortStyleChanged

(evt: ItemChangedEventArgs<IPort,IPortStyle>)

Raises the port-style-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<IPort,IPortStyle>: The parameters for the event.

Defined in

GraphWrapperBase

onPortTagChanged

(evt: ItemChangedEventArgs<IPort,any>)

Raises the port-tag-changed event.

Parameters

options - Object
A map of options to pass to the method.

evt - ItemChangedEventArgs<IPort,any>: The parameters for the event.

Defined in

GraphWrapperBase

outDegree

(owner: IPortOwner) : number

Calculates the number of outgoing edges at the given IPortOwner for this graph.

Parameters

options - Object
A map of options to pass to the method.

owner - IPortOwner: The port owner to count the outgoing edges of.

Returns

↪number: The number of edges that have the port owner as their source port's owner.

Throws

Exception({ name: 'ArgumentError' }): owner is not in this graph.

Overrides

IGraph.outDegree(yfiles.graph.IPortOwner)

outDegree

(port: IPort) : number

Calculates the number of outgoing edges at the given IPort for this graph.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: The port to count the outgoing edges of.

Returns

↪number: The number of edges that have the port as their source port.

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph.

Overrides

IGraph.outDegree(yfiles.graph.IPort)

outEdgesAt

(owner: IPortOwner) : IListEnumerable<IEdge>

Returns the outgoing edges at the given owner.

Remarks

This method delegates to edgesAt using OUTGOING.

Parameters

options - Object
A map of options to pass to the method.

owner - IPortOwner: The owner of the edges.

Returns

↪IListEnumerable<IEdge>: An enumerable for the edges.

Throws

Exception({ name: 'ArgumentError' }): owner is not in this graph.

Overrides

IGraph.outEdgesAt(yfiles.graph.IPortOwner)

outEdgesAt

(port: IPort) : IListEnumerable<IEdge>

Returns the outgoing edges at the given port.

Remarks

This method delegates to edgesAt using OUTGOING.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: The owner of the edges.

Returns

↪IListEnumerable<IEdge>: An enumerable for the edges.

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph.

Overrides

IGraph.outEdgesAt(yfiles.graph.IPort)

predecessors

(node: INode) : IEnumerable<INode>

Enumerates the predecessors of a given INode.

Remarks

Predecessors are calculated by going through all ports and inspecting the incoming edges at these ports, collecting the sourcePort owners.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node.

Returns

↪IEnumerable<INode>: An enumerable over all predecessors.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph.

Overrides

IGraph.predecessors

remove

(item: IModelItem)

Removes the given item from this graph.

Remarks

The item must be a part of this graph.

If the item is a node, the node-removed event will be triggered. This will remove all adjacent edges and their corresponding ports in proper order before the node will be removed. Also, this will trigger the removal of all labels owned by this instance.

If the item is an edge, the edge-removed event will be triggered. Also, this will trigger the removal of all labels and bends owned by this instance. An implementation may decide to remove the corresponding ports from the node if no other edge connects to them after the given edge has been removed. The implementations provided by yFiles do so according to the value set to autoCleanUp in their IPortDefaults.

If the item is a bend, the bend-removed event will be triggered.

If the item is a port, the port-removed event will be triggered. This will also remove all edges that are currently connected to the port and all labels and bends owned by this instance.

If the item is a label, the label-removed event will be triggered.

Parameters

options - Object
A map of options to pass to the method.

item - IModelItem: the item to be removed from this graph instance

Throws

Exception({ name: 'ArgumentError' }): item is not in this graph.

Implements

IGraph

removeEventHandlers

(graph: IGraph)

Removes event handlers for graph that have been added with addEventHandlers.

Parameters

options - Object
A map of options to pass to the method.

graph - IGraph: The graph for which event propagators should be removed

Overrides

GraphWrapperBase.removeEventHandlers

reverse

(edge: IEdge)

Reverses an edge by setting source and target port to targetPort and sourcePort.

Remarks

This also reverses the bends by clearing them and reinserting them in reverse order if there is more than one bend.

Parameters

options - Object
A map of options to pass to the method.

edge - IEdge: The edge to reverse.

Throws

Exception({ name: 'ArgumentError' }): edge is not in this graph.

Overrides

IGraph.reverse

setBendLocation

(bend: IBend, location: Point)

Modifies the location of the given bend.

Remarks

To query a bend location, use location.

Parameters

options - Object
A map of options to pass to the method.

bend - IBend: the bend whose location is to be modified
location - Point: the new location of the bend

Throws

Exception({ name: 'ArgumentError' }): bend is not in this graph, or location contains one or more NaN values.

Implements

IGraph

setEdgePorts

(edge: IEdge, sourcePort: IPort, targetPort: IPort)

Sets the source and target ports of the given edge to the new values.

Remarks

This will trigger an edge-ports-changed event if source or target ports differ from the current ones. Both ports and the edge must belong to the current graph instance.

An implementation may decide to remove the corresponding ports if no other edge connects to them after the given edge has its source or target port changed. The implementations provided by yFiles do so according to the value set to autoCleanUp in their IPortDefaults.

To query the current source and target ports, you can use the sourcePort and targetPort properties.

Parameters

options - Object
A map of options to pass to the method.

edge - IEdge: The edge to change the ports.
sourcePort - IPort: The new source port instance.
targetPort - IPort: The new target port instance.

Throws

Exception({ name: 'ArgumentError' }): Either edge, sourcePort, or targetPort are not in this graph.

Implements

IGraph

setIsGroupNode

(node: INode, isGroupNode: boolean)

Changes whether the given node is a group node or not.

Remarks

Group nodes are nodes which can have children. They may not necessarily have to, however.

Attempting to set a node to the non-group-node-status while it has children at the same time will result in an InvalidOperationError.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node to set the group node status for.
isGroupNode - boolean: Whether to make the node a group node.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph.
Exception({ name: 'InvalidOperationError' }): node is null or currently has children and isGroupNode is false.

Overrides

IGraph.setIsGroupNode

setLabelLayoutParameter

(label: ILabel, layoutParameter: ILabelModelParameter)

Sets the label model parameter for the given label.

Remarks

To query the label layout parameter, use layoutParameter.

Parameters

options - Object
A map of options to pass to the method.

label - ILabel: The label.
layoutParameter - ILabelModelParameter: The new parameter.

Throws

Exception({ name: 'ArgumentError' }): label is not in this graph, or layoutParameter cannot be used for label.

Implements

IGraph

setLabelPreferredSize

(label: ILabel, preferredSize: Size)

Sets the preferred size of the label.

Remarks

To query the label preferred size, use preferredSize.

Parameters

options - Object
A map of options to pass to the method.

label - ILabel: The label.
preferredSize - Size: The new preferred size.

Throws

Exception({ name: 'ArgumentError' }): label is not in this graph or preferredSize contains one or more NaN values.

Implements

IGraph

setLabelText

(label: ILabel, text: string)

Sets the label text of the given label.

Remarks

To query the label text, use text.

Parameters

options - Object
A map of options to pass to the method.

label - ILabel: the label to modify
text - string: the new text of the label

Throws

Exception({ name: 'ArgumentError' }): label is not in this graph.

Implements

IGraph

setNodeCenter

(node: INode, center: Point)

Sets the center of a node to the given world coordinates.

Remarks

This implementation delegates to setNodeLayout

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node to recenter.
center - Point: The new center coordinates of the node in the world coordinate system.

Throws

Exception({ name: 'ArgumentError' }): center contains one or more NaN values.

Overrides

IGraph.setNodeCenter

setNodeLayout

(node: INode, layout: Rect)

Sets the layout of the given node to the new value.

Remarks

To query the node layout, use layout. To place the node center at an absolute location, you can use the setNodeCenter convenience method.

Parameters

options - Object
A map of options to pass to the method.

node - INode: a live node that belongs to this graph
layout - Rect: The new layout of the node to assign to its layout.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph, or layout contains one or more NaN values.

Implements

IGraph

setParent

(node: INode, parent: INode)

Sets the parent node for a given node.

Remarks

Use null as parent to make node a top-level node for this graph.

This method does not move or enlarge the parent to enclose its new node. Developers have to take care to adjust the node layout after grouping, e.g. by calling adjustGroupNodeLayout.

If parent is not a group node before the call it will be converted into one.

To query the parent of a node, use getParent.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node to assign a new parent.
parent - INode: The parent group node to assign to node or null to make node a top-level node.

Throws

Exception({ name: 'ArgumentError' }): Either node or parent is not in this graph.

Overrides

IGraph.setParent

setPortLocation

(port: IPort, location: Point)

Tries to set the absolute coordinates of the given port to the given values.

Remarks

For full control over the placement of the ports, the setPortLocationParameter method should be used instead. This implementation will use the port's locationParameter's model to obtain a new IPortLocationModelParameter via the createParameter method. This might result in the port using a different location, because the model might not support parameters that result in the given location. This will also trigger an invalidateDisplays call.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: The port to modify
location - Point: the new absolute coordinates of the port

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph.
Exception({ name: 'ArgumentError' }): location contains one or more NaN values.

Overrides

IGraph.setPortLocation

setPortLocationParameter

(port: IPort, locationParameter: IPortLocationModelParameter)

Sets a new IPortLocationModelParameter for the given port.

Remarks

To query the port location parameter, use locationParameter. To place the port at an absolute resp. relative location, you can use the setPortLocation resp. setRelativePortLocation convenience methods.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: The port to modify
locationParameter - IPortLocationModelParameter: The new parameter that determines the coordinates of the port

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph, or locationParameter cannot be used for port.

Implements

IGraph

setRelativePortLocation

(port: IPort, relativeLocation: Point)

Tries to set the location of the port relative to its owner if the owner is a node.

Remarks

If the port is not owned by a node that is part of this graph, this method will throw an ArgumentError. This method will delegate to setPortLocation.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: the port
relativeLocation - Point: the new coordinate offsets relative to the center of the node's layout's center.

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph or has no owner.
Exception({ name: 'ArgumentError' }): relativeLocation contains one or more NaN values.

Overrides

IGraph.setRelativePortLocation

setStyle

(node: INode, style: INodeStyle)

Assigns the given style instance by reference to the node.

Remarks

Style instances can be shared.

To query the node style, use style.

Styles are automatically converted between WebGL and SVG rendering modes. Due to differences in feature sets, conversion may not be exact. For better control, apply styles specific to the rendering mode or use a WebGLNodeStyleDecorator style when switching render modes.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node that will be assigned the new style
style - INodeStyle: The style instance that will be assigned to the node.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph.

Implements

IGraph

setStyle

(label: ILabel, style: ILabelStyle)

Assigns the given style instance by reference to the label.

Remarks

Style instances can be shared.

To query the label style, use style.

Styles are automatically converted between WebGL and SVG rendering modes. Due to differences in feature sets, conversion may not be exact. For better control, apply styles specific to the rendering mode or use a WebGLLabelStyleDecorator style when switching render modes.

Parameters

options - Object
A map of options to pass to the method.

label - ILabel: The label that will be assigned the new style
style - ILabelStyle: The style instance that will be assigned to the label.

Throws

Exception({ name: 'ArgumentError' }): label is not in this graph.

Implements

IGraph

setStyle

(edge: IEdge, style: IEdgeStyle)

Assigns the given style instance by reference to the edge.

Remarks

Style instances can be shared.

To query the edge style, use style.

Styles are automatically converted between WebGL and SVG rendering modes. Due to differences in feature sets, conversion may not be exact. For better control, apply styles specific to the rendering mode or use a WebGLEdgeStyleDecorator style when switching render modes.

Parameters

options - Object
A map of options to pass to the method.

edge - IEdge: The edge that will be assigned the new style
style - IEdgeStyle: The style instance that will be assigned to the edge.

Throws

Exception({ name: 'ArgumentError' }): edge is not in this graph.

Implements

IGraph

setStyle

(port: IPort, style: IPortStyle)

Assigns the given style instance by reference to the port.

Remarks

Style instances can be shared.

To query the port style, use style.

Parameters

options - Object
A map of options to pass to the method.

port - IPort: The port that will be assigned the new style
style - IPortStyle: The style instance that will be assigned to the port.

Throws

Exception({ name: 'ArgumentError' }): port is not in this graph.

Implements

IGraph

successors

(node: INode) : IEnumerable<INode>

Enumerates the successors of a given INode.

Remarks

Successors are calculated by going through all ports and inspecting the outgoing edges at these ports, collecting the targetPort owners.

Parameters

options - Object
A map of options to pass to the method.

node - INode: The node.

Returns

↪IEnumerable<INode>: An enumerable over all successors.

Throws

Exception({ name: 'ArgumentError' }): node is not in this graph.

Overrides

IGraph.successors

Events

'bend-added'

: function(ItemEventArgs<IBend>, this):void

Occurs when a bend has been added to an edge in this graph.

Remarks

This event is intended to provide notification of low level changes in the graph structure. Please use the bend-created event if you are interested only in bend creation events that result from user interaction.

Overrides

IGraph.added

'bend-location-changed'

: function(IBend, Point, this):void

Occurs when the location of a bend has been changed.

Remarks

This event is intended to provide notification of low level changes in the graph structure.

Overrides

IGraph.changed

'bend-removed'

: function(BendEventArgs, this):void

Occurs when a bend has been removed from an edge in this graph.

Remarks

Remarks

This event is intended to provide notification of low level changes in the graph structure. Please use the deleted-item event if you are interested only in port removal events that result from user interaction.

Overrides

IGraph.removed

'port-style-changed'

: function(ItemChangedEventArgs<IPort,IPortStyle>, this):void

Occurs when a port style has been replaced.

Remarks

This event is intended to provide notification of low level changes in the graph structure.

Overrides

IGraph.changed

'port-tag-changed'

: function(ItemChangedEventArgs<IPort,any>, this):void

Occurs when the tag of a port has been replaced.

Remarks

This event is intended to provide notification of low level changes in the graph structure.

Overrides

IGraph.changed

FilteredGraphWrapper

Remarks

Related Programming Samples

Type Details

Constructors

FilteredGraphWrapper

Remarks

Parameters

Signature Details

Parameters

Returns

Signature Details

Parameters

Returns

Throws

Properties

bends

See Also

Overrides

decorator

Overrides

edgeDefaults

Remarks

Implements

edgeLabels

Overrides

edgePredicate

Remarks

Signature Details

Parameters

Returns

edges

Remarks

Overrides

foldingView

Remarks

See Also

Overrides

groupingSupport

Remarks

Overrides

groupNodeDefaults

Remarks

Implements

labels

Remarks

See Also

Overrides

nodeDefaults

Remarks

Implements

nodeLabels

Overrides

nodePredicate

Remarks

Signature Details

Parameters

Returns

nodes

Remarks

Overrides

portLabels

Overrides

ports

Remarks

Overrides

tag

Remarks

Implements

undoEngine

Remarks

Overrides

undoEngineEnabled

See Also

Overrides

wrappedGraph

Property Value

Defined in

Methods

addBend