fcs-core-viewer 0.2.0

package/fcs-core-viewer@types/TaskHandler/TaskHandler.d.ts

@@ -0,0 +1,325 @@
+/**
+ * 1) Task-ok inditasa es bezarasa
+ *    - megjeloli az eppen futo task-ot (melyik gombot nyomtuk meg) (active / inactive) --> pl. a_id(a gomb neve) is active
+ *    - Ha elindítunk egy task-ot, akkor az eppen futo task-ot leallitja es elinditja az ujat
+ *
+ *    - inditas alatt azt ertem, hogy csak akkor jelolhetunk ki egy entity-t, hogy ha az indikatora active:
+ *    - pl. csak akkor jelolhetunk ki vertex-et, ha indicatorVertex = active --> ezt elkuldjuk a selectionToolnak
+ *
+ * 2) Kovetelmenyeket tartalmaz
+ *    - Milyen entity-t jelolhetunk ki
+ *    - Mennyi entity-t jelolhetunk ki
+ *
+ *    - ez lehet egy json dict, melyben minden gomb nevehez (key) hozzarendelunk kovetelmenyeket (value)
+ *
+ *    - a selectionTool-ba kell egy counter, ami folyamatosan minden kijelolest kovetoen elkuldi az eppen kijelolt entity-k szamat a hitelesito tool-nak:
+ *      pl. counterVertex = N
+ *
+ * 3) Hitelesiti a kijelolest mielott elkuldjuk a backend-nek
+ *    - A hitelesito osszehasonlitja az N szamot a json dict-ben találhato elvart ertekkel es ha megfelelt akkor a statusbna kiirja, hogy kijeloles kesz
+ *    - Uzenet a status bar-ban: N = elvart --> zolddel kiirja hogy sikeres kijeloles! Nyomja meg a middle mouse button-t hogy jovahagyja a muveletet
+ *                               N < elvart --> feketevel kiirja hogy mibol mennyit kell kijelolni
+ *                               N > elvart --> Hibauzenet: valamibol tul sokat jelolt ki, torolje a kijelolest!
+ *
+ *    - A Hitelesito folyamatosan track-eli a kijelolt entityk fuggvenyeben valtozo N ertekeket (N_vertex, N_edge, N_face) + regisztraljuk az ID-kat is
+ *
+ *  A teljes folyamat:
+ *  Megnyomom a gombot --> adott task activva valik --> adott entity-k kijelolese lehetsegesse valik --> elkezdek kijelolni --> select/unselect fuggvenyeben valtoznak itt az N_vertex, N_edge, N_face ertekek --> a hitelesito folyamatosan track-eli az N ertekeket es uzen a statusbarban --> ha minden jo MMB lenyomasa utan elkuldju ka backendnek a kijelolt ID-kat
+ *                     --> ESC vagy masik task inditasaval inactive-va tesszuk az epen futo task-ot
+ *
+ */
+import { MeshWrapper } from "../Model/MeshWrapper";
+import { SceneWrapper } from "../Model/SceneWrapper";
+import { Unselection } from "../SelectionTools/Unselection";
+import { SelectionValidation } from "../SelectionTools/SelectionValidation";
+import { ExplodedView } from "./Topbar/View/ExplodedView";
+import { CutView } from "./Topbar/View/CutView";
+import { TreeView } from "../UserInterface/UIComponents/TreeView";
+/**
+ * A task elindulasahoz es befejezesehez szukseges kiegeszito/tamogato funkciok
+ */
+export declare class TaskHandler {
+    static instance: TaskHandler;
+    setButtons(namesToObjects: any): void;
+    a_entity1: HTMLElement;
+    meshWrapper: MeshWrapper;
+    sceneWrapper: SceneWrapper;
+    unselection: Unselection;
+    selectionValidation: SelectionValidation;
+    explodedView: ExplodedView;
+    cutView: CutView;
+    treeView: any;
+    readonly currentCamera: any;
+    readonly scene: any;
+    readonly renderer: any;
+    readonly status: HTMLElement;
+    readonly a_vertex: HTMLElement;
+    readonly a_edge: HTMLElement;
+    readonly a_face: HTMLElement;
+    readonly menuSections: any[];
+    readonly topbarSections_L1: any[];
+    image: HTMLImageElement;
+    a_toolbarButtons: any[];
+    selected: any;
+    grMesh: any;
+    grLine: any;
+    grPoint: any;
+    method: any;
+    mode: any;
+    entityType: any;
+    buttonActive: any;
+    taskActive: any;
+    entityButtons: any;
+    section_geom: HTMLElement;
+    input_id: any;
+    input_disp: any;
+    input_text_explode: HTMLInputElement;
+    input_range_explode: HTMLInputElement;
+    /**
+     * Constructor.
+     * @param meshWrapper
+     * @param sceneWrapper
+     * @param unselection
+     * @param selectionValidation
+     * @param explodedView
+     */
+    constructor(meshWrapper: MeshWrapper, sceneWrapper: SceneWrapper, explodedView: ExplodedView, treeView: TreeView);
+    static getInstance(): TaskHandler;
+    setPrerequisites(selectionValidation: SelectionValidation, unselector: Unselection, cutView: CutView): void;
+    /**
+     * Get selection method (byID, byClick)
+     * @returns
+     */
+    getMethod(): any;
+    /**
+     * Set selection method (byID, byClick)
+     * @param value
+     */
+    setMethod(value: string): void;
+    /**
+     * Set selection method equal to "null"
+     * @param buttonObject
+     * @param caption
+     */
+    resetMethod(buttonObject: any, caption: any): void;
+    /**
+     * Get enabled entity (vertex, edge, face)
+     * @returns
+     */
+    getEntity(): any;
+    /**
+     * Set enabled entity (vertex, edge, face)
+     * @param entType
+     */
+    setEntity(entType: any): void;
+    /**
+     * Get selection mode (visibleOnly, throughAll)
+     * @returns
+     */
+    getMode(): any;
+    /**
+     * Set preferred selection mode (visibleOnly, throughAll)
+     * @param slctnMode
+     */
+    setMode(slctnMode: any): void;
+    /**
+     * Get running task
+     * @returns
+     */
+    getTaskActive(): any;
+    /**
+     * Set task active
+     * @param taskName
+     */
+    setTaskActive(taskName: any): void;
+    /**
+     * Get current button
+     * @returns
+     */
+    getButtonActive(): any;
+    /**
+     * Set button active
+     * @param buttonActive
+     */
+    setButtonActive(buttonActive: any): void;
+    /**
+     * Visszaallitja a GUI elemeket, miutan bezartuk a task-ot
+     */
+    reset(): void;
+    /**
+     * Hide all sections in the menu
+     * @param section
+     */
+    menuHide(section: any): void;
+    /**
+     * Hide all topbar dropdown sections
+     * @param section
+     */
+    topbarHide(section: any): void;
+    /**
+     * Enable selection methods
+     */
+    enableMethods(): void;
+    /**
+     * Enable selection modes
+     */
+    enableModes(): void;
+    /**
+     * Engedelyeezuk az entity valaszto gombokat
+     */
+    enableEntities(): void;
+    /**
+     *
+     * @param button disable buttons
+     */
+    disableButtons(button: any): void;
+    /**
+     *
+     * @param button Enable buttons
+     */
+    enableButtons(button: any): void;
+}
+export declare class Task {
+    taskName: any;
+    section: any;
+    taskHandler: TaskHandler;
+    entityButtons: any;
+    acceptButtons: any;
+    cancelButton: any;
+    args: any;
+    treeCore: any;
+    constructor(taskName: string, // A task neve
+    section: Element, // A megjelenitendo section
+    taskHandler: TaskHandler, // A TaskHandler class instance-e
+    entityButtons: any, // Az 'entity' button-ok object-jei (ami a findelementByID visszaad)
+    acceptButtons?: any, // Az 'accept' button-ok object-jei (ami a findelementByID visszaad)
+    cancelButton?: any, // Az 'cancel' button-ok object-jei (ami a findelementByID visszaad)
+    defaultMethod?: any, // Elore beallitott selection method 
+    defaultMode?: any, // Elore beallitott selection mode 
+    defaultEntity?: any, // Elore beallitott selection entity 
+    args?: any);
+    /**
+     * Enable all buttons
+     * @param object
+     */
+    enableButtons(object: any): void;
+    /**
+     * Disable all buttons
+     * @param object
+     */
+    disableButtons(object: any): void;
+    /**
+     * Set tak active
+     * @param taskName
+     */
+    setTaskActive(taskName: any): void;
+    /**
+     * Minden dropdown es egyeb menut eltuntet es csak a task kezelofeluletet jeleniti meg
+     * @param section
+     */
+    showSection(section: any): void;
+    /**
+     * Hide all sections in the menu
+     * @param section
+     */
+    menuHide(section: any): void;
+    /**
+     * Hide all topbar dropdown sections
+     * @param section
+     */
+    topbarHide(section: any): void;
+    /**
+     * Set default method
+     * @param method
+     */
+    setDefaultMethod(method: any): void;
+    /**
+     * Set default mode
+     * @param mode
+     */
+    setDefaultMode(mode: any): void;
+    /**
+     * Set default entity
+     * @param entity
+     */
+    setDefaultEntity(entity: any): void;
+    /**
+     * Megjeloli a treeView-ban azt az item-et, amelyikre rakattintottunk
+     * @param className
+     */
+    markSelected(className: any): void;
+    /**
+     * Unselect all
+     */
+    unselectAll(): void;
+    /**
+     * Az "Accept" gomb megnyomasara lefuttatja a task-hoz tartozo fuggvenyt a kivalasztott entity-kel
+     * @param targetFunction
+     * @param args
+     * @param validateOnAccept
+     */
+    run(targetFunction: any, args?: any, validateOnAccept?: boolean): Promise<void>;
+}
+export declare class Entity {
+    button: any;
+    requirement: any;
+    taskHandler: TaskHandler;
+    buttonName: any;
+    newTask: Task;
+    /**
+     * Entity button
+     */
+    constructor(button: any, requirement: any, taskHandler: TaskHandler);
+    /**
+     * Visszaallitja a gombot normal nezetbe
+     * @param button
+     */
+    resetButton(button: any): void;
+    /**
+     * Aktivalja a gombot. Ezt kovetoen a kijelolt entity-k emoge a gomb moge leszenk regisztralva
+     * @param disableButtons
+     */
+    setButtonActive(disableButtons?: any): void;
+    /**
+     * Mindn gombhoz definialhatunk a kijelolt entity-k szamaval kapcsolatos limiteket. Itt ezt a limitet lehet lekerni.
+     * @returns
+     */
+    getRequirement(): any;
+    /**
+     * Ha RMB-vel kattintunk a gombra...
+     */
+    context(): void;
+    /**
+     * Ha LMB-vel kattintunk a gombra...
+     */
+    click(): void;
+}
+export declare class Accept {
+    taskHandler: TaskHandler;
+    /**
+     * Accept button
+     */
+    constructor(taskHandler: TaskHandler);
+    /**
+     * Futtatja a taskhoz tartozo fv-t
+     * @param anyFunction
+     * @param args
+     * @param validateOnAccept
+     */
+    run(anyFunction: any, args?: any, validateOnAccept?: boolean): Promise<void>;
+    /**
+     * Validalja a gomb-hoz tartozo kijelolest
+     * @returns
+     */
+    validate(): any;
+    /**
+     * Unselectalja a tashoz tartozo osszes gomb mogotti kijelolest
+     */
+    unselectButtons(): void;
+}
+export declare class Cancel {
+    /**
+    * Cancel button
+    */
+    constructor();
+}

