fcs-core-viewer 0.2.0

package/fcs-core-viewer@types/Tree/TreeStructure/TreeStructure.d.ts

@@ -0,0 +1,68 @@
+import { TreeCore } from '../TreeView/TreeCore';
+import { MeshWrapper } from '../../Model/MeshWrapper';
+/**
+ * TreeStructure.
+ */
+export declare class TreeStructure {
+    static instance: TreeStructure;
+    treeCore: TreeCore;
+    treeJSON: any;
+    components: any;
+    meshWrapper: MeshWrapper;
+    /**
+     * Constructor.
+     * @param treeView
+     * @param treeJson
+     */
+    constructor(treeCore: TreeCore, meshWrapper: MeshWrapper);
+    static getInstance(): TreeStructure;
+    /**
+     *
+     * Az addToTreeJSON kisegito fuggvenye. Egy file-t ad hozza a treeJSON-hoz
+     *
+     * 1) copy/move          --> itemVID = meglevo, parentVID == undefined --> az itemVID benne van valamelyik top-level item hierarchy list-jeben
+     *
+     * 2) add top-level item --> itemVID = uj,      parentVID == undefined --> az itemVID nincs benne egyik top-level item hierarchy list-jeben
+     *
+     * 3) add sub-level item --> itemVID = uj,      parentVID != undefined --> az itemVID nincs benne egyik top-level item hierarchy list-jeben; a parentVID viszont igen
+     *
+     */
+    addToTreeJSON(itemUID: number, componentUID: number, parentUID: number, containerUID: number, itemName: string, elemType: string): void;
+    removeFromTreeJSON(itemUID: number, elemType: string): void;
+    private removeFile;
+    private removeFolder;
+    private removeContainer;
+    /**
+     *
+     * @param parent
+     * @param itemName
+     * @param containerName
+     * @param itemVID
+     * @param componentVID
+     */
+    private createFile;
+    /**
+     * Az addToTreeJSON kisegito fuggvenye. Egy container-t ad hozza a treeJSON-hoz
+     * @param containerName
+     * @returns
+     */
+    private createFolder;
+    /**
+     * Az addToTreeJSON kisegito fuggvenye. Egy container-t ad hozza a treeJSON-hoz
+     * @param containerName
+     * @returns
+     */
+    private createContainer;
+    /**
+     *
+     * @returns
+     */
+    getTreeJSON: () => any;
+    /**
+     *
+     * @param itemUID
+     * @returns
+     */
+    findItem(itemUID: number): [{}, {}];
+    findChildren(file: {}): [any, any];
+}

package/fcs-core-viewer@types/Tree/TreeView/TreeCore.d.ts

