fcs-core-viewer 0.2.0

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

@@ -0,0 +1,85 @@
+import { SceneWrapper } from '../../../Model/SceneWrapper';
+import { MeshWrapper } from '../../../Model/MeshWrapper';
+import { LoaderTools } from '../../../Loader/LoaderUtils';
+import { TreeView } from '../../../UserInterface/UIComponents/TreeView';
+export declare class CutView {
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    loaderTools: LoaderTools;
+    treeView: TreeView;
+    generalMeshMaterial: any;
+    customMeshMaterial: any;
+    generalLineMaterial: any;
+    customLineMaterial: any;
+    generalPointMaterial: any;
+    customPointMaterial: any;
+    readonly controls: any;
+    readonly scene: any;
+    readonly currentCamera: any;
+    readonly renderer: any;
+    readonly grMesh: any;
+    readonly grLine: any;
+    readonly grPoint: any;
+    grStencilMesh: any;
+    grPlaneObj: any;
+    localPlanes: any;
+    localPlane_x: any;
+    localPlane_y: any;
+    localPlane_z: any;
+    planeGeoms: any;
+    planeGeom_x: any;
+    planeGeom_y: any;
+    planeGeom_z: any;
+    planeObj: any;
+    matBackSide: any;
+    matFrontSide: any;
+    mesh0: any;
+    mesh1: any;
+    vecMax: any;
+    vecMin: any;
+    xMax: any;
+    yMax: any;
+    zMax: any;
+    xMin: any;
+    yMin: any;
+    zMin: any;
+    r: any;
+    g: any;
+    b: any;
+    readonly input_range_cut_x: HTMLInputElement;
+    readonly input_range_cut_y: HTMLInputElement;
+    readonly input_range_cut_z: HTMLInputElement;
+    components: {};
+    /**
+     * Constructor.
+     */
+    constructor(sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper, loaderTools: LoaderTools, treeView: TreeView);
+    /**
+     * Letrehozza a cutting plane-eket es modositja azoknak a meshobject-eknek a materialjat, amelyeket el akarunk vagni
+     * @param items_sel
+     */
+    init(items_sel: any): void;
+    /**
+     * Visszaalitjuk az eredeti allapotot.
+     */
+    resetObjects(): void;
+    /**
+     * Elmetszuk az object-et egy clipping plane-nel
+     * @param items_sel
+     */
+    cutView(items_sel: any[]): void;
+    /**
+     * Letrehozzuk a clipping plane-eket
+     * @param localPlane
+     * @param planeGeom
+     * @param color
+     * @returns
+     */
+    createClippingPlane(localPlane: any, planeGeom: any, color: any): any;
+    /**
+     * Olyan materialt-t keszitunk, ami tamogatja a cutView-t
+     * @param object
+     * @param localPlane
+     */
+    createStencilMesh(object: any, localPlane: any): void;
+}

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

@@ -0,0 +1,38 @@
+import { SceneWrapper } from '../../../Model/SceneWrapper';
+import { MeshWrapper } from '../../../Model/MeshWrapper';
+import { TreeView } from '../../../UserInterface/UIComponents/TreeView';
+/**
+ * Exploded View
+ */
+export declare class ExplodedView {
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    treeView: TreeView;
+    readonly controls: any;
+    readonly treeJSON: any;
+    readonly input_text_explode: HTMLInputElement;
+    readonly input_range_explode: HTMLInputElement;
+    componentVIDToCenter: {};
+    components: {};
+    /**
+     * Constructor
+     */
+    constructor(sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper, treeView: TreeView);
+    /**
+     *
+     * @returns
+     */
+    getInitCenterPos(): {};
+    /**
+     * Exploded view kewszitese - component-ek eltolasa egy referencia ponthoz kepest radialis itanyba
+     * @param inputStart
+     * @param inputTarget
+     * @param dict
+     */
+    explodedView(inputStart: any, inputTarget: any, dict: any): void;
+    /**
+     * Kiszamoljuk a center point-ot, amihez kepest eltoljuk a component-eket/item-eket
+     * @returns
+     */
+    calcCenterPnts(): {};
+}

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