package/fcs-core-viewer@types/TaskHandler/TaskUtils.d.ts

@@ -0,0 +1,54 @@
+import { MeshWrapper } from '../Model/MeshWrapper';
+import { SceneWrapper } from '../Model/SceneWrapper';
+import { BackendManager } from '../Common/CommsChannels/BackendClient';
+import { ITaskUtilities } from '../CloudViewer/CoreInterfaces';
+/**
+ * Task Utilities
+ */
+export declare class TaskUtils implements ITaskUtilities {
+    meshWrapper: MeshWrapper;
+    sceneWrapper: SceneWrapper;
+    private _backendManager;
+    private _wasBackendManagerSet;
+    readonly grMesh: any;
+    readonly grLine: any;
+    readonly grPoint: any;
+    readonly scene: any;
+    input: {};
+    entityUIDs: any;
+    selected: any;
+    aSphereCompound: any;
+    /**
+     * Constructor.
+     */
+    constructor(meshWrapper: MeshWrapper, sceneWrapper: SceneWrapper);
+    /**
+     * We can only set the backend manager once. There is a 'defense mechanism' for this.
+     * Not an ideal solution to have this dependency, but this setter shall communicate
+     * with the developer that this can only be done once.
+     */
+    setBackendManager(backendManager: BackendManager): void;
+    /**
+     * Public getter for backend manager.
+     * Throws an exception if backend manager was not yet set because
+     * it means we want to send a transaction without the backend manager
+     * being alive.
+     */
+    getBackendManager(): BackendManager;
+    /**
+     * A selected-bol elokeresi a kijelolt ID-kat mielott elkuldjuk a backendnek (task-ok hasznaljak)
+     * @returns
+     */
+    getDataFromSelected(): {};
+    /**
+     * Kiirat infot a status bar-ba
+     * @param message
+     */
+    outputToStatusBar(message: any): void;
+    /**
+     * Looks up the currently active item's ID.
+     * We select only the first one and whatever is nested underneath it will export
+     * as a STEP compound.
+     */
+    exportSTEPForSelection(): void;
+}

