@cpfr/tootframes 1.0.9

package/dist/NodeEditor.d.ts

@@ -0,0 +1,183 @@
+import { Widget } from './Widget';
+import { Vector2 } from './Math';
+import { Draggable, DragInfo } from './dragAndDrop';
+import { Menu } from './Menu';
+import { UndoHistory } from './UndoHistory';
+declare enum DragMode {
+    None = 0,
+    MoveNodes = 1,
+    MoveSelectedNodes = 2,
+    Select = 3,
+    MoveViewport = 4
+}
+declare class ConnectionSettingsBeforeDragging {
+    fromOutput: NodePort;
+    toInput: NodePort;
+    constructor(fromOutput: NodePort, toInput: NodePort);
+}
+declare class NodeEditorClipboardData {
+    nodes: NodeClipboardData[];
+    connections: NodeConnectionClipboardData[];
+    constructor(nodes: NodeClipboardData[], connections: NodeConnectionClipboardData[]);
+}
+declare class NodeConnectionClipboardData {
+    fromNodeIndex: number;
+    fromOutputIndex: number;
+    toNodeIndex: number;
+    toInputIndex: number;
+    constructor(fromNodeIndex: number, fromOutputIndex: number, toNodeIndex: number, toInputIndex: number);
+}
+declare class NodePortClipboardData {
+    name: string;
+    allowMultipleConnectionsForOutput: boolean;
+    canConnectCheck: (other: NodePort) => boolean;
+    allowMultipleConnections?: boolean;
+    constructor(name: string, allowMultipleConnectionsForOutput: boolean, canConnectCheck: (other: NodePort) => boolean, allowMultipleConnections?: boolean);
+}
+export declare class NodeClipboardData {
+    title: string;
+    inputs: NodePortClipboardData[];
+    outputs: NodePortClipboardData[];
+    pos: Vector2;
+    data: any;
+    constructor(title: string, inputs: NodePortClipboardData[], outputs: NodePortClipboardData[], pos: Vector2);
+}
+declare class NodeEditorViewport {
+    x: number;
+    y: number;
+    zoom: number;
+    constructor(x: number, y: number, zoom: number);
+    getPixelPos(): Vector2;
+    getPixelPosFromPos(x: number, y: number): Vector2;
+    getPosFromPixelPos(pixelX: number, pixelY: number): Vector2;
+}
+declare class NodeEditor extends Widget {
+    _undoHistory: UndoHistory;
+    private _svg;
+    private _nodes;
+    _viewport: NodeEditorViewport;
+    private _zoomWithoutCtrl;
+    _addArrowHeads: boolean;
+    private _defineCtrlShortcuts;
+    _targetInput?: NodePort;
+    _targetOutput?: NodePort;
+    _targetNode?: Node;
+    _dragStart: Vector2;
+    private _viewportDragStart;
+    _dragMode: DragMode;
+    private _selectRect;
+    contextMenu: Menu;
+    _draggedConnection?: NodeConnection;
+    protected _hasFocus: boolean;
+    _connectionSettingsBeforeDragging: ConnectionSettingsBeforeDragging;
+    _selectedNodes: Node[];
+    _nodeSelectedCallback: (selectedNode: Node) => void;
+    _nodeDeselectedCallback: (deselectedNode: Node) => void;
+    _nodeAddedCallback: (addedNode: Node) => void;
+    _nodeRemovedCallback: (removedNode: Node) => void;
+    _previouslySelectedNodes: any[];
+    _connections: any;
+    constructor(nodeSelectedCallback?: (selectedNode: Node) => void, nodeDeselectedCallback?: (deselectedNode: Node) => void, nodeAddedCallback?: (addedNode: Node) => void, nodeRemovedCallback?: (removedNode: Node) => void, zoomWithoutCtrl?: boolean, addArrowHeads?: boolean, defineCtrlShortcuts?: boolean, undoHistory?: UndoHistory);
+    onCopy(): void;
+    onCut(): void;
+    onPaste(fromContextMenu: boolean): void;
+    canPaste(): boolean;
+    overridableCopy(data: NodeEditorClipboardData): void;
+    overridablePaste(): NodeEditorClipboardData;
+    copy(): void;
+    cut(): void;
+    paste(useContextMenu: boolean): void;
+    _applyZoom(newZoom: number, x?: number, y?: number): void;
+    useArrowHeads(useArrowHeads: boolean): void;
+    zoomWithoutCtrl(zoomWithoutCtrl: boolean): void;
+    _addConnection(connection: NodeConnection): void;
+    _removeConnection(connection: NodeConnection): void;
+    _removeSelectedNodes(): void;
+    onAttached(): void;
+    getSelectedNodes(): Node[];
+    clear(): void;
+    _createNodeForPaste(data: NodeClipboardData): Node;
+    _getNodesCopyData(): NodeEditorClipboardData;
+    _paste(data: NodeEditorClipboardData, pixelPos: Vector2): void;
+    _onNodesPasted(pastedNodes: Node[]): void;
+    removeNode(node: Node): void;
+    addNode(node: Node): void;
+    addNodeWithUndo(node: Node, actionName: string): void;
+    getNodes(): Node[];
+    connect(output: NodePort, input: NodePort): void;
+    disconnect(output: NodePort, input: NodePort): void;
+    onDragStart(mouseEvt: MouseEvent): boolean;
+    onDragNodesStarted(): void;
+    onDragging(dragInfo: DragInfo): void;
+    onDragEnd(mouseEvt: MouseEvent): void;
+    intersection(rect1: DOMRect, rect2: DOMRect): boolean;
+    deselectAllWithUndo(): void;
+    selectAllWithUndo(): void;
+    deselectAll(): void;
+    selectAll(): void;
+}
+declare class NodeConnection {
+    _fromOutput: NodePort;
+    _toInput: NodePort;
+    _path: SVGPathElement;
+    constructor(fromOutput: NodePort, toInput: NodePort);
+    setUseArrowHead(useArrowHead: boolean): void;
+    update(x?: number, y?: number): void;
+}
+export declare class NodePort {
+    _node: Node;
+    _name: string;
+    _isInput: boolean;
+    _allowMultipleConnectionsForOutput: boolean;
+    _canConnectCheck: (source: NodePort) => boolean;
+    _bullet: HTMLSpanElement;
+    constructor(node: Node, name: string, isInput: boolean, canConnectCheck?: (source: NodePort) => boolean, allowMultipleConnectionsForOutput?: boolean);
+    createInput(): HTMLSpanElement;
+    createOutput(): HTMLSpanElement;
+    isInput(): boolean;
+    isOutput(): boolean;
+}
+declare class Node extends Widget {
+    _connectionDragging: Draggable;
+    private _title;
+    _pos: Vector2;
+    _connections: NodeConnection[];
+    _inputs: NodePort[];
+    _outputs: NodePort[];
+    _inputsElement: HTMLDivElement;
+    _contentsElement: HTMLDivElement;
+    _outputsElement: HTMLDivElement;
+    _dragEditorPixelStartX: number;
+    _dragEditorPixelStartY: number;
+    _editor: NodeEditor;
+    _dragEditorStartX: number;
+    _dragEditorStartY: number;
+    _wasActuallyDragged: boolean;
+    constructor(title: string);
+    _mapNodePort(nodePort: NodePort): NodePortClipboardData;
+    _copy(): NodeClipboardData;
+    _onConnectionAdded(connection: NodeConnection): void;
+    _onConnectionRemoved(connection: NodeConnection): void;
+    _removeDraggedConnection(connection: NodeConnection): void;
+    onAttached(): void;
+    _getViewport(): NodeEditorViewport;
+    setPixelPos(x: number, y: number): void;
+    getPixelPos(): Vector2;
+    setPos(x: number, y: number): void;
+    getPos(): Vector2;
+    getTitle(): string;
+    setTitle(title: string): void;
+    addInput(name: string, canConnectCheck?: (other: NodePort) => boolean): NodePort;
+    addOutput(name: string, canConnectCheck?: (other: NodePort) => boolean, allowMultipleConnections?: boolean): NodePort;
+    addConnection(nodeConnection: NodeConnection): void;
+    removeConnection(nodeConnection: NodeConnection): void;
+    onDragStart(mouseEvt: MouseEvent): boolean;
+    onDragStarted(): void;
+    onDragEnd(mouseEvt: MouseEvent): void;
+    isSelected(): boolean;
+    select(): void;
+    deselect(): void;
+    selectSingle(): void;
+    update(): void;
+}
+export { NodeEditor, Node, NodeConnection };

