graojs

// Type definitions for GoJS 1.4 // Project: http://gojs.net // Definitions by: Barbara Duckworth <https://github.com/barbara42/> // Definitions: https://github.com/borisyankov/DefinitelyTyped /* Copyright (C) 1998-2015 by Northwoods Software Corporation. */ // A number of types have been declared "any" because they would best be described by a union of specific types, // not as truly "any" type, and TypeScript does not support union types. Most of the cases are due to: // - a property of type Margin whose setter also accepts a number, for a uniform Margin of that thickness // - a property of type Brush whose setter also accepts a string, a CSS color string for a solid color Brush // - a boolean property that may also be null (tri-state) // - a key type, which may be a string or a number, uniquely identifying a node data within a Model // - a property that is string that names a property or that is a function that gets or sets a value, on an Object in a Model declare module go { /** * An adornment is a special kind of Part that is associated with another Part, * the Adornment.adornedPart. * Adornments are normally associated with a particular GraphObject in the adorned part -- * that is the value of .adornedObject. * However, the .adornedObject may be null, in which case the .adornedPart will also be null. */ class Adornment extends Part { /** * @param {EnumValue=} type if not supplied, the default Panel type is Panel.Position. */ constructor(type?: EnumValue); /**Gets or sets the GraphObject that is adorned.*/ adornedObject: GraphObject; /**This read-only property returns the Part that contains the adorned object.*/ adornedPart: Part; /**This read-only property returns a Placeholder that this Adornment may contain in its visual tree.*/ placeholder: Placeholder; } /** * This class handles animations in a Diagram. Each Diagram has one, the Diagram.animationManager. */ class AnimationManager { /**You do not normally need to create an instance of this class because one already exists as the Diagram.animationManager, which you can modify.*/ constructor(); /**Gets or sets the duration for animations, in milliseconds. The default value is 600 milliseconds.*/ duration: number; /**This read-only property is true when the AnimationManager is currently animating.*/ isAnimating: boolean; /**Gets or sets whether this AnimationManager operates. The default value is true.*/ isEnabled: boolean; /**This read-only property is true when the animation manager is in the middle of an animation tick.*/ isTicking: boolean; /** * Stops any running animation and updates the Diagram to its final state. */ stopAnimation(); } /** * The Diagram.commandHandler implements various * commands such as CommandHandler.deleteSelection or CommandHandler.redo. * The CommandHandler includes keyboard event handling to interpret * key presses as commands. */ class CommandHandler { /** * The constructor produces a CommandHandler with the default key bindings. */ constructor(); /**Gets or sets a data object that is copied by .groupSelection when creating a new Group. The default value is null.*/ archetypeGroupData: Object; /**Gets or sets whether copySelection and copyToClipboard copy the node data property whose value is the containing group data's key. The default value is false.*/ copiesGroupKey: boolean; /**Gets or sets whether copySelection and copyToClipboard copy the node data property whose value is the tree-parent node data's key. The default value is false.*/ copiesParentKey: boolean; /**Gets or sets whether .copySelection should also copy subtrees. The default value is false.*/ copiesTree: boolean; /**Gets or sets the Diagram.scale set by resetZoom. The default value is 1.0.*/ defaultScale: number; /**Gets or sets whether .deleteSelection should also delete subtrees. The default value is false.*/ deletesTree: boolean; /**This read-only property returns the Diagram that is using this CommandHandler.*/ diagram: Diagram; /**Gets or sets the predicate that determines whether or not a node may become a member of a group. The default predicate is null, which is equivalent to simply returning true.*/ memberValidation: (g: Group, p: Part) => boolean; /**Gets or sets the amount by which .decreaseZoom and .increaseZoom change the Diagram.scale. The default value is 1.05 (5%).*/ zoomFactor: number; /** * Make sure all of the unnested Parts in the given collection are removed from any containing Groups. * @param {Iterable} coll a collection of Parts. * @param {boolean=} check whether to call .isValidMember to confirm that changing the Part to be a top-level Part is valid. */ addTopLevelParts(coll: Iterable, check?: boolean): boolean; /** * This predicate controls whether the user can collapse expanded Groups. * @param {Group=} group if supplied, ignore the selection and consider collapsing this particular Group. */ canCollapseSubGraph(group?: Group): boolean; /** * This predicate controls whether the user can collapse expanded subtrees of Nodes. * @param {Node=} node if supplied, ignore the selection and consider collapsing this particular Node. */ canCollapseTree(node?: Node): boolean; /** * This predicate controls whether or not the user can invoke the .copySelection command. */ canCopySelection(): boolean; /** * This predicate controls whether or not the user can invoke the .cutSelection command. */ canCutSelection(): boolean; /** * This predicate controls whether or not the user can invoke the .decreaseZoom command. * @param {number=} factor This defaults to 1/.zoomFactor. The value should be less than one. */ canDecreaseZoom(factor?: number): boolean; /** * This predicate controls whether or not the user can invoke the .deleteSelection command. */ canDeleteSelection(): boolean; /** * This predicate controls whether or not the user can invoke the .editTextBlock command. * @param {TextBlock=} textblock the TextBlock to consider editing. */ canEditTextBlock(textblock?: TextBlock): boolean; /** * This predicate controls whether the user can expand collapsed Groups. * @param {Group=} group if supplied, ignore the selection and consider expanding this particular Group. */ canExpandSubGraph(group?: Group): boolean; /** * This predicate controls whether the user can expand collapsed subtrees of Nodes. * @param {Node=} node if supplied, ignore the selection and consider expanding this particular Node. */ canExpandTree(node?: Node): boolean; /** * This predicate controls whether or not the user can invoke the .groupSelection command. */ canGroupSelection(): boolean; /** * This predicate controls whether or not the user can invoke the .increaseZoom command. * @param {number=} factor This defaults to .zoomFactor. The value should be greater than one. */ canIncreaseZoom(factor?: number): boolean; /** * This predicate controls whether or not the user can invoke the .pasteSelection command. */ canPasteSelection(): boolean; /** * This predicate controls whether or not the user can invoke the .redo command. */ canRedo(): boolean; /** * This predicate controls whether or not the user can invoke the .resetZoom command. * @param {number=} newscale This defaults to 1. The value should be greater than zero. */ canResetZoom(newscale?: number): boolean; /** * This predicate controls whether or not the user can invoke the .selectAll command. */ canSelectAll(): boolean; /** * This predicate controls whether or not the user can invoke the .showContextMenu command. * @param {GraphObject|Diagram=} obj a GraphObject or Diagram with a contextMenu defined. * If none is given, this method will use the first selected object, or else the Diagram. */ canShowContextMenu(obj: Diagram): boolean; canShowContextMenu(obj?: GraphObject): boolean; /** * This predicate controls whether the user may stop the current tool. */ canStopCommand(): boolean; /** * This predicate controls whether or not the user can invoke the .undo command. */ canUndo(): boolean; /** * This predicate controls whether or not the user can invoke the .ungroupSelection command. * @param {Group=} group if supplied, ignore the selection and consider ungrouping this particular Group. */ canUngroupSelection(group?: Group): boolean; /** * This predicate controls whether or not the user can invoke the .zoomToFit command. */ canZoomToFit(): boolean; /** * Collapse all expanded selected Groups. * @param {Group=} group if supplied, ignore the selection and collapse this particular Group. */ collapseSubGraph(group?: Group); /** * Collapse all expanded selected Nodes. * @param {Node=} node if supplied, ignore the selection and collapse this particular Node subtree. */ collapseTree(node?: Node); /** * Copy the currently selected parts, Diagram.selection, from the Diagram into the clipboard. */ copySelection(); /** * This makes a copy of the given collection of Parts and stores it in a static variable acting as the clipboard. * @param {Iterable} coll A collection of Parts. */ copyToClipboard(coll: Iterable); /** * Execute a .copySelection followed by a .deleteSelection. */ cutSelection(); /** * Decrease the Diagram.scale by a given factor. * @param {number=} factor This defaults to 1/.zoomFactor. The value should be less than one. */ decreaseZoom(factor?: number); /** * Delete the currently selected parts from the diagram. */ deleteSelection(); /** * This is called by tools to handle keyboard commands. */ doKeyDown(); /** * This is called by tools to handle keyboard commands. */ doKeyUp(); /** * Start in-place editing of a TextBlock in the selected Part. * @param {TextBlock=} textblock the TextBlock to start editing. */ editTextBlock(textblock?: TextBlock); /** * Expand all collapsed selected Groups. * @param {Group=} group if supplied, ignore the selection and expand this particular Group. */ expandSubGraph(group?: Group); /** * Expand all collapsed selected Nodes. * @param {Node=} node if supplied, ignore the selection and collapse this particular Node subtree. */ expandTree(node?: Node); /** * Add a copy of .archetypeGroupData and add it to the diagram's model to create a new Group and then add the selected Parts to that new group. */ groupSelection(); /** * Increase the Diagram.scale by a given factor. * @param {number=} factor This defaults to .zoomFactor. The value should be greater than one. */ increaseZoom(factor?: Number); /** * This predicate is called to determine whether a Node may be added as a member of a Group. * @param {Group} group this may be null if the node is being added as a top-level node. * @param {Part} part a Part, usually a Node, possibly another Group, but not a Link or an Adornment. */ isValidMember(group: Group, part: Part): boolean; /** * If the clipboard holds a collection of Parts, and if the Model.dataFormat matches that stored in the clipboard, this makes a copy of the clipboard's parts and adds the copies to this Diagram. */ pasteFromClipboard(): Set; /** * Copy the contents of the clipboard into this diagram, and make those new parts the new selection. * @param {Point=} pos Point at which to center the newly pasted parts; if not present the parts are not moved. */ pasteSelection(pos?: Point); /** * Call UndoManager.redo. */ redo(); /** * Set the Diagram.scale to a new scale value, by default 1. * @param {number=} newscale This defaults to 1. The value should be greater than zero. */ resetZoom(newscale?: number); /** * Select all of the selectable Parts in the diagram. */ selectAll(); /** * Open the context menu of a given GraphObject. * The given GraphObject must have a GraphObject.contextMenu * defined in order to show anything. * @param {GraphObject|Diagram=} obj a GraphObject or Diagram with a contextMenu defined. * If none is given, this method will use the first selected object, or else the Diagram. */ showContextMenu(obj: Diagram); showContextMenu(obj?: GraphObject); /** * Cancel the operation of the current tool. */ stopCommand(); /** * Call UndoManager.undo. */ undo(); /** * Remove the group from the diagram without removing its members from the diagram. * @param {Group=} group if supplied, ignore the selection and consider ungrouping this particular Group. */ ungroupSelection(group?: Group); /** * Change the Diagram.scale so that the Diagram.documentBounds fits within the viewport. */ zoomToFit(); } /** * A Diagram is associated with an HTML DIV element. Constructing a Diagram creates * an HTML Canvas element which it places inside of the given DIV element, in addition to several helper divs. * GoJS will manage the contents of this DIV, and the contents should not be modified otherwise, * though the given DIV may be styled (background, border, etc) and positioned as needed. */ class Diagram { /** * Construct an empty Diagram for a particular DIV HTML element. * @param {HTMLDivElement} div A reference to a DIV HTML element in the DOM. * If no DIV is supplied one will be created in memory. The Diagram's Diagram.div property * can then be set later on. */ constructor(div: HTMLDivElement); /** * Construct an empty Diagram for a particular DIV HTML element. * @param {string=} div The ID of a DIV element in the DOM. * If no DIV identifier is supplied one will be created in memory. The Diagram's Diagram.div property * can then be set later on. */ constructor(div?: string); /**Gets or sets whether the user may copy to or paste parts from the internal clipboard.*/ allowClipboard: boolean; /**Gets or sets whether the user may copy objects.*/ allowCopy: boolean; /**Gets or sets whether the user may delete objects from the Diagram.*/ allowDelete: boolean; /**Gets or sets whether the user may start a drag-and-drop in this Diagram, possibly dropping in a different element.*/ allowDragOut: boolean; /**Gets or sets whether the user may end a drag-and-drop operation in this Diagram.*/ allowDrop: boolean; /**Gets or sets whether the user may group parts together.*/ allowGroup: boolean; /**Gets or sets whether the user is allowed to use the horizontal scrollbar.*/ allowHorizontalScroll: boolean; /**Gets or sets whether the user may add parts to the Diagram.*/ allowInsert: boolean; /**Gets or sets whether the user may draw new links.*/ allowLink: boolean; /**Gets or sets whether the user may move objects.*/ allowMove: boolean; /**Gets or sets whether the user may reconnect existing links.*/ allowRelink: boolean; /**Gets or sets whether the user may reshape parts.*/ allowReshape: boolean; /**Gets or sets whether the user may resize parts.*/ allowResize: boolean; /**Gets or sets whether the user may rotate parts.*/ allowRotate: boolean; /**Gets or sets whether the user may select objects.*/ allowSelect: boolean; /**Gets or sets whether the user may do in-place text editing.*/ allowTextEdit: boolean; /**Gets or sets whether the user may undo or redo any changes.*/ allowUndo: boolean; /**Gets or sets whether the user may ungroup existing groups.*/ allowUngroup: boolean; /**Gets or sets whether the user is allowed to use the vertical scrollbar.*/ allowVerticalScroll: boolean; /**Gets or sets whether the user may zoom into or out of the Diagram.*/ allowZoom: boolean; /**This read-only property returns the AnimationManager for this Diagram.*/ animationManager: AnimationManager; /**Gets or sets the autoScale of the Diagram, controlling whether or not the Diagram's bounds automatically scale to fit the view.*/ autoScale: EnumValue; /**Gets or sets the Margin (or number for a uniform Margin) that describes the Diagram's autoScrollRegion.*/ autoScrollRegion: any; /**Gets or sets the function to execute when the user single-primary-clicks on the background of the Diagram.*/ click: (e: InputEvent) => void; /**Gets or sets the CommandHandler for this Diagram.*/ commandHandler: CommandHandler; /**Gets or sets the content alignment Spot of this Diagram, to be used in determining how parts are positioned when the .viewportBounds width or height is smaller than the .documentBounds.*/ contentAlignment: Spot; /**Gets or sets the function to execute when the user single-secondary-clicks on the background of the Diagram.*/ contextClick: (e: InputEvent) => void; /**This Adornment is shown when the use context clicks in the background.*/ contextMenu: Adornment; /**Gets or sets the current cursor for the Diagram, overriding the .defaultCursor.*/ currentCursor: string; /**Gets or sets the current tool for this Diagram that handles all input events.*/ currentTool: Tool; /**Gets or sets the cursor to be used for the Diagram when no GraphObject specifies a different cursor.*/ defaultCursor: string; /**Gets or sets the default tool for this Diagram that becomes the current tool when the current tool stops.*/ defaultTool: Tool; /**Gets or sets the Diagram's HTMLDivElement, via an HTML Element ID.*/ div: HTMLDivElement; /**This read-only property returns the model-coordinate bounds of the Diagram.*/ documentBounds: Rect; /**Gets or sets the function to execute when the user double-primary-clicks on the background of the Diagram.*/ doubleClick: (e: InputEvent) => void; /**Gets or sets the most recent mouse-down InputEvent that occurred.*/ firstInput: InputEvent; /**Gets or sets a fixed bounding rectangle to be returned by .documentBounds and .computeBounds.*/ fixedBounds: Rect; /**Gets or sets a Panel of type Panel.Grid acting as the background grid extending across the whole viewport of this diagram.*/ grid: Panel; /**Gets or sets the default selection Adornment template, used to adorn selected Groups.*/ groupSelectionAdornmentTemplate: Adornment; /**Gets or sets the default Group template used as the archetype for group data that is added to the .model.*/ groupTemplate: Group; /**Gets or sets a Map mapping template names to Groups.*/ groupTemplateMap: Map; /**Gets or sets whether the Diagram has a horizontal Scrollbar.*/ hasHorizontalScrollbar: boolean; /**Gets or sets whether the Diagram has a vertical Scrollbar.*/ hasVerticalScrollbar: boolean; /**This read-only property returns the read-only collection of highlighted Parts.*/ highlighteds: Set; /**Gets or sets the initialAutoScale of the Diagram.*/ initialAutoScale: EnumValue; /**Gets or sets the initial content alignment Spot of this Diagram, to be used in determining how parts are positioned initially relative to the viewport.*/ initialContentAlignment: Spot; /**Gets or sets the spot in the document's area that should be coincident with the .initialViewportSpot of the viewport when the document is first initialized.*/ initialDocumentSpot: Spot; /**Gets or sets the initial coordinates of this Diagram in the viewport, eventually setting the .position.*/ initialPosition: Point; /**Gets or sets the initial scale of this Diagram in the viewport, eventually setting the .scale.*/ initialScale: number; /**Gets or sets the spot in the viewport that should be coincident with the .initialDocumentSpot of the document when the document is first initialized.*/ initialViewportSpot: Spot; /**Gets or sets whether the user may interact with the Diagram.*/ isEnabled: boolean; /**Gets or sets whether the Diagram's Diagram.model is Model.isReadOnly.*/ isModelReadOnly: boolean; /**Gets or sets whether this Diagram's state has been modified.*/ isModified: boolean; /**Gets or sets whether mouse events initiated within the Diagram will be captured.*/ isMouseCaptured: boolean; /**Gets or sets whether the Diagram may be modified by the user, while still allowing the user to scroll, zoom, and select.*/ isReadOnly: boolean; /**Gets or sets whether the Diagram tree structure is defined by links going from the parent node to their children, or vice-versa.*/ isTreePathToChildren: boolean; /**Gets or sets the last InputEvent that occurred.*/ lastInput: InputEvent; /**Gets an iterator for this Diagram's Layers.*/ layers: Iterator; /**Gets or sets the Layout used to position all of the top-level nodes and links in this Diagram.*/ layout: Layout; /**Returns an iterator of all Links in the Diagram.*/ links: Iterator; /**Gets or sets the default selection Adornment template, used to adorn selected Links.*/ linkSelectionAdornmentTemplate: Adornment; /**Gets or sets the default Link template used as the archetype for link data that is added to the .model.*/ linkTemplate: Link; /**Gets or sets a Map mapping template names to Links.*/ linkTemplateMap: Map; /**Gets or sets the largest value that .scale may take.*/ maxScale: number; /**Gets or sets the maximum number of selected objects.*/ maxSelectionCount: number; /**Gets or sets the smallest value greater than zero that .scale may take.*/ minScale: number; /**Gets or sets the Model holding data corresponding to the data-bound nodes and links of this Diagram.*/ model: Model; /**Gets or sets the function to execute when the user is dragging the selection in the background of the Diagram during a DraggingTool drag-and-drop, not over any GraphObjects.*/ mouseDragOver: (e: InputEvent) => void; /**Gets or sets the function to execute when the user drops the selection in the background of the Diagram at the end of a DraggingTool drag-and-drop, not onto any GraphObjects.*/ mouseDrop: (e: InputEvent) => void; /**Gets or sets the function to execute when the user holds the mouse stationary in the background of the Diagram while holding down a button, not over any GraphObjects.*/ mouseHold: (e: InputEvent) => void; /**Gets or sets the function to execute when the user holds the mouse stationary in the background of the Diagram without holding down any buttons, not over any GraphObjects.*/ mouseHover: (e: InputEvent) => void; /**Gets or sets the function to execute when the user moves the mouse in the background of the Diagram without holding down any buttons, not over any GraphObjects.*/ mouseOver: (e: InputEvent) => void; /**Returns an iterator of all Nodes and Groups in the Diagram.*/ nodes: Iterator; /**Gets or sets the default selection Adornment template, used to adorn selected Parts other than Groups or Links.*/ nodeSelectionAdornmentTemplate: Adornment; /**Gets or sets the default Node template used as the archetype for node data that is added to the .model.*/ nodeTemplate: Part; /**Gets or sets a Map mapping template names to Parts.*/ nodeTemplateMap: Map; /**Gets or sets the Margin (or number for a uniform Margin) that describes the Diagram's padding, which controls how much extra space there is around the area occupied by the document.*/ padding: any; /**Returns an iterator of all Parts in the Diagram that are not Nodes or Links or Adornments.*/ parts: Iterator; /**Gets or sets the coordinates of this Diagram in the viewport.*/ position: Point; /**Gets or sets the scale transform of this Diagram.*/ scale: number; /**Gets or sets the distance in screen pixels that the horizontal scrollbar will scroll when scrolling by a line.*/ scrollHorizontalLineChange: number; /**Gets or sets the distance in screen pixels that the vertical scrollbar will scroll when scrolling by a line.*/ scrollVerticalLineChange: number; /**This read-only property returns the read-only collection of selected Parts.*/ selection: Set; /**Gets or sets whether ChangedEvents are not recorded by the UndoManager.*/ skipsUndoManager: boolean; /**This read-only property returns the ToolManager for this Diagram.*/ toolManager: ToolManager; /**This Adornment is shown when the mouse stays motionless in the background.*/ toolTip: Adornment; /**This read-only property returns the UndoManager for this Diagram, which actually belongs to the .model.*/ undoManager: UndoManager; /**Gets or sets what kinds of graphs this diagram allows the user to draw.*/ validCycle: EnumValue; /**This read-only property returns the bounds of the portion of the Diagram that is viewable from its HTML Canvas.*/ viewportBounds: Rect; /**Gets or sets the point, in viewport coordinates, where changes to the .scale will keep the focus in the document.*/ zoomPoint: Point; /** * Adds a Part to the Layer that matches the Part's Part.layerName, or else to the default layer, which is named with the empty string. * @param {Part} part */ add(part: Part); /** * Register an event handler that is called when there is a ChangedEvent. * @param {function(ChangedEvent)} listener a function that takes a ChangedEvent as its argument. */ addChangedListener(listener: (e: ChangedEvent) => void ); /** * Register an event handler that is called when there is a DiagramEvent of a given name. * @param {string} name the name is normally capitalized, but this method uses case-insensitive comparison. * @param {function(DiagramEvent)} listener a function that takes a DiagramEvent as its argument. */ addDiagramListener(name: string, listener: (e: DiagramEvent) => void ); /** * Adds a Layer to the list of layers. * @param {Layer} layer The Layer to add. */ addLayer(layer: Layer); /** * Adds a layer to the list of layers after a specified layer. * @param {Layer} layer The Layer to add. * @param {Layer} existingLayer The layer to insert after. */ addLayerAfter(layer: Layer, existingLayer: Layer); /** * Adds a layer to the list of layers before a specified layer. * @param {Layer} layer The Layer to add. * @param {Layer} existingLayer The layer to insert before. */ addLayerBefore(layer: Layer, existingLayer: Layer); /** * Aligns the Diagram's .position based on a desired document Spot and viewport Spot. * @param {Spot} documentspot * @param {Spot} viewportspot */ alignDocument(documentspot: Spot, viewportspot: Spot); /** * Modifies the .position to show a given Rect of the Diagram by centering the viewport on that Rect. * @param {Rect} r */ centerRect(r: Rect); /** * Removes all Parts from the Diagram, including unbound Parts and the background grid, and also clears out the Model and UndoManager. */ clear(); /** * Remove highlights from all Parts. */ clearHighlighteds(); /** * Deselect all selected Parts. */ clearSelection(); /** * Commit the changes of the current transaction. * This just calls UndoManager.commitTransaction. * @param {string} tname a descriptive name for the transaction. */ commitTransaction(tname: string): boolean; /** * This is called during a Diagram update to determine a new value for .documentBounds. */ computeBounds(): Rect; /** * Find the union of the GraphObject.actualBounds of all of the Parts in the given collection. * @param {Iterable} coll a collection of Parts. */ computePartsBounds(coll: Iterable): Rect; /** * Make a copy of a collection of Parts and return them in a Map mapping each original Part to its copy. * @param {Iterable} coll A List or a Set or Iterator of Parts. * @param {Diagram} diagram The destination diagram; if null, the copied parts are not added to this diagram. * @param {boolean} check Whether to check Part.canCopy on each part. */ copyParts(coll: Iterable, diagram: Diagram, check: boolean); /** * Updates the diagram immediately, then resets initialization flags so that actions taken in the argument function will be considered part of Diagram initialization, and will participate in initial layouts, .initialAutoScale, .initialContentAlignment, etc. * @param {function()|null=} func an optional function of actions to perform as part of another diagram initialization. */ delayInitialization(func?: () => void ); /** * Finds a layer with a given name. * @param {string} name */ findLayer(name: string): Layer; /** * Look for a Link corresponding to a GraphLinksModel's link data object. * @param {Object} linkdata */ findLinkForData(linkdata: Object): Link; /** * Look for a Node or Group corresponding to a model's node data object. * @param {Object} nodedata */ findNodeForData(nodedata: Object): Node; /** * Look for a Node or Group corresponding to a model's node data object's unique key. * @param {*} key a string or number. */ findNodeForKey(key: any): Node; /** * Find the front-most GraphObject at the given point in document coordinates. * @param {Point} p A Point in document coordinates. * @param {function(GraphObject):GraphObject | null=} navig A function taking a GraphObject and * returning a GraphObject, defaulting to the identity. * @param {function(GraphObject):boolean | null=} pred A function taking the GraphObject * returned by navig and returning true if that object should be returned, * defaulting to a predicate that always returns true. */ findObjectAt(p: Point, navig?: (obj: GraphObject) => GraphObject, pred?: (obj: GraphObject) => boolean): GraphObject; /** * Return a collection of the GraphObjects at the given point in document coordinates. * @param {Point} p A Point in document coordinates. * @param {function(GraphObject):GraphObject | null=} navig A function taking a GraphObject and * returning a GraphObject, defaulting to the identity. * If this function returns null, the given GraphObject will not be included in the results. * @param {function(GraphObject):boolean | null=} pred A function taking the GraphObject * returned by navig and returning true if that object should be returned, * defaulting to a predicate that always returns true. * @param {List|Set=} coll An optional collection (List or Set) to add the results to. */ findObjectsAt(p: Point, navig?: (obj: GraphObject) => GraphObject, pred?: (obj: GraphObject) => boolean, coll?: List): List; findObjectsAt(p: Point, navig?: (obj: GraphObject) => GraphObject, pred?: (obj: GraphObject) => boolean, coll?: Set): Set; /** * Returns a collection of all GraphObjects that are inside or that intersect a given Rect in document coordinates. * @param {Rect} r A Rect in document coordinates. * @param {function(GraphObject):GraphObject | null=} navig A function taking a GraphObject and * returning a GraphObject, defaulting to the identity. * If this function returns null, the given GraphObject will not be included in the results. * @param {function(GraphObject):boolean | null=} pred A function taking the GraphObject * returned by navig and returning true if that object should be returned, * defaulting to a predicate that always returns true. * @param {boolean=} partialInclusion Whether an object can match if it merely intersects the rectangular area (true) or * if it must be entirely inside the rectangular area (false). The default value is false. * @param {List|Set=} coll An optional collection (List or Set) to add the results to. */ findObjectsIn(r: Rect, navig?: (obj: GraphObject) => GraphObject, pred?: (obj: GraphObject) => boolean, partialInclusion?: boolean, coll?: List): List; findObjectsIn(r: Rect, navig?: (obj: GraphObject) => GraphObject, pred?: (obj: GraphObject) => boolean, partialInclusion?: boolean, coll?: Set): Set; /** * Returns a collection of all GraphObjects that are within a certain distance of a given point in document coordinates. * @param {Point} p A Point in document coordinates. * @param {number} dist The distance from the point. * @param {function(GraphObject):GraphObject | null=} navig A function taking a GraphObject and * returning a GraphObject, defaulting to the identity. * If this function returns null, the given GraphObject will not be included in the results. * @param {function(GraphObject):boolean | null=} pred A function taking the GraphObject * returned by navig and returning true if that object should be returned, * defaulting to a predicate that always returns true. * @param {boolean=} partialInclusion Whether an object can match if it merely intersects the circular area (true) or * if it must be entirely inside the circular area (false). The default value is true. * The default is true. * @param {List|Set=} coll An optional collection (List or Set) to add the results to. */ findObjectsNear(p: Point, dist: number, navig?: (obj: GraphObject) => GraphObject, pred?: (obj: GraphObject) => boolean, partialInclusion?: boolean, coll?: List): List; findObjectsNear(p: Point, dist: number, navig?: (obj: GraphObject) => GraphObject, pred?: (obj: GraphObject) => boolean, partialInclusion?: boolean, coll?: Set): Set; /** * This convenience function finds the front-most Part that is at a given point and that might be selectable. * @param {Point} p a Point in document coordinates. * @param {boolean} selectable Whether to only consider parts that are Part.selectable. */ findPartAt(p: Point, selectable: boolean): Part; /** * Look for a Part, Node, Group, or Link corresponding to a Model's data object. * @param {Object} data */ findPartForData(data: Object): Part; /** * Look for a Part or Node or Group corresponding to a model's data object's unique key. * @param {*} key a string or number. */ findPartForKey(key: any): Part; /** * Returns an iterator of all Groups that are at top-level, in other words that are not themselves inside other Groups. */ findTopLevelGroups(): Iterator; /** * Returns an iterator of all top-level Nodes that have no tree parents. */ findTreeRoots(): Iterator; /** * Explicitly bring focus to the Diagram's canvas. */ focus(); /** * This static method gets the Diagram that is attached to an HTML DIV element. * @param {HTMLDivElement} div */ static fromDiv(div: HTMLDivElement): Diagram; /** * Make the given part the only highlighted part. * @param {Part} part */ highlight(part: Part); /** * Highlight all of the Parts supplied in the given collection, and clear all other highlighted Parts. * @param {Iterable} coll an Iterable of Parts */ highlightCollection(coll: Iterable); /** * Highlight all of the Parts supplied in the given collection, and clear all other highlighted Parts. * @param {Array} coll an Array of Parts */ highlightCollection(coll: Part[]); /** * This static function declares that a class (constructor function) derives from another class -- but please note that most classes do not support inheritance. * @param {Function} derivedclass * @param {Function} baseclass */ static inherit(derivedclass: new (...args: any[]) => Object, baseclass: new (...args: any[]) => Object); /** * Perform all invalid layouts. * @param {boolean=} invalidateAll If true, this will explicitly set Layout.isValidLayout to false on each Layout in the diagram. */ layoutDiagram(invalidateAll?: boolean); /** * Create an HTMLImageElement that contains a bitmap of the current Diagram. * @param {Object=} properties For details see the argument description of .makeImageData. */ makeImage(properties?: Object): HTMLImageElement; /** * Create a bitmap of the current Diagram encoded as a base64 string. * @param {{ size: Size, scale: number, maxSize: Size, position: Point, parts: Iterable, padding: (Margin|number), showTemporary: boolean, showGrid: boolean, document: Document, type: string, details: * }=} properties a JavaScript object detailing optional arguments for image creation, to be passed to makeImageData. */ makeImageData(properties?: Object): string; /** * Create an SVGElement that contains a SVG rendering of the current Diagram. * By default this method returns a snapshot of the visible diagram, but optional arguments give more options. * @param {{ size: Size, scale: number, maxSize: Size, position: Point, parts: Iterable, padding: (Margin|number), showTemporary: boolean, showGrid: boolean, document: Document, elementFinished: function(GraphObject, SVGElement), details: * }=} properties a JavaScript object detailing optional arguments for SVG creation. * @return {SVGElement} */ makeSvg(properties?: Object): SVGElement; /** * Move a collection of Parts in this Diagram by a given offset. * @param {Iterable} coll A List or a Set or Iterator of Parts. * @param {Point} offset the X and Y change to be made to each Part, in document coordinates. * @param {boolean} check Whether to check Part.canMove on each part. */ moveParts(coll: Iterable, offset: Point, check: boolean); /** * Remove all of the Parts created from model data and then create them again. */ rebuildParts(); /** * Removes a Part from its Layer, provided the Layer is in this Diagram. * @param {Part} part */ remove(part: Part); /** * Unregister an event handler listener. * @param {function(ChangedEvent)} listener a function that takes a ChangedEvent as its argument. */ removeChangedListener(listener: (e: ChangedEvent) => void ); /** * Unregister a DiagramEvent handler. * @param {string} name the name is normally capitalized, but this method uses case-insensitive comparison. * @param {function(DiagramEvent)} listener a function that takes a DiagramEvent as its argument. */ removeDiagramListener(name: string, listener: (e: DiagramEvent) => void ); /** * Removes the given layer from the list of layers. * @param {Layer} layer */ removeLayer(layer: Layer); /** * This method removes from this Diagram all of the Parts in a collection. * @param {Iterable} coll A List or Set or Iterator of Parts. * @param {boolean} check Whether to check Part.canDelete on each part. */ removeParts(coll: Iterable, check: boolean); /** * Rollback the current transaction, undoing any recorded changes. * This just calls UndoManager.rollbackTransaction. */ rollbackTransaction(): boolean; /** * Scrolling function used by primarily by .commandHandler's CommandHandler.doKeyDown. * @param {string} unit A string representing the unit of the scroll operation. Can be 'pixel', 'line', or 'page'. * @param {string} dir The direction of the scroll operation. Can be 'up', 'down', 'left', or 'right'. * @param {number=} dist An optional distance multiplier, for multiple pixels, lines, or pages. Default is 1. */ scroll(unit: string, dir: string, dist?: number); /** * Modifies the .position to show a given Rect of the Diagram by centering the viewport on that Rect. * @param {Rect} r */ scrollToRect(r: Rect); /** * Make the given object the only selected object. * @param {GraphObject} part a GraphObject that is already in a layer of this Diagram. * If the value is null, this does nothing. */ select(part: Part); /** * Select all of the Parts supplied in the given collection. * @param {Iterable} coll a List or Set of Parts to be selected. */ selectCollection(coll: Iterable); /** * Select all of the Parts supplied in the given collection. * @param {Array} coll an Array of Parts to be selected. */ selectCollection(coll: Part[]); /** * Begin a transaction, where the changes are held by a Transaction object in the UndoManager. * This just calls UndoManager.startTransaction. * @param {string=} tname a descriptive name for the transaction. */ startTransaction(tname?: string): boolean; /** * Given a Point in document coordinates, return a new Point in viewport coordinates. * @param {Point} p */ transformDocToView(p: Point): Point; /** * Given a point in viewport coordinates, return a new point in document coordinates. * @param {Point} p */ transformViewToDoc(p: Point): Point; /** * Update all of the data-bound properties of Nodes and Links in this diagram. */ updateAllTargetBindings(); /** * Scales the Diagram to uniformly fit into the viewport. */ zoomToFit(); /** * Modifies the .scale and .position of the Diagram so that the viewport displays a given document-coordinates rectangle. * @param {Rect} r rectangular bounds in document coordinates. * @param {EnumValue=} scaling an optional value of either .Uniform (the default) or .UniformToFill. */ zoomToRect(r: Rect, scaling?: EnumValue); /**This value for Diagram.validCycle states that there are no restrictions on making cycles of links.*/ static CycleAll: EnumValue; /**This value for Diagram.validCycle states that any number of destination links may go out of a node, but at most one source link may come into a node, and there are no directed cycles.*/ static CycleDestinationTree: EnumValue; /**This value for Diagram.validCycle states that a valid link from a node will not produce a directed cycle in the graph.*/ static CycleNotDirected: EnumValue; /**This value for Diagram.validCycle states that a valid link from a node will not produce an undirected cycle in the graph.*/ static CycleNotUndirected: EnumValue; /**This value for Diagram.validCycle states that any number of source links may come into a node, but at most one destination link may go out of a node, and there are no directed cycles.*/ static CycleSourceTree: EnumValue; /**The default autoScale type, used as the value of Diagram.autoScale: The Diagram does not attempt to scale its bounds to fit the view.*/ static None: EnumValue; /**Diagrams with this autoScale type, used as the value of Diagram.autoScale, are scaled uniformly until the documentBounds fits in the view.*/ static Uniform: EnumValue; /**Diagrams with this autoScale type, used as the value of Diagram.autoScale, are scaled uniformly until the documentBounds fits in the view.*/ static UniformToFill: EnumValue; maybeUpdate(); // undocumented requestUpdate(); // undocumented } /** * A DiagramEvent represents a more abstract event than an InputEvent. * They are raised on the Diagram class. * One can receive such events by registering a DiagramEvent listener on a Diagram * by calling Diagram.addDiagramListener. * Some DiagramEvents such as "ObjectSingleClicked" are normally * associated with InputEvents. * Some DiagramEvents such as "SelectionMoved" or "PartRotated" are associated with the * results of Tool-handled gestures or CommandHandler actions. * Some DiagramEvents are not necessarily associated with any input events at all, * such as "ViewportBoundsChanged", which can happen due to programmatic * changes to the Diagram.position and Diagram.scale properties. */ class DiagramEvent { /** * The DiagramEvent class constructor produces an empty DiagramEvent. */ constructor(); /**Gets or sets whether any default actions associated with this diagram event should be avoided or cancelled.*/ cancel: boolean; /**This read-only property returns the diagram associated with the event.*/ diagram: Diagram; /**Gets or sets the name of the kind of diagram event that this represents.*/ name: string; /**Gets or sets an optional object that describes the change to the subject of the diagram event.*/ parameter: any; /**Gets or sets an optional object that is the subject of the diagram event.*/ subject: Object; } /** * This is the abstract base class for all graphical objects. */ class GraphObject { /** * This is an abstract class, so you should not use this constructor. */ constructor(); /**Gets or sets the function to execute when the ActionTool is cancelled and this GraphObject's .isActionable is set to true.*/ actionCancel: (e: InputEvent, obj: GraphObject) => void; /**Gets or sets the function to execute on a mouse-down event when this GraphObject's .isActionable is set to true.*/ actionDown: (e: InputEvent, obj: GraphObject) => void; /**Gets or sets the function to execute on a mouse-move event when this GraphObject's .isActionable is set to true.*/ actionMove: (e: InputEvent, obj: GraphObject) => void; /**Gets or sets the function to execute on a mouse-up event when this