@@ -0,0 +1,46 @@
+import * as THREE from '../../../three/build/three.module.js';
+import { SceneWrapper } from "../../../Model/SceneWrapper";
+import { LoaderTools } from "../../../Loader/LoaderUtils";
+/**
+ * Geometry Visualisation
+ */
+export declare class GeomVisualisation {
+    sceneWrapper: SceneWrapper;
+    loaderTools: LoaderTools;
+    readonly controls: any;
+    readonly scene: any;
+    readonly currentCamera: any;
+    readonly renderer: any;
+    generalMeshMaterial: any;
+    customMeshMaterial: any;
+    generalLineMaterial: any;
+    customLineMaterial: any;
+    generalPointMaterial: any;
+    customPointMaterial: any;
+    grMesh: THREE.Group;
+    grLine: THREE.Group;
+    grPoint: THREE.Group;
+    /**
+     * Constructor.
+     */
+    constructor(sceneWrapper: SceneWrapper, loaderTools: LoaderTools);
+    /**
+     * A szürke (valamilyen magasabb rendu geometriahoz kotott, annak vonalainak vegen vagy metszeteben talalhato) vertex-eket jeleniti meg
+     */
+    /**
+     * A geometriahoz kotott vertex-ek megjelenitese/eltuntetese
+     */
+    showVertex_0(): void;
+    /**
+     * A sarga (szabadon allo) pontok megjelenitese/eltuntetese
+     */
+    showVertex_1(): void;
+    /**
+     * Edge-ek megjelenitese/eltuntetese
+     */
+    showLine(): void;
+    /**
+     * Face-ek megjelenitese/eltuntetese
+     */
+    showFace(): void;
+}

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

@@ -0,0 +1,54 @@
+import { SceneWrapper } from '../../../Model/SceneWrapper';
+/**
+ * Rotate
+ */
+export declare class Rotate {
+    sceneWrapper: SceneWrapper;
+    eye: any;
+    rotAxis: any;
+    camPos: any;
+    axis: any;
+    angle: any;
+    quaternion: any;
+    axisPos: any;
+    camToAxis: any;
+    axisX: any;
+    axisY: any;
+    axisZ: any;
+    labelX: any;
+    labelY: any;
+    labelZ: any;
+    camToStart_world: any;
+    camToStart_world_unit: any;
+    camToStart_length: any;
+    camToStart_local: any;
+    readonly currentCamera: any;
+    readonly controls: any;
+    readonly scene: any;
+    readonly renderer: any;
+    readonly camToStart: any;
+    /**
+     * Constructor.
+     */
+    constructor(sceneWrapper: SceneWrapper);
+    /**
+     * A kepernyore meroleges vektor korul oramutato jarasaval megegyezo iranyba forgat midnent
+     */
+    rotatePlus(): void;
+    /**
+     * A kepernyore meroleges vektor korul oramutato jarasaval ellentetes iranyba forgat midnent
+     */
+    rotateMinus(): void;
+    /**
+     *
+     */
+    camera(): void;
+    /**
+     *
+     */
+    axes(): void;
+    /**
+     *
+     */
+    labels(): void;
+}

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

@@ -0,0 +1,41 @@
+import { SceneWrapper } from '../../../Model/SceneWrapper';
+/**
+ * Screenshot
+ */
+export declare class Screenshot {
+    readonly myCanvas: HTMLCanvasElement;
+    readonly img_myCanvas: HTMLImageElement;
+    readonly img_labels: HTMLImageElement;
+    readonly sceneWrapper: any;
+    img_canvas: HTMLImageElement;
+    canvas: HTMLCanvasElement;
+    ctx: any;
+    a_labels: HTMLAnchorElement;
+    constructor(sceneWrapper: SceneWrapper);
+    /**
+     * Method to take a screenshot and return it as a File object.
+     * @returns Promise<File>
+     */
+    takeScreenshot(): Promise<string>;
+    /**
+     * Takes a screenshot of the provided element.
+     * @param element The element to take a screenshot of.
+     * @returns Promise<string> The data URL of the screenshot.
+     */
+    takeLabelScreenshot(element: HTMLElement): Promise<string>;
+    /**
+     *
+     * @returns
+     */
+    addBackgroundToCanvas(): Promise<unknown>;
+    /**
+     *
+     */
+    addObjectsToCanvas(): Promise<void>;
+    /**
+     * Add labels to canvas and return the final image URL.
+     * @param dataUrl The data URL of the labels image.
+     * @returns Promise<string> The data URL of the final canvas image.
+     */
+    addLabelsToCanvas(dataUrl: any): Promise<string>;
+}

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

