gs-bim-air 1.6.1-cae.3 → 1.6.1-cae.4

package/types/longan/src/longan/style.d.ts

@@ -0,0 +1,11 @@
+import { Segment } from "./segment";
+import { IKey } from "./utility";
+export declare class Style implements IKey {
+    _key: number;
+    get key(): number;
+    get segment(): Segment;
+    get conditions(): string;
+    constructor(key: number);
+    delete(): void;
+    equals(obj: IKey): boolean;
+}

package/types/longan/src/longan/utility.d.ts

@@ -0,0 +1,10 @@
+import { Camera } from "./segment";
+export interface IKey {
+    readonly key: number;
+    delete(): void;
+    equals(obj: IKey): boolean;
+}
+export declare function CreateKeyObject(key: number): IKey;
+export declare function deepClone(obj: any): any;
+export declare function guid(): string;
+export declare function CalculateNearFar(camera: Camera, min: Float64Array, max: Float64Array): void;

package/types/longan/src/longanLoad.d.ts

@@ -0,0 +1,10 @@
+export default class LonganLoad {
+    static onReady(): Promise<void>;
+    static import(src?: any): Promise<void>;
+    private static srcArr;
+    private static _isLoaded;
+    private static loadScript;
+    static set isLoaded(isLoaded: boolean);
+    static get isLoaded(): boolean;
+    constructor();
+}

package/types/longan/src/managers/animationManager.d.ts

@@ -0,0 +1,61 @@
+import { List, StringKeyList } from "../longan/gs.collections";
+import { Process } from "../process";
+import { ProcessManagerBase } from "./processManagerBase";
+export declare class AnimationManager extends ProcessManagerBase {
+    then: number;
+    beforeUpdateList: List<() => void>;
+    renderList: StringKeyList<{
+        isStop: boolean;
+        func: (deltaTime: number) => void;
+        roamTime?: number;
+        playTime?: number;
+    }>;
+    afterUpdateList: List<() => void>;
+    protected _running: boolean;
+    protected _roamPlaying: boolean;
+    get isRunning(): boolean;
+    constructor(process: Process);
+    /**
+     * 播放一个或多段动画.
+     * @param ids 缺省/null/undefined则为播放全部.
+     * @param keepRunning 保持不在ids的动画继续播放
+     */
+    run(ids?: string[], keepRunning?: boolean): void;
+    /**
+     * 停止全部动画播放
+     */
+    stop(): void;
+    /**
+     * 暂停某段动画
+     * @param id
+     * @returns 返回播放进度
+     */
+    pauseAnime(id: string): number;
+    /**
+     * 获取播放进度.
+     * @param id
+     * @returns
+     */
+    getPlayingPercent(id: string): number;
+    /**
+     * 停止一段动画,且将播放进度设为0
+     * @param id
+     */
+    stopAnime(id: string): void;
+    /**
+     *
+     * @param id 从头播放某段动画.
+     */
+    restartAnime(id: string): void;
+    /**
+     * 删除某段动画
+     * @param id
+     */
+    removeAnime(id: string): void;
+    /**
+     * 是否存在某段动画.
+     * @param id
+     * @returns
+     */
+    existAnime(id: string): boolean;
+}

package/types/longan/src/managers/asynTaskManager.d.ts

@@ -0,0 +1,20 @@
+import { ViewerManagerBase } from "./viewerManagerBase";
+export declare class AysnTaskManager extends ViewerManagerBase {
+    private asynTaskList_pro1;
+    private asynTaskList_pro2;
+    private asynTaskList_pro3;
+    private asynTaskList_pro4;
+    private asynTaskList_pro5;
+    private isRunning;
+    asynTask(task: any, params: any[], priority: number): void;
+    asynTaskManagerRun(): void;
+    removeTask(currentAsynTask: AsynTask): void;
+    clearTask(priority: number): void;
+    getTaskLength(priority: number): number;
+}
+export declare class AsynTask {
+    operation: (...value: any[]) => Promise<boolean>;
+    params: any[];
+    priority: number;
+    constructor(operation: (...value: any[]) => Promise<boolean>, params: any[], priority?: number);
+}