package/dist/Panel.d.ts

@@ -0,0 +1,10 @@
+import { Widget } from './Widget';
+declare class Panel extends Widget {
+    children: Widget[];
+    constructor();
+    appendChild(child: Widget): void;
+    removeChild(child: Widget): void;
+    onAttached(): void;
+    onResize(): void;
+}
+export { Panel };

package/dist/ROOT.d.ts

@@ -0,0 +1,3 @@
+import { Panel } from './Panel';
+declare const ROOT: Panel;
+export { ROOT };

package/dist/TreeView.d.ts

@@ -0,0 +1,37 @@
+import { Widget } from './Widget';
+import { Menu } from './Menu';
+declare class TreeView<T> extends Widget {
+    items: TreeViewItem<T>[];
+    clickHandler: (evt: MouseEvent, item: TreeViewItem<T>, previouslySelectedItem?: TreeViewItem<T>) => void;
+    _focusedItem: TreeViewItem<T>;
+    constructor(clickHandler?: (evt: MouseEvent, item: TreeViewItem<T>, previouslySelectedItem?: TreeViewItem<T>) => void);
+    addItem(label: string, data: T, clickHandler: (evt: MouseEvent, item: TreeViewItem<T>, previouslySelectedItem?: TreeViewItem<T>) => void, doubleClickHandler?: (evt: MouseEvent, item: TreeViewItem<T>) => void, contextMenu?: Menu): TreeViewItem<T>;
+    removeItem(item: TreeViewItem<T>): void;
+    clear(): void;
+    getItems(): TreeViewItem<T>[];
+    deselectAll(): void;
+    getSelectedItem(): TreeViewItem<T>;
+    getFocusedItem(): TreeViewItem<T>;
+    _sortFunction(a: TreeViewItem<T>, b: TreeViewItem<T>): number;
+    sortItems(): void;
+}
+declare class TreeViewItem<T> extends Widget {
+    children: TreeViewItem<T>[];
+    label: string;
+    expander: HTMLSpanElement;
+    labelElement: HTMLSpanElement;
+    childrenElement: HTMLDivElement;
+    contextMenu?: Menu;
+    parentItem?: TreeViewItem<T>;
+    data: T;
+    constructor(label: string, data: T, clickHandler?: (evt: MouseEvent, item: TreeViewItem<T>, previouslySelectedItem?: TreeViewItem<T>) => void, doubleClickHandler?: (evt: MouseEvent, item: TreeViewItem<T>) => void, contextMenu?: Menu);
+    addChildItem(item: TreeViewItem<T>): TreeViewItem<T>;
+    addChild(label: string, data: T, clickHandler?: (evt: MouseEvent, item: TreeViewItem<T>, previouslySelectedItem?: TreeViewItem<T>) => void, doubleClickHandler?: (evt: MouseEvent, item: TreeViewItem<T>) => void, contextMenu?: Menu): TreeViewItem<T>;
+    removeChild(child: TreeViewItem<T>): void;
+    sortChildren(): void;
+    deselect(): void;
+    select(): void;
+    setFocus(hasFocus: boolean): void;
+    _getIfSelected(): TreeViewItem<T>;
+}
+export { TreeView, TreeViewItem };