@@ -0,0 +1,22 @@
+import { SceneWrapper } from '../../../Model/SceneWrapper';
+/**
+ * Views
+ */
+export declare class Views {
+    sceneWrapper: SceneWrapper;
+    /**
+     * Constructor.
+     * @param sceneWrapper
+     */
+    constructor(sceneWrapper: SceneWrapper);
+    /**
+     * Fit model (= center view)
+     */
+    fit(): void;
+    /**
+     * Oriented Views - ezek a 6 default nezet, melyek merolgesek a xyz iranyokra
+     * @param cameraPos
+     * @param cameraUp
+     */
+    orientedViews(cameraPos: any, cameraUp: any): void;
+}

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

@@ -0,0 +1,16 @@
+import { MeshWrapper } from "../../../Model/MeshWrapper";
+import { UIDGenerator } from "../../../Common/UIDGenerator/UIDGenerator";
+import { AddTreeItem } from "../ResponseHandler/AddTreeItem";
+export declare class AddContainer {
+    static instance: AddContainer;
+    meshWrapper: MeshWrapper;
+    uidGenerator: UIDGenerator;
+    addTreeItem: AddTreeItem;
+    constructor(meshWrapper: MeshWrapper, uidGenerator: UIDGenerator, addTreeItem: AddTreeItem);
+    static getInstance(): AddContainer;
+    /**
+     * Create an empty Folder at top level
+     * @param folderName
+     */
+    perform(containerName: string, containerUID?: number): void;
+}

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

@@ -0,0 +1,18 @@
+import { TaskUtils } from "../../TaskUtils";
+import { UIDGenerator } from "../../../Common/UIDGenerator/UIDGenerator";
+import { AddTreeItem } from "../ResponseHandler/AddTreeItem";
+export declare class AddFile {
+    static instance: AddFile;
+    taskUtils: TaskUtils;
+    uidGenerator: UIDGenerator;
+    addTreeItem: AddTreeItem;
+    element: HTMLElement;
+    div_treeHTML: HTMLElement;
+    itemToUnique: {};
+    constructor(taskUtils: TaskUtils, uidGenerator: UIDGenerator, addTreeItem: AddTreeItem);
+    static getInstance(): AddFile;
+    /**
+     * Add file to container at top-level right under a container or under a selected folder.
+     */
+    perform(itemName: string, parentUID: number, itemType: string, itemVID?: number, itemUID?: number): void;
+}

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

@@ -0,0 +1,16 @@
+import { AddTreeItem } from "../ResponseHandler/AddTreeItem";
+import { UIDGenerator } from "../../../Common/UIDGenerator/UIDGenerator";
+export declare class AddFolder {
+    static instance: AddFolder;
+    addTreeItem: AddTreeItem;
+    uidGenerator: UIDGenerator;
+    element: HTMLElement;
+    div_treeHTML: HTMLElement;
+    itemToUnique: {};
+    constructor(addTreeItem: AddTreeItem, uidGenerator: UIDGenerator);
+    static getInstance(): AddFolder;
+    /**
+     * Add folder to container at top-level right under a container or under a selected folder.
+     */
+    perform(itemName: string, parentUID: number, itemType: string, itemUID?: number): void;
+}

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

@@ -0,0 +1,5 @@
+export declare abstract class ITaskDefinition {
+    abstract getGuid(): string;
+    abstract perform(): boolean;
+    abstract undo(): boolean;
+}

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