package/types/longan/src/managers/cloneManager.d.ts

@@ -0,0 +1,9 @@
+import { Process } from "../process";
+import { RenderObject } from "../objects/renderObject";
+import { PersistenceManager } from "./persistenceManager";
+export declare class CloneManager {
+    process: Process;
+    persistenceManager: PersistenceManager;
+    constructor(process: Process);
+    cloneObject(obj: any): RenderObject;
+}

package/types/longan/src/managers/collisionManager.d.ts

@@ -0,0 +1,25 @@
+import { CollisionType } from "../longan/gs.viewer";
+import { List } from "../longan/gs.collections";
+import { Segment } from "../longan/segment";
+import { Process } from "../process";
+import { ProcessManagerBase } from "./processManagerBase";
+import { Viewer } from "../viewer";
+export declare class CollisionManager extends ProcessManagerBase {
+    _oneList: List<Int32Array>;
+    _twoList: List<Int32Array>;
+    constructor(process: Process);
+    addTask(one: ArrayLike<Segment>, two: ArrayLike<Segment>): void;
+    clear(): void;
+    /**
+     *
+     * @param type
+     * @param cb 碰撞过程的回调
+     * @param co 单组碰撞结果触发
+     * @returns
+     */
+    compute(type: CollisionType, cb?: (viewer: Viewer, task_total: number, task_current: number, total: number, current: number) => void, co?: (viewer: Viewer, collisionList: Array<{
+        elements: Int32Array;
+        collsionPos: Float32Array;
+        collType: string;
+    }>) => void): Promise<number>;
+}

package/types/longan/src/managers/commandManager.d.ts

@@ -0,0 +1,35 @@
+import { StatePack } from "../history/statePack";
+import { DeltaState } from "../history/deltaState";
+import { List, Stack } from "../longan/gs.collections";
+import { Process } from "../process";
+import { Command } from "../workFlow/command";
+import { ProcessManagerBase } from "./processManagerBase";
+export declare class CommandManager extends ProcessManagerBase {
+    commandStack: Stack<Command>;
+    _previousCommand: Command;
+    protected isCommandChanging: boolean;
+    protected _defaultCommandType: any;
+    updateCommandUI: List<(process: Process, byState: boolean) => void>;
+    beforeCommandBegin: List<(process: Process, command: Command, byState: boolean) => void>;
+    beforeCommandEnd: List<(process: Process, command: Command, byState: boolean) => void>;
+    afterCommandBegin: List<(process: Process, command: Command, byState: boolean) => void>;
+    afterCommandEnd: List<(process: Process, command: Command, byState: boolean) => void>;
+    beforeCommandInterrupt: List<(process: Process, command: Command, byState: boolean) => void>;
+    beforeCommandRestore: List<(process: Process, command: Command, byState: boolean) => void>;
+    afterCommandRestore: List<(process: Process, command: Command, byState: boolean) => void>;
+    afterCommandInterrupt: List<(process: Process, command: Command, byState: boolean) => void>;
+    get defaultCommandType(): any;
+    set defaultCommandType(value: any);
+    get currentCommand(): Command;
+    get previousCommand(): Command;
+    get interruptedCommand(): Command;
+    constructor(process: Process);
+    private internalExecute;
+    execute(command: Command, deltaState?: DeltaState): StatePack;
+    private internalInterruptExecute;
+    interruptExecute(command: Command, deltaState?: DeltaState): StatePack;
+    interruptExecuteByState(command: Command): void;
+    terminateByState(command: Command): void;
+    terminateCurrentCommand(deltaState?: DeltaState): StatePack;
+    private handledDelatStateOnCommandEnd;
+}

package/types/longan/src/managers/dataManagerBase.d.ts