package/dist/UndoHistory.d.ts

@@ -0,0 +1,28 @@
+declare enum UdoableActionCategory {
+    ModifyData = 1,
+    ModifyView = 2
+}
+declare class UndoHistory {
+    private _history;
+    private _currentIndex;
+    private _idCounter;
+    private _onChangedCallback;
+    constructor(onChangedCallback?: (history: UndoableCommand[], index: number) => void);
+    add(cmd: UndoableCommand): void;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    wasDataModifiedSinceVersion(versionId: number): boolean;
+    getCurrentCommand(): UndoableCommand;
+}
+declare class UndoableCommand {
+    id: number;
+    title: string;
+    do: () => void;
+    undo: () => void;
+    category: UdoableActionCategory;
+    constructor(title: string, doAction: () => void, undoAction: () => void, category: UdoableActionCategory);
+    wasDataModified(): boolean;
+}
+export { UndoHistory, UndoableCommand, UdoableActionCategory };

package/dist/Widget.d.ts

@@ -0,0 +1,19 @@
+import { DragInfo } from "./dragAndDrop";
+interface IDraggable {
+    element: HTMLElement;
+    onDragStart(mouseEvt: MouseEvent): boolean;
+    onDragEnd(mouseEvt: MouseEvent): void;
+    onDragging(dragInfo: DragInfo): void;
+}
+declare class Widget implements IDraggable {
+    element: HTMLElement;
+    parentWidget?: Widget;
+    constructor(element?: HTMLElement);
+    onDragStart(mouseEvt: MouseEvent): boolean;
+    onDragEnd(mouseEvt: MouseEvent): void;
+    onDragging(dragInfo: DragInfo): void;
+    onAttached(): void;
+    isAttached(): boolean;
+    onResize(): void;
+}
+export { Widget, IDraggable };