@@ -0,0 +1,47 @@
+import { SceneWrapper } from "../../../Model/SceneWrapper";
+import { MeshWrapper } from "../../../Model/MeshWrapper";
+import { TreeStructure } from "../../../Tree/TreeStructure/TreeStructure";
+import { TreeCore } from "../../../Tree/TreeView/TreeCore";
+import { TreeOperations } from "../Tree";
+import { TreeView } from "../../../UserInterface/UIComponents/TreeView";
+export declare class Interactions_req {
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    treeStructure: TreeStructure;
+    treeCore: TreeCore;
+    treeView: TreeView;
+    treeOperations: TreeOperations;
+    selected: {};
+    constructor();
+    /**
+     * original: TreeWrapper/registerEventListener() + TreeWrapper/select()
+     * LMB on 'file' tree item
+     */
+    onClickFile(event: MouseEvent, summary: HTMLElement): void;
+    /**
+     * LMB on 'folder' tree item
+     */
+    onClickFolder(): void;
+    /**
+     * LMB on 'container' tree item
+     */
+    onClickContainer(): void;
+    /**
+     * RMB on 'file' tree item
+     */
+    onContextMenuFile(event: MouseEvent, summary: HTMLElement): void;
+    onClickCheckbox(event: MouseEvent, checkbox: HTMLInputElement): void;
+    /**
+     * RMB on 'folder' tree item
+     */
+    onContextMenuFolder(): void;
+    /**
+     * RMB on 'container' tree item
+     */
+    onContextMenuContainer(): void;
+    onToggleDisclosureWidget(summary: HTMLElement): void;
+    /**
+     * Toggles visibility of the corresponding part
+     */
+    onToggleCheckmark(): void;
+}

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

@@ -0,0 +1,6 @@
+export declare class RemoveFile {
+    private static _instance;
+    private constructor();
+    static getInstance(): RemoveFile;
+    perform(itemUID: number): void;
+}

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

@@ -0,0 +1,14 @@
+import { MeshWrapper } from "../../../Model/MeshWrapper";
+import { LoaderUtils } from "../../../Loader/LoaderUtils";
+import { TreeView } from "../../../UserInterface/UIComponents/TreeView";
+export declare class AddTreeItem {
+    meshWrapper: MeshWrapper;
+    loaderUtils: LoaderUtils;
+    treeView: TreeView;
+    constructor(meshWrapper: MeshWrapper, loaderUtils: LoaderUtils, treeView: TreeView);
+    /**
+     * Add a Container, File or Folder (= all of them are generally called "treeItem" or just "Item") manually to the tree
+     * @param {*} data
+     */
+    perform(data: {}): void;
+}

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

@@ -0,0 +1,3 @@
+export declare class Interactions_res {
+    selectItemByClickOnTreeItem(): void;
+}

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

@@ -0,0 +1,10 @@
+import { TreeStructure } from "../../../Tree/TreeStructure/TreeStructure";
+import { TreeCore } from "../../../Tree/TreeView/TreeCore";
+import { MeshWrapper } from "../../../Model/MeshWrapper";
+export declare class RemoveTreeItem {
+    treeStructure: TreeStructure;
+    treeCore: TreeCore;
+    meshWrapper: MeshWrapper;
+    constructor();
+    perform(data: {}): void;
+}

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

@@ -0,0 +1,5 @@
+/**
+     * Add a File (= Item) manually to the tree (= ResponseHandler)
+     * @param {*} data
+     */
+declare function createEmptyFile(data: {}): void;

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

