@mindfusion/graphs 4.0.4 → 4.0.5-beta.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cjs/graphs.js +1 -1
- package/dist/esm/graphs.js +1 -1
- package/dist/esm/graphs.mjs +1 -0
- package/dist/umd/graphs.js +1 -1
- package/graphs.d.mts +1998 -0
- package/package.json +21 -7
- package/LICENSE.txt +0 -64
- package/README.md +0 -57
package/graphs.d.mts
ADDED
|
@@ -0,0 +1,1998 @@
|
|
|
1
|
+
/// <reference types="../../@mindfusion/drawing" />
|
|
2
|
+
/// <reference types="../../@mindfusion/collections" />
|
|
3
|
+
declare module "Graphs/Enum" {
|
|
4
|
+
/**
|
|
5
|
+
* Specifies the final position of an assistant node. Assistants with type left
|
|
6
|
+
* or right are always positioned to the left or right respectively. The position
|
|
7
|
+
* of the "normal" assistants depends on their index in the children list.
|
|
8
|
+
*/
|
|
9
|
+
export type AssistantPosition = number;
|
|
10
|
+
export namespace AssistantPosition {
|
|
11
|
+
const Left: number;
|
|
12
|
+
const Right: number;
|
|
13
|
+
}
|
|
14
|
+
/**
|
|
15
|
+
* Indicates the type of an assistant node in a tree.
|
|
16
|
+
*/
|
|
17
|
+
export type AssistantType = number;
|
|
18
|
+
export namespace AssistantType {
|
|
19
|
+
export const Normal: number;
|
|
20
|
+
const Left_1: number;
|
|
21
|
+
export { Left_1 as Left };
|
|
22
|
+
const Right_1: number;
|
|
23
|
+
export { Right_1 as Right };
|
|
24
|
+
}
|
|
25
|
+
/**
|
|
26
|
+
* Defines values that specify how automatic layout algorithms align links to anchor points.
|
|
27
|
+
*/
|
|
28
|
+
export type Anchoring = number;
|
|
29
|
+
export namespace Anchoring {
|
|
30
|
+
const Ignore: number;
|
|
31
|
+
const Keep: number;
|
|
32
|
+
const Reassign: number;
|
|
33
|
+
const Custom: number;
|
|
34
|
+
}
|
|
35
|
+
/**
|
|
36
|
+
* Specifies in what direction to place nodes processed by a layout algorithm.
|
|
37
|
+
*/
|
|
38
|
+
export type LayoutDirection = number;
|
|
39
|
+
export namespace LayoutDirection {
|
|
40
|
+
const TopToBottom: number;
|
|
41
|
+
const LeftToRight: number;
|
|
42
|
+
const BottomToTop: number;
|
|
43
|
+
const RightToLeft: number;
|
|
44
|
+
}
|
|
45
|
+
/**
|
|
46
|
+
* Specifies the shape of the diagram links after they are laid out.
|
|
47
|
+
*/
|
|
48
|
+
export type TreeLayoutLinkType = number;
|
|
49
|
+
export namespace TreeLayoutLinkType {
|
|
50
|
+
const Default: number;
|
|
51
|
+
const Straight: number;
|
|
52
|
+
const Cascading: number;
|
|
53
|
+
}
|
|
54
|
+
/**
|
|
55
|
+
* Specifies placement of graph connected components relatively to each other.
|
|
56
|
+
*/
|
|
57
|
+
export type MultipleGraphsPlacement = number;
|
|
58
|
+
export namespace MultipleGraphsPlacement {
|
|
59
|
+
const Vertical: number;
|
|
60
|
+
const Horizontal: number;
|
|
61
|
+
}
|
|
62
|
+
/**
|
|
63
|
+
* Specifies general layout orientation.
|
|
64
|
+
*/
|
|
65
|
+
export type Orientation = number;
|
|
66
|
+
export namespace Orientation {
|
|
67
|
+
const Vertical_1: number;
|
|
68
|
+
export { Vertical_1 as Vertical };
|
|
69
|
+
const Horizontal_1: number;
|
|
70
|
+
export { Horizontal_1 as Horizontal };
|
|
71
|
+
}
|
|
72
|
+
}
|
|
73
|
+
declare module "Graphs/Vertex" {
|
|
74
|
+
export default Vertex;
|
|
75
|
+
/**
|
|
76
|
+
* @class Represents a vertex in a graph.
|
|
77
|
+
*/
|
|
78
|
+
class Vertex {
|
|
79
|
+
/**
|
|
80
|
+
* A list containing all edges incident with this vertex.
|
|
81
|
+
* returns {Array}
|
|
82
|
+
*/
|
|
83
|
+
edges: any[];
|
|
84
|
+
/**
|
|
85
|
+
* A list containing all outgoing edges.
|
|
86
|
+
*/
|
|
87
|
+
outEdges: any[];
|
|
88
|
+
/**
|
|
89
|
+
* A list containing all incoming edges.
|
|
90
|
+
*/
|
|
91
|
+
inEdges: any[];
|
|
92
|
+
/**
|
|
93
|
+
* The relative weight of this vertex.
|
|
94
|
+
*/
|
|
95
|
+
weight: number;
|
|
96
|
+
/**
|
|
97
|
+
* For internal use only.
|
|
98
|
+
* @private
|
|
99
|
+
*/
|
|
100
|
+
private clone;
|
|
101
|
+
/**
|
|
102
|
+
* For internal use only.
|
|
103
|
+
* @private
|
|
104
|
+
*/
|
|
105
|
+
private removeEdge;
|
|
106
|
+
/**
|
|
107
|
+
* Checks if the current vertex is incident with the specified edge.
|
|
108
|
+
* @param {Edge} edge The edge to check.
|
|
109
|
+
* @returns {Boolean} true if the vertex is incident with the edge; otherwise, false.
|
|
110
|
+
*/
|
|
111
|
+
incidentWith(edge: any): boolean;
|
|
112
|
+
/**
|
|
113
|
+
* Checks if there is an edge connecting this vertex with the specified vertex.
|
|
114
|
+
* @param {Vertex} vertex The vertex to check.
|
|
115
|
+
* @returns {Boolean} true if the vertices are connected; otherwise, false.
|
|
116
|
+
*/
|
|
117
|
+
adjacentTo(vertex: Vertex): boolean;
|
|
118
|
+
/**
|
|
119
|
+
* Finds the edge connecting the current vertex with the specified vertex.
|
|
120
|
+
* @param {Vertex} vertex The vertex to find an edge for.
|
|
121
|
+
* @returns {Edge} The edge connecting the vertices or null.
|
|
122
|
+
*/
|
|
123
|
+
getCommonEdge(vertex: Vertex): any;
|
|
124
|
+
getCommonEdges(vertex: any): boolean;
|
|
125
|
+
/**
|
|
126
|
+
* For internal use only.
|
|
127
|
+
* @private
|
|
128
|
+
*/
|
|
129
|
+
private edgeTo;
|
|
130
|
+
/**
|
|
131
|
+
* Returns an array containing all vertices adjacent to the current vertex.
|
|
132
|
+
* @returns {Array} A list with all neighbors.
|
|
133
|
+
*/
|
|
134
|
+
getNeighbors(): any[];
|
|
135
|
+
/**
|
|
136
|
+
* Returns the number of incident edges.
|
|
137
|
+
* @returns {Number} The number of incident edges.
|
|
138
|
+
*/
|
|
139
|
+
degree(): number;
|
|
140
|
+
inDegree(): number;
|
|
141
|
+
outDegree(): number;
|
|
142
|
+
toString(): any;
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
declare module "Graphs/Edge" {
|
|
146
|
+
export default Edge;
|
|
147
|
+
/**
|
|
148
|
+
* @class Represents an edge connecting two vertices in a graph.
|
|
149
|
+
*/
|
|
150
|
+
class Edge {
|
|
151
|
+
/**
|
|
152
|
+
* Initializes a new instance of the Edge class.
|
|
153
|
+
* @constructor
|
|
154
|
+
* @param {Vertex} origin The origin vertex.
|
|
155
|
+
* @param {Vertex} destination The destination vertex.
|
|
156
|
+
*/
|
|
157
|
+
constructor(origin: any, destination: any, prototype: any);
|
|
158
|
+
/**
|
|
159
|
+
* The origin vertex.
|
|
160
|
+
*/
|
|
161
|
+
origin: any;
|
|
162
|
+
/**
|
|
163
|
+
* The destination vertex.
|
|
164
|
+
*/
|
|
165
|
+
destination: any;
|
|
166
|
+
weight: any;
|
|
167
|
+
/**
|
|
168
|
+
* Returns the vertex connected by this edge that is not the specified vertex.
|
|
169
|
+
* @param {Vertex} vertex One of the vertices connected by this edge.
|
|
170
|
+
* @returns {Vertex} The other vertex connected by this edge.
|
|
171
|
+
*/
|
|
172
|
+
getOtherEnd(vertex: any): any;
|
|
173
|
+
/**
|
|
174
|
+
* Returns a common vertex for the current edge and the specified edge.
|
|
175
|
+
* @param {Edge} edge The edge for which to find common vertex.
|
|
176
|
+
* @returns {Vertex} The common vertex if it exists, otherwise null.
|
|
177
|
+
*/
|
|
178
|
+
getCommonVertex(edge: Edge): any;
|
|
179
|
+
/**
|
|
180
|
+
* Checks if the current edge connects the specified vertices.
|
|
181
|
+
* @param {Vertex} v1 The first vertex.
|
|
182
|
+
* @param {Vertex} v2 The second vertex.
|
|
183
|
+
* @returns {Boolean} true if the current edge connects the specified vertices; otherwise, false.
|
|
184
|
+
*/
|
|
185
|
+
joins(v1: any, v2: any): boolean;
|
|
186
|
+
/**
|
|
187
|
+
* Returns an array containing the origin and destination vertices of this edge.
|
|
188
|
+
* @returns {Array} An array containing the related vertices.
|
|
189
|
+
*/
|
|
190
|
+
getEnds(): any[];
|
|
191
|
+
/**
|
|
192
|
+
* Checks if the current edge is incident with the specified vertex.
|
|
193
|
+
* @param {Vertex} vertex The vertex to check.
|
|
194
|
+
* @returns {Boolean} true if the edge is incident with the vertex; otherwise, false.
|
|
195
|
+
*/
|
|
196
|
+
incidentWith(vertex: any): boolean;
|
|
197
|
+
/**
|
|
198
|
+
* Checks if the current edge is adjacent to the specified edge, that is,
|
|
199
|
+
* they have common vertex.
|
|
200
|
+
* @param {Edge} edge The edge to check.
|
|
201
|
+
* @returns {Boolean} true if the current edge is adjacent to the specified edge; otherwise, false.
|
|
202
|
+
*/
|
|
203
|
+
adjacentTo(edge: Edge): boolean;
|
|
204
|
+
/**
|
|
205
|
+
* Changes the origin of the current edge to the specified vertex.
|
|
206
|
+
* @param {Vertex} vertex The new origin of the edge.
|
|
207
|
+
*/
|
|
208
|
+
changeOrigin(v: any): void;
|
|
209
|
+
/**
|
|
210
|
+
* Changes the destination of the current edge to the specified vertex.
|
|
211
|
+
* @param {Vertex} vertex The new destination of the edge.
|
|
212
|
+
*/
|
|
213
|
+
changeDestination(v: any): void;
|
|
214
|
+
changeVertex(v: any, w: any): void;
|
|
215
|
+
/**
|
|
216
|
+
* Reverses this edge.
|
|
217
|
+
*/
|
|
218
|
+
reverse(): void;
|
|
219
|
+
directTo(destination: any): void;
|
|
220
|
+
/**
|
|
221
|
+
* Creates a new edge similar to the current edge but with reversed direction.
|
|
222
|
+
* @returns {Edge}
|
|
223
|
+
*/
|
|
224
|
+
createReverseEdge(): Edge;
|
|
225
|
+
toString(): string;
|
|
226
|
+
}
|
|
227
|
+
}
|
|
228
|
+
declare module "Graphs/PQTree" {
|
|
229
|
+
export class PQTree {
|
|
230
|
+
init(): void;
|
|
231
|
+
consecutiveNodes: any;
|
|
232
|
+
modifiedNodes: any[];
|
|
233
|
+
root: any;
|
|
234
|
+
reinit(): void;
|
|
235
|
+
reduction(s: any): any;
|
|
236
|
+
bubble(s: any): boolean;
|
|
237
|
+
reduce(s: any): any;
|
|
238
|
+
pertinentRoot: any;
|
|
239
|
+
templateL1(lNode: any): boolean;
|
|
240
|
+
templateP1(pNode: any): boolean;
|
|
241
|
+
templateP2(pNode: any): boolean;
|
|
242
|
+
templateP3(pNode: any): boolean;
|
|
243
|
+
templateP4(pNode: any): boolean;
|
|
244
|
+
templateP5(pNode: any): boolean;
|
|
245
|
+
templateP6(pNode: any): boolean;
|
|
246
|
+
templateQ1(qNode: any): boolean;
|
|
247
|
+
templateQ2(qNode: any): boolean;
|
|
248
|
+
templateQ3(qNode: any): boolean;
|
|
249
|
+
}
|
|
250
|
+
export namespace PQTree {
|
|
251
|
+
export { Node };
|
|
252
|
+
export { NodePair };
|
|
253
|
+
}
|
|
254
|
+
export namespace NodeType {
|
|
255
|
+
const pNode: number;
|
|
256
|
+
const qNode: number;
|
|
257
|
+
const directionIndicator: number;
|
|
258
|
+
}
|
|
259
|
+
export namespace NodeLabel {
|
|
260
|
+
const empty: number;
|
|
261
|
+
const partial: number;
|
|
262
|
+
const full: number;
|
|
263
|
+
}
|
|
264
|
+
class Node {
|
|
265
|
+
constructor(type: any, data: any);
|
|
266
|
+
data: any;
|
|
267
|
+
immediateSiblings: {
|
|
268
|
+
nodes: any[];
|
|
269
|
+
trackDirection: boolean;
|
|
270
|
+
directedTowardsIndex: any;
|
|
271
|
+
add(node: any): void;
|
|
272
|
+
remove(node: any): boolean;
|
|
273
|
+
removeAt(index: any): boolean;
|
|
274
|
+
getOther(node: any): any;
|
|
275
|
+
replace(oldNode: any, newNode: any): void;
|
|
276
|
+
indexOf(node: any): number;
|
|
277
|
+
contains(node: any): boolean;
|
|
278
|
+
get(index: any): any;
|
|
279
|
+
readonly count: number;
|
|
280
|
+
direction: any;
|
|
281
|
+
};
|
|
282
|
+
readInReverseDirection: boolean;
|
|
283
|
+
init(nodeType: any): void;
|
|
284
|
+
_type: any;
|
|
285
|
+
parent: any;
|
|
286
|
+
endMostChildren: any;
|
|
287
|
+
circularLink: any;
|
|
288
|
+
left: any;
|
|
289
|
+
right: any;
|
|
290
|
+
childCount: any;
|
|
291
|
+
fullChildrenList: any;
|
|
292
|
+
fullLeft: any;
|
|
293
|
+
fullRight: any;
|
|
294
|
+
fullChildren: any;
|
|
295
|
+
partialChildrenList: any;
|
|
296
|
+
partialLeft: any;
|
|
297
|
+
partialRight: any;
|
|
298
|
+
partialChildren: any;
|
|
299
|
+
pertinentChildCount: any;
|
|
300
|
+
pertinentLeafCount: any;
|
|
301
|
+
_label: any;
|
|
302
|
+
blocked: boolean;
|
|
303
|
+
queued: boolean;
|
|
304
|
+
pseudoRoot: any;
|
|
305
|
+
destroyed: any;
|
|
306
|
+
destroy(): void;
|
|
307
|
+
reinit(reinitParent: any): void;
|
|
308
|
+
set label(arg: any);
|
|
309
|
+
get label(): any;
|
|
310
|
+
getBlockedSiblings(): any[];
|
|
311
|
+
getUnblockedSiblings(): any[];
|
|
312
|
+
getEndMostDirectedSibling(otherSide: any): any;
|
|
313
|
+
getNonDirectedSibling(otherSide: any): any;
|
|
314
|
+
setPseudoRoot(blockedList: any): void;
|
|
315
|
+
set type(arg: any);
|
|
316
|
+
get type(): any;
|
|
317
|
+
getMaximalConsecutiveBlockedSiblings(): any[];
|
|
318
|
+
markBlocked(): void;
|
|
319
|
+
markUnblocked(): void;
|
|
320
|
+
markQueued(): void;
|
|
321
|
+
fullChildrenAreAdjacent(): boolean;
|
|
322
|
+
fullChildrenAreAdjacentTo(node: any): any;
|
|
323
|
+
fullChildrenAreEndMost(): boolean;
|
|
324
|
+
partialChildrenAtEnds(): boolean;
|
|
325
|
+
endMostChildrenAreEmptyOrPartial(): boolean;
|
|
326
|
+
childrenAreFull(): boolean;
|
|
327
|
+
twoChildrenLeft(): boolean;
|
|
328
|
+
getPartialChild(index: any): any;
|
|
329
|
+
getFirstFullChild(): any;
|
|
330
|
+
getFirstEmptyChild(): any;
|
|
331
|
+
addToFullList(node: any): void;
|
|
332
|
+
removeFromFullList(node: any): void;
|
|
333
|
+
addToPartialList(node: any): void;
|
|
334
|
+
removeFromPartialList(node: any): void;
|
|
335
|
+
addChildToPNode(node: any): void;
|
|
336
|
+
removeChildFromPNode(node: any): void;
|
|
337
|
+
addChildToQNode(node: any): void;
|
|
338
|
+
removeChildFromQNode(node: any): void;
|
|
339
|
+
addChildToPseudoRoot(node: any): void;
|
|
340
|
+
addChild(node: any, updateTree: any): void;
|
|
341
|
+
removeChild(node: any, updateTree: any): void;
|
|
342
|
+
replaceChild(node: any, newNode: any): void;
|
|
343
|
+
getPertinentNeighbor(si: any): any;
|
|
344
|
+
getEmptyNeighbor(si: any): any;
|
|
345
|
+
getEndMostChild(nodeLabel: any): any;
|
|
346
|
+
absorbPartialChild(qNode: any): void;
|
|
347
|
+
replaceFullChildrenWith(node: any): void;
|
|
348
|
+
becomeChild(theChild: any): void;
|
|
349
|
+
moveFullChildrenTo(newParent: any): void;
|
|
350
|
+
checkLabelDirected(node: any, nodeLabel: any): any;
|
|
351
|
+
hasChildren(): boolean;
|
|
352
|
+
getEndmostLeaves(): any[];
|
|
353
|
+
getAllNodes(list: any, nodeType: any): void;
|
|
354
|
+
getQChildren(): any[];
|
|
355
|
+
getLeaf(): any;
|
|
356
|
+
siblingOf(node: any): boolean;
|
|
357
|
+
getFullLeavesFrom(): any;
|
|
358
|
+
getFullLeavesTo(): any;
|
|
359
|
+
getFullLeaves(): any[];
|
|
360
|
+
get nextPSibling(): any;
|
|
361
|
+
get childLink(): any;
|
|
362
|
+
get children(): any;
|
|
363
|
+
get emptyChildren(): number;
|
|
364
|
+
get unmarked(): boolean;
|
|
365
|
+
set direction(arg: any);
|
|
366
|
+
get direction(): any;
|
|
367
|
+
}
|
|
368
|
+
class NodePair {
|
|
369
|
+
constructor(directionIndex: any);
|
|
370
|
+
nodes: any[];
|
|
371
|
+
trackDirection: boolean;
|
|
372
|
+
directedTowardsIndex: any;
|
|
373
|
+
add(node: any): void;
|
|
374
|
+
remove(node: any): boolean;
|
|
375
|
+
removeAt(index: any): boolean;
|
|
376
|
+
getOther(node: any): any;
|
|
377
|
+
replace(oldNode: any, newNode: any): void;
|
|
378
|
+
indexOf(node: any): number;
|
|
379
|
+
contains(node: any): boolean;
|
|
380
|
+
get(index: any): any;
|
|
381
|
+
get count(): number;
|
|
382
|
+
set direction(arg: any);
|
|
383
|
+
get direction(): any;
|
|
384
|
+
}
|
|
385
|
+
export {};
|
|
386
|
+
}
|
|
387
|
+
declare module "Graphs/Face" {
|
|
388
|
+
/**
|
|
389
|
+
* @namespace MindFusion.Graphs
|
|
390
|
+
*/
|
|
391
|
+
export default class Face {
|
|
392
|
+
constructor(prototype: any);
|
|
393
|
+
edges: any;
|
|
394
|
+
incidentWith(v: any): boolean;
|
|
395
|
+
adjacentTo(face: any): boolean;
|
|
396
|
+
getCommonEdge(face: any): any;
|
|
397
|
+
get degree(): any;
|
|
398
|
+
getVertices(): Set<any>;
|
|
399
|
+
enumVertices(): any[];
|
|
400
|
+
isCycle(): boolean;
|
|
401
|
+
edgeFromVertex(vertex: any): any;
|
|
402
|
+
replaceEdge(edge: any, replacement: any): void;
|
|
403
|
+
get bigAngles(): any[];
|
|
404
|
+
_bigAngles: any[];
|
|
405
|
+
}
|
|
406
|
+
}
|
|
407
|
+
declare module "Graphs/Embedding" {
|
|
408
|
+
export default class Embedding {
|
|
409
|
+
constructor(graph: any, copy: any, vertexCopyToOrigMap: any, edgeCopyToOrigMap: any);
|
|
410
|
+
graph: any;
|
|
411
|
+
embedding: any;
|
|
412
|
+
addBlockEmbedding(block: any, blockEmbedding: any): void;
|
|
413
|
+
add(v: any): void;
|
|
414
|
+
remove(v: any): void;
|
|
415
|
+
getNextRightFaceEdge(e: any): any;
|
|
416
|
+
createDirectedEdges(): void;
|
|
417
|
+
reverseEdges: Map<any, any>;
|
|
418
|
+
replaceEdges(e: any, e1: any, e2: any, r: any, r1: any, r2: any, newVertex: any): void;
|
|
419
|
+
addEdge(e: any, r: any, fromEdge: any, toEdge: any): void;
|
|
420
|
+
getNext(v: any, e: any): any;
|
|
421
|
+
getPrevious(v: any, e: any): any;
|
|
422
|
+
setReverseEdges(e: any, r: any): void;
|
|
423
|
+
isVertexBimodal(v: any): boolean;
|
|
424
|
+
isBimodal(): boolean;
|
|
425
|
+
contractEdge(edge: any, vertex: any): void;
|
|
426
|
+
replaceEdge(edge: any, vertex: any): void;
|
|
427
|
+
quasiCapacity(face: any): number;
|
|
428
|
+
countSourceSwitches(face: any): number;
|
|
429
|
+
enumerateFaces(): void;
|
|
430
|
+
_faces: any[];
|
|
431
|
+
faceOnLeftMap: Map<any, any>;
|
|
432
|
+
faceOnRightMap: Map<any, any>;
|
|
433
|
+
externalFace: any;
|
|
434
|
+
enumerateFaceEdges(startEdge: any, startVertex: any): Face;
|
|
435
|
+
prevInEmbedding(edge: any, vertex: any): any;
|
|
436
|
+
insertEdge(edge: any, vertex: any, face: any): void;
|
|
437
|
+
edgesBetween(edge1: any, edge2: any, vertex: any): any[];
|
|
438
|
+
getReverse(e: any): any;
|
|
439
|
+
get(v: any): any;
|
|
440
|
+
get vertices(): any;
|
|
441
|
+
get faces(): any[];
|
|
442
|
+
}
|
|
443
|
+
import Face from "Graphs/Face";
|
|
444
|
+
}
|
|
445
|
+
declare module "Graphs/Interval" {
|
|
446
|
+
/**
|
|
447
|
+
* @namespace MindFusion.Graphs
|
|
448
|
+
*/
|
|
449
|
+
export default class Interval {
|
|
450
|
+
constructor(min: any, max: any);
|
|
451
|
+
min: any;
|
|
452
|
+
max: any;
|
|
453
|
+
contains(interval: any): boolean;
|
|
454
|
+
intersects(interval: any): boolean;
|
|
455
|
+
overlaps(interval: any): boolean;
|
|
456
|
+
}
|
|
457
|
+
}
|
|
458
|
+
declare module "Graphs/BinaryTree" {
|
|
459
|
+
/**
|
|
460
|
+
* @namespace MindFusion.Graphs
|
|
461
|
+
*/
|
|
462
|
+
class BinaryTree {
|
|
463
|
+
constructor(item: any);
|
|
464
|
+
root: {
|
|
465
|
+
item: any;
|
|
466
|
+
addChildren(left: any, right: any): void;
|
|
467
|
+
left: any;
|
|
468
|
+
right: any;
|
|
469
|
+
getLeaves(): any[];
|
|
470
|
+
collectLeaves(leaves: any): void;
|
|
471
|
+
};
|
|
472
|
+
getLeaves(): any[];
|
|
473
|
+
}
|
|
474
|
+
namespace BinaryTree {
|
|
475
|
+
export { Node };
|
|
476
|
+
}
|
|
477
|
+
export default BinaryTree;
|
|
478
|
+
class Node {
|
|
479
|
+
constructor(item: any);
|
|
480
|
+
item: any;
|
|
481
|
+
addChildren(left: any, right: any): void;
|
|
482
|
+
left: {
|
|
483
|
+
item: any;
|
|
484
|
+
addChildren(left: any, right: any): void;
|
|
485
|
+
left: any;
|
|
486
|
+
right: any;
|
|
487
|
+
getLeaves(): any[];
|
|
488
|
+
collectLeaves(leaves: any): void;
|
|
489
|
+
};
|
|
490
|
+
right: {
|
|
491
|
+
item: any;
|
|
492
|
+
addChildren(left: any, right: any): void;
|
|
493
|
+
left: any;
|
|
494
|
+
right: any;
|
|
495
|
+
getLeaves(): any[];
|
|
496
|
+
collectLeaves(leaves: any): void;
|
|
497
|
+
};
|
|
498
|
+
getLeaves(): any[];
|
|
499
|
+
collectLeaves(leaves: any): void;
|
|
500
|
+
}
|
|
501
|
+
}
|
|
502
|
+
declare module "Graphs/PriorityQueue" {
|
|
503
|
+
/**
|
|
504
|
+
* @namespace MindFusion.Graphs
|
|
505
|
+
*/
|
|
506
|
+
export default class PriorityQueue {
|
|
507
|
+
constructor(maxN: any, array: any);
|
|
508
|
+
a: any;
|
|
509
|
+
N: number;
|
|
510
|
+
d: number;
|
|
511
|
+
pq: number[];
|
|
512
|
+
qp: number[];
|
|
513
|
+
empty(): boolean;
|
|
514
|
+
insert(v: any): void;
|
|
515
|
+
getMin(): number;
|
|
516
|
+
lower(k: any): void;
|
|
517
|
+
less(i: any, j: any): boolean;
|
|
518
|
+
exchange(i: any, j: any): void;
|
|
519
|
+
swim(k: any): void;
|
|
520
|
+
sink(k: any, N: any): void;
|
|
521
|
+
}
|
|
522
|
+
}
|
|
523
|
+
declare module "Graphs/Factory" {
|
|
524
|
+
/**
|
|
525
|
+
* @namespace MindFusion.Graphs
|
|
526
|
+
*/
|
|
527
|
+
export default class Factory {
|
|
528
|
+
}
|
|
529
|
+
}
|
|
530
|
+
declare module "Graphs/TreeHelper" {
|
|
531
|
+
export default class TreeHelper {
|
|
532
|
+
constructor(reversedLinks: any);
|
|
533
|
+
reversedLinks: any;
|
|
534
|
+
parentNode(edge: any): any;
|
|
535
|
+
childNode(edge: any): any;
|
|
536
|
+
parentEdges(vertex: any): any;
|
|
537
|
+
childEdges(vertex: any): any;
|
|
538
|
+
assignPoints(edge: any, points: any): void;
|
|
539
|
+
}
|
|
540
|
+
}
|
|
541
|
+
declare module "Graphs/Graph" {
|
|
542
|
+
/**
|
|
543
|
+
* @class Represents a graph.
|
|
544
|
+
*/
|
|
545
|
+
export class Graph {
|
|
546
|
+
/**
|
|
547
|
+
* A list containing all vertices in the graph.
|
|
548
|
+
*/
|
|
549
|
+
vertices: any[];
|
|
550
|
+
/**
|
|
551
|
+
* A list containing all edges in the graph.
|
|
552
|
+
*/
|
|
553
|
+
edges: any[];
|
|
554
|
+
/**
|
|
555
|
+
* Creates an exact copy of the current graph.
|
|
556
|
+
* @param {Boolean} [saveMapping] Indicates whether to store vertex and edge mapping information in the copy.
|
|
557
|
+
* @returns {Graph} The newly created copy.
|
|
558
|
+
*/
|
|
559
|
+
clone(saveMapping?: boolean): Graph;
|
|
560
|
+
cloneSubset(vertexSubset: any, saveMapping: any): Graph;
|
|
561
|
+
createReverseMaps(): void;
|
|
562
|
+
vertexOrigToCopyMap: Map<any, any>;
|
|
563
|
+
edgeOrigToCopyMap: Map<any, any>;
|
|
564
|
+
/**
|
|
565
|
+
* Returns a new graph object containing a subset of the vertices and edges
|
|
566
|
+
* of the original graph, such that the new graph is a tree.
|
|
567
|
+
* @param {Vertex} root The desired root vertex of the tree.
|
|
568
|
+
* @param {Boolean} enableAssistants
|
|
569
|
+
* @param {Boolean} compactAssistants
|
|
570
|
+
* @returns {Graph} The newly created tree.
|
|
571
|
+
*/
|
|
572
|
+
tree(root: Vertex, reversedLinks: any, enableAssistants: boolean, compactAssistants: boolean): Graph;
|
|
573
|
+
collectLevels(parent: any): void;
|
|
574
|
+
/**
|
|
575
|
+
* @private
|
|
576
|
+
*/
|
|
577
|
+
private childrenOf;
|
|
578
|
+
/**
|
|
579
|
+
* Reassigns tree levels when "assistants" are enabled.
|
|
580
|
+
* @private
|
|
581
|
+
*/
|
|
582
|
+
private reassignLevels;
|
|
583
|
+
/**
|
|
584
|
+
* Creates a new edge connecting the specified vertices and adds it to the graph.
|
|
585
|
+
* @param {Vertex} origin The origin vertex.
|
|
586
|
+
* @param {Vertex} destination The destination vertex.
|
|
587
|
+
* @param {Object} [owner] The owner of the new edge.
|
|
588
|
+
* @returns {Edge} The newly created edge.
|
|
589
|
+
*/
|
|
590
|
+
createEdge(origin: Vertex, destination: Vertex, owner?: any): Edge;
|
|
591
|
+
createEdgeP(origin: any, destination: any, prototype: any): Edge;
|
|
592
|
+
/**
|
|
593
|
+
* Adds an existing edge to the graph.
|
|
594
|
+
* @param {Edge} edge The edge to add.
|
|
595
|
+
*/
|
|
596
|
+
addEdge(edge: Edge): void;
|
|
597
|
+
/**
|
|
598
|
+
* Removes an edge from the graph.
|
|
599
|
+
* @param {Edge} edge The edge to remove.
|
|
600
|
+
*/
|
|
601
|
+
removeEdge(edge: Edge): void;
|
|
602
|
+
removeAllEdges(): void;
|
|
603
|
+
/**
|
|
604
|
+
* Creates a new vertex with the specified position and size and adds it to the graph.
|
|
605
|
+
* @param {Rect} layoutRect A rectangle specifying the position and size of the vertex.
|
|
606
|
+
* @param {Object} [owner] The owner of the new vertex.
|
|
607
|
+
* @returns {Vertex} The newly created vertex.
|
|
608
|
+
*/
|
|
609
|
+
createVertex(layoutRect: any, owner?: any): Vertex;
|
|
610
|
+
removeVertex(vertex: any): void;
|
|
611
|
+
/**
|
|
612
|
+
* Adds an existing vertex and its related edges to the graph.
|
|
613
|
+
* @param {Vertex} vertex The vertex to add.
|
|
614
|
+
* @private
|
|
615
|
+
*/
|
|
616
|
+
private addVertexAndOutEdges;
|
|
617
|
+
addVertex(debugId: any): Vertex;
|
|
618
|
+
/**
|
|
619
|
+
* Assigns unique indices to the items in the graph.
|
|
620
|
+
* @private
|
|
621
|
+
*/
|
|
622
|
+
private setItemIndices;
|
|
623
|
+
splitEdge(e: any): Vertex;
|
|
624
|
+
findShortestPathVS(v1: any, destSet: any): any[];
|
|
625
|
+
findShortestPathSS(originSet: any, destSet: any): any[];
|
|
626
|
+
findShortestPathBfs(e: any, destSet: any, mark: any, searchTree: any, path: any): void;
|
|
627
|
+
findShortestWeightedPathVS(origin: any, destSet: any, outMinWeigth: any): any[];
|
|
628
|
+
findShortestWeightedPathSS(originSet: any, destSet: any): any[];
|
|
629
|
+
/**
|
|
630
|
+
* Returns a list with the connected subgraphs in the current graph.
|
|
631
|
+
* @returns {Array} An array with connected Graph objects.
|
|
632
|
+
*/
|
|
633
|
+
getConnectedComponents(): any[];
|
|
634
|
+
searchCounter: number;
|
|
635
|
+
/**
|
|
636
|
+
* Performs a depth-first search for connected components.
|
|
637
|
+
* @private
|
|
638
|
+
*/
|
|
639
|
+
private dfsConnectivity;
|
|
640
|
+
getBiconnectedComponents(saveMapping: any, blocksHandler: any): any[];
|
|
641
|
+
getBiconnectedComponentsOfConnectedGraph(): any[];
|
|
642
|
+
visitedEdges: any[];
|
|
643
|
+
cutVertices: any[];
|
|
644
|
+
foundComponents: any[];
|
|
645
|
+
secondLevel: any[];
|
|
646
|
+
searchOrder: any[];
|
|
647
|
+
backMostEdges: any[];
|
|
648
|
+
biconnectivityDfs(parent: any, vertexId: any): void;
|
|
649
|
+
stackToComponent2(child: any): void;
|
|
650
|
+
getBiconnectedComponents2(): Graph[];
|
|
651
|
+
planarMakeBiconnected(): Edge[];
|
|
652
|
+
stillPlanar(v1: any, v2: any): boolean;
|
|
653
|
+
father(vertex: any): any;
|
|
654
|
+
getOutsideVertexCP(cutpoints: any): any;
|
|
655
|
+
getOutsideVertexCPN(cutpoints: any, neighbor: any): any;
|
|
656
|
+
get3EdgeConnectedComponents(): any[];
|
|
657
|
+
getCutPairs(): any[];
|
|
658
|
+
test3EdgeConnectivity(returnPairs: any): any[];
|
|
659
|
+
findBlockSeparationPairs(): any[][];
|
|
660
|
+
findBlockSeparationPairsB(): any[];
|
|
661
|
+
depthFirstSearch(start: any): void;
|
|
662
|
+
searchParent: any[];
|
|
663
|
+
searchComponent(origin: any, dest: any): void;
|
|
664
|
+
getStNumbering(sink: any): any[];
|
|
665
|
+
stOrder: any[];
|
|
666
|
+
convertToStGraph(sink: any): any[];
|
|
667
|
+
isCycleEdge(edge: any): boolean;
|
|
668
|
+
findPath(v: any, oldVertices: any, oldEdges: any): any[];
|
|
669
|
+
isPlanar(): boolean;
|
|
670
|
+
isPlanarSingleBicomponent(embeddingInfo: any): boolean;
|
|
671
|
+
getPlanarEmbedding(): Embedding;
|
|
672
|
+
getPlanarEmbeddingSingleBicomp(embeddingInfo: any): Map<any, any>;
|
|
673
|
+
/**
|
|
674
|
+
* Should be called on a planar graph.
|
|
675
|
+
* @param {Map} [embedding] Receives the embedding lists.
|
|
676
|
+
* @param {Map} [embeddingInfo] Optional.
|
|
677
|
+
* @returns {Vertex} The t node in st ordering.
|
|
678
|
+
*/
|
|
679
|
+
getUpwardEmbedding(embedding?: Map<any, any>, embeddingInfo?: Map<any, any>): Vertex;
|
|
680
|
+
entireEmbed(upEmbedding: any, tVertex: any): Map<any, any>;
|
|
681
|
+
entireEmbedDfs(upEmbedding: any, entireEmbedding: any, vertex: any, oldVertices: any): void;
|
|
682
|
+
findPlanarSubgraph(edgesToDelete: any, crossingConstrainedEdges: any): any;
|
|
683
|
+
findPlanarSubgraphBySimpleEdgeInsertion(edgesToDelete: any, knownPlanarEdges: any, crossingConstrainedEdges: any): any;
|
|
684
|
+
findPlanarSubgraphByBookEmbedding(edgesToDelete: any, crossingConstrainedEdges: any): any;
|
|
685
|
+
minAdjacenciesNeighbor(vertex: any, vset: any): any;
|
|
686
|
+
minDegreeVertex(vset: any): any;
|
|
687
|
+
countAdjacencies(vertex: any, vset: any): number;
|
|
688
|
+
embedOnSameFace(faceVertices: any): Embedding;
|
|
689
|
+
planarize(edgeToDummyEdgesMap: any, crossingConstrainedEdges: any): any;
|
|
690
|
+
/**
|
|
691
|
+
* Makes the graph acyclic by reversing the direction of selected edges.
|
|
692
|
+
* @returns {Array} A list with all edges that were reversed in order to make the graph acyclic.
|
|
693
|
+
* @remarks Must be called on a simple connected graph.
|
|
694
|
+
*/
|
|
695
|
+
makeAcyclic(): any[];
|
|
696
|
+
getDualGraph(cacheIncidentFaces: any): any;
|
|
697
|
+
getDualGraphE(embedding: any, s: any, t: any): any;
|
|
698
|
+
topologicalSort(): any[];
|
|
699
|
+
postCounter: number;
|
|
700
|
+
topologicalSortDfs(postOrder: any, topologicalOrder: any, dest: any): boolean;
|
|
701
|
+
getWeightedTopologicalNumbering(minNumber: any): any[];
|
|
702
|
+
getWeightedTopologicalNumberingTS(tsort: any, minNumber: any): any[];
|
|
703
|
+
splitToMaxDegree(maxDegree: any, embedding: any): Map<any, any>;
|
|
704
|
+
splitToMaxDegreeV(vertex: any, maxDegree: any, embedding: any): Graph;
|
|
705
|
+
reorderTopologically(): void;
|
|
706
|
+
maxWeightedCliqueOfTransitiveDAG(): any[];
|
|
707
|
+
}
|
|
708
|
+
import Vertex from "Graphs/Vertex";
|
|
709
|
+
import Edge from "Graphs/Edge";
|
|
710
|
+
import Embedding from "Graphs/Embedding";
|
|
711
|
+
}
|
|
712
|
+
declare module "Graphs/BlockCutpointGraph" {
|
|
713
|
+
export default class BlockCutpointGraph extends Graph {
|
|
714
|
+
constructor(graph: any);
|
|
715
|
+
targetGraph: any;
|
|
716
|
+
blockToBnodeMap: Map<any, any>;
|
|
717
|
+
cutToCnodeMap: Map<any, any>;
|
|
718
|
+
blocks: any;
|
|
719
|
+
onComponentBlocks(componentBlocks: any, componentCuts: any): void;
|
|
720
|
+
cutVerticesB(block: any): any[];
|
|
721
|
+
cutVerticesV(bNode: any): any[];
|
|
722
|
+
isPendant(bNode: any): boolean;
|
|
723
|
+
adjacentBlocks(cutVertex: any): any[];
|
|
724
|
+
directFromRoot(): void;
|
|
725
|
+
root: any;
|
|
726
|
+
directFrom(parent: any, vertex: any): void;
|
|
727
|
+
findPendantCut(): any;
|
|
728
|
+
getOutsideVertex(bNode: any): any;
|
|
729
|
+
getOutsideVertexN(bNode: any, neighborCnode: any): any;
|
|
730
|
+
getBlock(bNode: any): any;
|
|
731
|
+
getCutvertex(cNode: any): any;
|
|
732
|
+
getCnode(cut: any): any;
|
|
733
|
+
mapVertices(vertices: any, map: any): any[];
|
|
734
|
+
mergeBlocks(bnodes: any, parent: any): void;
|
|
735
|
+
setNewParent(vertex: any, parent: any): void;
|
|
736
|
+
removeCnode(cNode: any): void;
|
|
737
|
+
removeBnode(bNode: any): void;
|
|
738
|
+
isCnode(vertex: any): boolean;
|
|
739
|
+
isBnode(vertex: any): boolean;
|
|
740
|
+
}
|
|
741
|
+
import { Graph } from "Graphs/Graph";
|
|
742
|
+
}
|
|
743
|
+
declare module "Graphs/DualGraph" {
|
|
744
|
+
export default class DualGraph extends Graph {
|
|
745
|
+
constructor(graph: any, embedding: any, cacheIncidentFaces: any, s: any, t: any);
|
|
746
|
+
graph: any;
|
|
747
|
+
embedding: any;
|
|
748
|
+
faces: Face[];
|
|
749
|
+
edgeToFaceMap: Map<any, any>;
|
|
750
|
+
incidentFaces: Map<any, any>;
|
|
751
|
+
faceToVertexMap: Map<any, any>;
|
|
752
|
+
vertexToFaceMap: Map<any, any>;
|
|
753
|
+
splitExternalFace(s: any, t: any): void;
|
|
754
|
+
leftExFace: any;
|
|
755
|
+
leftExVertex: any;
|
|
756
|
+
rightExFace: Face;
|
|
757
|
+
rightExVertex: Vertex;
|
|
758
|
+
getIncidentFaces(v: any): any;
|
|
759
|
+
cacheIncidentFace(v: any, f: any): void;
|
|
760
|
+
getVertices(face: any): Set<any>;
|
|
761
|
+
getFaceVertices(faceList: any): Set<any>;
|
|
762
|
+
getCommonEdge(f1: any, f2: any): any;
|
|
763
|
+
getCommonEdgeMinWeight(f1: any, f2: any): any;
|
|
764
|
+
getOriginalEdge(e: any): any;
|
|
765
|
+
replaceEdge(oldEdge: any, newVertex: any): void;
|
|
766
|
+
splitFace(f: any, newEdge: any): void;
|
|
767
|
+
dgCreateVertex(f: any): Vertex;
|
|
768
|
+
dgCreateEdge(e: any): Edge;
|
|
769
|
+
setFaceIndices(): void;
|
|
770
|
+
left(e: any): any;
|
|
771
|
+
right(e: any): any;
|
|
772
|
+
}
|
|
773
|
+
import { Graph } from "Graphs/Graph";
|
|
774
|
+
import Face from "Graphs/Face";
|
|
775
|
+
import Vertex from "Graphs/Vertex";
|
|
776
|
+
import Edge from "Graphs/Edge";
|
|
777
|
+
}
|
|
778
|
+
declare module "Graphs/IntervalGraph" {
|
|
779
|
+
export default class IntervalGraph extends Graph {
|
|
780
|
+
constructor(intervals: any);
|
|
781
|
+
intervalVertices: Map<any, any>;
|
|
782
|
+
intervals: any;
|
|
783
|
+
maxWeightedIndependentSet(): any[];
|
|
784
|
+
}
|
|
785
|
+
import { Graph } from "Graphs/Graph";
|
|
786
|
+
}
|
|
787
|
+
declare module "Graphs/OverlapGraph" {
|
|
788
|
+
export default class OverlapGraph extends Graph {
|
|
789
|
+
constructor(intervals: any);
|
|
790
|
+
intervalVertices: Map<any, any>;
|
|
791
|
+
vertexIntervals: Map<any, any>;
|
|
792
|
+
intervals: any;
|
|
793
|
+
maxIndependentSet(): Set<any>;
|
|
794
|
+
inclusionLevels: Map<any, any>;
|
|
795
|
+
levelVertices: any[];
|
|
796
|
+
setInclusionLevel(vertex: any): any;
|
|
797
|
+
assignVertexToLevel(vertex: any, level: any): void;
|
|
798
|
+
}
|
|
799
|
+
import { Graph } from "Graphs/Graph";
|
|
800
|
+
}
|
|
801
|
+
declare module "Graphs/Path" {
|
|
802
|
+
export default Path;
|
|
803
|
+
/**
|
|
804
|
+
* @namespace MindFusion.Graphs
|
|
805
|
+
*/
|
|
806
|
+
class Path {
|
|
807
|
+
static isNode(obj: any): boolean;
|
|
808
|
+
static isLink(obj: any): boolean;
|
|
809
|
+
/**
|
|
810
|
+
* Initializes a new instance of the Path class.
|
|
811
|
+
* @constructor
|
|
812
|
+
*/
|
|
813
|
+
constructor(path: any);
|
|
814
|
+
nodes: any[];
|
|
815
|
+
links: any[];
|
|
816
|
+
items: any[];
|
|
817
|
+
contains(item: any): boolean;
|
|
818
|
+
getWeight(incNodes: any, incLinks: any): number;
|
|
819
|
+
add(link: any, node: any): void;
|
|
820
|
+
}
|
|
821
|
+
}
|
|
822
|
+
declare module "Graphs/PathFinder" {
|
|
823
|
+
export class PathFinder {
|
|
824
|
+
/**
|
|
825
|
+
* Finds and returns all paths starting from node 'from' and
|
|
826
|
+
* ending at node 'to'. Returns empty collection if no
|
|
827
|
+
* path exists.
|
|
828
|
+
*/
|
|
829
|
+
static findAllPaths(graph: any, from: any, to: any): Path[];
|
|
830
|
+
static findPaths(graph: any, from: any, to: any, shortestOnly: any, maxPaths: any): Path[];
|
|
831
|
+
static findShortestPath(graph: any, from: any, to: any, useNodeWeights: any, useLinkWeights: any): Path;
|
|
832
|
+
static findLongestPath(graph: any, from: any, to: any): Path;
|
|
833
|
+
static findCycle(graph: any, participant: any): Path;
|
|
834
|
+
static enumAllCycles(graph: any): any[];
|
|
835
|
+
static enumAllCyclesDirected(graph: any, callbackEnum: any): void;
|
|
836
|
+
static deleted(v: any): any;
|
|
837
|
+
}
|
|
838
|
+
import Path from "Graphs/Path";
|
|
839
|
+
}
|
|
840
|
+
declare module "Graphs/Layout" {
|
|
841
|
+
/**
|
|
842
|
+
* @class Superclass of graph layout algorithms that defines their common properties.
|
|
843
|
+
*/
|
|
844
|
+
export class Layout {
|
|
845
|
+
set anchoring(arg: number);
|
|
846
|
+
/**
|
|
847
|
+
* Gets or sets how to align links to the anchor points of nodes.
|
|
848
|
+
* @type {Anchoring}
|
|
849
|
+
* @summary A member of the LayoutDirection enumeration.
|
|
850
|
+
*/
|
|
851
|
+
get anchoring(): number;
|
|
852
|
+
set keepGroupLayout(arg: boolean);
|
|
853
|
+
/**
|
|
854
|
+
* Gets or sets whether to treat each group of attached nodes as a single vertex in the arranged graph.
|
|
855
|
+
* @type {Boolean}
|
|
856
|
+
* @summary true if each group should be processed as an integral graph node, or false otherwise. The default is false.
|
|
857
|
+
*/
|
|
858
|
+
get keepGroupLayout(): boolean;
|
|
859
|
+
set multipleGraphsPlacement(arg: number);
|
|
860
|
+
/**
|
|
861
|
+
* Gets or sets how multiple independent graphs in the diagram should be positioned relatively to each other.
|
|
862
|
+
* @type {MultipleGraphsPlacement}
|
|
863
|
+
* @summary A member of the MultipleGraphsPlacement enumeration.
|
|
864
|
+
*/
|
|
865
|
+
get multipleGraphsPlacement(): number;
|
|
866
|
+
set margins(arg: number);
|
|
867
|
+
/**
|
|
868
|
+
* Gets or sets the margins' size around individual subgraphs processed by this layout object.
|
|
869
|
+
* @type {Number}
|
|
870
|
+
* @summary A number specifying size of margins around arranged graphs.
|
|
871
|
+
*/
|
|
872
|
+
get margins(): number;
|
|
873
|
+
_anchoring: number;
|
|
874
|
+
_keepGroupLayout: boolean;
|
|
875
|
+
_multipleGraphsPlacement: number;
|
|
876
|
+
_margins: number;
|
|
877
|
+
get setsLinkEndPoints(): boolean;
|
|
878
|
+
get setsLinkPoints(): boolean;
|
|
879
|
+
get requiresConnectedGraph(): boolean;
|
|
880
|
+
get requiresSimpleGraph(): boolean;
|
|
881
|
+
get routeRepeatingLinks(): boolean;
|
|
882
|
+
get requiresBezierLinks(): boolean;
|
|
883
|
+
get requiresCascadingLinks(): boolean;
|
|
884
|
+
get requiresHierarchyInfo(): boolean;
|
|
885
|
+
get isStatic(): boolean;
|
|
886
|
+
}
|
|
887
|
+
}
|
|
888
|
+
declare module "Graphs/BorderedTreeLayout" {
|
|
889
|
+
/**
|
|
890
|
+
* @class Implements algorithms for arranging tree structures.
|
|
891
|
+
* @augments Layout
|
|
892
|
+
*/
|
|
893
|
+
export class BorderedTreeLayout extends Layout {
|
|
894
|
+
set levelDistance(arg: number);
|
|
895
|
+
/**
|
|
896
|
+
* Gets or sets the space to leave between adjacent levels of the tree.
|
|
897
|
+
* @type {Number}
|
|
898
|
+
* @summary The space to leave between adjacent levels of the tree.
|
|
899
|
+
*/
|
|
900
|
+
get levelDistance(): number;
|
|
901
|
+
set nodeDistance(arg: number);
|
|
902
|
+
/**
|
|
903
|
+
* Gets or sets the space to leave between adjacent nodes on the same level.
|
|
904
|
+
* @type {Number}
|
|
905
|
+
* @summary The space to leave between adjacent nodes on the same level.
|
|
906
|
+
*/
|
|
907
|
+
get nodeDistance(): number;
|
|
908
|
+
set keepRootPosition(arg: boolean);
|
|
909
|
+
/**
|
|
910
|
+
* Gets or sets a value indicating whether to keep the root node at its original position.
|
|
911
|
+
* @type {Boolean}
|
|
912
|
+
* @summary true if the root node should be kept at its original position, or false otherwise.
|
|
913
|
+
*/
|
|
914
|
+
get keepRootPosition(): boolean;
|
|
915
|
+
set direction(arg: number);
|
|
916
|
+
/**
|
|
917
|
+
* Gets or sets the orientation of the arranged graph.
|
|
918
|
+
* @type {LayoutDirection}
|
|
919
|
+
* @summary A member of the LayoutDirection enumeration.
|
|
920
|
+
*/
|
|
921
|
+
get direction(): number;
|
|
922
|
+
set linkType(arg: number);
|
|
923
|
+
/**
|
|
924
|
+
* Gets or sets the type of links in the arranged tree.
|
|
925
|
+
* @type {TreeLayoutLinkType}
|
|
926
|
+
* @summary A member of the TreeLayoutLinkType enumeration.
|
|
927
|
+
*/
|
|
928
|
+
get linkType(): number;
|
|
929
|
+
set reversedLinks(arg: boolean);
|
|
930
|
+
/**
|
|
931
|
+
* Gets or sets a value indicating the link direction that relates parent nodes to child nodes.
|
|
932
|
+
* @type {Boolean}
|
|
933
|
+
* @summary true to indicate reversed direction (links point to parent nodes), or false otherwise.
|
|
934
|
+
*/
|
|
935
|
+
get reversedLinks(): boolean;
|
|
936
|
+
/**
|
|
937
|
+
* Applies the layout to the specified graph.
|
|
938
|
+
* @param {Graph} graph The graph to arrange.
|
|
939
|
+
*/
|
|
940
|
+
arrange(graph: any): any;
|
|
941
|
+
treeHelper: TreeHelper;
|
|
942
|
+
/**
|
|
943
|
+
* @private
|
|
944
|
+
*/
|
|
945
|
+
private tree;
|
|
946
|
+
/**
|
|
947
|
+
* @private
|
|
948
|
+
*/
|
|
949
|
+
private x;
|
|
950
|
+
/**
|
|
951
|
+
* @private
|
|
952
|
+
*/
|
|
953
|
+
private y;
|
|
954
|
+
/**
|
|
955
|
+
* @private
|
|
956
|
+
*/
|
|
957
|
+
private rarrange;
|
|
958
|
+
/**
|
|
959
|
+
* Offset a branch of the tree with the specified values.
|
|
960
|
+
* @private
|
|
961
|
+
*
|
|
962
|
+
* @param {Vertex} nodeFrom The root node of the branch to offset.
|
|
963
|
+
* @param {Number} xoff The x-axis offset.
|
|
964
|
+
* @param {Number} yoff The y-axis offset.
|
|
965
|
+
*/
|
|
966
|
+
private offsetBranch;
|
|
967
|
+
/**
|
|
968
|
+
* @private
|
|
969
|
+
*/
|
|
970
|
+
private isHorizontal;
|
|
971
|
+
/**
|
|
972
|
+
* @private
|
|
973
|
+
*/
|
|
974
|
+
private isStraight;
|
|
975
|
+
getType(): any;
|
|
976
|
+
_levelDistance: number;
|
|
977
|
+
_nodeDistance: number;
|
|
978
|
+
_keepRootPosition: boolean;
|
|
979
|
+
_direction: number;
|
|
980
|
+
_linkType: number;
|
|
981
|
+
_reversedLinks: boolean;
|
|
982
|
+
}
|
|
983
|
+
import { Layout } from "Graphs/Layout";
|
|
984
|
+
import TreeHelper from "Graphs/TreeHelper";
|
|
985
|
+
}
|
|
986
|
+
declare module "Graphs/LayoutUtils" {
|
|
987
|
+
export default LayoutUtils;
|
|
988
|
+
class LayoutUtils {
|
|
989
|
+
static getGraphBounds(graph: any, defaultBounds: any): any;
|
|
990
|
+
}
|
|
991
|
+
}
|
|
992
|
+
declare module "Graphs/Tools" {
|
|
993
|
+
export function newPoint(x: any, y: any): Point;
|
|
994
|
+
export function bounds(v: any): any;
|
|
995
|
+
export class Tools {
|
|
996
|
+
static GetLFarCenter(node: any, o: any): Point;
|
|
997
|
+
static GetLNearCenter(node: any, o: any): Point;
|
|
998
|
+
static GetBNearCenter(node: any, o: any): Point;
|
|
999
|
+
static GetBFarCenter(node: any, o: any): Point;
|
|
1000
|
+
static MoveNode(node: any, x: any, y: any): void;
|
|
1001
|
+
static SetLinkPoints(link: any, points: any, ...args: any[]): void;
|
|
1002
|
+
static SetLinkPointsA(link: any, points: any): void;
|
|
1003
|
+
static GetLinkPoints(link: any): any;
|
|
1004
|
+
static Mirror(point: any, origin: any): Point;
|
|
1005
|
+
static GetBreadth(node: any, o: any): any;
|
|
1006
|
+
static GetBCenter(node: any, o: any): any;
|
|
1007
|
+
static GetLength(node: any, o: any): any;
|
|
1008
|
+
static GetLCenter(node: any, o: any): any;
|
|
1009
|
+
static GetBNear(node: any, o: any): any;
|
|
1010
|
+
static GetBFar(node: any, o: any): any;
|
|
1011
|
+
static GetLNear(node: any, o: any): any;
|
|
1012
|
+
static GetLFar(node: any, o: any): any;
|
|
1013
|
+
static GetBNearRect(rect: any, o: any): any;
|
|
1014
|
+
static GetBFarRect(rect: any, o: any): any;
|
|
1015
|
+
static GetLNearRect(rect: any, o: any): any;
|
|
1016
|
+
static GetLFarRect(rect: any, o: any): any;
|
|
1017
|
+
static GetB(point: any, o: any): any;
|
|
1018
|
+
static GetL(point: any, o: any): any;
|
|
1019
|
+
static OffsetL(node: any, offset: any, o: any): void;
|
|
1020
|
+
static OffsetOutLinks(links: any, offx: any, offy: any, o: any): void;
|
|
1021
|
+
}
|
|
1022
|
+
import { Point } from "@mindfusion/drawing";
|
|
1023
|
+
}
|
|
1024
|
+
declare module "Graphs/FlowchartLayout" {
|
|
1025
|
+
/**
|
|
1026
|
+
* @class FlowchartLayout can be used to arrange flowcharts representing program source code.
|
|
1027
|
+
* @augments Layout
|
|
1028
|
+
*/
|
|
1029
|
+
export class FlowchartLayout extends Layout {
|
|
1030
|
+
set nodeDistance(arg: number);
|
|
1031
|
+
/**
|
|
1032
|
+
* Gets or sets the distance between consecutive nodes in the flowchart.
|
|
1033
|
+
* @type {Number}
|
|
1034
|
+
* @summary A numeric value specifying the distance between neighbor nodes in the same sequence.
|
|
1035
|
+
*/
|
|
1036
|
+
get nodeDistance(): number;
|
|
1037
|
+
set branchPadding(arg: number);
|
|
1038
|
+
/**
|
|
1039
|
+
* Gets or sets how much space to leave between adjacent decision branches in the flowchart.
|
|
1040
|
+
* @type {Number}
|
|
1041
|
+
* @summary A numeric value specifying the distance between adjacent branches.
|
|
1042
|
+
*/
|
|
1043
|
+
get branchPadding(): number;
|
|
1044
|
+
set linkPadding(arg: number);
|
|
1045
|
+
/**
|
|
1046
|
+
* Gets or sets how much space to leave between adjacent back links designating nested loops.
|
|
1047
|
+
* @type {Number}
|
|
1048
|
+
* @summary A numeric value specifying the distance between adjacent back links.
|
|
1049
|
+
*/
|
|
1050
|
+
get linkPadding(): number;
|
|
1051
|
+
set orientation(arg: number);
|
|
1052
|
+
/**
|
|
1053
|
+
* Gets or sets the orientation of the arranged graph.
|
|
1054
|
+
* @type {Orientation}
|
|
1055
|
+
* @summary A member of the Orientation enumeration.
|
|
1056
|
+
*/
|
|
1057
|
+
get orientation(): number;
|
|
1058
|
+
nodeOrder: Map<any, any>;
|
|
1059
|
+
progressCounter: number;
|
|
1060
|
+
branchings: any[];
|
|
1061
|
+
visitedNodes: Map<any, any>;
|
|
1062
|
+
postOrder: Map<any, any>;
|
|
1063
|
+
topologicalOrder: Map<any, any>;
|
|
1064
|
+
searchCounter: number;
|
|
1065
|
+
flowchartNodes: Map<any, any>;
|
|
1066
|
+
mm: number;
|
|
1067
|
+
arrange(graph: any): boolean;
|
|
1068
|
+
graph: any;
|
|
1069
|
+
placedNodes: any[];
|
|
1070
|
+
furthestL: number;
|
|
1071
|
+
layoutRect: any;
|
|
1072
|
+
composeFlowChart(startNode: any): any;
|
|
1073
|
+
composeBlocks(node: any, parentBlock: any, loopDepth: any, onlyNotVisited: any, ignoreMerge: any): any;
|
|
1074
|
+
getSequence(block: any): any;
|
|
1075
|
+
followedByMergeNode(block: any): boolean;
|
|
1076
|
+
getFlowchartNode(node: any): any;
|
|
1077
|
+
getStartNodes(): any[];
|
|
1078
|
+
getOutgoingDownLinks(node: any): number;
|
|
1079
|
+
getIncomingDownLinks(node: any): number;
|
|
1080
|
+
getType(): any;
|
|
1081
|
+
getOutgoingLoopLinks(node: any): number;
|
|
1082
|
+
getIncomingLoopLinks(node: any): number;
|
|
1083
|
+
isVisited(node: any): boolean;
|
|
1084
|
+
isStartNode(node: any): boolean;
|
|
1085
|
+
isEndNode(node: any): boolean;
|
|
1086
|
+
inDegree(node: any): any;
|
|
1087
|
+
outDegree(node: any): any;
|
|
1088
|
+
isBackLink(link: any): boolean;
|
|
1089
|
+
isDownLink(link: any): boolean;
|
|
1090
|
+
depthFirstSearch(node: any): void;
|
|
1091
|
+
topologicalSort(startNode: any, graphOrder: any): Map<any, any>;
|
|
1092
|
+
getDownLinks(links: any): any[];
|
|
1093
|
+
getTopologicalOrder(): Map<any, any>;
|
|
1094
|
+
findPath(link: any, o: any, relaxed: any): Point[];
|
|
1095
|
+
segmentsFromPoints(points: any): {
|
|
1096
|
+
index: number;
|
|
1097
|
+
points: any;
|
|
1098
|
+
horizontal(): boolean;
|
|
1099
|
+
xint(): any[];
|
|
1100
|
+
yint(): any[];
|
|
1101
|
+
}[];
|
|
1102
|
+
pullLinksApart(links: any): void;
|
|
1103
|
+
splitPaths(links: any, horizontal: any): void;
|
|
1104
|
+
_branchPadding: number;
|
|
1105
|
+
_linkPadding: number;
|
|
1106
|
+
_nodeDistance: number;
|
|
1107
|
+
_orientation: number;
|
|
1108
|
+
dumpGraph(): void;
|
|
1109
|
+
}
|
|
1110
|
+
import { Layout } from "Graphs/Layout";
|
|
1111
|
+
import { Point } from "@mindfusion/drawing";
|
|
1112
|
+
}
|
|
1113
|
+
declare module "Graphs/FractalLayout" {
|
|
1114
|
+
/**
|
|
1115
|
+
* @class The FractalLayout tree layout algorithm places child nodes symmetrically around their parent node.
|
|
1116
|
+
* Nodes at the lowest level are arranged directly in a circle around their parent. At the upper level,
|
|
1117
|
+
* the already arranged nodes form branches that are arranged in a circle around the new parent node.
|
|
1118
|
+
* The algorithm is recursively repeated till the highest level is reached.
|
|
1119
|
+
* @augments Layout
|
|
1120
|
+
*/
|
|
1121
|
+
export class FractalLayout extends Layout {
|
|
1122
|
+
set root(arg: any);
|
|
1123
|
+
/**
|
|
1124
|
+
* Gets or sets the node that should be placed at the center of the tree.
|
|
1125
|
+
* @type {DiagramNode}
|
|
1126
|
+
* @summary The node that should be placed at the center of the tree.
|
|
1127
|
+
*/
|
|
1128
|
+
get root(): any;
|
|
1129
|
+
arrange(graph: any): void;
|
|
1130
|
+
branchCircles: Map<any, any>;
|
|
1131
|
+
measureCircles(node: any): {
|
|
1132
|
+
node: any;
|
|
1133
|
+
radius: any;
|
|
1134
|
+
centerX: any;
|
|
1135
|
+
centerY: any;
|
|
1136
|
+
childCircles: any[];
|
|
1137
|
+
};
|
|
1138
|
+
arrangeCircles(circle: any, center: any, angle: any): void;
|
|
1139
|
+
getType(): any;
|
|
1140
|
+
_root: any;
|
|
1141
|
+
}
|
|
1142
|
+
import { Layout } from "Graphs/Layout";
|
|
1143
|
+
}
|
|
1144
|
+
declare module "Graphs/LayeredLayout" {
|
|
1145
|
+
/**
|
|
1146
|
+
* @class Implements a layered graph layout algorithm.
|
|
1147
|
+
* This algorithm assigns diagram nodes to distinct horizontal or vertical layers.
|
|
1148
|
+
* While arranging the layers, the layout routine seeks to meet the following criteria:
|
|
1149
|
+
* - connected nodes must be placed close together;
|
|
1150
|
+
* - links must flow in one direction if possible;
|
|
1151
|
+
* - links must cross as few layers as possible;
|
|
1152
|
+
* - links must not cross other links;
|
|
1153
|
+
* @augments Layout
|
|
1154
|
+
*/
|
|
1155
|
+
export class LayeredLayout extends Layout {
|
|
1156
|
+
set nodeDistance(arg: number);
|
|
1157
|
+
/**
|
|
1158
|
+
* Gets or sets the space to leave between adjacent nodes on the same level.
|
|
1159
|
+
* @type {Number}
|
|
1160
|
+
* @summary The space to leave between adjacent nodes on the same level.
|
|
1161
|
+
*/
|
|
1162
|
+
get nodeDistance(): number;
|
|
1163
|
+
set layerDistance(arg: number);
|
|
1164
|
+
/**
|
|
1165
|
+
* Gets or sets the desired distance between layer axis lines.
|
|
1166
|
+
* @type {Number}
|
|
1167
|
+
* @summary The desired distance between layer axis lines.
|
|
1168
|
+
*/
|
|
1169
|
+
get layerDistance(): number;
|
|
1170
|
+
set direction(arg: number);
|
|
1171
|
+
/**
|
|
1172
|
+
* Gets or sets the orientation of the arranged graph.
|
|
1173
|
+
* @type {LayoutDirection}
|
|
1174
|
+
* @summary A member of the LayoutDirection enumeration.
|
|
1175
|
+
*/
|
|
1176
|
+
get direction(): number;
|
|
1177
|
+
set siftingRounds(arg: number);
|
|
1178
|
+
/**
|
|
1179
|
+
* Gets or sets the number of iterations to perform when untwining the layout.
|
|
1180
|
+
* @type {Number}
|
|
1181
|
+
* @summary The number of iterations to perform when untwining the layout.
|
|
1182
|
+
*/
|
|
1183
|
+
get siftingRounds(): number;
|
|
1184
|
+
initialMinimizeCrossingsDown: boolean;
|
|
1185
|
+
/**
|
|
1186
|
+
* Applies the layout to the specified graph.
|
|
1187
|
+
* @param {Graph} graph The graph to arrange.
|
|
1188
|
+
*/
|
|
1189
|
+
arrange(graph: any): void;
|
|
1190
|
+
graph: any;
|
|
1191
|
+
layers: any[];
|
|
1192
|
+
/**
|
|
1193
|
+
* @private
|
|
1194
|
+
*/
|
|
1195
|
+
private setMinDist;
|
|
1196
|
+
/**
|
|
1197
|
+
* @private
|
|
1198
|
+
*/
|
|
1199
|
+
private getMinDist;
|
|
1200
|
+
/**
|
|
1201
|
+
* @private
|
|
1202
|
+
*/
|
|
1203
|
+
private computeLeftClasses;
|
|
1204
|
+
nodeLeftClass: any;
|
|
1205
|
+
/**
|
|
1206
|
+
* @private
|
|
1207
|
+
*/
|
|
1208
|
+
private computeRightClasses;
|
|
1209
|
+
nodeRightClass: any;
|
|
1210
|
+
/**
|
|
1211
|
+
* @private
|
|
1212
|
+
*/
|
|
1213
|
+
private computeClasses;
|
|
1214
|
+
/**
|
|
1215
|
+
* @private
|
|
1216
|
+
*/
|
|
1217
|
+
private placeLeftToRight;
|
|
1218
|
+
dump(pos: any): void;
|
|
1219
|
+
/**
|
|
1220
|
+
* @private
|
|
1221
|
+
*/
|
|
1222
|
+
private placeRightToLeft;
|
|
1223
|
+
/**
|
|
1224
|
+
* @private
|
|
1225
|
+
*/
|
|
1226
|
+
private assignCoordinates;
|
|
1227
|
+
minDistances: any[];
|
|
1228
|
+
downNodes: Map<any, any>;
|
|
1229
|
+
upNodes: Map<any, any>;
|
|
1230
|
+
/**
|
|
1231
|
+
* @private
|
|
1232
|
+
*/
|
|
1233
|
+
private adjustDirections;
|
|
1234
|
+
/**
|
|
1235
|
+
* @private
|
|
1236
|
+
*/
|
|
1237
|
+
private getNeighborOnLayer;
|
|
1238
|
+
/**
|
|
1239
|
+
* @private
|
|
1240
|
+
*/
|
|
1241
|
+
private placeSequence;
|
|
1242
|
+
/**
|
|
1243
|
+
* @private
|
|
1244
|
+
*/
|
|
1245
|
+
private placeSingle;
|
|
1246
|
+
/**
|
|
1247
|
+
* @private
|
|
1248
|
+
*/
|
|
1249
|
+
private combineSequences;
|
|
1250
|
+
/**
|
|
1251
|
+
* @private
|
|
1252
|
+
*/
|
|
1253
|
+
private placeLeft;
|
|
1254
|
+
/**
|
|
1255
|
+
* @private
|
|
1256
|
+
*/
|
|
1257
|
+
private placeRight;
|
|
1258
|
+
/**
|
|
1259
|
+
* @private
|
|
1260
|
+
*/
|
|
1261
|
+
private leftSibling;
|
|
1262
|
+
/**
|
|
1263
|
+
* @private
|
|
1264
|
+
*/
|
|
1265
|
+
private rightSibling;
|
|
1266
|
+
/**
|
|
1267
|
+
* @private
|
|
1268
|
+
*/
|
|
1269
|
+
private L;
|
|
1270
|
+
/**
|
|
1271
|
+
* Move nodes to their barycenters, according to their
|
|
1272
|
+
* priority but doing so without any box swapping
|
|
1273
|
+
* (i.e. the boxes' order remains the same).
|
|
1274
|
+
* @private
|
|
1275
|
+
*/
|
|
1276
|
+
private layout;
|
|
1277
|
+
/**
|
|
1278
|
+
* @private
|
|
1279
|
+
*/
|
|
1280
|
+
private layoutLayer;
|
|
1281
|
+
/**
|
|
1282
|
+
* @private
|
|
1283
|
+
*/
|
|
1284
|
+
private moveRight;
|
|
1285
|
+
/**
|
|
1286
|
+
* @private
|
|
1287
|
+
*/
|
|
1288
|
+
private moveLeft;
|
|
1289
|
+
/**
|
|
1290
|
+
* @private
|
|
1291
|
+
*/
|
|
1292
|
+
private mapVirtualNode;
|
|
1293
|
+
/**
|
|
1294
|
+
* @private
|
|
1295
|
+
*/
|
|
1296
|
+
private nodesInLongLink;
|
|
1297
|
+
/**
|
|
1298
|
+
* @private
|
|
1299
|
+
*/
|
|
1300
|
+
private dummify;
|
|
1301
|
+
linkToNodeMap: Map<any, any>;
|
|
1302
|
+
nodeToLinkMap: Map<any, any>;
|
|
1303
|
+
/**
|
|
1304
|
+
* @private
|
|
1305
|
+
*/
|
|
1306
|
+
private dedummify;
|
|
1307
|
+
/**
|
|
1308
|
+
* Tries to minimize crossings across all levels.
|
|
1309
|
+
* @private
|
|
1310
|
+
*/
|
|
1311
|
+
private minimizeCrossings;
|
|
1312
|
+
/**
|
|
1313
|
+
* Calculates up barycenters and linkCount for the nodes
|
|
1314
|
+
* in the layer whose index is specified in the parameter.
|
|
1315
|
+
* @private
|
|
1316
|
+
*/
|
|
1317
|
+
private calcUpData;
|
|
1318
|
+
/**
|
|
1319
|
+
* Calculates down barycenters and linkCount for the nodes
|
|
1320
|
+
* in the layer whose index is specified in the parameter.
|
|
1321
|
+
* @private
|
|
1322
|
+
*/
|
|
1323
|
+
private calcDownData;
|
|
1324
|
+
/**
|
|
1325
|
+
* Tries to minimize crossings between layers 'layer' and
|
|
1326
|
+
* 'layer' + 1 if down is true and between layers 'layer' - 1
|
|
1327
|
+
* and 'layer' if down is false.
|
|
1328
|
+
* @private
|
|
1329
|
+
*/
|
|
1330
|
+
private minimizeCrossingsDir;
|
|
1331
|
+
/**
|
|
1332
|
+
* This method performs a single pass over the graph in an attempt to reduce
|
|
1333
|
+
* link crossings through neighbors swapping.
|
|
1334
|
+
* @private
|
|
1335
|
+
*/
|
|
1336
|
+
private swapPairs;
|
|
1337
|
+
/**
|
|
1338
|
+
* Returns the total number of crossings for the links inbetween the specified layers.
|
|
1339
|
+
* @private
|
|
1340
|
+
*/
|
|
1341
|
+
private countCrossings;
|
|
1342
|
+
getType(): any;
|
|
1343
|
+
_nodeDistance: number;
|
|
1344
|
+
_layerDistance: number;
|
|
1345
|
+
_direction: number;
|
|
1346
|
+
_siftingRounds: number;
|
|
1347
|
+
}
|
|
1348
|
+
import { Layout } from "Graphs/Layout";
|
|
1349
|
+
}
|
|
1350
|
+
declare module "Graphs/SpringLayout" {
|
|
1351
|
+
/**
|
|
1352
|
+
* @class Implements the Spring-Embedder graph layout algorithm.
|
|
1353
|
+
* @augments Layout
|
|
1354
|
+
*/
|
|
1355
|
+
export class SpringLayout extends Layout {
|
|
1356
|
+
set nodeDistance(arg: number);
|
|
1357
|
+
/**
|
|
1358
|
+
* Gets or sets the desired distance between nodes.
|
|
1359
|
+
* @type {Number}
|
|
1360
|
+
* @summary the desired distance between nodes.
|
|
1361
|
+
*/
|
|
1362
|
+
get nodeDistance(): number;
|
|
1363
|
+
set iterations(arg: number);
|
|
1364
|
+
/**
|
|
1365
|
+
* Gets or sets the number of iterations to run the layout routine.
|
|
1366
|
+
* @type {Number}
|
|
1367
|
+
* @summary The number of iterations to run the layout routine.
|
|
1368
|
+
*/
|
|
1369
|
+
get iterations(): number;
|
|
1370
|
+
/**
|
|
1371
|
+
* @private
|
|
1372
|
+
*/
|
|
1373
|
+
private refineStage;
|
|
1374
|
+
/**
|
|
1375
|
+
* @private
|
|
1376
|
+
*/
|
|
1377
|
+
private initialTemperature;
|
|
1378
|
+
/**
|
|
1379
|
+
* @private
|
|
1380
|
+
*/
|
|
1381
|
+
private temperature;
|
|
1382
|
+
/**
|
|
1383
|
+
* Applies the layout to the specified graph.
|
|
1384
|
+
* @param {Graph} graph The graph to arrange.
|
|
1385
|
+
*/
|
|
1386
|
+
arrange(graph: any): void;
|
|
1387
|
+
graph: any;
|
|
1388
|
+
width: number;
|
|
1389
|
+
height: number;
|
|
1390
|
+
/**
|
|
1391
|
+
* @private
|
|
1392
|
+
*/
|
|
1393
|
+
private moveToEpsilonCircle;
|
|
1394
|
+
/**
|
|
1395
|
+
* @private
|
|
1396
|
+
*/
|
|
1397
|
+
private attraction;
|
|
1398
|
+
/**
|
|
1399
|
+
* @private
|
|
1400
|
+
*/
|
|
1401
|
+
private repulsion;
|
|
1402
|
+
/**
|
|
1403
|
+
* @private
|
|
1404
|
+
*/
|
|
1405
|
+
private calcRepulsionForce;
|
|
1406
|
+
/**
|
|
1407
|
+
* @private
|
|
1408
|
+
*/
|
|
1409
|
+
private calcSpringForce;
|
|
1410
|
+
/**
|
|
1411
|
+
* @private
|
|
1412
|
+
*/
|
|
1413
|
+
private applyForce;
|
|
1414
|
+
getType(): any;
|
|
1415
|
+
_nodeDistance: number;
|
|
1416
|
+
_iterations: number;
|
|
1417
|
+
}
|
|
1418
|
+
import { Layout } from "Graphs/Layout";
|
|
1419
|
+
}
|
|
1420
|
+
declare module "Graphs/TopologicalLayout" {
|
|
1421
|
+
/**
|
|
1422
|
+
* @class Implements a topological ordering.
|
|
1423
|
+
* The algorithm arranges nodes in a row or a column (depending on the value of the direction property)
|
|
1424
|
+
* in such a way that there are as few back links as possible. The links connecting non-adjacent nodes
|
|
1425
|
+
* are rendered as arcs. The links connecting adjacent nodes are rendered either as arcs or as straight lines,
|
|
1426
|
+
* depending on the bendAdjacentLinks property. The amplitude of the link arcs is proportional to the
|
|
1427
|
+
* distance between the connected nodes. All forward links are rendered at one side of the nodes and all
|
|
1428
|
+
* back links are rendered at the opposite side. Thus, all bent links follow the same rotation direction.
|
|
1429
|
+
* @augments Layout
|
|
1430
|
+
*/
|
|
1431
|
+
export class TopologicalLayout extends Layout {
|
|
1432
|
+
set nodeDistance(arg: number);
|
|
1433
|
+
/**
|
|
1434
|
+
* Gets or sets the desired distance between adjacent nodes.
|
|
1435
|
+
* @type {Number}
|
|
1436
|
+
* @summary The desired distance between adjacent nodes.
|
|
1437
|
+
*/
|
|
1438
|
+
get nodeDistance(): number;
|
|
1439
|
+
set direction(arg: number);
|
|
1440
|
+
/**
|
|
1441
|
+
* Gets or sets the orientation of the arranged graph.
|
|
1442
|
+
* @type {LayoutDirection}
|
|
1443
|
+
* @summary A member of the LayoutDirection enumeration.
|
|
1444
|
+
*/
|
|
1445
|
+
get direction(): number;
|
|
1446
|
+
set bendAdjacentLinks(arg: boolean);
|
|
1447
|
+
/**
|
|
1448
|
+
* Gets or sets a value indicating whether to bend links connecting adjacent nodes or draw them as straight lines.
|
|
1449
|
+
* @type {Boolean}
|
|
1450
|
+
* @summary true to bend links connecting adjacent nodes, or false otherwise.
|
|
1451
|
+
*/
|
|
1452
|
+
get bendAdjacentLinks(): boolean;
|
|
1453
|
+
mm: number;
|
|
1454
|
+
/**
|
|
1455
|
+
* Applies the layout to the specified graph.
|
|
1456
|
+
* @param {Graph} graph The graph to arrange.
|
|
1457
|
+
*/
|
|
1458
|
+
arrange(graph: any): boolean;
|
|
1459
|
+
graph: any;
|
|
1460
|
+
getType(): any;
|
|
1461
|
+
_nodeDistance: number;
|
|
1462
|
+
_direction: number;
|
|
1463
|
+
_bendAdjacentLinks: boolean;
|
|
1464
|
+
}
|
|
1465
|
+
import { Layout } from "Graphs/Layout";
|
|
1466
|
+
}
|
|
1467
|
+
declare module "Graphs/TreeLayout" {
|
|
1468
|
+
/**
|
|
1469
|
+
* @class Implements algorithms for arranging tree structures.
|
|
1470
|
+
* @augments Layout
|
|
1471
|
+
*/
|
|
1472
|
+
export class TreeLayout extends Layout {
|
|
1473
|
+
set levelDistance(arg: number);
|
|
1474
|
+
/**
|
|
1475
|
+
* Gets or sets the space to leave between adjacent levels of the tree.
|
|
1476
|
+
* @type {Number}
|
|
1477
|
+
* @summary The space to leave between adjacent levels of the tree.
|
|
1478
|
+
*/
|
|
1479
|
+
get levelDistance(): number;
|
|
1480
|
+
set nodeDistance(arg: number);
|
|
1481
|
+
/**
|
|
1482
|
+
* Gets or sets the space to leave between adjacent nodes on the same level.
|
|
1483
|
+
* @type {Number}
|
|
1484
|
+
* @summary The space to leave between adjacent nodes on the same level.
|
|
1485
|
+
*/
|
|
1486
|
+
get nodeDistance(): number;
|
|
1487
|
+
set keepRootPosition(arg: boolean);
|
|
1488
|
+
/**
|
|
1489
|
+
* Gets or sets a value indicating whether to keep the root node at its original position.
|
|
1490
|
+
* @type {Boolean}
|
|
1491
|
+
* @summary true if the root node should be kept at its original position, or false otherwise.
|
|
1492
|
+
*/
|
|
1493
|
+
get keepRootPosition(): boolean;
|
|
1494
|
+
set direction(arg: number);
|
|
1495
|
+
/**
|
|
1496
|
+
* Gets or sets the orientation of the arranged graph.
|
|
1497
|
+
* @type {LayoutDirection}
|
|
1498
|
+
* @summary A member of the LayoutDirection enumeration.
|
|
1499
|
+
*/
|
|
1500
|
+
get direction(): number;
|
|
1501
|
+
set linkType(arg: number);
|
|
1502
|
+
/**
|
|
1503
|
+
* Gets or sets the type of the links in the arranged tree.
|
|
1504
|
+
* @type {TreeLayoutLinkType}
|
|
1505
|
+
* @summary A member of the TreeLayoutLinkType enumeration.
|
|
1506
|
+
*/
|
|
1507
|
+
get linkType(): number;
|
|
1508
|
+
set enableAssistants(arg: boolean);
|
|
1509
|
+
/**
|
|
1510
|
+
* Gets or sets a value Indicating whether the "assistant" trait is regarded when performing the layout.
|
|
1511
|
+
* @type {Boolean}
|
|
1512
|
+
* @summary true if the "assistant" trait is regarded when performing the layout, or false otherwise.
|
|
1513
|
+
*/
|
|
1514
|
+
get enableAssistants(): boolean;
|
|
1515
|
+
set compactAssistants(arg: boolean);
|
|
1516
|
+
/**
|
|
1517
|
+
* Gets or sets a value indicating whether the "assistant" nodes on the same side of a single parent
|
|
1518
|
+
* are arranged as close to each other as possible.
|
|
1519
|
+
* @type {Boolean}
|
|
1520
|
+
* @summary true if the "assistant" nodes on the same side of a single parent
|
|
1521
|
+
* are arranged as close to each other as possible, or false otherwise.
|
|
1522
|
+
*/
|
|
1523
|
+
get compactAssistants(): boolean;
|
|
1524
|
+
set reversedLinks(arg: boolean);
|
|
1525
|
+
/**
|
|
1526
|
+
* Gets or sets a value indicating the link direction that relates parent nodes to child nodes.
|
|
1527
|
+
* @type {Boolean}
|
|
1528
|
+
* @summary true to indicate reversed direction (links point to parent nodes), or false otherwise.
|
|
1529
|
+
*/
|
|
1530
|
+
get reversedLinks(): boolean;
|
|
1531
|
+
/**
|
|
1532
|
+
* Applies the layout to the specified graph.
|
|
1533
|
+
* @param {Graph} graph The graph to arrange.
|
|
1534
|
+
*/
|
|
1535
|
+
arrange(graph: any): any;
|
|
1536
|
+
treeHelper: TreeHelper;
|
|
1537
|
+
/**
|
|
1538
|
+
* @private
|
|
1539
|
+
*/
|
|
1540
|
+
private hasAssistants;
|
|
1541
|
+
/**
|
|
1542
|
+
* Calculates the bounding rectangle of the tree branch defined by
|
|
1543
|
+
* the specified node. The result is the smallest rectangle containing
|
|
1544
|
+
* all children of the specified node and the node itself.
|
|
1545
|
+
* @private
|
|
1546
|
+
*/
|
|
1547
|
+
private branchBounds;
|
|
1548
|
+
/**
|
|
1549
|
+
* Calculate the distance between the branches, whose
|
|
1550
|
+
* root nodes are specified as arguments.
|
|
1551
|
+
* @private
|
|
1552
|
+
*
|
|
1553
|
+
* @param {Vertex} node1 The root node of the first branch.
|
|
1554
|
+
* @param {Vertex} node2 The root note of the second branch.
|
|
1555
|
+
* @returns {Number} The distance between the branches.
|
|
1556
|
+
*/
|
|
1557
|
+
private branchDistance;
|
|
1558
|
+
right(vertex: any): any;
|
|
1559
|
+
left(vertex: any): number;
|
|
1560
|
+
/**
|
|
1561
|
+
* Offset a branch of the tree with the specified values.
|
|
1562
|
+
* @private
|
|
1563
|
+
*
|
|
1564
|
+
* @param {Vertex} nodeFrom The root node of the branch to offset.
|
|
1565
|
+
* @param {Number} xoff The x-axis offset.
|
|
1566
|
+
* @param {Number} yoff The y-axis offset.
|
|
1567
|
+
*/
|
|
1568
|
+
private offsetBranch;
|
|
1569
|
+
/**
|
|
1570
|
+
* @private
|
|
1571
|
+
*/
|
|
1572
|
+
private isHorizontal;
|
|
1573
|
+
/**
|
|
1574
|
+
* @private
|
|
1575
|
+
*/
|
|
1576
|
+
private isStraight;
|
|
1577
|
+
/**
|
|
1578
|
+
* @private
|
|
1579
|
+
*/
|
|
1580
|
+
private intDiv;
|
|
1581
|
+
getType(): any;
|
|
1582
|
+
_levelDistance: number;
|
|
1583
|
+
_nodeDistance: number;
|
|
1584
|
+
_keepRootPosition: boolean;
|
|
1585
|
+
_direction: number;
|
|
1586
|
+
_linkType: number;
|
|
1587
|
+
_enableAssistants: boolean;
|
|
1588
|
+
_compactAssistants: boolean;
|
|
1589
|
+
_reversedLinks: boolean;
|
|
1590
|
+
}
|
|
1591
|
+
import { Layout } from "Graphs/Layout";
|
|
1592
|
+
import TreeHelper from "Graphs/TreeHelper";
|
|
1593
|
+
}
|
|
1594
|
+
declare module "Graphs/TreeMapLayout" {
|
|
1595
|
+
/**
|
|
1596
|
+
* @class Performs tree-map layout on a graph.
|
|
1597
|
+
* @augments Layout
|
|
1598
|
+
*/
|
|
1599
|
+
export class TreeMapLayout extends Layout {
|
|
1600
|
+
set orientation(arg: number);
|
|
1601
|
+
/**
|
|
1602
|
+
* Gets or sets the orientation of the arranged graph.
|
|
1603
|
+
* @type {Orientation}
|
|
1604
|
+
* @summary A member of the Orientation enumeration.
|
|
1605
|
+
*/
|
|
1606
|
+
get orientation(): number;
|
|
1607
|
+
set squarify(arg: boolean);
|
|
1608
|
+
/**
|
|
1609
|
+
* Gets or sets a value indicating whether the layout should attempt to keep the dimension ratio of nodes closer to 1.
|
|
1610
|
+
* @type {Boolean}
|
|
1611
|
+
* @summary true if the layout should attempt to keep the dimension ratio of nodes closer to 1, or false otherwise.
|
|
1612
|
+
*/
|
|
1613
|
+
get squarify(): boolean;
|
|
1614
|
+
set padding(arg: number);
|
|
1615
|
+
/**
|
|
1616
|
+
* Gets or sets the distance between adjacent nodes.
|
|
1617
|
+
* @type {Number}
|
|
1618
|
+
* @summary The distance between adjacent nodes.
|
|
1619
|
+
*/
|
|
1620
|
+
get padding(): number;
|
|
1621
|
+
set layoutArea(arg: Rect);
|
|
1622
|
+
/**
|
|
1623
|
+
* Gets or sets the rectangle in which the layout will try to arrange nodes.
|
|
1624
|
+
* @type {Rect}
|
|
1625
|
+
* @summary The rectangle in which the layout will try to arrange nodes.
|
|
1626
|
+
*/
|
|
1627
|
+
get layoutArea(): Rect;
|
|
1628
|
+
set containerPadding(arg: number);
|
|
1629
|
+
/**
|
|
1630
|
+
* Gets or sets the padding inside containers.
|
|
1631
|
+
* @type {Number}
|
|
1632
|
+
* @summary The padding inside containers.
|
|
1633
|
+
*/
|
|
1634
|
+
get containerPadding(): number;
|
|
1635
|
+
minNodeSize: number;
|
|
1636
|
+
/**
|
|
1637
|
+
* Applies the layout to the specified graph.
|
|
1638
|
+
* @param {Graph} graph The graph to arrange.
|
|
1639
|
+
*/
|
|
1640
|
+
arrange(graph: any): void;
|
|
1641
|
+
weights: Map<any, any>;
|
|
1642
|
+
arrangeSquare(nodes: any, layoutArea: any, row: any, parentWeight: any): void;
|
|
1643
|
+
doSquarify(children: any, layoutArea: any, row: any, parentWeight: any): void;
|
|
1644
|
+
weight(row: any): number;
|
|
1645
|
+
subtractPadding(rect: any): void;
|
|
1646
|
+
layoutRow(layoutArea: any, row: any, horizontal: any, parentWeight: any): number;
|
|
1647
|
+
arrangeSiblings(nodes: any, layoutArea: any, horizontal: any, totalWeight: any): void;
|
|
1648
|
+
evalRatio(row: any, sideLen: any, rowArea: any): number;
|
|
1649
|
+
calcWeights(root: any): any;
|
|
1650
|
+
layOutArea(node: any): any;
|
|
1651
|
+
getType(): any;
|
|
1652
|
+
_orientation: number;
|
|
1653
|
+
_squarify: boolean;
|
|
1654
|
+
_padding: number;
|
|
1655
|
+
_layoutArea: Rect;
|
|
1656
|
+
_containerPadding: number;
|
|
1657
|
+
}
|
|
1658
|
+
import { Layout } from "Graphs/Layout";
|
|
1659
|
+
import { Rect } from "@mindfusion/drawing";
|
|
1660
|
+
}
|
|
1661
|
+
declare module "Graphs/DrawingGrid" {
|
|
1662
|
+
export default DrawingGrid;
|
|
1663
|
+
class DrawingGrid {
|
|
1664
|
+
constructor(graph: any, vertexPoints: any, edgePoints: any);
|
|
1665
|
+
graph: any;
|
|
1666
|
+
vertexPoints: any;
|
|
1667
|
+
edgePoints: any;
|
|
1668
|
+
cells: {
|
|
1669
|
+
has(point: any): boolean;
|
|
1670
|
+
get(point: any): any;
|
|
1671
|
+
set(point: any, value: any): void;
|
|
1672
|
+
delete(point: any): boolean;
|
|
1673
|
+
key(point: any): string;
|
|
1674
|
+
clear(): void;
|
|
1675
|
+
forEach(callbackfn: (value: any, key: any, map: Map<any, any>) => void, thisArg?: any): void;
|
|
1676
|
+
readonly size: number;
|
|
1677
|
+
entries(): IterableIterator<[any, any]>;
|
|
1678
|
+
keys(): IterableIterator<any>;
|
|
1679
|
+
values(): IterableIterator<any>;
|
|
1680
|
+
[Symbol.iterator](): IterableIterator<[any, any]>;
|
|
1681
|
+
readonly [Symbol.toStringTag]: string;
|
|
1682
|
+
};
|
|
1683
|
+
bounds: {
|
|
1684
|
+
left: any;
|
|
1685
|
+
top: any;
|
|
1686
|
+
right: any;
|
|
1687
|
+
bottom: any;
|
|
1688
|
+
};
|
|
1689
|
+
columnWidths: Map<any, any>;
|
|
1690
|
+
rowHeights: Map<any, any>;
|
|
1691
|
+
setCellDimensions(vertexSize: any, padding: any, edgeCellSize: any): void;
|
|
1692
|
+
minWidth: Map<any, any>;
|
|
1693
|
+
maxWidth: Map<any, any>;
|
|
1694
|
+
minHeight: Map<any, any>;
|
|
1695
|
+
maxHeight: Map<any, any>;
|
|
1696
|
+
columnPositions: Map<any, any>;
|
|
1697
|
+
rowPositions: Map<any, any>;
|
|
1698
|
+
getPosition(point: any): Point;
|
|
1699
|
+
getEdgePointPosition(point: any, edge: any, width: any, height: any): Point;
|
|
1700
|
+
updateBounds(point: any): void;
|
|
1701
|
+
updateBoundsFromPoints(points: any): void;
|
|
1702
|
+
refine(iterations: any): void;
|
|
1703
|
+
refineSpace(): void;
|
|
1704
|
+
refineCacheEdges(): void;
|
|
1705
|
+
refineDegreeOneVertices(): void;
|
|
1706
|
+
removeUnusedRows(): void;
|
|
1707
|
+
removeUnusedColumns(): void;
|
|
1708
|
+
removeFromCell(cell: any, p: any, edge: any, horizontal: any): void;
|
|
1709
|
+
refineUTurns(): void;
|
|
1710
|
+
removeRedundantBends(): void;
|
|
1711
|
+
setSegmentsInRange(e: any, p1: any, includeP1: any, p2: any, includeP2: any): void;
|
|
1712
|
+
removeSegmentsFromRange(e: any, p1: any, removeP1: any, p2: any, removeP2: any): void;
|
|
1713
|
+
edgeContainsRange(e: any, p1: any, includeP1: any, p2: any, includeP2: any): boolean;
|
|
1714
|
+
normalizePath(path: any, e: any, setSegments: any): void;
|
|
1715
|
+
setApartOverlappingEdges(): void;
|
|
1716
|
+
horizontalEdges: Grid;
|
|
1717
|
+
verticalEdges: Grid;
|
|
1718
|
+
getBendNeighborPoints(bend: any, column: any, row: any): any;
|
|
1719
|
+
bendsToTheLeft(bend: any, column: any, row: any): boolean;
|
|
1720
|
+
bendsToTheTop(bend: any, column: any, row: any): boolean;
|
|
1721
|
+
setHorizontalEdgesInRange(edges: any, row: any, c1: any, c2: any): void;
|
|
1722
|
+
setVerticalEdgesInRange(edges: any, column: any, r1: any, r2: any): void;
|
|
1723
|
+
countHorizontalEdgesCrossings(edges: any, row: any, c1: any, c2: any, permutation: any): number;
|
|
1724
|
+
countVerticalEdgesCrossings(edges: any, column: any, r1: any, r2: any, permutation: any): number;
|
|
1725
|
+
permuteHorizontalEdgeLanes(row: any, c1: any, c2: any, permutation: any): void;
|
|
1726
|
+
permuteVerticalEdgeLanes(column: any, r1: any, r2: any, permutation: any): void;
|
|
1727
|
+
getCell(column: any, row: any): any;
|
|
1728
|
+
}
|
|
1729
|
+
namespace DrawingGrid {
|
|
1730
|
+
export { Cell };
|
|
1731
|
+
export { Rectangle };
|
|
1732
|
+
export { Size };
|
|
1733
|
+
export { EdgeSegment };
|
|
1734
|
+
export { Bend };
|
|
1735
|
+
export { PointMap };
|
|
1736
|
+
export { PermutationSet };
|
|
1737
|
+
}
|
|
1738
|
+
import { Point } from "@mindfusion/drawing";
|
|
1739
|
+
import { Grid } from "@mindfusion/collections";
|
|
1740
|
+
class Cell {
|
|
1741
|
+
content: any[];
|
|
1742
|
+
add(item: any): void;
|
|
1743
|
+
removeEdgeOrBend(e: any, horizontal: any): void;
|
|
1744
|
+
countEdges(horizontal: any): number;
|
|
1745
|
+
containsVertex(): boolean;
|
|
1746
|
+
containsVertexOrBend(): boolean;
|
|
1747
|
+
containsEdge(edge: any): boolean;
|
|
1748
|
+
containsEdgeSegment(edge: any, horizontal: any): boolean;
|
|
1749
|
+
getEdgeSegment(edge: any, horizontal: any): {
|
|
1750
|
+
edge: any;
|
|
1751
|
+
dx: any;
|
|
1752
|
+
dy: any;
|
|
1753
|
+
lane: number;
|
|
1754
|
+
maxNeighbors: number;
|
|
1755
|
+
readonly horizontal: boolean;
|
|
1756
|
+
};
|
|
1757
|
+
getEdgeBend(edge: any): {
|
|
1758
|
+
edge: any;
|
|
1759
|
+
horizontalLane: number;
|
|
1760
|
+
maxHNeighbors: number;
|
|
1761
|
+
verticalLane: number;
|
|
1762
|
+
maxVNeighbors: number;
|
|
1763
|
+
neighborPoints: any;
|
|
1764
|
+
};
|
|
1765
|
+
getEdgeLane(edge: any, horizontal: any, neighbors: any): number;
|
|
1766
|
+
permuteLanes(permutation: any, horizontal: any): void;
|
|
1767
|
+
}
|
|
1768
|
+
class Rectangle {
|
|
1769
|
+
constructor(left: any, top: any, right: any, bottom: any);
|
|
1770
|
+
left: any;
|
|
1771
|
+
top: any;
|
|
1772
|
+
right: any;
|
|
1773
|
+
bottom: any;
|
|
1774
|
+
}
|
|
1775
|
+
class Size {
|
|
1776
|
+
constructor(width: any, height: any);
|
|
1777
|
+
width: any;
|
|
1778
|
+
height: any;
|
|
1779
|
+
}
|
|
1780
|
+
class EdgeSegment {
|
|
1781
|
+
constructor(edge: any, dx: any, dy: any);
|
|
1782
|
+
edge: any;
|
|
1783
|
+
dx: any;
|
|
1784
|
+
dy: any;
|
|
1785
|
+
lane: number;
|
|
1786
|
+
maxNeighbors: number;
|
|
1787
|
+
get horizontal(): boolean;
|
|
1788
|
+
}
|
|
1789
|
+
class Bend {
|
|
1790
|
+
constructor(edge: any);
|
|
1791
|
+
edge: any;
|
|
1792
|
+
horizontalLane: number;
|
|
1793
|
+
maxHNeighbors: number;
|
|
1794
|
+
verticalLane: number;
|
|
1795
|
+
maxVNeighbors: number;
|
|
1796
|
+
neighborPoints: any;
|
|
1797
|
+
}
|
|
1798
|
+
class PointMap extends Map<any, any> {
|
|
1799
|
+
constructor();
|
|
1800
|
+
constructor(entries?: readonly (readonly [any, any])[]);
|
|
1801
|
+
constructor(iterable: Iterable<readonly [any, any]>);
|
|
1802
|
+
key(point: any): string;
|
|
1803
|
+
}
|
|
1804
|
+
class PermutationSet {
|
|
1805
|
+
constructor(n: any);
|
|
1806
|
+
permutations: any[];
|
|
1807
|
+
current: number[];
|
|
1808
|
+
heapPermute(n: any): void;
|
|
1809
|
+
addItem(): void;
|
|
1810
|
+
swap(i: any, j: any): void;
|
|
1811
|
+
get(i: any): any;
|
|
1812
|
+
list(): any[];
|
|
1813
|
+
}
|
|
1814
|
+
}
|
|
1815
|
+
declare module "Graphs/Representation" {
|
|
1816
|
+
/**
|
|
1817
|
+
* @namespace MindFusion.Graphs
|
|
1818
|
+
*/
|
|
1819
|
+
export default class Representation {
|
|
1820
|
+
constructor(stGraph: any, weighted: any, xOrdering: any, stEmbedding: any);
|
|
1821
|
+
stsort: any;
|
|
1822
|
+
Y: any;
|
|
1823
|
+
s: any;
|
|
1824
|
+
t: any;
|
|
1825
|
+
d: any;
|
|
1826
|
+
X: any;
|
|
1827
|
+
left(e: any): any;
|
|
1828
|
+
right(e: any): any;
|
|
1829
|
+
leftV(v: any): any;
|
|
1830
|
+
rightV(v: any): any;
|
|
1831
|
+
orig(e: any): any;
|
|
1832
|
+
dest(e: any): any;
|
|
1833
|
+
origF(f: any): any;
|
|
1834
|
+
destF(f: any): any;
|
|
1835
|
+
leftMostIncoming(v: any): any;
|
|
1836
|
+
leftMostOutgoing(v: any): any;
|
|
1837
|
+
rightMostOutgoing(v: any): any;
|
|
1838
|
+
getOutEdges(v: any): any[];
|
|
1839
|
+
getInEdges(v: any): any[];
|
|
1840
|
+
getOutMedian(v: any): any;
|
|
1841
|
+
getInMedian(v: any): any;
|
|
1842
|
+
newHSegment(): {
|
|
1843
|
+
y: number;
|
|
1844
|
+
x1: number;
|
|
1845
|
+
x2: number;
|
|
1846
|
+
};
|
|
1847
|
+
newVSegment(): {
|
|
1848
|
+
x: number;
|
|
1849
|
+
y1: number;
|
|
1850
|
+
y2: number;
|
|
1851
|
+
};
|
|
1852
|
+
get dualGraph(): any;
|
|
1853
|
+
get source(): any;
|
|
1854
|
+
get sink(): any;
|
|
1855
|
+
get topologicalSort(): any;
|
|
1856
|
+
}
|
|
1857
|
+
}
|
|
1858
|
+
declare module "Graphs/ConstrainedVisibility" {
|
|
1859
|
+
export default class ConstrainedVisibility extends Representation {
|
|
1860
|
+
constructor(stGraph: any, vpaths: any);
|
|
1861
|
+
edgeToPathMap: Map<any, any>;
|
|
1862
|
+
pathToVertexMap: Map<any, any>;
|
|
1863
|
+
hSegments: Map<any, any>;
|
|
1864
|
+
vSegments: Map<any, any>;
|
|
1865
|
+
get vertexSegments(): Map<any, any>;
|
|
1866
|
+
get edgeSegments(): Map<any, any>;
|
|
1867
|
+
}
|
|
1868
|
+
import Representation from "Graphs/Representation";
|
|
1869
|
+
}
|
|
1870
|
+
declare module "Graphs/OrthogonalLayout" {
|
|
1871
|
+
/**
|
|
1872
|
+
* @class Implements orthogonal graph layout algorithm.
|
|
1873
|
+
* Each link is drawn as a chain of alternating horizontal and vertical segments.
|
|
1874
|
+
* Nodes are placed in a way that facilitates few links bends and crossings.
|
|
1875
|
+
* @augments Layout
|
|
1876
|
+
*/
|
|
1877
|
+
export class OrthogonalLayout extends Layout {
|
|
1878
|
+
set refine(arg: boolean);
|
|
1879
|
+
/**
|
|
1880
|
+
* Gets or sets a value indicating whether to refine the layout.
|
|
1881
|
+
* @type {Boolean}
|
|
1882
|
+
* @summary True to refine the layout, or false otherwise.
|
|
1883
|
+
*/
|
|
1884
|
+
get refine(): boolean;
|
|
1885
|
+
set padding(arg: number);
|
|
1886
|
+
/**
|
|
1887
|
+
* Gets or sets a value indicating how much space to leave between nodes in adjacent lanes.
|
|
1888
|
+
* @type {Number}
|
|
1889
|
+
* @summary The space to leave between nodes in adjacent lanes.
|
|
1890
|
+
*/
|
|
1891
|
+
get padding(): number;
|
|
1892
|
+
set minLaneSize(arg: number);
|
|
1893
|
+
/**
|
|
1894
|
+
* Gets or sets a value indicating the minimum size of a lane.
|
|
1895
|
+
* @type {Number}
|
|
1896
|
+
* @summary The minimum size of a lane.
|
|
1897
|
+
*/
|
|
1898
|
+
get minLaneSize(): number;
|
|
1899
|
+
mm: number;
|
|
1900
|
+
/**
|
|
1901
|
+
* Applies the layout to the specified graph.
|
|
1902
|
+
* @param {Graph} graph The graph to arrange.
|
|
1903
|
+
*/
|
|
1904
|
+
arrange(graph: any): boolean;
|
|
1905
|
+
graph: any;
|
|
1906
|
+
vertexPoints: Map<any, any>;
|
|
1907
|
+
edgePoints: Map<any, any>;
|
|
1908
|
+
drawingGrid: DrawingGrid;
|
|
1909
|
+
applyGrid(grid: any): boolean;
|
|
1910
|
+
alignEndsToNode(edge: any): void;
|
|
1911
|
+
getType(): any;
|
|
1912
|
+
reverseRange(array: any, l: any, r: any): void;
|
|
1913
|
+
mergePaths(v: any, c: any, rs: any, re: any, step: any): void;
|
|
1914
|
+
mergePath(edges: any, stgEdgePoints: any): any[];
|
|
1915
|
+
_refine: boolean;
|
|
1916
|
+
_padding: number;
|
|
1917
|
+
_minLaneSize: number;
|
|
1918
|
+
}
|
|
1919
|
+
import { Layout } from "Graphs/Layout";
|
|
1920
|
+
import DrawingGrid from "Graphs/DrawingGrid";
|
|
1921
|
+
}
|
|
1922
|
+
declare module "Graphs/RadialTreeLayout" {
|
|
1923
|
+
/**
|
|
1924
|
+
* @class Implements a radial tree layout algorithm.
|
|
1925
|
+
* @augments Layout
|
|
1926
|
+
*/
|
|
1927
|
+
export class RadialTreeLayout extends Layout {
|
|
1928
|
+
set levelDistance(arg: number);
|
|
1929
|
+
/**
|
|
1930
|
+
* Gets or sets the space to leave between adjacent levels of the tree.
|
|
1931
|
+
* @type {Number}
|
|
1932
|
+
* @summary The space to leave between adjacent levels of the tree.
|
|
1933
|
+
*/
|
|
1934
|
+
get levelDistance(): number;
|
|
1935
|
+
set keepRootPosition(arg: boolean);
|
|
1936
|
+
/**
|
|
1937
|
+
* Gets or sets a value indicating whether to keep the root node at its original position.
|
|
1938
|
+
* @type {Boolean}
|
|
1939
|
+
* @summary true if the root node should be kept at its original position, or false otherwise.
|
|
1940
|
+
*/
|
|
1941
|
+
get keepRootPosition(): boolean;
|
|
1942
|
+
set direction(arg: number);
|
|
1943
|
+
/**
|
|
1944
|
+
* Gets or sets the orientation of the arranged graph.
|
|
1945
|
+
* @type {LayoutDirection}
|
|
1946
|
+
* @summary A member of the LayoutDirection enumeration.
|
|
1947
|
+
*/
|
|
1948
|
+
get direction(): number;
|
|
1949
|
+
set stretchFactor(arg: number);
|
|
1950
|
+
/**
|
|
1951
|
+
* Gets or sets the stretch factor in radial layouts.
|
|
1952
|
+
* @type {Number}
|
|
1953
|
+
* @summary The stretch factor.
|
|
1954
|
+
*/
|
|
1955
|
+
get stretchFactor(): number;
|
|
1956
|
+
set reversedLinks(arg: boolean);
|
|
1957
|
+
/**
|
|
1958
|
+
* Gets or sets a value indicating the link direction that relates parent nodes to child nodes.
|
|
1959
|
+
* @type {Boolean}
|
|
1960
|
+
* @summary true to indicate reversed direction (links point to parent nodes), or false otherwise.
|
|
1961
|
+
*/
|
|
1962
|
+
get reversedLinks(): boolean;
|
|
1963
|
+
/**
|
|
1964
|
+
* Applies the layout to the specified graph.
|
|
1965
|
+
* @param {Graph} graph The graph to arrange.
|
|
1966
|
+
*/
|
|
1967
|
+
arrange(graph: any): any;
|
|
1968
|
+
treeHelper: TreeHelper;
|
|
1969
|
+
tree: any;
|
|
1970
|
+
arrangeLevel(parentLevel: any): any;
|
|
1971
|
+
calcBounds(): any;
|
|
1972
|
+
calcRadius(level: any): any;
|
|
1973
|
+
getType(): any;
|
|
1974
|
+
_levelDistance: number;
|
|
1975
|
+
_keepRootPosition: boolean;
|
|
1976
|
+
_direction: number;
|
|
1977
|
+
_stretchFactor: number;
|
|
1978
|
+
_reversedLinks: boolean;
|
|
1979
|
+
}
|
|
1980
|
+
import { Layout } from "Graphs/Layout";
|
|
1981
|
+
import TreeHelper from "Graphs/TreeHelper";
|
|
1982
|
+
}
|
|
1983
|
+
declare module "@mindfusion/graphs" {
|
|
1984
|
+
import { AssistantPosition, AssistantType, Anchoring, LayoutDirection, TreeLayoutLinkType, MultipleGraphsPlacement, Orientation } from "Graphs/Enum";
|
|
1985
|
+
export { AssistantPosition, AssistantType, Anchoring, LayoutDirection, TreeLayoutLinkType, MultipleGraphsPlacement, Orientation };
|
|
1986
|
+
export { Graph } from "Graphs/Graph";
|
|
1987
|
+
export { PathFinder } from "Graphs/PathFinder";
|
|
1988
|
+
export { BorderedTreeLayout } from "Graphs/BorderedTreeLayout";
|
|
1989
|
+
export { FlowchartLayout } from "Graphs/FlowchartLayout";
|
|
1990
|
+
export { FractalLayout } from "Graphs/FractalLayout";
|
|
1991
|
+
export { LayeredLayout } from "Graphs/LayeredLayout";
|
|
1992
|
+
export { SpringLayout } from "Graphs/SpringLayout";
|
|
1993
|
+
export { TopologicalLayout } from "Graphs/TopologicalLayout";
|
|
1994
|
+
export { TreeLayout } from "Graphs/TreeLayout";
|
|
1995
|
+
export { TreeMapLayout } from "Graphs/TreeMapLayout";
|
|
1996
|
+
export { OrthogonalLayout } from "Graphs/OrthogonalLayout";
|
|
1997
|
+
export { RadialTreeLayout } from "Graphs/RadialTreeLayout";
|
|
1998
|
+
}
|