@@ -0,0 +1,22 @@
+import { NumberKeyList } from "../longan/gs.collections";
+export declare class DataManagerBase {
+    protected _datas: NumberKeyList<string>;
+    protected _currentKey: number;
+    protected _currentPath: string;
+    /**
+     * segmentKey和RO的映射表
+     */
+    static SegmentKeyMapRoNo: NumberKeyList<number>;
+    maxMultiCount: number;
+    get currentKey(): number;
+    get currentPath(): string;
+    get datas(): NumberKeyList<string>;
+    get keys(): number[];
+    get paths(): string[];
+    constructor();
+    hasKey(key: number, path: string): boolean;
+    addDatas(keys: number[], paths: string[], callback?: (key: any, path: any) => void): void;
+    removeDatas(keys: number[], paths: string[], callback?: (key: any, path: any) => void): void;
+    removeDatasByName(name: string): void;
+    removeAllDatas(): void;
+}

package/types/longan/src/managers/highlightManager.d.ts

@@ -0,0 +1,23 @@
+import { NumberKeyList } from "../longan/gs.collections";
+import { Viewer } from "../viewer";
+import { DataManagerBase } from "./dataManagerBase";
+import { StyleManagerBase } from "./styleManagerBase";
+import { ViewerManagerBase } from "./viewerManagerBase";
+export declare class HighlightManager extends ViewerManagerBase {
+    get highlightDatas(): NumberKeyList<string>;
+    styleManagerBase: StyleManagerBase;
+    dataManagerBase: DataManagerBase;
+    constructor(viewer: Viewer);
+    clearHighlightKeys(keys: number[], paths: string[]): void;
+    /**
+     * 取消所有隐藏
+     */
+    clearAllHighlight(): void;
+    /**
+     * 隐藏多个
+     * @param key
+     * @param path
+     */
+    highlightKeys(keys: number[], paths: string[]): void;
+    isKeyHighlight(key: number, path: string): boolean;
+}

package/types/longan/src/managers/historyManager.d.ts

@@ -0,0 +1,38 @@
+import { DeltaState } from "../history/deltaState";
+import { List } from "../longan/gs.collections";
+import { Process } from "../process";
+import { ProcessManagerBase } from "./processManagerBase";
+export declare class HistoryManager extends ProcessManagerBase {
+    private _rollBackInCommand;
+    protected _recordedStateCount: number;
+    protected _stateList: List<DeltaState>;
+    protected _currentStateIndex: number;
+    beforeRollBack: List<(process: Process, deltaState: DeltaState) => void>;
+    afterRollBack: List<(process: Process, deltaState: DeltaState) => void>;
+    beforeRollForward: List<(process: Process, deltaState: DeltaState) => void>;
+    afterRollForward: List<(process: Process, deltaState: DeltaState) => void>;
+    get recordedStateCount(): number;
+    set recordedStateCount(value: number);
+    get stateList(): List<DeltaState>;
+    get currentStateIndex(): number;
+    get currentState(): DeltaState;
+    lastState(): DeltaState;
+    get canRollBack(): boolean;
+    get canRollForward(): boolean;
+    get rollBackInCommand(): boolean;
+    set rollBackInCommand(value: boolean);
+    constructor(process: Process);
+    getDeltaStateByName(name: string): DeltaState;
+    addState(state: DeltaState): void;
+    addStateWithoutCommandHistoryHandle(state: DeltaState): void;
+    rollBack(): void;
+    rollForward(): void;
+    removeDeltaState(state: DeltaState): void;
+    removeOneDeltaStateByName(name: string): void;
+    removeDeltaStateByName(begin_state: DeltaState, name: string): void;
+    removeAllDeltaStateAfter(deltaState: DeltaState): void;
+    removeLastDeltaState(): void;
+    clearDeltaState(): void;
+    private removeHandledCommandState;
+    disposeStates(): void;
+}

package/types/longan/src/managers/invisibleManager.d.ts