package/dist/dragAndDrop.d.ts

@@ -0,0 +1,22 @@
+import { Vector2 } from './Math';
+import { IDraggable } from './Widget';
+type DragInfo = {
+    mouseEvent: MouseEvent;
+    rect: DOMRect;
+    posWithOffsetToParentConsidered: Vector2;
+    posRelativeToElement: Vector2;
+    posRelativeToDragStart: Vector2;
+};
+declare let currentMousePos: {
+    x: number;
+    y: number;
+};
+declare function getDragStart(draggable: IDraggable, dragStartMethod?: (draggable: IDraggable, evt: MouseEvent) => boolean): (evt: MouseEvent) => void;
+declare class Draggable implements IDraggable {
+    element: HTMLElement;
+    onDragStart: (mouseEvt: MouseEvent) => boolean;
+    onDragging: (ragInfo: DragInfo) => void;
+    onDragEnd: (mouseEvt: MouseEvent) => void;
+    constructor(element: HTMLElement, onDragStart: (mouseEvt: MouseEvent) => boolean, onDragging: (dragInfo: DragInfo) => void, onDragEnd: (mouseEvt: MouseEvent) => void);
+}
+export { getDragStart, currentMousePos, Draggable, DragInfo };

package/dist/main.d.ts

@@ -0,0 +1,23 @@
+import "./style.scss";
+export * from './Math';
+export * from './Color';
+export * from './ColorPicker';
+export * from './Widget';
+export * from './Panel';
+export * from './Button';
+export * from './Dropdown';
+export * from './ListBox';
+export * from './ListView';
+export * from './TreeView';
+export * from './ROOT';
+export * from './Menu';
+export * from './MenuBar';
+export * from './Label';
+export * from './Image';
+export * from './DockContainer';
+export * from './Dialog';
+export * from './MessageDialog';
+export * from './NodeEditor';
+export * from './UndoHistory';
+export * from './FakeClipboard';
+export { currentMousePos } from './dragAndDrop';