@@ -0,0 +1,175 @@
+import { TreeStructure } from '../TreeStructure/TreeStructure';
+import { TreeStyle } from '../../StyleHandler/TreeStyle';
+import { UIDGenerator } from '../../Common/UIDGenerator/UIDGenerator';
+import { AddContainer } from '../../TaskHandler/Tree/RequestHandler/AddContainer';
+export declare class Emitter {
+    private events;
+    /**
+     * Subscribe to an event and put the event into the dictionary 'events'
+     * @param name
+     * @param callback
+     */
+    on(name: string, callback: any): void;
+    /**
+     * Once
+     * @param name
+     * @param callback
+     */
+    once(name: string, callback: any): void;
+    /**
+     * Emit the event - lefuttatja az adott nevhez tartozo event-eket (ezek fuggvenyek). Egy nevhez tobb fuggveny is tartozhat.
+     * A 'created' nevu bejegyzeshez pl. 2 fuggveny tartozik. ezeket a for ciklussal sorban lefuttatjuk itt.
+     * @param name
+     * @param data
+     * @returns
+     */
+    emit(name: string, ...data: any[]): void;
+}
+/**
+ * Simple Tree
+ */
+export declare class SimpleTree extends Emitter {
+    grMesh: any;
+    grLine: any;
+    grPoint: any;
+    parent: HTMLElement;
+    interrupt: (node: any) => any;
+    FILE: string;
+    FOLDER: string;
+    CONTAINER: string;
+    treeStyle: TreeStyle;
+    currentCamera: any;
+    scene: any;
+    renderer: any;
+    checked: boolean;
+    nodeParentDetails: any;
+    /**
+     *
+     * @param parent
+     * @param properties
+     */
+    constructor(parent: HTMLElement, treeStyle: TreeStyle, options: {});
+    /**
+     *
+     * @param element
+     * @param parent
+     * @param before
+     * @param callback
+     * @returns
+     */
+    append(element: HTMLElement, parent: HTMLElement, before?: HTMLElement, callback?: () => void): HTMLElement;
+    /**
+     *
+     * @param node
+     * @param summary
+     * @param mesh
+     * @param line
+     * @param vertex
+     * @param grMesh
+     * @param grLine
+     * @param grPoint
+     * @param grEntityLabel
+     * @param treeJSON
+     * @param before
+     */
+    file(node: any, summary: HTMLElement, before?: any): void;
+    /**
+     * Folder
+     * @param node
+     * @param parent
+     * @param before
+     * @returns
+     */
+    folder(node: any, summary: HTMLElement, before?: any): HTMLElement;
+    /**
+     * Open
+     * @param details
+     */
+    open(details: {
+        open: boolean;
+    }): void;
+    /**
+     * Hierarchy - ToDo: What about 'this.active()' default arg call?
+     * @param element
+     * @returns
+     */
+    hierarchy(element: HTMLElement): any[];
+    /**
+     * Siblings
+     * @param element
+     * @returns
+     */
+    siblings(element?: HTMLElement): Element[];
+    /**
+     * Children
+     * @param details
+     * @returns
+     */
+    children(details: {
+        querySelector: (arg0: string) => any;
+    }): Element[];
+}
+export declare class SelectTree extends SimpleTree {
+    /**
+     * Constructor.
+     * @param parent
+     * @param options
+     */
+    constructor(parent: HTMLElement, treeStyle: TreeStyle, options?: {});
+    /**
+     * Select
+     * @param event
+     * @param target
+     */
+    select(target: any): void;
+    /**
+     * Unselect
+     * Removes the '.selected' css class assigned to the elements of the div_treeHTML
+     */
+    unselect(): void;
+    /**
+     * Active
+     * @returns
+     */
+    active(): any;
+    /**
+     * Make Current
+     */
+    makeCurrent(): void;
+}
+export declare class TreeCore extends SelectTree {
+    static instance: TreeCore;
+    element: HTMLElement;
+    uidGenerator: UIDGenerator;
+    addContainer: AddContainer;
+    treeStructure: TreeStructure;
+    constructor(element: HTMLElement, treeStyle: TreeStyle, options?: {});
+    setPrerequisites(treeStructure: TreeStructure): void;
+    init(uidGenerator: UIDGenerator, addContainer: AddContainer): void;
+    static getInstance(): TreeCore;
+    addToTreeHTML(itemUID: number, parentUID: any, elemType: string): void;
+    removeFromTreeHTML(itemUID: number, elemType: string): void;
+    private removeFile;
+    private removeFolder;
+    private removeContainer;
+    /**
+     * Creates a file in the tree.
+     * @param itemName
+     * @param itemUID
+     * @param parentUID
+     */
+    private createFile;
+    /**
+     * Creates a folder in the tree.
+     * @param itemName
+     * @param itemUID
+     * @param parentUID
+     */
+    private createFolder;
+    /**
+     * Creates a container in the tree.
+     * @param itemName
+     * @param itemUID
+     */
+    private createContainer;
+}

package/fcs-core-viewer@types/Tree/TreeView/TreeCoreUtils.d.ts