@@ -0,0 +1,25 @@
+import { NumberKeyList } from "../longan/gs.collections";
+import { Segment } from "../longan/segment";
+import { Viewer } from "../viewer";
+import { DataManagerBase } from "./dataManagerBase";
+import { StyleManagerBase } from "./styleManagerBase";
+import { ViewerManagerBase } from "./viewerManagerBase";
+export declare class InvisibleManager extends ViewerManagerBase {
+    get invisibleStyleSegment(): Segment;
+    get invisibleDatas(): NumberKeyList<string>;
+    styleManagerBase: StyleManagerBase;
+    dataManagerBase: DataManagerBase;
+    constructor(viewer: Viewer);
+    clearInvisibleKeys(keys: any, paths: any): void;
+    /**
+     * 取消所有隐藏
+     */
+    clearAllInvisible(): void;
+    /**
+     * 隐藏多个
+     * @param key
+     * @param path
+     */
+    invisibleKeys(keys: any, paths: any): void;
+    isKeyInvisible(key: any, path: any): boolean;
+}

package/types/longan/src/managers/isolationManager.d.ts

@@ -0,0 +1,25 @@
+import { NumberKeyList } from "../longan/gs.collections";
+import { Segment } from "../longan/segment";
+import { Viewer } from "../viewer";
+import { DataManagerBase } from "./dataManagerBase";
+import { StyleManagerBase } from "./styleManagerBase";
+import { ViewerManagerBase } from "./viewerManagerBase";
+export declare class IsolationManager extends ViewerManagerBase {
+    get isolationStyleSegment(): Segment;
+    get isolationDatas(): NumberKeyList<string>;
+    styleManagerBase: StyleManagerBase;
+    dataManagerBase: DataManagerBase;
+    constructor(viewer: Viewer);
+    clearIsolationKeys(keys: any, paths: any): void;
+    /**
+     * 取消所有隐藏
+     */
+    clearAllIsolation(): void;
+    /**
+     * 隐藏多个
+     * @param key
+     * @param path
+     */
+    isolationKeys(keys: any, paths: any): void;
+    isKeyIsolation(key: any, path: any): boolean;
+}

package/types/longan/src/managers/operatorManager.d.ts

@@ -0,0 +1,14 @@
+import { List } from "../longan/gs.collections";
+import { Viewer } from "../viewer";
+import { ViewerOperator } from "../operators/viewerOperator";
+import { ViewerManagerBase } from "./viewerManagerBase";
+export declare class OperatorManager extends ViewerManagerBase {
+    operatorList: List<ViewerOperator>;
+    constructor(viewer: Viewer);
+    add(opt: ViewerOperator): void;
+    remove(opt: ViewerOperator): void;
+    removeT(type: string): void;
+    clear(): void;
+    find<T extends ViewerOperator>(type: string): T | null;
+    findByType(type: any): ViewerOperator;
+}

package/types/longan/src/managers/persistenceManager.d.ts

@@ -0,0 +1,38 @@
+import { List, StringKeyList } from "../longan/gs.collections";
+import { Process } from "../process";
+import { RenderObject } from "../objects/renderObject";
+export declare class PersistenceManager {
+    instanceToLoad: number;
+    referceLightModelMCAToLoad: number;
+    process: Process;
+    typeList: StringKeyList<any>;
+    loadList: List<any>;
+    xhrList: List<XMLHttpRequest>;
+    oneModelLoaded: List<(ro: RenderObject) => void>;
+    modelLoaded: List<() => void>;
+    allModelLoaded: List<() => void>;
+    referenceObjectLoaded: List<(bb: any) => void>;
+    /**
+     * 当前正在请求实例(referenceLightModel数据.)
+     */
+    hasInstance: boolean;
+    referencedObjects: StringKeyList<any>;
+    private counter;
+    static loadAction: (ro: RenderObject) => {
+        url: any;
+        httpType: any;
+    } | null;
+    static save(ro: RenderObject): any;
+    static open(obj: any): RenderObject;
+    constructor(process: Process);
+    open(model: any): RenderObject;
+    save(ro: RenderObject): any;
+    registerNativeTypes(): void;
+    registerType(type: string, prototype: any): void;
+    fileNameFromHeader(disposition: any): string;
+    loadModels(): Promise<void>;
+    protected getDataByXhr(modelObject: any, len: any): void;
+    protected roModelLoaded(modelObject: any, data: any, len: any, ...args: any[]): void;
+    protected deserializeObject(obj: any): RenderObject;
+    protected serializeObject(ro: RenderObject): any;
+}

