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).

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 any more. 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-component
yfiles-umd modules: All view modules
Legacy UMD name: yfiles.graph.FilteredGraphWrapper

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 afterwards 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 the predicate function for the edges.

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 folding view 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

mapperRegistry

: IMapperRegistry

Gets the mapper registry that is associated with this graph instance.

Remarks

The registry can be used to store data mappings for the items in this instance.

Implements

IGraph

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 the predicate function for the nodes.

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

tag

: any

Gets or sets the tag associated with this instance.

Remarks

The tag is an optional user-defined object which can be used to store arbitrary data related to this item. The item itself does not normally depend on the tag associated with it. It serves as storage for the object only.

Implements

ITagOwner

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.

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?: Object) : 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 - Object: 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?: Object) : 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 an NotSupportedError if the type of the owner instance does not support adding of 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. INSTANCE. To change the style after the port has been added, use setStyle.
tag - Object: 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?: Object) : 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. INSTANCE.
tag - Object: 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)

Convenience method that 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.getPathToRoot(
  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, updateContentRect?: boolean, automaticEdgeGrouping?: boolean, configureTableLayout?: boolean, considerViewportLimiter?: boolean, fixPorts?: boolean, hideEdgesAtEdges?: boolean, portAdjustmentPolicy?: PortAdjustmentPolicy, portLabelPolicies?: ItemMapping<ILabel,PortLabelPolicy>, targetBoundsInsets?: Insets, labelPreferredPlacementPolicy?: LabelPreferredPlacementPolicy)

Runs an ILayoutAlgorithm synchronously on the given graph.

Remarks

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

ParametersOptions Overload

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

layout - ILayoutAlgorithm: The layout.
layoutData - LayoutData: The layout data.
updateContentRect - boolean: A value indicating whether the content rectangle property of the CanvasComponent
automaticEdgeGrouping - boolean: A value indicating whether edge groups are automatically created for edges that are connected to the same port.
configureTableLayout - boolean: A value indicating whether to automatically perform calls to prepare and restore in order to layout table nodes.
considerViewportLimiter - boolean: A value that controls whether strong port constraints are automatically created.
fixPorts - boolean: A value that controls whether strong port constraints are automatically created.
hideEdgesAtEdges - boolean: A value that controls whether edges at other edges will be hidden from the layout graph or included.
portAdjustmentPolicy - PortAdjustmentPolicy: The policy that specifies how port locations should be adjusted after a layout has been calculated.
portLabelPolicies - ItemMapping<ILabel,PortLabelPolicy>: Sets how ILabels at IPorts should be treated by the layout algorithm.
targetBoundsInsets - Insets: the insets (in world coordinates) that will be added to the content rectangle when calculating the target viewport.
labelPreferredPlacementPolicy - LabelPreferredPlacementPolicy: The policy that specifies how edge labels should be treated by the layout algorithm.

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) {
  _name
  position
  age

  /**
   * @param {!string} name
   * @param {!string} position
   * @param {number} age
   */
  constructor(name, position, age) {
    super()
    this._name = name
    this.position = position
    this.age = age
  }

  /**
   * @type {!string}
   */
  get name() {
    return this._name
  }

  /**
   * @template {*} T
   * @param {!Class.<T>} type
   * @returns {?T}
   */
  lookup(type) {
    if (type === IMementoSupport.$class) {
      return new EmployeeMementoSupport()
    }
    return null
  }
}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
  }

  @typescript-eslint/no-unnecessary-type-constraint
  lookup<T extends any>(type: Class<T>): T | null {
    if (type === IMementoSupport.$class) {
      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 {
  _name
  position
  age

  /**
   * @param {!string} name
   * @param {!string} position
   * @param {number} age
   */
  constructor(name, position, age) {
    this._name = name
    this.position = position
    this.age = age
  }

  /**
   * @type {!string}
   */
  get name() {
    return this._name
  }
}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) {
  /**
   * @param {*} subject
   * @returns {?EmployeeState}
   */
  getState(subject) {
    if (subject instanceof Employee) {
      return new EmployeeState(subject.position, subject.age)
    }
    return null
  }

  /**
   * @param {*} subject
   * @param {*} state
   */
  applyState(subject, state) {
    if (subject instanceof Employee && state instanceof EmployeeState) {
      subject.position = state.position
      subject.age = state.age
    }
  }

  /**
   * @param {*} state1
   * @param {*} state2
   * @returns {boolean}
   */
  stateEquals(state1, state2) {
    if (state1 instanceof EmployeeState && state2 instanceof EmployeeState) {
      return state1.position === state2.position && state1.age === state2.age
    }
    return state1 === state2
  }
}
class EmployeeState {
  _position
  _age

  /**
   * @param {!string} position
   * @param {number} age
   */
  constructor(position, age) {
    this._position = position
    this._age = age
  }

  /**
   * @type {!string}
   */
  get position() {
    return this._position
  }

  /**
   * @type {number}
   */
  get age() {
    return this._age
  }
}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?: Object) : 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 - Object: 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