@@ -0,0 +1,82 @@
+import { SceneWrapper } from '../../Model/SceneWrapper';
+/**
+ * Tree On Mouse Click
+ */
+export declare class TreeCoreUtils {
+    sceneWrapper: SceneWrapper;
+    cssRules: CSSRuleList;
+    summary_ruleID: any;
+    details_ruleID: any;
+    div_ruleID: any;
+    diff_tree_init: any;
+    mouseX_init: any;
+    windowWidth: any;
+    mouseX: number;
+    mouseX_: number;
+    mouseDX: number;
+    dx_length: number;
+    currentCamera: any;
+    renderer: any;
+    labelRenderer2D: any;
+    controls: any;
+    left_canvas_init: any;
+    width_canvas_init: any;
+    section_tree_width_init: number;
+    section_tree_width_min: number;
+    topbarWidth_init: any;
+    topbarLeft_init: any;
+    total_a_topbar: any;
+    topbar_a_width: any;
+    axis_X: any;
+    axis_X_init_pos: any;
+    axis_X_pos: any;
+    axis_Y: any;
+    axis_Y_init_pos: any;
+    axis_Y_pos: any;
+    axis_Z: any;
+    axis_Z_init_pos: any;
+    axis_Z_pos: any;
+    sidebar: HTMLElement;
+    div_leftSidebar: HTMLElement;
+    div_treeHTML: HTMLElement;
+    topbar: any;
+    nav_topbar: any;
+    collection_a_topbar: HTMLCollectionOf<any>;
+    myCanvas: HTMLElement;
+    myLabelRenderer2D: HTMLElement;
+    scene: any;
+    readonly label_X: HTMLElement;
+    readonly label_Y: HTMLElement;
+    readonly label_Z: HTMLElement;
+    readonly dx_local: any;
+    readonly dx_world_unit: any;
+    label_X_init: any;
+    label_Y_init: any;
+    label_Z_init: any;
+    dx_world_rel: any;
+    dx_world_total: any;
+    camToStart_world: any;
+    camToStart_world_unit: any;
+    camToStart_local: any;
+    camToStart: any;
+    camToStart_length: any;
+    fcs_viewer_div: HTMLDivElement;
+    constructor(sceneWrapper: SceneWrapper);
+    /**
+     * Reads stylesheets from the CSS files and adapts the style of certain HTML elements
+     */
+    onMouseUpDivTree(event: MouseEvent): void;
+    onMouseDownDivTree(event: MouseEvent): void;
+    /**
+     * Get relative mouse position
+     */
+    private calcRelativeMousePos;
+    /**
+     * Event triggered on mouse down
+     */
+    private mouseDown;
+    /**
+     * Translates triade.
+     */
+    private translateTriade;
+}

package/fcs-core-viewer@types/UserInterface/EventListeners/EventListeners.d.ts

@@ -0,0 +1,32 @@
+import { SceneWrapper } from '../../Model/SceneWrapper';
+import { MeshWrapper } from '../../Model/MeshWrapper';
+import { Selection } from '../../SelectionTools/Selection';
+import { Unselection } from '../../SelectionTools/Unselection';
+import { SelectionUtils } from '../../SelectionTools/SelectionUtils';
+import { TaskHandler } from '../../TaskHandler/TaskHandler';
+import { UIComponents } from '../UIComponents/UIComponents';
+export declare class EventListeners {
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    selection: Selection;
+    unselection: Unselection;
+    selectionUtils: SelectionUtils;
+    taskHandler: TaskHandler;
+    uiComponents: UIComponents;
+    div_treeHTML: HTMLElement;
+    div_leftSidebar: HTMLElement;
+    myCanvas: HTMLCanvasElement;
+    mouseOnCanvas: boolean;
+    buttonActive: any;
+    enabledMethod: any;
+    enabledEntity: any;
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+    constructor(sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper, selection: Selection, unselection: Unselection, selectionUtils: SelectionUtils, taskHandler: TaskHandler);
+    /**
+     * Register all event listeners used throughout the application
+     */
+    private register;
+}