package/fcs-core-viewer@types/TaskHandler/Topbar/Delete/Delete.d.ts

@@ -0,0 +1,89 @@
+import { MeshWrapper } from '../../../Model/MeshWrapper';
+import { TreeView } from '../../../UserInterface/UIComponents/TreeView';
+import { Unselection } from '../../../SelectionTools/Unselection';
+import { TaskHandler } from '../../TaskHandler';
+import { TaskUtils } from '../../TaskUtils';
+import { SceneWrapper } from '../../../Model/SceneWrapper';
+export declare class DeleteEntity {
+    uniqueToViewer: {};
+    faceVID_To_iFace: {};
+    edgeVID_To_iEdge: {};
+    vertexVID_To_iVertex: {};
+    treeJSON: any;
+    selected: any;
+    object: any;
+    enabledEntity: any;
+    components: {};
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    taskUtils: TaskUtils;
+    taskHandler: TaskHandler;
+    unselection: Unselection;
+    treeView: TreeView;
+    readonly grMesh: any;
+    readonly grLine: any;
+    readonly grPoint: any;
+    pointDeleter: PointDeleter;
+    lineDeleter: Line2Deleter;
+    faceDeleter: FaceDeleter;
+    /**
+     * Constructor.
+     */
+    constructor(sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper, taskUtils: TaskUtils, taskHandler: TaskHandler, unselection: Unselection, treeView: TreeView);
+    /**
+     * Osszegyujtjuk az osszes kijelolt entityUID-t es alkuldjuk a backend-nek
+     */
+    delete(): void;
+}
+/**
+ * Face Deleter
+ */
+export declare class FaceDeleter {
+    uniqueToViewer: {};
+    faceVID_To_iFace: {};
+    edgeVID_To_iEdge: {};
+    vertexVID_To_iVertex: {};
+    faceDeleter: FaceDeleter;
+    lineDeleter: Line2Deleter;
+    pointDeleter: PointDeleter;
+    constructor(pointDeleter: PointDeleter, lineDeleter: Line2Deleter, meshWrapper: MeshWrapper);
+    delete(entityUID: any, object: any): void;
+    updateObject(object: any, indices: any): void;
+    updateDicts(object: any, entityUID: any): void;
+}
+/**
+ * Line Deleter
+ */
+export declare class Line2Deleter {
+    treeView: TreeView;
+    pointDeleter: PointDeleter;
+    uniqueToViewer: {};
+    faceVID_To_iFace: {};
+    edgeVID_To_iEdge: {};
+    vertexVID_To_iVertex: {};
+    constructor(treeView: TreeView, pointDeleter: PointDeleter, meshWrapper: MeshWrapper);
+    delete(entityUID: any, object: any): void;
+    updateObject(object: any, indices: any): void;
+    updateDicts(object: any, entityUID: any, edgeUID: any): void;
+}
+export declare class PointDeleter {
+    treeView: TreeView;
+    uniqueToViewer: any;
+    faceVID_To_iFace: {};
+    edgeVID_To_iEdge: {};
+    vertexVID_To_iVertex: {};
+    constructor(treeView: TreeView, meshWrapper: MeshWrapper);
+    /**
+     *
+     * @param entityUID
+     * @param object
+     */
+    delete(entityUID: any, object: any): void;
+    /**
+     *
+     * @param object
+     * @param indices
+     */
+    updateObject(object: any, indices: any): void;
+    updateDicts(object: any, indices: any, vertexUID: any): void;
+}