(edge: 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.

edge - IEdge: the edge whose bends will be removed

Throws

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

Overrides

IGraph.clearBends

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

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?: Object) : 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 - Object: 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.

Returns

↪IEdge: the newly created edge instance

Implements

IGraph

createEdge

(source: INode, target: INode, style?: IEdgeStyle, tag?: Object) : 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 - Object: 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.

Returns

↪IEdge: the newly created edge instance

Implements

IGraph

createGroupNode

(parent?: INode, layout?: Rect, style?: INodeStyle, tag?: Object) : 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 - Object: 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.

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?: Object) : 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 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 - Object: 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.

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?: Object) : 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 - Object: 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' }): layout contains one or more NaN values.

Implements

IGraph

createNodeAt

(location: Point, style?: INodeStyle, tag?: Object) : 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 - Object: 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 if the edgePredicate changed for the given edge in the graph.

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 IEnumerable<T> for all edges that are adjacent to the given port as a sourcePort or targetPort.

Remarks

Parameters

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

port - IPort: the port to check
type - AdjacencyTypes: The type of adjacency to consider.

Returns

↪IListEnumerable<IEdge>: An enumeration of all adjacent edges of the given type.

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 all edges that have the given port owner as their target port's or source port's owner depending on the AdjacencyTypes

Remarks

Parameters

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

owner - IPortOwner: the port owner to check
type - AdjacencyTypes: The type of adjacency to consider.

Returns

↪IListEnumerable<IEdge>: An enumeration of all adjacent edges of the given type.

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)

getLabelDefaults

(owner: ILabelOwner) : ILabelDefaults

Gets the label defaults 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

getLookup

() : ILookup

Gets the lookup instance to use in lookup

Defined in

GraphWrapperBase

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 port defaults 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>) : 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.
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)

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>

Convenience method that yields 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>

Convenience method that yields 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 DisplaysInvalidated 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 DisplaysInvalidated 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

<Textends any>(type: Class<T>) : T

Returns an instance that implements the given type or null.

Remarks

Typically, this method will be called in order 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 reobtained for subsequent use.

Type Parameters

T: any

Parameters

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

type - Class<T>: The type for which an instance shall be returned.

Returns

↪T: an instance that is assignable to 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 clients if the nodePredicate changed for the given node.

Parameters

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

node - INode: The node.

nodePredicateChanged

()

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

onBendAdded

(evt: ItemEventArgs<IBend>)

Raises the BendAdded 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 BendLocationChanged 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 BendRemoved 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,Object>)

Raises the BendTagChanged event

Parameters

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

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

Defined in

GraphWrapperBase

onEdgeCreated

(evt: ItemEventArgs<IEdge>)

Raises the EdgeCreated 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 EdgePortsChanged 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 EdgeRemoved 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 EdgeStyleChanged 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,Object>)

Raises the EdgeTagChanged event

Parameters

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

evt - ItemChangedEventArgs<IEdge,Object>: 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,Object>)

Raises the GraphTagChanged event

Parameters

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

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

Defined in

GraphWrapperBase

onInvalidateDisplays

(evt: EventArgs)