package/fcs-core-viewer@types/UserInterface/EventListeners/ModelEvents.d.ts

@@ -0,0 +1,13 @@
+import { SceneWrapper } from "../../Model/SceneWrapper";
+import { UIComponents } from "../UIComponents/UIComponents";
+import { ModelContextMenu } from "../UIComponents/Model";
+export declare class ModelEvents {
+    sceneWrapper: SceneWrapper;
+    uiComponents: UIComponents;
+    div_treeHTML: HTMLElement;
+    modelContextMenu: ModelContextMenu;
+    userId: string;
+    fcs_viewer: HTMLDivElement;
+    constructor(sceneWrapper: SceneWrapper);
+    register(): any;
+}

package/fcs-core-viewer@types/UserInterface/EventListeners/TreeViewEvents.d.ts

@@ -0,0 +1,15 @@
+import { MeshWrapper } from "../../Model/MeshWrapper";
+import { UIComponents } from "../UIComponents/UIComponents";
+import { TreeItemContextMenu } from "../UIComponents/TreeView";
+export declare class TreeViewEvents {
+    meshWrapper: MeshWrapper;
+    uiComponents: UIComponents;
+    div_treeHTML: HTMLElement;
+    treeItemContextMenu: TreeItemContextMenu;
+    constructor();
+    onToggleDisclosureWidget(summary: HTMLElement): void;
+    onClickFile(summary: HTMLElement): void;
+    onContextMenuFile(summary: HTMLElement): void;
+    onClickCheckbox(checkbox: any): void;
+    register(): void;
+}

package/fcs-core-viewer@types/UserInterface/UIComponents/Model.d.ts

@@ -0,0 +1,33 @@
+import { MeshWrapper } from '../../Model/MeshWrapper';
+import * as THREE from '../../three/build/three.module';
+declare enum ModelContextMenuButtons {
+    add_comment = 0,
+    appearance = 1,
+    hide = 2,
+    show_only = 3,
+    show_all = 4,
+    edit_geom = 5,
+    sel_entity = 6,
+    sel_method = 7,
+    create_mesh = 8,
+    delete = 9
+}
+export declare class ModelContextMenu {
+    meshWrapper: MeshWrapper;
+    instance: ModelContextMenu;
+    element: HTMLDivElement;
+    parent: HTMLDivElement;
+    buttons: typeof ModelContextMenuButtons;
+    buttonElements: {
+        [key: number]: HTMLAnchorElement;
+    };
+    mouse3DPosition: THREE.Vector3;
+    constructor(meshWrapper: MeshWrapper);
+    getInstance(): ModelContextMenu;
+    getElement(int: number): HTMLAnchorElement;
+    setMouse3DPosition(pointOnModel: THREE.Vector3D): void;
+    show(event: MouseEvent): void;
+    hide(): void;
+    setPosition(location: THREE.Vector3): void;
+}
+export {};

package/fcs-core-viewer@types/UserInterface/UIComponents/TreeView.d.ts