package/fcs-core-viewer@types/TaskHandler/Topbar/Display/Display.d.ts

@@ -0,0 +1,31 @@
+import { SceneWrapper } from "../../../Model/SceneWrapper";
+import { MeshWrapper } from "../../../Model/MeshWrapper";
+/**
+ * Enumerates possible display options.
+ */
+export declare enum DisplayOption {
+    HideOnly = 0,
+    ShowAll = 1,
+    ShowOnly = 2
+}
+/**
+ * Megjeleniti/eltunteni az adott tipusu entity-ket (face, edge, vertex)
+ */
+export declare class Display {
+    selected: any;
+    grMesh: any;
+    itemVIDs: any;
+    faceVIDs: any;
+    faceUID: any;
+    facesToPolygons: any;
+    polygonIndices: any;
+    color: any;
+    constructor(meshWrapper: MeshWrapper, sceneWrapper: SceneWrapper);
+    display(action: any): void;
+    setOpacityOnly(opacity: number): void;
+    setOpacityAll(opacity: number): void;
+    showOnly(): void;
+    showAll(): void;
+    hideOnly(): void;
+    hideAll(): void;
+}

package/fcs-core-viewer@types/TaskHandler/Topbar/Tools/Find.d.ts

@@ -0,0 +1,86 @@
+import { TaskHandler } from "../../TaskHandler";
+import { SceneWrapper } from '../../../Model/SceneWrapper';
+import { MeshWrapper } from '../../../Model/MeshWrapper';
+import { Selection } from '../../../SelectionTools/Selection';
+import { Unselection } from '../../../SelectionTools/Unselection';
+import { TaskUtils } from '../../TaskUtils';
+import { TreeView } from '../../../UserInterface/UIComponents/TreeView';
+/**
+ * Find
+ */
+export declare class Find {
+    meshWrapper: MeshWrapper;
+    sceneWrapper: SceneWrapper;
+    selection: Selection;
+    unselection: Unselection;
+    taskUtils: TaskUtils;
+    taskHandler: TaskHandler;
+    treeView: TreeView;
+    readonly grMesh: any;
+    readonly grLine: any;
+    readonly grPoint: any;
+    selected: any;
+    scene: any;
+    currentCamera: any;
+    controls: any;
+    status: any;
+    table: HTMLTableElement;
+    enabledEntity: any;
+    buttonActive: any;
+    itemVIDs: any;
+    entityVIDs: any;
+    entityUIDs: any;
+    subObject: any;
+    posLabel: any;
+    text: any;
+    text1: any;
+    text2: any;
+    components: {};
+    constructor(meshWrapper: MeshWrapper, sceneWrapper: SceneWrapper, selection: Selection, unselection: Unselection, taskUtils: TaskUtils, taskHandler: TaskHandler, treeView: TreeView);
+    /**
+     * Find entity and display ID
+     * @param action
+     */
+    find(action: any): void;
+    /**
+     * Egerkattintasra keresi meg az entity-t es ad infot rola
+     * @param action
+     */
+    findByClick(action: string): void;
+    /**
+     * Az adott entity VID-janak megadasaval keresi meg az entity-t es ad infot rola
+     * @param action
+     */
+    findByID(action: string): void;
+    processInput(action: string): Promise<void>;
+    removeLabelFromTree(labelObject: any, itemVID: any): void;
+    addLabelToTree(labelObject: any, itemVID: any): void;
+    /**
+     * Letrehoz egy tablazatot a rightPanel-on
+     * @param text1
+     * @param text2
+     * @param trClass
+     * @param td1Class
+     * @param td2Class
+     */
+    addTableRow(text1: any, text2: any, trClass: any, td1Class: any, td2Class: any): void;
+    /**
+     * Kitorli a tablazatot a rightPanel-on
+     * @param entityVID
+     */
+    delTableRow(entityVID: any): void;
+    /**
+     * Megjeleniit adatokaz a kijelolt entity-rol a rightPanel-on letrehozott tablazatban es kiirja az ID-t a viewPort-ban
+     * @param coords
+     * @param entityVID
+     * @param entityUIDs
+     * @returns
+     */
+    showVertexVID(coords: any, entityVID: any, entityUIDs: any): any;
+    /**
+     * Torli a megjelenitett adatokat
+     * @param entityVID
+     * @returns
+     */
+    hideVertexVID(entityVID: any): any;
+}

