ngx-diagrams
Version:
> Light Weight, Modular, Typed Diagram Engine for Angular
154 lines (153 loc) • 6.6 kB
TypeScript
import { ComponentFactoryResolver, ComponentRef, Renderer2, RendererFactory2, ViewContainerRef } from '@angular/core';
import { BaseEntity } from '../base.entity';
import { AbstractLabelFactory } from '../factories/label.factory';
import { AbstractLinkFactory } from '../factories/link.factory';
import { AbstractNodeFactory } from '../factories/node.factory';
import { AbstractPortFactory } from '../factories/port.factory';
import { DiagramModel } from '../models/diagram.model';
import { LabelModel } from '../models/label.model';
import { LinkModel } from '../models/link.model';
import { NodeModel } from '../models/node.model';
import { PortModel } from '../models/port.model';
import { PathFinding } from '../plugins/smart-routing.plugin';
import { EntityMap } from '../utils';
export declare class DiagramEngine {
protected resolver: ComponentFactoryResolver;
protected rendererFactory: RendererFactory2;
protected _renderer: Renderer2;
protected nodeFactories: Map<string, AbstractNodeFactory<NodeModel<PortModel>>>;
protected labelFactories: Map<string, AbstractLabelFactory<LabelModel>>;
protected linkFactories: Map<string, AbstractLinkFactory<LinkModel>>;
protected portFactories: Map<string, AbstractPortFactory<PortModel>>;
protected canvas$: import("../state/state").ValueState<Element>;
smartRouting: boolean;
pathFinding: PathFinding;
canvasMatrix: number[][];
routingMatrix: number[][];
hAdjustmentFactor: number;
vAdjustmentFactor: number;
diagramModel: DiagramModel;
constructor(resolver: ComponentFactoryResolver, rendererFactory: RendererFactory2);
createDiagram(): DiagramModel;
registerDefaultFactories(): void;
registerLabelFactory(labelFactory: AbstractLabelFactory): void;
getLabelFactories(): EntityMap<AbstractLabelFactory>;
getLabelFactory(type: string): AbstractLabelFactory;
getFactoryForLabel(label: LabelModel): AbstractLabelFactory | null;
generateWidgetForLabel(label: LabelModel, labelHost: ViewContainerRef): ComponentRef<LabelModel> | null;
registerNodeFactory(nodeFactory: AbstractNodeFactory): void;
getNodeFactories(): EntityMap<AbstractNodeFactory>;
getNodeFactory(type: string): AbstractNodeFactory;
getFactoryForNode(node: NodeModel): AbstractNodeFactory | null;
generateWidgetForNode(node: NodeModel, nodesHost: ViewContainerRef): ComponentRef<NodeModel> | null;
registerPortFactory(factory: AbstractPortFactory): void;
getPortFactories(): Map<string, AbstractPortFactory<PortModel>>;
getPortFactory(type: string): AbstractPortFactory;
getFactoryForPort(port: PortModel): AbstractPortFactory | null;
generateWidgetForPort(port: PortModel, portsHost: ViewContainerRef): ComponentRef<PortModel> | null;
getLinkFactories(): EntityMap<AbstractLinkFactory>;
registerLinkFactory(factory: AbstractLinkFactory): void;
getLinkFactory(type: string): AbstractLinkFactory;
getFactoryForLink(link: LinkModel): AbstractLinkFactory | null;
generateWidgetForLink(link: LinkModel, linksHost: ViewContainerRef): ComponentRef<LinkModel> | null;
getNodeElement(node: NodeModel): HTMLElement;
getNodePortElement(port: PortModel): HTMLElement;
getPortCenter(port: PortModel): {
x: number;
y: number;
};
/**
* Calculate rectangular coordinates of the port passed in.
*/
getPortCoords(port: PortModel): {
x: number;
y: number;
width: number;
height: number;
};
/**
* Determine the width and height of the node passed in.
* It currently assumes nodes have a rectangular shape, can be overriden for customised shapes.
*/
getNodeDimensions(node: NodeModel): {
width: number;
height: number;
};
setCanvas(canvas: Element): void;
getRelativeMousePoint(event: MouseEvent): {
x: number;
y: number;
};
getRelativePoint(x: number, y: number): {
x: number;
y: number;
};
getDiagramModel(): DiagramModel;
isModelLocked(model: BaseEntity): boolean;
/**
* fit the canvas zoom levels to the elements contained.
* @param additionalZoomFactor allow for further zooming out to make sure edges doesn't cut
*/
zoomToFit(additionalZoomFactor?: number): void;
setSmartRoutingStatus(status: boolean): void;
getPathfinding(): PathFinding;
calculateCanvasMatrix(): void;
/**
* Despite being a long method, we simply iterate over all three collections (nodes, ports and points)
* to find the highest X and Y dimensions, so we can build the matrix large enough to contain all elements.
*/
calculateMatrixDimensions(): {
width: number;
hAdjustmentFactor: number;
height: number;
vAdjustmentFactor: number;
};
/**
* A representation of the canvas in the following format:
*
* +-----------------+
* | 0 0 0 0 0 0 0 0 |
* | 0 0 0 0 0 0 0 0 |
* | 0 0 0 0 0 0 0 0 |
* | 0 0 0 0 0 0 0 0 |
* | 0 0 0 0 0 0 0 0 |
* +-----------------+
*
* In which all walkable points are marked by zeros.
* It uses @link{#ROUTING_SCALING_FACTOR} to reduce the matrix dimensions and improve performance.
*/
getCanvasMatrix(): number[][];
/**
* The routing matrix does not have negative indexes, but elements could be negatively positioned.
* We use the functions below to translate back and forth between these coordinates, relying on the
* calculated values of hAdjustmentFactor and vAdjustmentFactor.
*/
translateRoutingX(x: number, reverse?: boolean): number;
translateRoutingY(y: number, reverse?: boolean): number;
/**
* A representation of the canvas in the following format:
*
* +-----------------+
* | 0 0 1 1 0 0 0 0 |
* | 0 0 1 1 0 0 1 1 |
* | 0 0 0 0 0 0 1 1 |
* | 1 1 0 0 0 0 0 0 |
* | 1 1 0 0 0 0 0 0 |
* +-----------------+
*
* In which all points blocked by a node (and its ports) are
* marked as 1; points were there is nothing (ie, free) receive 0.
*/
getRoutingMatrix(): number[][];
calculateRoutingMatrix(): void;
getSmartRouting(): boolean;
/**
* Updates (by reference) where nodes will be drawn on the matrix passed in.
*/
markNodes(matrix: number[][]): void;
/**
* Updates (by reference) where ports will be drawn on the matrix passed in.
*/
markPorts(matrix: number[][]): void;
markMatrixPoint: (matrix: number[][], x: number, y: number) => void;
}