@@ -0,0 +1,52 @@
+import * as THREE from '../../three/build/three.module';
+import { MeshWrapper } from '../../Model/MeshWrapper';
+import { TreeStyle } from '../../StyleHandler/TreeStyle';
+import { TreeCore } from '../../Tree/TreeView/TreeCore';
+import { TreeStructure } from '../../Tree/TreeStructure/TreeStructure';
+export declare class TreeView {
+    meshWrapper: MeshWrapper;
+    style: TreeStyle;
+    treeCore: TreeCore;
+    treeStructure: TreeStructure;
+    static instance: TreeView;
+    element: HTMLElement;
+    parent: HTMLDivElement;
+    constructor(meshWrapper: MeshWrapper);
+    static getInstance(): TreeView;
+    show(): void;
+    hide(): void;
+}
+export declare class TreeContainerContextMenu {
+}
+declare enum TreeItemContextMenuButtons {
+    add = 0,
+    show = 1,
+    hide = 2,
+    show_only = 3,
+    show_all = 4,
+    hide_all = 5,
+    color = 6,
+    rename = 7,
+    current = 8,
+    copy = 9,
+    move = 10,
+    paste = 11,
+    delete = 12
+}
+export declare class TreeItemContextMenu {
+    meshWrapper: MeshWrapper;
+    instance: TreeItemContextMenu;
+    element: HTMLDivElement;
+    parent: HTMLDivElement;
+    buttons: typeof TreeItemContextMenuButtons;
+    buttonElements: {
+        [key: number]: HTMLAnchorElement;
+    };
+    constructor(meshWrapper: MeshWrapper);
+    getInstance(): TreeItemContextMenu;
+    getElement(int: number): HTMLAnchorElement;
+    show(event: MouseEvent): void;
+    hide(): void;
+    setPosition(location: THREE.Vector3): void;
+}
+export {};

package/fcs-core-viewer@types/UserInterface/UIComponents/UIComponents.d.ts

@@ -0,0 +1,32 @@
+import { MeshWrapper } from '../../Model/MeshWrapper';
+import { TreeView } from '../UIComponents/TreeView';
+import { TreeItemContextMenu } from '../UIComponents/TreeView';
+import { ModelContextMenu } from '../UIComponents/Model';
+/**
+ * Botond's proposal for creating building blocks of HTML elements
+ * HTML blocks are initialized in viewerWrapper!
+ */
+export declare class UIComponents {
+    meshWrapper: MeshWrapper;
+    static instance: UIComponents;
+    treeView: TreeView;
+    treeItemContextMenu: TreeItemContextMenu;
+    modelContextMenu: ModelContextMenu;
+    constructor(meshWrapper: MeshWrapper);
+    static getInstance(): UIComponents;
+    /**
+     * Returns the fcs-viewer div element
+     */
+    getContainer(): HTMLDivElement;
+    /**
+     * Returns the class instances of the requested HTML UI components
+     * @param parent
+     * @param className
+     * @returns
+     */
+    getUIComponentsByClassName(parent: HTMLElement | Document, className: string): any[];
+    static getUIComponentsByID(parent: HTMLElement | Document, id: string): void;
+}
+/**
+ * Singleton classes for adding predefined UI components to fcs-viewer
+ */ 

package/fcs-core-viewer@types/UserInterface/UIComponents.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @namespace UI
+ * The namespace that holds all UI related stuff.
+ */
+export declare namespace UI {
+    /**
+     * @enum {number} ElementTypes
+     * Enumeration of HTML element types for user interface.
+     * @property {number} Canvas - Represents the Canvas element.
+     * @property {number} TreeView - Represents the TreeView element.
+     */
+    enum Components {
+        Canvas = 0,
+        WrapperDiv = 1,
+        TreeView = 2,
+        TreeCopy = 3,
+        TreeCopy_Entity = 4,
+        TreeCopy_Accept = 5,
+        TreeMove = 6,
+        TreeMove_Entity = 7,
+        TreeMove_Accept = 8,
+        ColorBar = 9,
+        ColorTable = 10,
+        ColorInputRange = 11,
+        CustomScript = 12,
+        GeometrySection = 13,
+        DeleteGeneric = 14,
+        ReactTaskDialog = 15
+    }
+    enum SelectorKeys {
+        SummarySelected = 0,
+        Selected = 1,
+        Summary = 2
+    }
+    /**
+     * @constant {Object} ElementTypeToIDs
+     * Constant dictionary mapping `Components` elements to their respective string IDs.
+     * @property {string} Components.Canvas - ID of the Canvas HTML element.
+     * @property {string} Components.TreeView - ID of the TreeView HTML element.
+     */
+    const ElementTypeToIDs: {
+        [key in Components]?: string;
+    };
+}