package/fcs-core-viewer@types/TaskHandler/Topbar/Tools/Measurement.d.ts

@@ -0,0 +1,26 @@
+import { SceneWrapper } from '../../../Model/SceneWrapper';
+import { LoaderTools } from '../../../Loader/LoaderUtils';
+import { TaskUtils } from "../../TaskUtils";
+export declare class Measurement {
+    sceneWrapper: SceneWrapper;
+    loaderTools: LoaderTools;
+    taskUtils: TaskUtils;
+    currentCamera: any;
+    grMesh: any;
+    scene: any;
+    controls: any;
+    constructor(sceneWrapper: SceneWrapper, loaderTools: LoaderTools, taskUtils: TaskUtils);
+    /**
+     * Measure distance between two points
+     * @param event
+     */
+    distance_two_vertices(event: string): void;
+    /**
+     * Visszakapjuk a backend-tol a szamitott tavolsagot es megjelenitjuk a viewPortban
+     */
+    measure_distance(data: {}): void;
+    /**
+     * Elkuldjuk a backend-nek, hogy melyik entity-rol szeretnenk adatokat kerni.
+     */
+    whatIs(event: string): Promise<any>;
+}

package/fcs-core-viewer@types/TaskHandler/Topbar/Tools/Transformation.d.ts