package/types/longan/src/managers/processManagerBase.d.ts

@@ -0,0 +1,6 @@
+import { Process } from "../process";
+export declare class ProcessManagerBase {
+    protected _process: Process;
+    get process(): Process;
+    constructor(process: Process);
+}

package/types/longan/src/managers/selectionManager.d.ts

@@ -0,0 +1,63 @@
+import { RenderObject } from "../objects/renderObject";
+import { Viewer } from "../viewer";
+import { DataManagerBase } from "./dataManagerBase";
+import { ViewerManagerBase } from "./viewerManagerBase";
+export declare class SelectionKey {
+    protected _key: number;
+    protected _position: Float32Array;
+    protected _winPosition: Float32Array;
+    protected _path: string;
+    protected _pathKeys: Int32Array;
+    protected _indexes: Int32Array;
+    get key(): number;
+    get position(): Float32Array;
+    get winPosition(): Float32Array;
+    get path(): string;
+    get pathKeys(): Int32Array;
+    get indexes(): Int32Array;
+    constructor(key: number, position: Float32Array, path: string, pathKeys: Int32Array, indexes: Int32Array);
+}
+export declare class SelectionManager extends ViewerManagerBase {
+    dataManagerBase: DataManagerBase;
+    get selectedKey(): number;
+    get selectedPath(): string;
+    get selectedKeys(): number[];
+    get selectedPaths(): string[];
+    get selectedDatas(): import("..").NumberKeyList<string>;
+    get selectedRenderObject(): RenderObject;
+    get selectedRenderObjects(): RenderObject[];
+    constructor(viewer: Viewer);
+    static getCondition(path: any): string;
+    /**
+     * 取消多个选择
+     * @param key
+     */
+    clearSelectionKeys(keys: number[], paths: string[]): void;
+    /**
+     * 取消所有隐藏
+     */
+    clearAllSelection(): void;
+    /**
+     * 隐藏多个
+     * @param key
+     * @param path
+     */
+    selectKeys(keys: number[], paths: string[]): void;
+    isKeySelected(key: number, path: string): boolean;
+    /**
+     * 清楚多个选择与高亮
+     */
+    clearSelectionAndHighlightKeys(keys: number[], paths: string[]): void;
+    /**
+     * 清除所有选择与高亮
+     */
+    clearAllSelectionAndHighlight(): void;
+    /**
+     * 在当前基础上选择与高亮
+     */
+    selectAndHighlightKeys(keys: number[], paths: string[]): void;
+    /**
+     * 清除当前的选择与高亮
+     */
+    clearCurrentSelectionAndHighlght(): void;
+}

package/types/longan/src/managers/styleManagerBase.d.ts

@@ -0,0 +1,8 @@
+import { Segment } from "../longan/segment";
+export declare class StyleManagerBase {
+    protected _styleSegment: Segment;
+    get styleSegment(): Segment;
+    constructor(styleSegment: Segment);
+    setStyles(keys: any, paths: any): void;
+    unsetStyles(keys: any, paths: any): void;
+}

package/types/longan/src/managers/synchronManager.d.ts