Raises the DisplaysInvalidated 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 IsGroupNodeChanged 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 LabelAdded 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 LabelLayoutParameterChanged 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 LabelPreferredSizeChanged 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 LabelRemoved 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 LabelStyleChanged 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,Object>)

Raises the LabelTagChanged event

Parameters

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

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

Defined in

GraphWrapperBase

onLabelTextChanged

(evt: ItemChangedEventArgs<ILabel,string>)

Raises the LabelTextChanged 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 NodeCreated 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 NodeLayoutChanged 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 NodeRemoved 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 NodeStyleChanged 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,Object>)

Raises the NodeTagChanged event

Parameters

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

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

Defined in

GraphWrapperBase

onParentChanged

(evt: NodeEventArgs)

Dispatches the ParentChanged 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 PortAdded 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 PortLocationParameterChanged 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 PortRemoved 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 PortStyleChanged 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,Object>)

Raises the PortTagChanged event

Parameters

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

evt - ItemChangedEventArgs<IPort,Object>: 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>

Convenience method that yields 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>

Convenience method that yields 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 NodeRemoved 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 EdgeRemoved 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 BendRemoved event will be triggered.

If the item is a port the PortRemoved 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 LabelRemoved 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 EdgePortsChanged 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

setLookup

(lookup: ILookup)

Sets the lookup instance to use in lookup

Defined in

GraphWrapperBase

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 are not in this graph.

Overrides

IGraph.setParent

setPortLocation

(port: IPort, location: Point)

Convenience method that 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.

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.

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.

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

BendAdded

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 BendCreated event if you are interested only in bend creation events that result from user interaction.

Overrides

IGraph.BendAdded

Event Registration

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

Event Deregistration

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

Signature Details