@@ -0,0 +1,35 @@
+import { TaskUtils } from "../../TaskUtils";
+import { TreeView } from "../../../UserInterface/UIComponents/TreeView";
+import { MeshWrapper } from "../../../Model/MeshWrapper";
+export declare class Translate {
+    taskUtils: TaskUtils;
+    treeView: TreeView;
+    meshWrapper: MeshWrapper;
+    constructor(taskUtils: TaskUtils, treeView: TreeView, meshWrapper: MeshWrapper);
+    /**
+     * Translate object by two points
+     * @param event
+     */
+    translate_two_points(event: any): void;
+    translate_twoPoints_distance(): void;
+    translate_dx_dy_dz(): void;
+    translate_dx0_dy0_dz0_distance(): void;
+    translate_vector(): void;
+    translate_vector_distance(): void;
+    /**
+     * Ha sikerult a Backend-nek eltolni a kivalasztott componentet, item-et vagy egyeb entity-it, akkor a viewer is eltolja.
+     * Ez most CSAK FACE-eket tol el faceUID vagy itemUID alapjan!
+     * @param data
+     */
+    translate(data: {}): void;
+}
+export declare class Rotate {
+    constructor();
+    rotate_axis_angle(): void;
+    rotate_quaternion(): void;
+    rotate_euler(): void;
+}
+export declare class Position {
+    constructor();
+    position_twoLCSs(): void;
+}