@@ -0,0 +1,236 @@
+import { MeshWrapper } from '../../Model/MeshWrapper';
+import { SceneWrapper } from '../../Model/SceneWrapper';
+import { TreeView } from '../../UserInterface/UIComponents/TreeView';
+import { TaskUtils } from '../TaskUtils';
+import { LoaderTools, LoaderUtils } from '../../Loader/LoaderUtils';
+import { Appearance } from '../Context/Context';
+import { Loader } from '../../Loader/Loader';
+import { DeleteEntity } from '../Topbar/Delete/Delete';
+import { TaskHandler } from '../../TaskHandler/TaskHandler';
+import { Face } from '../../SelectionTools/SelectionFace';
+import { Unselection } from '../../SelectionTools/Unselection';
+/**
+ * Tree Operations
+ */
+export declare class TreeOperations {
+    static instance: TreeOperations;
+    meshWrapper: MeshWrapper;
+    sceneWrapper: SceneWrapper;
+    treeView: TreeView;
+    taskUtils: TaskUtils;
+    loaderUtils: LoaderUtils;
+    loaderTools: LoaderTools;
+    appearance: Appearance;
+    loader: Loader;
+    deleteEntity: DeleteEntity;
+    readonly div_treeHTML: HTMLElement;
+    readonly context_tree: HTMLElement;
+    readonly context_item: HTMLElement;
+    readonly parent: any;
+    grMesh: any;
+    grLine: any;
+    grPoint: any;
+    readonly selected: any;
+    readonly itemToUnique: {
+        [key: string]: string;
+    };
+    readonly scene: any;
+    readonly currentCamera: any;
+    readonly renderer: any;
+    readonly grEntityLabel: any;
+    data: any;
+    elements_all: any;
+    element_sel: any;
+    child_idx: any;
+    node_idx: any;
+    parentID: any;
+    element: any;
+    elements: any;
+    escapePressed: boolean;
+    positions: any;
+    normals: any;
+    treeJSON: any;
+    controls: any;
+    selected_elements: HTMLElement[];
+    selected_itemVIDs: any[];
+    dataset: {};
+    components: {};
+    fcs_viewer_div: HTMLDivElement;
+    readonly input_range_color: HTMLInputElement;
+    readonly input_rename: HTMLInputElement;
+    /**
+     * Constructor
+     */
+    constructor(meshWrapper: MeshWrapper, sceneWrapper: SceneWrapper, treeView: TreeView, taskUtils: TaskUtils, loaderUtils: LoaderUtils, loaderTools: LoaderTools, appearance: Appearance, loader: Loader, deleteEntity: DeleteEntity);
+    static getInstance(): TreeOperations;
+    /**
+     * Hide selected item
+     */
+    hideSelected(): Promise<void>;
+    /**
+     * Show selected item
+     */
+    showSelected(): Promise<void>;
+    /**
+     * Hide all
+     */
+    hideAll(): Promise<void>;
+    /**
+     * Show all
+     */
+    showAll(): Promise<void>;
+    /**
+     * Show selected items only
+     */
+    showOnlyItem(): Promise<void>;
+    /**
+     * Megkeresi az adott item-hez tartozo osszes tobbi item-et (file-t) es tovabbitja a show() fv-nek
+     * @param items
+     */
+    showItem(items: any): void;
+    /**
+     * Megkeresi az adott item-hez tartozo osszes tobbi item-et (file-t) es tovabbitja a hide() fv-nek
+     * @param items
+     */
+    hideItemsByUIDs(itemUIDs: any[]): void;
+    /**
+     * Toggles on checkbox for showable items in UI and makes them visible.
+     * @param itemVIDs VIDs of showable objects
+     */
+    showItemsByUIDs(itemUIDs: number[]): void;
+    /**
+     * Elemi fuggveny, mely ugy jeleniti meg az item-eket vagy azok komponenseit, hogy beleteszi oket az adott container-be
+     */
+    show(files: any[]): void;
+    /**
+     * Elemi fuggveny, mely ugy tunteni el az item-eket vagy azok komponenseit, hogy kiveszi oket az adott container-bol
+     */
+    hide(files: any[]): void;
+    /**
+     * Underlying method that sets OPACITY for elements that are available
+     * in the model tree.
+     * @param elementVID Element VID of item available in tree.
+     * @param opacityValue Value that should be in between
+     */
+    setOpacityForElementUID(elementUID: number, opacityValue: number): void;
+    /**
+     * Underlying method that sets COLOR for elements that are available
+     * in the model tree.
+     * @param elementVID Element VID of item available in tree.
+     * @param colorRGB Array of three integers [R, G, B]
+     */
+    setColorForElementUID(elementUID: number, colorRGB: number[]): void;
+    /**
+     * Sets the opacity of all selected elements.
+     */
+    setOpacity(selectedElements: HTMLElement[]): void;
+    /**
+     *
+     */
+    private sortByOpacity;
+    /**
+     * A treeView-ban kivalasztott item-eknek valtoztatja a szinet
+     */
+    setColor(selectedElements: HTMLElement[], cell: HTMLElement): void;
+    /**
+     * Rename selected item
+     */
+    rename(): void;
+    /**
+     * Make Item Current
+     */
+    makeCurrent(): void;
+    /**
+     * Move selecte item to a folder
+     */
+    move(): Promise<void>;
+    /**
+     * Copy an item and add it to another item
+     * Todo: nagyon regi kod. At kell irni!!!
+     */
+    copy(): Promise<void>;
+    /**
+     * Delete item from tree
+     * Todo: Nagyon regi kod. At kell irni!!!
+     */
+    delete(): void;
+    /**
+     * Ha script-bol torlunk, ez a function helyettesiti az egerrel valo kijelolest es szolgaltatja a szukseges adatokat
+     * @param removed_itemUIDs
+     */
+    generate_dataset(removed_itemUIDs: any[]): void;
+    /**
+     * Ezt a function-t hivjuk meg ha script-tel torlunk
+     * @param removed_itemUIDs
+     */
+    remove_from_document(removed_itemUIDs: number[]): void;
+    /**
+     * Torlesnel torli az adott component-et alkoto mesh, line, point object-eket a group-okbol
+     * Ez Elavult!!!
+     * @param item
+     */
+    update_Groups(item: {}): void;
+    /**
+     * A gyorsabb kereses erdekeben a tob-level item-ek a treeView-ban tartalmazzak az osszes tobbi item VID-jat, ami alattuk van child-kent
+     * Torles eseten ebbol a listabol kitoroljuk az adott item itemVID-jat
+     * @param TL_itemVID
+     * @param folder
+     * @param deleted_itemVIDs
+     */
+    update_includedVIDs(TL_itemVID: number, folder: {}, deleted_itemVIDs: number[]): void;
+    /**
+     * ha megtalaltuk a treeView-ban az adott item-et, annak path-jabol kiszedjuk az ot tartalmazo top-level item itemVID-jat
+     * @param fullPath
+     * @returns
+     */
+    getTopLevel(fullPath: any): number;
+    /**
+     * A kitorolni kivant item parent-jet adja vissza
+     * @param fullPath
+     * @returns
+     */
+    getParent(fullPath: any): any;
+    /**
+     * Torli a children-ek kozul a kijelolt itemVID-t
+     * @param fullPath
+     * @param parent
+     * @param itemVID
+     */
+    update_treeJSON(fullPath: any, parent: {}, itemVID: number): void;
+    /**
+     * Ha egy folder osszes elemet toroltuk, akkor hide-oljuk a disclosure widget-et es a show/hide check box fog megjelenni
+     * @param viewerIDs
+     * @param parent
+     * @param parentVID
+     */
+    hideWidget(viewerIDs: string[], parent: any, parentVID: string): void;
+    update_treeHTML(viewerIDs: string[], parent: any, itemVID: number, element: HTMLElement, folder: {}): void;
+    /**
+     * Visszaadja a kitorolni kivant item path-jet a treeView-ban
+     * @param file
+     * @returns
+     */
+    getFullPath(file: {}): any[];
+    /**
+     * Hide items and menus
+     */
+    hideInputRename(): void;
+}
+/**
+ *
+ */
+export declare class TreeSelection {
+    /**
+     * Azt definialja, hogy ha a tree-ben kattintunk, akkor highlight-olja az item-eket a viewport-ban
+     */
+    sceneWrapper: SceneWrapper;
+    meshWrapper: MeshWrapper;
+    taskHandler: TaskHandler;
+    face: Face;
+    treeView: TreeView;
+    unselection: Unselection;
+    scene: any;
+    currentCamera: any;
+    renderer: any;
+    constructor(sceneWrapper: SceneWrapper, meshWrapper: MeshWrapper, taskHandler: TaskHandler, face: Face, treeView: TreeView, unselection: Unselection);
+}