@@ -0,0 +1,24 @@
+import { ViewerManagerBase } from "./viewerManagerBase";
+import { Viewer } from "../viewer";
+export declare class SynchronManager extends ViewerManagerBase {
+    private synchronList;
+    private _currentIndex;
+    private _indexList;
+    private _isUpdating;
+    private _batchUpdate;
+    private _isMngRunning;
+    get batchUpdate(): boolean;
+    set batchUpdate(value: boolean);
+    constructor(viewer: Viewer);
+    batchBegin(): void;
+    batchEnd(): Promise<void>;
+    sync(operation: (...values: any[]) => void, params: any[]): Promise<void>;
+    syncRun(): Promise<void>;
+    checkIsFirst(index: number): boolean;
+    synchronization(): void;
+}
+export declare class SynchronObj {
+    operation: (...values: any[]) => void;
+    params: any[];
+    constructor(operation: (...values: any[]) => void, params: any[]);
+}

package/types/longan/src/managers/taskManager.d.ts

@@ -0,0 +1,36 @@
+import { List } from "../longan/gs.collections";
+import { Task } from "../workFlow/task";
+import { ProcessManagerBase } from "./processManagerBase";
+import { DeltaState } from "../history/deltaState";
+import { StatePack } from "../history/statePack";
+import { Process } from "../process";
+export declare class TaskManager extends ProcessManagerBase {
+    private _taskStack;
+    private _previousTask;
+    taskPrepare: List<(sender: Task) => void>;
+    taskClean: List<(sender: Task, event: string) => void>;
+    taskInterupt: List<(sender: Task, event: string) => void>;
+    taskRestore: List<(sender: Task, event: string) => void>;
+    taskPrepareByState: List<(sender: Task, event: string) => void>;
+    taskCleanByState: List<(sender: Task, event: string) => void>;
+    taskInteruptByState: List<(sender: Task, event: string) => void>;
+    taskRestoreByState: List<(sender: Task, event: string) => void>;
+    get currentTask(): Task;
+    get previousTask(): Task;
+    set previousTask(value: Task);
+    get InterruptedTask(): Task;
+    constructor(process: Process);
+    execute(task: Task, deltaState?: DeltaState): StatePack;
+    executeByState(task: Task): void;
+    finishByState(task: Task): void;
+    finishCurrentTask(deltaState?: DeltaState): StatePack;
+    setOriginal(): void;
+    onTaskInterupt(sender: Task, e: string): void;
+    onTaskPrepare(sender: Task, e: string): void;
+    onTaskInteruptByState(sender: Task, e: string): void;
+    onTaskPrepareByState(sender: Task, e: string): void;
+    onTaskCleanByState(sender: Task, e: string): void;
+    onTaskRestoreByState(sender: Task, e: string): void;
+    onTaskClean(sender: Task, e: string): void;
+    onTaskRestore(sender: Task, e: string): void;
+}

package/types/longan/src/managers/viewerManagerBase.d.ts

@@ -0,0 +1,6 @@
+import { Viewer } from "../viewer";
+export declare class ViewerManagerBase {
+    protected _viewer: Viewer;
+    get viewer(): Viewer;
+    constructor(viewer: Viewer);
+}

package/types/longan/src/objects/cube.d.ts

@@ -0,0 +1,14 @@
+import { RenderObject } from "./renderObject";
+export declare class Cube extends RenderObject {
+    typeName: string;
+    _name: string;
+    _image: string;
+    _expanded: boolean;
+    _length: number;
+    get length(): number;
+    set length(value: number);
+    constructor();
+    render(): void;
+    serialize(): any;
+    deserialize(obj: any): void;
+}

package/types/longan/src/objects/earthLabelObjectList.d.ts

@@ -0,0 +1,15 @@
+import { Viewer } from "../viewer";
+import { RenderObject } from "./renderObject";
+export declare class EarthLabelObjectList extends RenderObject {
+    typeName: string;
+    _name: string;
+    _idList: string[];
+    _lonlatList: number[];
+    _typeList: number[];
+    static updatePosition: any;
+    markerkeyList: number[];
+    constructor();
+    serialize(): any;
+    deserialize(obj: any): void;
+    afterInstantiate(viewer: Viewer, instanceObj: any): void;
+}