function(sender: this, evt: ItemEventArgs<IBend>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemEventArgs<IBend>: An object that contains the event data.

BendLocationChanged

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.BendLocationChanged

Event Registration

addBendLocationChangedListener(function(this, IBend, Point):void)

Event Deregistration

removeBendLocationChangedListener(function(this, IBend, Point):void)

Signature Details

function(source: any, bend: IBend, oldLocation: Point)

Event delegate method that is used in IGraph's BendLocationChanged event.

Parameters

source - any: The source of the event.
bend - IBend: The bend whose location has changed.
oldLocation - Point: The bend location before the change.

BendRemoved

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

Remarks

This event will be triggered, too, if an edge has been removed from the graph, for each of the bends that belonged to the edge.

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

Overrides

IGraph.BendRemoved

Event Registration

addBendRemovedListener(function(this, BendEventArgs):void)

Event Deregistration

removeBendRemovedListener(function(this, BendEventArgs):void)

Signature Details

function(sender: this, evt: BendEventArgs)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - BendEventArgs: An object that contains the event data.

BendTagChanged

Occurs when the tag of a bend has been replaced.

Remarks

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

Overrides

IGraph.BendTagChanged

Event Registration

addBendTagChangedListener(function(this, ItemChangedEventArgs<IBend,Object>):void)

Event Deregistration

removeBendTagChangedListener(function(this, ItemChangedEventArgs<IBend,Object>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<IBend,Object>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<IBend,Object>: An object that contains the event data.

DisplaysInvalidated

Occurs when the graph has changed visually and the display should be updated to reflect the changes.

Remarks

This event is invoked with EMPTY per default.

Overrides

IGraph.DisplaysInvalidated

Event Registration

addDisplaysInvalidatedListener(function(this, EventArgs):void)

Event Deregistration

removeDisplaysInvalidatedListener(function(this, EventArgs):void)

Signature Details

function(sender: this, evt: EventArgs)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - EventArgs: An object that contains the event data.

EdgeCreated

Occurs when an edge has been created.

Remarks

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

Overrides

IGraph.EdgeCreated

Event Registration

addEdgeCreatedListener(function(this, ItemEventArgs<IEdge>):void)

Event Deregistration

removeEdgeCreatedListener(function(this, ItemEventArgs<IEdge>):void)

Signature Details

function(sender: this, evt: ItemEventArgs<IEdge>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemEventArgs<IEdge>: An object that contains the event data.

EdgePortsChanged

Occurs when an edge had its sourcePort or targetPort changed.

Remarks

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

Overrides

IGraph.EdgePortsChanged

Event Registration

addEdgePortsChangedListener(function(this, EdgeEventArgs):void)

Event Deregistration

removeEdgePortsChangedListener(function(this, EdgeEventArgs):void)

Signature Details

function(sender: this, evt: EdgeEventArgs)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - EdgeEventArgs: An object that contains the event data.

EdgeRemoved

Occurs when an edge has been removed.

Remarks

This event will be triggered, too, prior to a node removal.

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

Overrides

IGraph.EdgeRemoved

Event Registration

addEdgeRemovedListener(function(this, EdgeEventArgs):void)

Event Deregistration

removeEdgeRemovedListener(function(this, EdgeEventArgs):void)

Signature Details

function(sender: this, evt: EdgeEventArgs)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - EdgeEventArgs: An object that contains the event data.

EdgeStyleChanged

Occurs when an edge style has been replaced.

Remarks

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

Overrides

IGraph.EdgeStyleChanged

Event Registration

addEdgeStyleChangedListener(function(this, ItemChangedEventArgs<IEdge,IEdgeStyle>):void)

Event Deregistration

removeEdgeStyleChangedListener(function(this, ItemChangedEventArgs<IEdge,IEdgeStyle>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<IEdge,IEdgeStyle>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<IEdge,IEdgeStyle>: An object that contains the event data.

EdgeTagChanged

Occurs when the tag of an edge has been replaced.

Remarks

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

Overrides

IGraph.EdgeTagChanged

Event Registration

addEdgeTagChangedListener(function(this, ItemChangedEventArgs<IEdge,Object>):void)

Event Deregistration

removeEdgeTagChangedListener(function(this, ItemChangedEventArgs<IEdge,Object>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<IEdge,Object>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<IEdge,Object>: An object that contains the event data.

GraphTagChanged

Occurs when the tag of the graph has been replaced.

Remarks

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

Overrides

IGraph.GraphTagChanged

Event Registration

addGraphTagChangedListener(function(this, ItemChangedEventArgs<IGraph,Object>):void)

Event Deregistration

removeGraphTagChangedListener(function(this, ItemChangedEventArgs<IGraph,Object>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<IGraph,Object>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<IGraph,Object>: An object that contains the event data.

IsGroupNodeChanged

Occurs if the group node status of a node has changed.

Overrides

IGraph.IsGroupNodeChanged

Event Registration

addIsGroupNodeChangedListener(function(this, NodeEventArgs):void)

Event Deregistration

removeIsGroupNodeChangedListener(function(this, NodeEventArgs):void)

Signature Details

function(sender: this, evt: NodeEventArgs)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - NodeEventArgs: An object that contains the event data.

LabelAdded

Occurs when a label has been added to this graph instance.

Remarks

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

Overrides

IGraph.LabelAdded

Event Registration

addLabelAddedListener(function(this, ItemEventArgs<ILabel>):void)

Event Deregistration

removeLabelAddedListener(function(this, ItemEventArgs<ILabel>):void)

Signature Details

function(sender: this, evt: ItemEventArgs<ILabel>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemEventArgs<ILabel>: An object that contains the event data.

LabelLayoutParameterChanged

Occurs when the model parameter of a label has been changed.

Remarks

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

Overrides

IGraph.LabelLayoutParameterChanged

Event Registration

addLabelLayoutParameterChangedListener(function(this, ItemChangedEventArgs<ILabel,ILabelModelParameter>):void)

Event Deregistration

removeLabelLayoutParameterChangedListener(function(this, ItemChangedEventArgs<ILabel,ILabelModelParameter>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<ILabel,ILabelModelParameter>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<ILabel,ILabelModelParameter>: An object that contains the event data.

LabelPreferredSizeChanged

Occurs when the preferred size of a label has been changed.

Remarks

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

Overrides

IGraph.LabelPreferredSizeChanged

Event Registration

addLabelPreferredSizeChangedListener(function(this, ItemChangedEventArgs<ILabel,Size>):void)

Event Deregistration

removeLabelPreferredSizeChangedListener(function(this, ItemChangedEventArgs<ILabel,Size>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<ILabel,Size>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<ILabel,Size>: An object that contains the event data.

LabelRemoved

Occurs when a label has been removed from this graph instance.

Remarks

This event will also be triggered, prior to the removal of the owner of the label.

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

Overrides

IGraph.LabelRemoved

Event Registration

addLabelRemovedListener(function(this, LabelEventArgs):void)

Event Deregistration

removeLabelRemovedListener(function(this, LabelEventArgs):void)

Signature Details

function(sender: this, evt: LabelEventArgs)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - LabelEventArgs: An object that contains the event data.

LabelStyleChanged

Occurs when a label style has been replaced.

Remarks

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

Overrides

IGraph.LabelStyleChanged

Event Registration

addLabelStyleChangedListener(function(this, ItemChangedEventArgs<ILabel,ILabelStyle>):void)

Event Deregistration

removeLabelStyleChangedListener(function(this, ItemChangedEventArgs<ILabel,ILabelStyle>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<ILabel,ILabelStyle>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<ILabel,ILabelStyle>: An object that contains the event data.

LabelTagChanged

Occurs when the tag of a label has been replaced.

Remarks

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

Overrides

IGraph.LabelTagChanged

Event Registration

addLabelTagChangedListener(function(this, ItemChangedEventArgs<ILabel,Object>):void)

Event Deregistration

removeLabelTagChangedListener(function(this, ItemChangedEventArgs<ILabel,Object>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<ILabel,Object>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<ILabel,Object>: An object that contains the event data.

LabelTextChanged

Occurs when the text of a label has been changed.

Remarks

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

Overrides

IGraph.LabelTextChanged

Event Registration

addLabelTextChangedListener(function(this, ItemChangedEventArgs<ILabel,string>):void)

Event Deregistration

removeLabelTextChangedListener(function(this, ItemChangedEventArgs<ILabel,string>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<ILabel,string>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<ILabel,string>: An object that contains the event data.

NodeCreated

Occurs when a node has been created.

Remarks

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

Overrides

IGraph.NodeCreated

Event Registration

addNodeCreatedListener(function(this, ItemEventArgs<INode>):void)

Event Deregistration

removeNodeCreatedListener(function(this, ItemEventArgs<INode>):void)

Signature Details

function(sender: this, evt: ItemEventArgs<INode>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemEventArgs<INode>: An object that contains the event data.

NodeLayoutChanged

Occurs when a node layout has been changed.

Remarks

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

Overrides

IGraph.NodeLayoutChanged

Event Registration

addNodeLayoutChangedListener(function(this, INode, Rect):void)

Event Deregistration

removeNodeLayoutChangedListener(function(this, INode, Rect):void)

Signature Details

function(source: any, node: INode, oldLayout: Rect)

Event delegate method that is used in IGraph's NodeLayoutChanged event.

Parameters

source - any: The source of the event.
node - INode: The node whose layout has changed.
oldLayout - Rect: The node layout before the change.

NodeRemoved

Occurs when a node has been removed.

Remarks

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

Overrides

IGraph.NodeRemoved

Event Registration

addNodeRemovedListener(function(this, NodeEventArgs):void)

Event Deregistration

removeNodeRemovedListener(function(this, NodeEventArgs):void)

Signature Details

function(sender: this, evt: NodeEventArgs)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - NodeEventArgs: An object that contains the event data.

NodeStyleChanged

Occurs when a node style has been replaced.

Remarks

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

Overrides

IGraph.NodeStyleChanged

Event Registration

addNodeStyleChangedListener(function(this, ItemChangedEventArgs<INode,INodeStyle>):void)

Event Deregistration

removeNodeStyleChangedListener(function(this, ItemChangedEventArgs<INode,INodeStyle>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<INode,INodeStyle>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<INode,INodeStyle>: An object that contains the event data.

NodeTagChanged

Occurs when the tag of a node has been replaced.

Remarks

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

Overrides

IGraph.NodeTagChanged

Event Registration

addNodeTagChangedListener(function(this, ItemChangedEventArgs<INode,Object>):void)

Event Deregistration

removeNodeTagChangedListener(function(this, ItemChangedEventArgs<INode,Object>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<INode,Object>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<INode,Object>: An object that contains the event data.

ParentChanged

Occurs if a node has been reparented in the model.

Overrides

IGraph.ParentChanged

Event Registration

addParentChangedListener(function(this, NodeEventArgs):void)

Event Deregistration

removeParentChangedListener(function(this, NodeEventArgs):void)

Signature Details

function(sender: this, evt: NodeEventArgs)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - NodeEventArgs: An object that contains the event data.

PortAdded

Occurs when a port has been added to this graph instance.

Remarks

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

Overrides

IGraph.PortAdded

Event Registration

addPortAddedListener(function(this, ItemEventArgs<IPort>):void)

Event Deregistration

removePortAddedListener(function(this, ItemEventArgs<IPort>):void)

Signature Details

function(sender: this, evt: ItemEventArgs<IPort>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemEventArgs<IPort>: An object that contains the event data.

PortLocationParameterChanged

Occurs when the location model parameter of a port has been changed.

Remarks

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

Overrides

IGraph.PortLocationParameterChanged

Event Registration

addPortLocationParameterChangedListener(function(this, ItemChangedEventArgs<IPort,IPortLocationModelParameter>):void)

Event Deregistration

removePortLocationParameterChangedListener(function(this, ItemChangedEventArgs<IPort,IPortLocationModelParameter>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<IPort,IPortLocationModelParameter>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<IPort,IPortLocationModelParameter>: An object that contains the event data.

PortRemoved

Occurs when a port has been removed from its owner.

Remarks

This event will also be triggered prior to the removal of the corresponding owner of the port.

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

Overrides

IGraph.PortRemoved

Event Registration

addPortRemovedListener(function(this, PortEventArgs):void)

Event Deregistration

removePortRemovedListener(function(this, PortEventArgs):void)

Signature Details

function(sender: this, evt: PortEventArgs)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - PortEventArgs: An object that contains the event data.

PortStyleChanged

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.PortStyleChanged

Event Registration

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

Event Deregistration

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

Signature Details

function(sender: this, evt: ItemChangedEventArgs<IPort,IPortStyle>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<IPort,IPortStyle>: An object that contains the event data.

PortTagChanged

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.PortTagChanged

Event Registration

addPortTagChangedListener(function(this, ItemChangedEventArgs<IPort,Object>):void)

Event Deregistration

removePortTagChangedListener(function(this, ItemChangedEventArgs<IPort,Object>):void)

Signature Details

function(sender: this, evt: ItemChangedEventArgs<IPort,Object>)

Represents the method that will handle an event when the event provides data.

Parameters

sender - this: The source of the event.
evt - ItemChangedEventArgs<IPort,Object>: An object that contains the event data.

FilteredGraphWrapper

Remarks

Related Programming Samples

Type Details

See Also

Constructors

FilteredGraphWrapper

Remarks

Parameters

Signature Details

Parameters

Returns

Signature Details

Parameters

Returns

Throws

Properties

bends

See Also

Overrides

decorator

See Also

Overrides

edgeDefaults

Remarks

See Also

Implements

edgeLabels

Overrides

edgePredicate

Signature Details

Parameters

Returns

See Also

edges

Remarks

See Also

Overrides

foldingView

Remarks

See Also

Overrides

groupingSupport

Remarks

See Also

Overrides

groupNodeDefaults

Remarks

See Also

Implements

labels

Remarks

See Also

Overrides

mapperRegistry

Remarks

See Also

Implements

nodeDefaults

Remarks

See Also

Implements

nodeLabels

Overrides

nodePredicate

Signature Details

Parameters

Returns

See Also

nodes

Remarks

See Also

Overrides

portLabels

Overrides

ports

Remarks

Overrides

tag

Remarks