package/fcs-core-viewer@types/UserInterface/UIDefinition.d.ts

@@ -0,0 +1,37 @@
+import { UI } from './UIComponents';
+/**
+ * HTML Element Wrapper
+ */
+export declare class UIDefinition {
+    addEventListener(type: UI.Components, eventType: string, handler: Function): void;
+    /**
+     * WE DO NOT WANT TO USE THIS, THIS IS ONLY TEMPORARY UNTIL
+     * WE HAVE THE REACT COMPONENTS IN PLACE
+     * Getter for the underlying HTML element.
+     * @param requestedElement Limited to the allowed enumeration.
+     * @returns The element object to which we want to get.
+     */
+    getRawElement<RequestedHtmlType>(requestedElement: UI.Components): RequestedHtmlType;
+    /**
+     * Populates the table color
+     */
+    addColorSelectionToTable(tableComponent: UI.Components): void;
+    /**
+     * Singleton instance
+     */
+    private static _instance;
+    /**
+     * Singleton getter
+     */
+    static getInstance(): UIDefinition;
+    /**
+     * Private constructor validates if all required HTML elements
+     * are present.
+     */
+    private constructor();
+    /**
+     * Checks if the UI definition has all the required elements present.
+     */
+    private _validateUiDefinition;
+}
+export declare const uiDef: UIDefinition;

package/fcs-core-viewer@types/UserInterface/UiApi/BaseComponents/FcsUiBaseComponent.d.ts

@@ -0,0 +1,6 @@
+/**
+ * BaseComponents cannot host any other components. They are the base building blocks.
+ * The 'FcsUiMainComponents' host them.
+ */
+export declare class FcsUiBaseComponent {
+}

package/fcs-core-viewer@types/UserInterface/UiApi/BaseComponents/FcsUiFunctionGroup.d.ts

@@ -0,0 +1,14 @@
+import { FcsUiBaseComponent } from "./FcsUiBaseComponent";
+import { FcsUiInputCollector } from "./FcsUiInputCollector";
+/**
+ * Function Groups serve to provide a User Interface that allows
+ * user to do following
+ */
+export declare class FcsUiFunctionGroup extends FcsUiBaseComponent {
+    private readonly _functionGroupId;
+    private readonly _title;
+    private _inputCollectors;
+    constructor(title: string);
+    activateFunctionGroup(): string;
+    addInputCollector(collector: FcsUiInputCollector): void;
+}

package/fcs-core-viewer@types/UserInterface/UiApi/BaseComponents/FcsUiInputCollector.d.ts

@@ -0,0 +1,10 @@
+import { FcsUiBaseComponent } from "./FcsUiBaseComponent";
+export declare class FcsUiInputCollector extends FcsUiBaseComponent {
+    private readonly _guid;
+    /**
+     * We generate a unique identifier for this input type. This will be required when we
+     * associate certain input collector UI elements to inputs they have collected.
+     */
+    constructor();
+    getId(): string;
+}

package/fcs-core-viewer@types/UserInterface/UiApi/BaseComponents/FcsUiPushButton.d.ts

@@ -0,0 +1,8 @@
+import { FcsUiBaseComponent } from "./FcsUiBaseComponent";
+export declare class FcsUiPushButton extends FcsUiBaseComponent {
+    private static _collectedIdentifiers;
+    private _actionIdentifier;
+    private _imageAssetIdentifier;
+    constructor(tooltipText: string, actionIdentifier: number, imageAssetId: number);
+    getActionIdentifier(): number;
+}

package/fcs-core-viewer@types/UserInterface/UiApi/BaseComponents/FcsUiSlider.d.ts

@@ -0,0 +1,3 @@
+import { FcsUiBaseComponent } from "./FcsUiBaseComponent";
+export declare class FcsUiSlider extends FcsUiBaseComponent {
+}