;
}
}
declare module "sk/frame/logic/editor/component/UiSafeLogicEditorContainer" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { UiSafeContainer, UiSafeContainerProps, UiSafeContainerState } from 'foundation/editor/ui/core/UiSafeContainer';
import { UiLogicEditorEvent } from "sk/frame/logic/editor/component/UiLogicEditorEvent";
import { UiLogicEditorPanel } from "sk/frame/logic/editor/component/UiLogicEditorPanel";
export interface UiSafeLogicEditorContainerProps extends UiSafeContainerProps {
}
export interface UiSafeLogicEditorContainerState extends UiSafeContainerState {
}
export class UiSafeLogicEditorContainer extends UiSafeContainer {
protected _editorPanel: UiLogicEditorPanel;
componentDidMount(): void;
componentWillUnmount(): void;
onEditorEntityChanged(context: ListenerContext, event: UiLogicEditorEvent): void;
onEditorActionAsync(context: ListenerContext, event: UiLogicEditorEvent): Promise;
}
}
declare module "sk/frame/logic/editor/component/EditorPropertyPanel" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { DataNode } from 'foundation/data/common/model/base/DataNode';
import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
import { UiLogicEditorContainer } from "sk/frame/logic/editor/component/UiLogicEditorContainer";
import { UiLogicEditorEvent } from "sk/frame/logic/editor/component/UiLogicEditorEvent";
import { UiSafeLogicEditorContainerProps, UiSafeLogicEditorContainerState } from "sk/frame/logic/editor/component/UiSafeLogicEditorContainer";
export enum EditorPropertyStyleType {
label = 0,
inputText = 1,
inputNumber = 2,
slider = 3,
checkbox = 4,
button = 5,
frame = 6,
config = 7,
textNumber = 8,
select = 9
}
export type EditorPropertyOption = {
max?: number;
min?: number;
step?: number;
digit?: number;
};
export type EditorPropertyConfig = {
key: string;
name: string;
element_name?: string;
label: string;
type: EditorPropertyStyleType;
style?: any;
frame?: any;
enable?: boolean;
option?: EditorPropertyOption;
mode?: string;
};
export interface EditorPropertyPanelProps extends UiSafeLogicEditorContainerProps {
}
export interface EditorPropertyPanelState extends UiSafeLogicEditorContainerState {
selectEntity: any;
}
export class EditorPropertyPanel extends UiLogicEditorContainer {
state: EditorPropertyPanelState;
selectEntities: any[];
protected configs: EditorPropertyConfig[];
protected newEntity: DataNode;
protected oldEntity: DataNode;
protected _coordService: CoordService;
get selectEntity(): any;
get editorEntity(): any;
UNSAFE_componentWillMount(): void;
componentWillUnmount(): void;
onEditorEntityChanged(context: ListenerContext, event: UiLogicEditorEvent): void;
onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
onValueChange(config: EditorPropertyConfig, value: any): void;
onButtonCilck: (e: any) => void;
onInputeTextChange(config: EditorPropertyConfig): (value: any) => void;
onInputeTextPressEnter(config: EditorPropertyConfig): (e: any) => void;
onInputeNumberChange(config: EditorPropertyConfig): (value: any) => void;
onInputTextNumberPressEnter(config: EditorPropertyConfig): (event: any) => void;
onInputTextNumberChange(config: EditorPropertyConfig): (event: any) => void;
onInputeNumberPressEnter(config: EditorPropertyConfig): (e: any) => void;
onSliderChange(config: EditorPropertyConfig): (value: any) => void;
onSliderAfterChange(config: EditorPropertyConfig): (value: any) => void;
onModeChange: (mode: string) => void;
protected convertLocalNumberToUser(name: string, value: number): number;
protected makeContents(): any;
makeSelect(list: any[], i: number, config: EditorPropertyConfig, state: EditorPropertyPanelState): any;
render(): JSX.Element;
}
}
declare module "sk/frame/logic/editor/action/PropertyChangeEvent" {
import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
import { EditorPropertyConfig } from "sk/frame/logic/editor/component/EditorPropertyPanel";
export class PropertyChangeEvent extends ContentActionEvent {
values: any;
multi: boolean;
configs: EditorPropertyConfig[];
document: SchemeDocument;
free(): void;
}
}
declare module "sk/frame/logic/editor/action/PropertyChangeAction" {
import { SchemeAction } from 'sk/editor/scheme/action/SchemeAction';
import { EditorPropertyConfig } from "sk/frame/logic/editor/component/EditorPropertyPanel";
import { PropertyChangeEvent } from "sk/frame/logic/editor/action/PropertyChangeEvent";
export class PropertyChangeAction extends SchemeAction {
oldValues: any;
newValues: any;
configs: EditorPropertyConfig[];
entity: any;
constructor();
onExecute(event: PropertyChangeEvent): void;
onUndo(): boolean;
onRedo(): boolean;
private isValid;
performCalculation(element: any): void;
}
}
declare module "sk/frame/logic/editor/base/base/EditorLayer" {
import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
export class EdiorLayer extends InstanceObject {
name: string;
container: FamilyInstanceNode;
visible: boolean;
dispose(): void;
}
}
declare module "sk/frame/logic/editor/base/base/LayerContontrllerEvent" {
import { EventObject } from 'cross/runtime/lang/EventObject';
import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
export class LayerContrllerEvent extends EventObject {
name: string;
container: FamilyInstanceNode;
visible: boolean;
free(): void;
}
}
declare module "sk/frame/logic/editor/base/base/LayerContrllerEventEnum" {
export class LayerContrllerEventEnum {
static Add: string;
static Init: string;
static Delete: string;
static Switch: string;
static VisibleChange: string;
}
}
declare module "sk/frame/logic/editor/base/util/AssembleEditorViewUtil" {
import { Matrix4 } from 'foundation/runtime/math/Matrix4';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { DataNode } from 'foundation/data/common/model/base/DataNode';
import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
export class AssembleEditorViewUtil {
static projectModelOutlineToTargetSpace(node: ContentNode, observeAxis: Vector3, targetMatrix: Matrix4): Vector2[];
static switchVisible(node: DataNode, visible: boolean): void;
static setNodeVisible(node: BrepNode, visible: boolean): void;
static switchOptionMove(node: ContentNode, move: boolean): void;
static setOptionMove(node: ContentNode, move: boolean): void;
}
}
declare module "sk/frame/logic/editor/base/base/LayerControlService" {
import { Service } from 'cross/runtime/module/Service';
import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
import { EdiorLayer } from "sk/frame/logic/editor/base/base/EditorLayer";
export class LayerControlService extends Service {
layers: Array;
currentVisibleLayers: Array;
currentControlLayer: EdiorLayer;
constructor();
switchControlLayer(name: string): void;
switchVisibleLayer(name: string): void;
register(): void;
getCurrentLayer(): string[];
pushLayer(layer: FamilyInstanceNode, name?: string, visible?: boolean): void;
hideDecorateLayer(): void;
switchLayer(name: string, visible: boolean): void;
switchLayerOptionMove(name: string, all: boolean): void;
switchLayerNoDispatch(name: string, visible: boolean): void;
resetLayer(name: string): void;
displayAll(): void;
init(): void;
protected dispatchLayerChangeEvent(layer: EdiorLayer): void;
private canSendMessage;
}
}
declare module "sk/frame/logic/editor/base/base/StateControllerEvent" {
import { EventObject } from 'cross/runtime/lang/EventObject';
export class StateControllerEvent extends EventObject {
name: string;
free(): void;
}
}
declare module "sk/frame/logic/editor/base/base/StateControllerEventEnum" {
export class StateControllerEventEnum {
static SurfaceDesign: string;
static CreviceDesign: string;
static CreviceEditor: string;
static CreviceEditorInnerBase: string;
static CreviceEditorOuterBase: string;
static CreviceEditorBase: string;
static CreviceEditorSurface: string;
static ReCaculateArea: string;
static ReCaculateHardware: string;
static Default: string;
static Switch: string;
static ViewInwall: string;
static ViewOuterWall: string;
static ViewTop: string;
static PartitionPlank: string;
static ArrayCommand: string;
static RefreshTree: string;
}
}
declare module "sk/frame/logic/editor/base/base/StateControlService" {
import { Service } from 'cross/runtime/module/Service';
export class StateControlService extends Service {
private current;
active(): void;
deactive(): void;
getCurrentstate(): string;
setCurrentState(value: string): void;
init(): void;
protected dispatchLayerChangeEvent(value: string): void;
}
}
declare module "sk/frame/logic/editor/base/util/AssembleNodeUtil" {
import { Line2 } from 'foundation/runtime/math/Line2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { DataNode } from 'foundation/data/common/model/base/DataNode';
import { BrepNode } from 'foundation/data/common/model/brep/BrepNode';
import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
import { HoleStructure } from 'foundation/data/common/structure/HoleStructure';
import { OperateLineNode } from 'sk/data/family/model/assistant/operate/OperateLineNode';
import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
import { PlaneNode } from 'sk/data/family/model/instance/PlaneNode';
import { PlankEntity } from 'sk/editor/logic/entity/PlankEntity';
export class AssembleNodeUtil {
static getEditorPolygonOnUserCoord(node: PatternInstanceNode): Array;
static getContentCenterOnUserCoord(node: ContentNode): Vector2;
static getPolygonOnUserCoord(entity: ContentNode): Array;
static getPlaneNodePolygonOnUserCoord(entity: PlaneNode): Array;
static getPlaneNodePolygonOnParentCoord(entity: PlaneNode): Array;
static getContentNodePolygonOnUserCoord(node: ContentNode): Array;
static getContentNodePolygonOnParentCoord(node: ContentNode): Array;
static getHoleStructurePolygonOnUserCoord(hole: HoleStructure, parent: ContentNode): Array;
static getLine2OnUserCoord(line: Line2, parent: ContentNode): Line2;
static getLocalPointOnUserCoord(point: Vector2, entity: OperateLineNode): Vector2;
static getObjPosFromUser(entity: PlankEntity, point: Vector2): Vector2;
static getProxyParent(node: BrepNode): PatternInstanceNode;
static dirtyRootParent(node: BrepNode): void;
static isExistParent(entity: DataNode, name: string): boolean;
static getContainerChildByName(node: ContentNode, name: string): ContainerNode;
}
}
declare module "sk/frame/logic/editor/base/editor/Inference" {
import { Types } from 'cross/runtime/lang/collection/Types';
import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
import { Line2 } from 'foundation/runtime/math/Line2';
import { Value2 } from 'foundation/runtime/math/Value2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { SnapRectInfo } from 'sk/editor/scheme/floorplan/view/canvas2d/inference/Inference';
import { CowallEntity } from 'sk/editor/scheme/floorplan/entity/CowallEntity';
import { FloorplanEntity } from 'sk/editor/scheme/floorplan/entity/FloorplanEntity';
import { C2dCanvasContext } from 'sk/editor/logic/view/canvas2d/C2dCanvasContext';
export type SnapInfo = {
pos: Vector2;
location: Vector2;
host?: any;
conent: any;
dis: number;
rate?: number;
type: SnapType;
score: number;
};
export enum SnapType {
Default = 0,
HistoryPoint = 1,
Corner = 2,
Center = 3,
EdgeCenter = 4,
AxisCorner = 5,
Anchor = 6,
HistoryLine = 7,
Edge = 8,
Line = 9,
AxisLine = 10,
CrossLine = 11,
CrossPoint = 12,
LineLineCross = 13
}
export type SnapPoint = {
point: Vector2;
type: SnapType;
target: any;
};
export type SnapLine = {
from: Vector2;
to: Vector2;
type: SnapType;
target: any;
};
export type CalcualteOption = {
isCrossLine?: boolean;
findAllSnapPts?: boolean;
isCorner?: boolean;
isCenterPoint?: boolean;
onlyPedal?: boolean;
};
export class Inference extends InstanceObject {
context: C2dCanvasContext;
protected _snapLines: Types;
protected _snapPoints: Types;
protected _snapEdgeCenterPoints: Types;
protected _snapCornerPoints: Types;
protected _snapAxiss: Types;
protected _snapLineCrossPoints: Types;
protected _alignTolerance: number;
snapOffset: number;
option: CalcualteOption;
floorplan: FloorplanEntity;
protected _snapWalls: Types;
protected _snapRectList: Types;
_lastSnappedLine: any;
snapPixelOffset: number;
enableWalls: boolean;
_orthogonalSnapLines: Array;
enableWallBorders: boolean;
enableWallAxes: boolean;
enableCrossOrthoCross: boolean;
enableBeamBorders: boolean;
enableBeamAxes: boolean;
firstPoint: Vector2;
constructor(option?: CalcualteOption);
get snapPoints(): Types;
get snapEdgeCenterPoints(): Types;
get snapCornerPoints(): Types;
get snapLineCrossPoints(): Types;
clear(): void;
setup(): void;
addRect(pos: Vector2, lenX: number, lenY: number, rot: number): void;
sort(infos: Array): void;
addSnapLine(line: SnapLine): void;
setOrthogonalSnapLines(lines: Array): void;
setSnapWalls(cowalls: Types): void;
snapLine(point: Vector2, line: SnapLine): SnapInfo;
addSnapAxis(line: SnapLine): void;
snapAxis(point: Value2, line: SnapLine): SnapInfo;
addSnapPoint(point: SnapPoint): void;
addSnapCornorPoint(point: SnapPoint): void;
addSnapEdgeCenterPoint(point: SnapPoint): void;
addSnapLineCrossPoint(point: SnapPoint): void;
protected getSnapPoints(): void;
private snapPoint;
private snapPosition;
private snapCrossLine;
snapCrossPoint(point: Vector2): SnapInfo;
removeRepeatVertices(gridVertices: Array): Array;
solve(point: Vector2, firstPt?: Vector2): Array;
snapAnchor(firstPt: Vector2, point: Vector2, line: SnapLine): SnapInfo;
reset(): void;
dispose(flag?: boolean): void;
}
}
declare module "sk/frame/logic/editor/base/editor/PointInference" {
import { Types } from 'cross/runtime/lang/collection/Types';
import { Line2 } from 'foundation/runtime/math/Line2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
import { HoleStructure } from 'foundation/data/common/structure/HoleStructure';
import { AreaPolygonNode } from 'sk/data/family/model/brep/area/AreaPolygonNode';
import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
import { CalcualteOption, Inference, SnapInfo, SnapLine, SnapPoint } from "sk/frame/logic/editor/base/editor/Inference";
export class SnapOption {
isCorner?: boolean;
isEdge?: boolean;
isBoxCenterLine?: boolean;
isEdgeCenter?: boolean;
isCenter?: boolean;
isTerminal?: boolean;
isPedal?: boolean;
isMid?: boolean;
isCirclrAxis?: boolean;
constructor();
centerMode(): void;
edgeMode(): void;
midMode(): void;
}
export class PointInference extends Inference {
constructor(option?: CalcualteOption);
setContents(contents: Array, option: SnapOption): void;
setContent(content: ContentNode, option: SnapOption): void;
setHoleStructureGroups(holes: Array>, host: ContentNode, option: SnapOption): void;
appendPoints(points: Vector2[], content: ContentNode): void;
appendLines(lines: Line2[], content: ContentNode): void;
calculateLineCrossPoints(): void;
protected setSnapPoints(points: Vector2[], content: any, option: SnapOption): void;
protected setSnapHolesStructure(hole: HoleStructure, host: ContentNode, option: SnapOption): void;
protected setSnapHolesGroup(holeGroup: Array, host: ContentNode): void;
snapContent(entity: ContentNode, position: Vector2): Array;
snapArea(entity: AreaPolygonNode, offset: Vector2): Array;
snapPos(position: Vector2): Array;
get snapLines(): Types;
setLines(contents: Array, option: SnapOption): void;
setPoint(point: Vector3): void;
setHistoryPoints(contents: Array, option: SnapOption): void;
setPatternInstance(pattern: PatternInstanceNode, option: SnapOption): void;
setPolygons(points: Array, option: SnapOption): void;
}
}
declare module "sk/frame/logic/editor/base/editor/C2dEditorMoveAction" {
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
import { ContentInstanceElement } from 'sk/data/family/element/instance/ContentInstanceElement';
import { FamilyInstanceActionEvent } from 'sk/editor/scheme/action/instance/FamilyInstanceActionEvent';
import { SchemeAction } from 'sk/editor/scheme/action/SchemeAction';
import { PointInference } from "sk/frame/logic/editor/base/editor/PointInference";
export class C2dEditorMoveAction extends SchemeAction {
entities: Array;
entity: ContentNode;
elements: Array;
element: ContentInstanceElement;
protected _basePoint: Vector3;
protected _baseOffset: Vector3;
ignoreSnapOffset: any;
currentPositon: Vector3;
protected _oldData: any;
protected _newData: any;
protected snapOffset: number;
snapScreenOffset: number;
defaultSnapOffset: number;
inference: PointInference;
protected _coordService: CoordService;
constructor();
onExecute(event: FamilyInstanceActionEvent): void;
protected setSnapContent(): void;
protected saveOldData(): void;
protected saveNewData(): void;
doSnap(location: Vector3, offset: Vector3, event: ContentActionEvent): Vector3;
protected isContentMoved(): boolean;
move(offset: Vector3, event: ContentActionEvent): Vector3;
moveTo(point: Vector3): void;
moveOffset(offset: Vector3): void;
getUserLocation(point: Vector3): Vector3;
protected computeMove(): void;
onMoveEnd(): void;
onMove(event: ContentActionEvent): void;
onMoveTo(event: ContentActionEvent): void;
protected onMoveStart(event: ContentActionEvent): void;
protected onMouseMove(event: ContentActionEvent): void;
onReceive(code: string, event: ContentActionEvent): boolean;
onUndo(): void;
onRedo(): void;
}
}
declare module "sk/frame/logic/editor/base/editor/C2dPlankMoveAction" {
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { FamilyInstanceActionEvent } from 'sk/editor/scheme/action/instance/FamilyInstanceActionEvent';
import { C2dEditorMoveAction } from "sk/frame/logic/editor/base/editor/C2dEditorMoveAction";
export class C2dPlankMoveAction extends C2dEditorMoveAction {
constructor();
onExecute(event: FamilyInstanceActionEvent): void;
doSnap(location: Vector3, offset: Vector3, event: FamilyInstanceActionEvent): Vector3;
}
}
declare module "sk/frame/logic/editor/base/display/C2dActionMoveGizmo" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { KeyboardDeviceService } from 'cross/editor/device/keyboard/KeyboardDeviceService';
import { MouseDeviceService } from 'cross/editor/device/mouse/MouseDeviceService';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
import { W2dTemp } from 'sk/editor/scheme/floorplan/view/canvas2d/W2dTemp';
import { FamilyInstanceActionEvent } from 'sk/editor/scheme/action/instance/FamilyInstanceActionEvent';
import { C2dCanvas } from 'sk/editor/logic/view/canvas2d/C2dCanvas';
import { C2dCanvasContext } from 'sk/editor/logic/view/canvas2d/C2dCanvasContext';
import { C2dPlankMoveAction } from "sk/frame/logic/editor/base/editor/C2dPlankMoveAction";
export class C2dActionMoveGizmo extends W2dTemp {
view: C2dCanvas;
context: C2dCanvasContext;
action: C2dPlankMoveAction;
graphic: V2dGraphicDrawing;
protected _pos: Vector2;
protected _originPos: Vector2;
protected _keyboardService: KeyboardDeviceService;
protected _mouseService: MouseDeviceService;
constructor();
setup(): void;
private drawLine;
private isValid;
drawGraphic(): void;
draw(): void;
onMouseDown(sender: ListenerContext, event: V2dHookEvent): void;
onDragMove(sender: ListenerContext, event: FamilyInstanceActionEvent): void;
onScaleChanged(): void;
addToView(): void;
dispose(): void;
}
}
declare module "sk/frame/logic/editor/base/display/C2dContentCornerGizmo" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { KeyboardDeviceEvent } from 'cross/editor/device/keyboard/KeyboardDeviceEvent';
import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
import { ActionEvent } from 'foundation/editor/view/action/ActionEvent';
import { ActionService } from 'foundation/editor/view/action/ActionService';
import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
import { C2dGizmo } from 'sk/editor/logic/view/canvas2d/gizmo/C2dGizmo';
export class WidgetsTypeEnum {
static CornerPoint: string;
}
export class C2dContentCornerGizmo extends C2dGizmo {
entity: ContentNode;
content: ContentNode;
protected _actionService: ActionService;
private _container;
private _graphics;
private _corners;
private _index;
private _statusShapeChanged;
private _statusTransformChanged;
private _dragPoint;
private _dragCorner;
protected _drag: boolean;
protected _hover: boolean;
constructor();
setup(): void;
onDirty(sender: ListenerContext, event: any): void;
updateZoomChanged(sender: ListenerContext, event: any): void;
onKeyDown(sender: ListenerContext, event: KeyboardDeviceEvent): void;
onKeyUp(sender: ListenerContext, event: KeyboardDeviceEvent): void;
updateTransform(): void;
updateShape(): void;
private drawRect;
onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
onCommandRunning(sender: ListenerContext, event: ActionEvent): void;
onDragStart: (index: number) => (sender: ListenerContext, event: V2dHookEvent) => void;
onDragMove: (index: number) => (sender: ListenerContext, event: V2dHookEvent) => void;
onDragEnd: (index: number) => (event: MouseEvent) => void;
shapedDirty(): void;
transformDirty(): void;
update(): void;
onDraw(displayContext?: DisplayContext): void;
private onMouseOver;
private onMouseOut;
bindRectCommand(rect: V2dGraphicDrawing, index: number): void;
show(): void;
hide(): void;
dispose(): void;
}
}
declare module "sk/frame/logic/editor/base/editor/C2dMoveAction" {
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { Vector3 } from 'foundation/runtime/math/Vector3';
import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
import { ActionService } from 'foundation/editor/view/action/ActionService';
import { SchemeAction } from 'sk/editor/scheme/action/SchemeAction';
import { PointInference } from "sk/frame/logic/editor/base/editor/PointInference";
export class C2dMoveAction extends SchemeAction {
protected _oldContent: any;
protected _newContent: any;
ignoreSnapOffset: any;
path: Array;
currentLocation: Vector3;
inference: PointInference;
protected _coordService: CoordService;
protected _actionService: ActionService;
constructor();
onExecute(event: ContentActionEvent): void;
doSnap(location: Vector3, event: ContentActionEvent): Vector3;
move(event: ContentActionEvent): Vector3;
onMouseMove(event: ContentActionEvent): void;
onMouseDown(event: ContentActionEvent): void;
onReceive(code: string, event: ContentActionEvent): boolean;
}
}
declare module "sk/frame/logic/editor/base/editor/C2dCutKeelAction" {
import { ResultObject } from 'cross/runtime/lang/ResultObject';
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
import { LoDbKeel } from 'sk/rule/data/rule/layout/entitys/LoDbKeel';
import { HardwareEntity } from 'sk/editor/logic/entity/HardwareEntity';
import { C2dMoveAction } from "sk/frame/logic/editor/base/editor/C2dMoveAction";
export type StorageData = {
visible: boolean;
};
export class C2dCutKeelAction extends C2dMoveAction {
entity: HardwareEntity;
visible: boolean;
protected _savedData: StorageData;
protected _restoreData: StorageData;
protected _coordService: CoordService;
protected _selectionService: SelectionService;
protected _calculatorService: CalculatorService;
constructor();
cutKeelAsync(distance: number): Promise>;
cutKeel(keel: LoDbKeel, distance: number): {
keel1: LoDbKeel;
keel2: LoDbKeel;
};
onUndo(): boolean;
onRedo(): boolean;
}
}
declare module "sk/frame/logic/editor/base/display/C2dCutKeelActionGizmo" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
import { V2dTemp } from 'foundation/editor/view/view2d/V2dTemp';
import { C2dCanvas } from 'sk/editor/logic/view/canvas2d/C2dCanvas';
import { C2dCanvasContext } from 'sk/editor/logic/view/canvas2d/C2dCanvasContext';
import { C2dCutKeelAction } from "sk/frame/logic/editor/base/editor/C2dCutKeelAction";
export class C2dCutKeelActionGizmo extends V2dTemp {
view: C2dCanvas;
context: C2dCanvasContext;
action: C2dCutKeelAction;
private _dragLineGraphics;
private _keelEntity;
protected _coordService: CoordService;
setup(): void;
onMove(sender: ListenerContext, event: ContentActionEvent): void;
onMouseDown(sender: ListenerContext, event: V2dHookEvent): void;
protected tryComplete(distance: number): void;
onMouseMove(sender: ListenerContext, event: V2dHookEvent): void;
draw(): void;
get scale(): number;
drawGraphic(): void;
removeFromView(): void;
onActivate(): void;
onDeactivate(): void;
dispose(): void;
onScaleChanged(): void;
addToView(): void;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorAreaLine" {
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { C2dBrep } from 'sk/editor/logic/view/canvas2d/C2dBrep';
export class C2dEditorAreaLine extends C2dBrep {
private line;
private origin;
protected _coordService: CoordService;
constructor();
setup(): void;
setupLayer(): void;
protected updateShape(): void;
protected updateTransform(): void;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorContent" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { Bound2 } from 'foundation/runtime/math/Bound2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
import { DataNodeFlagEvent } from 'foundation/data/common/model/base/DataNodeFlagEvent';
import { C2dContent } from 'sk/editor/logic/view/canvas2d/C2dContent';
export class C2dEditorContent extends C2dContent {
outline: Array;
origin: Vector2;
protected _coordService: CoordService;
constructor();
get bound(): Bound2;
setupLayer(): void;
onCoordChanged(sender: ListenerContext, event: any): void;
protected updateBound(): Bound2;
protected getLevelIndex(): number;
onEntityFlagChanged(sender: ListenerContext, event: DataNodeFlagEvent): void;
protected changeLayerTop(): void;
setup(): void;
bindAction(): void;
unbindAction(): void;
onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
protected updateShape(): void;
protected updateStyleStatus(): void;
protected updateTransform(): void;
dispose(): void;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorCircleContent" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
import { C2dEditorContent } from "sk/frame/logic/editor/base/display/C2dEditorContent";
export class C2dEditorCircleContent extends C2dEditorContent {
diameter: number;
center: Vector2;
protected _coordService: CoordService;
constructor();
onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
protected updateShape(): void;
protected updateStyleStatus(): void;
protected updateTransform(): void;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorCreateScaleRuler" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { DataNode } from 'foundation/data/common/model/base/DataNode';
import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
import { V2dGraphicText } from 'foundation/editor/view/view2d/render/V2dGraphicText';
import { V2dGraphicTextStyle } from 'foundation/editor/view/view2d/render/V2dGraphicTextStyle';
import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
import { EditorStackService } from 'foundation/editor/view/stack/EditorStackService';
import { FamilyInstanceNode } from 'sk/data/family/model/instance/FamilyInstanceNode';
import { W2dTemp } from 'sk/editor/scheme/floorplan/view/canvas2d/W2dTemp';
import { C2dAlignmentLines } from 'sk/editor/logic/view/canvas2d/gizmo/C2dAlignmentLines';
import { ContainerEntity } from 'sk/editor/logic/entity/ContainerEntity';
import { PointInference } from "sk/frame/logic/editor/base/editor/PointInference";
export class C2dEditorCreateScaleRuler extends W2dTemp {
private _lineGraphics;
private _beginGraphics;
private _endGraphics;
private _snapGraphics;
private _graphicsTxt;
private _baseColor;
private _surpportColor;
private _fontSize;
private _points;
protected _inference: PointInference;
protected _alignmentLines: C2dAlignmentLines;
protected _alignmentLineContainer: V2dGraphicDrawing;
private _currentPos;
private _snapedPos;
private _snapType;
private _textStyle;
protected _stackService: EditorStackService;
protected _selectionService: SelectionService;
statusAssistLine: boolean;
optionAssistLine: boolean;
private graphicsTxtArray;
constructor();
setup(): void;
onFieldChanged(sender: any, event: any): void;
onScaleChange(): void;
protected setSnapContent(): void;
obtainContent(contents: Array, parent: ContainerEntity, entity: DataNode): void;
onMouseDown(sender: ListenerContext, event: V2dHookEvent): void;
onMouseMove(sender: ListenerContext, event: V2dHookEvent): void;
private filterSnapPts;
private getClosestSnapPt;
snapPositon(startX: number, startY: number, endX: number, endY: number): Vector2;
drawDisplay(): void;
drawSnaps(): void;
drawingCircle(graphics: V2dGraphicDrawing, point: Vector2, radius: number, color?: number): void;
drawingRectLine(graphics: V2dGraphicDrawing, point: Vector2, long: number, offset?: boolean, lineWidth?: number, color?: number): void;
drawingPedal(graphics: V2dGraphicDrawing, point: Vector2, long: number, lineWidth?: number, color?: number): void;
drawingCross(graphics: V2dGraphicDrawing, point: Vector2, long: number, lineWidth?: number, color?: number): void;
drawingTriangle(graphics: V2dGraphicDrawing, point: Vector2, long: number, lineWidth?: number, color?: number): void;
drawStraightLine(graphics: V2dGraphicDrawing, start: Vector2, end: Vector2, lineWidth?: number, color?: number): void;
drawRules(): void;
private drawTextAssist;
private getGraphicText;
drawRulerText(): void;
drawText(gra: V2dGraphicText, start: Vector2, end: Vector2, location: Vector2, rotation: number, text: string, style: V2dGraphicTextStyle): void;
onActivate(): void;
onDeactivate(): void;
protected snapPerpendicular(canvasPos: Vector2, canvasFactor: number): Vector2;
dispose(): void;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorFloorplanArea" {
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
import { Display } from 'foundation/editor/view/base/Display';
import { DisplayContext } from 'foundation/editor/view/base/DisplayContext';
import { C2dCanvas } from 'sk/editor/logic/view/canvas2d/C2dCanvas';
import { C2dCanvasContext } from 'sk/editor/logic/view/canvas2d/C2dCanvasContext';
import { C2dLayer } from 'sk/editor/logic/view/canvas2d/C2dLayer';
export class C2dEditorFloorplanArea extends Display {
view: C2dCanvas;
context: C2dCanvasContext;
layer: C2dLayer;
node: V2dGraphicContainer;
protected _nodePoly: V2dGraphicDrawing;
private graphics;
protected _colorPoly: number;
protected _colorHole: number;
constructor();
setup(): void;
dispose(): void;
createNode(): void;
private outlinePoints;
private primitivePoints;
private innerOutLinePoints;
createShape(): void;
getPrimitivePoints(): Vector2[];
private readonly lineColor;
private readonly lineWidth;
private readonly lineAlpha;
private readonly innerLineWidth;
private readonly wallColor;
private readonly wallFillAlpha;
private readonly roomColor;
private readonly holeLineColor;
private readonly holeLineWidth;
private readonly holeFillColor;
protected drawGraphic(): void;
onDraw(displayContext?: DisplayContext): void;
}
}
declare module "sk/frame/logic/editor/base/editor/C2dEditorActionEvent" {
import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
export class C2dEditorActionEvent extends ContentActionEvent {
libraryId: string;
libraryVersion: number;
familyId: string;
familyVersion: number;
familySymbolId: string;
familyInfoId: string;
productId: string;
name: string;
elementClass: any;
info: ISpecificationFamilyInfo;
isDisableCompute: boolean;
flipAxis: 'X' | 'Y' | 'Z';
fieldMap: Map;
assign(event: C2dEditorActionEvent): void;
free(): void;
}
}
declare module "sk/frame/logic/editor/base/editor/C2dEditorController" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { ContentNode } from 'foundation/data/common/model/brep/ContentNode';
import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
import { ContentInstanceController } from 'sk/editor/scheme/view/base/ContentInstanceController';
import { C3dContent } from 'sk/editor/logic/view/webgl3d/C3dContent';
import { LayerControlService } from "sk/frame/logic/editor/base/base/LayerControlService";
import { StateControlService } from "sk/frame/logic/editor/base/base/StateControlService";
import { C2dEditorActionEvent } from "sk/frame/logic/editor/base/editor/C2dEditorActionEvent";
export class C2dEditorController extends ContentInstanceController {
display: C3dContent;
entity: ContentNode;
protected _stateService: StateControlService;
protected _layerService: LayerControlService;
getEntity(): ContentNode;
filterEntity(entity: ContentNode): boolean;
onMouseEnter(sender: ListenerContext, event: ContentActionEvent): void;
onMouseLeave(sender: ListenerContext, event: ContentActionEvent): void;
onDragStart(sender: ListenerContext, event: C2dEditorActionEvent): boolean;
isMultiSelectKey(event: ContentActionEvent): boolean;
onClick(sender: ListenerContext, event: ContentActionEvent): boolean;
dispatchEvent(code: any, event: any): boolean;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorGroup" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
import { V2dGraphicText } from 'foundation/editor/view/view2d/render/V2dGraphicText';
import { C2dEditorContent } from "sk/frame/logic/editor/base/display/C2dEditorContent";
export class C2dEditorGroup extends C2dEditorContent {
outline: Array;
origin: Vector2;
protected _textSprite: V2dGraphicText;
protected _textfont: number;
protected _coordService: CoordService;
constructor();
createNode(): void;
canDraw(): boolean;
setupLayer(): void;
setup(): void;
onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
protected updateShape(): void;
protected updateStyleStatus(): void;
protected updateTransform(): void;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorLinearDimension" {
import { C2dLinearDimension } from 'sk/editor/scheme/floorplan/view/canvas2d/gizmo/C2dLinearDimension';
export class C2dEditorLinearDimension extends C2dLinearDimension {
protected _state: number;
constructor();
isCharMatchTheRules(): any;
getStrValue(data: string): number;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorMoveActionController" {
import { DimensionEvent } from 'foundation/editor/ui/widget/DimensionEvent';
import { ActionService } from 'foundation/editor/view/action/ActionService';
import { DisplayController } from 'foundation/editor/view/base/DisplayController';
export class C2dEditorMoveActionController extends DisplayController {
protected _actionService: ActionService;
dispatch(event: DimensionEvent): void;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorPlankTexColorEnum" {
export class C2dEditorPlankTexColorEnum {
static Default: string;
static Base: string;
static BaseInner: string;
static BaseOuter: string;
static Surface: string;
}
}
declare module "sk/frame/logic/editor/base/display/C2dEditorPlank" {
import { TypeMap } from 'cross/runtime/lang/collection/TypeMap';
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { Circle2 } from 'foundation/runtime/math/Circle2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { DataNodeFieldEvent } from 'foundation/data/common/model/base/DataNodeFieldEvent';
import { V2dGraphicText } from 'foundation/editor/view/view2d/render/V2dGraphicText';
import { C2dEditorContent } from "sk/frame/logic/editor/base/display/C2dEditorContent";
export class C2dEditorPlank extends C2dEditorContent {
protected _textSprite: V2dGraphicText;
protected _textfont: number;
protected layerTextColor: TypeMap;
protected pathOutline: Array;
protected technologyHoleCircles: Array;
protected technologyHoleRects: Array>;
protected optionText: boolean;
protected optionHookNode: boolean;
constructor();
createNode(): void;
canDraw(): boolean;
setupLayer(): void;
setup(): void;
onEntityFieldChanged(sender: ListenerContext, event: DataNodeFieldEvent): void;
updateShapeCompute(): void;
protected updateShape(): void;
change4(identifier: string): string;
protected updateStyleStatus(): void;
protected updateTransform(): void;
}
}
declare module "sk/frame/logic/editor/base/display/C2dLevelingWallLineDimensionEnum" {
export class C2dLevelingWallLineDimensionEnum {
static plankType: string;
static outlineType: string;
}
}
declare module "sk/frame/logic/editor/base/display/C2dOpereateLineDimensionTypeEnum" {
export class C2dOpereateLineDimensionTypeEnum {
static plankType: string;
static outlineType: string;
}
}
declare module "sk/frame/logic/editor/base/editor/C2dPartitionPlankAction" {
import { ResultObject } from 'cross/runtime/lang/ResultObject';
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
import { PlankEntity } from 'sk/editor/logic/entity/PlankEntity';
import { C2dMoveAction } from "sk/frame/logic/editor/base/editor/C2dMoveAction";
export type StorageData = {
visible: boolean;
};
export class C2dPartitionPlankAction extends C2dMoveAction {
entity: PlankEntity;
protected oldPlank: PlankElement;
protected newPlanks: PlankElement[];
visible: boolean;
protected _savedData: StorageData;
protected _restoreData: StorageData;
protected _coordService: CoordService;
protected _selectionService: SelectionService;
protected _calculatorService: CalculatorService;
constructor();
partitionPlankAsync(path: Vector2[]): Promise>;
onUndoAsync(): Promise>;
onRedoAsync(): Promise>;
}
}
declare module "sk/frame/logic/editor/base/util/C2dPartionPlankEnum" {
export class C2dPartionPlankOperateEnum {
static Input: string;
static Drag: string;
}
export class C2dPartionPlankCutModeEnum {
static HorizenCut: string;
static VerticalCut: string;
}
export class C2dPartionPlankEnum {
static CutType: string;
static Distance: string;
static ButtonStartCut: string;
}
}
declare module "sk/frame/logic/editor/base/util/C2DPlankPartitionUtil" {
import { Line2 } from 'foundation/runtime/math/Line2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
export class C2DPlankPartitionUtil {
static pushLine(start: Vector2, end: Vector2, xLine: Line2[], yLine: Line2[]): void;
static pointOnXLine(point: Vector2, beginPoint: Vector2, endPoint: Vector2): boolean;
static pointOnYLine(point: Vector2, beginPoint: Vector2, endPoint: Vector2): boolean;
}
}
declare module "sk/frame/logic/editor/base/display/C2dPartitionPlankActionGizmo" {
import { Types } from 'cross/runtime/lang/collection/Types';
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { HotkeyService } from 'cross/editor/module/hotkey/HotkeyService';
import { TriggerHotkey } from 'cross/editor/module/hotkey/TriggerHotkey';
import { Line2 } from 'foundation/runtime/math/Line2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
import { V2dTemp } from 'foundation/editor/view/view2d/V2dTemp';
import { C2dLinearDimension } from 'sk/editor/scheme/floorplan/view/canvas2d/gizmo/C2dLinearDimension';
import { C2dAlignmentLines } from 'sk/editor/logic/view/canvas2d/gizmo/C2dAlignmentLines';
import { C2dCanvas } from 'sk/editor/logic/view/canvas2d/C2dCanvas';
import { C2dCanvasContext } from 'sk/editor/logic/view/canvas2d/C2dCanvasContext';
import { C2dLayer } from 'sk/editor/logic/view/canvas2d/C2dLayer';
import { PlankEntity } from 'sk/editor/logic/entity/PlankEntity';
import { StateControlService } from "sk/frame/logic/editor/base/base/StateControlService";
import { C2dPartitionPlankAction } from "sk/frame/logic/editor/base/editor/C2dPartitionPlankAction";
import { PointInference } from "sk/frame/logic/editor/base/editor/PointInference";
export class C2dPartitionPlankActionGizmo extends V2dTemp {
view: C2dCanvas;
context: C2dCanvasContext;
action: C2dPartitionPlankAction;
entity: PlankEntity;
private _dragLineGraphics;
snapPoints: Types;
snapLength: number;
protected snapLines: Types;
protected _pointValid: boolean;
protected _curMousePosCanvas: Vector2;
protected _alignmentLines: C2dAlignmentLines;
protected _alignmentLineGraphics: V2dGraphicDrawing;
inference: PointInference;
private _points;
protected _lengthDimension: C2dLinearDimension;
protected _traceDimension: C2dLinearDimension;
sceneContainer: V2dGraphicContainer;
layer: C2dLayer;
protected _isClose: boolean;
ignoreSnapOffset: any;
isSnapping: boolean;
protected _isTracing: boolean;
protected _tracingPosition: any;
protected _tracingTimer: any;
pointTracingStart: Vector2;
operateMode: string;
cutMode: string;
cutDistance: number;
minDistanceHorizen: number;
maxDistanceHorizen: number;
minDistanceVertical: number;
maxDistanceVertical: number;
leftCornerPoint: Vector2;
rightCornerPoint: Vector2;
upCornerPoint: Vector2;
downCornerPoint: Vector2;
cutPoint1: Vector2;
cutPoint2: Vector2;
xLinesPlank: Array;
yLinesPlank: Array;
protected _hotkeyService: HotkeyService;
protected showLineHotkey: TriggerHotkey;
protected _stateService: StateControlService;
protected _selectionService: SelectionService;
constructor();
setup(): void;
initSnapPoints(): void;
protected initDimension(): void;
initPartitionPlank(): void;
onValueChangeStart(sender: ListenerContext, event: any): void;
protected onTraceValueChangeCommit(sender: ListenerContext, event: any): void;
onMouseMove(sender: ListenerContext, event: V2dHookEvent): void;
onMouseDown(sender: ListenerContext, event: V2dHookEvent): void;
onMove(sender: ListenerContext, event: ContentActionEvent): void;
onCutTypeChanged(sender: ListenerContext, event: ContentActionEvent): void;
onDistanceChanged(sender: ListenerContext, event: ContentActionEvent): void;
onButtonStartCut(sender: ListenerContext, event: ContentActionEvent): void;
private startCutPlankAsync;
operateModeChange(): void;
protected addPoint(posX: number, posY: number): void;
protected tryCompleteAsync(points: Array): Promise;
doSnap(_point: Vector2): Vector2;
doTrace(point: Vector2): void;
computeCutPoint(cutDistance: number): Vector2[];
draw(): void;
get scale(): number;
drawGraphic(): void;
updateLengthDimension(dimension: C2dLinearDimension, start: Vector2, end: Vector2): void;
removeFromView(): void;
onActivate(): void;
onDeactivate(): void;
dispose(): void;
onScaleChanged(): void;
addToView(): void;
}
}
declare module "sk/frame/logic/editor/base/editor/C2dPartitionPlankDesignAction" {
import { ResultObject } from 'cross/runtime/lang/ResultObject';
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { CalculatorService } from 'foundation/core/module/calculator/CalculatorService';
import { EditorMessageService } from 'foundation/editor/view/base/message/EditorMessageService';
import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
import { PlankEntity } from 'sk/editor/logic/entity/PlankEntity';
import { C2dMoveAction } from "sk/frame/logic/editor/base/editor/C2dMoveAction";
export type StorageData = {
visible: boolean;
};
export class C2dPartitionPlankDesignAction extends C2dMoveAction {
plankEntitys: Array;
protected _newPlanks: PlankElement[];
protected _oldPlanks: PlankElement[];
visible: boolean;
protected _savedData: StorageData;
protected _restoreData: StorageData;
protected _parent: ContentElement;
type: string;
protected _coordService: CoordService;
protected _calculatorService: CalculatorService;
protected _editorMessageService: EditorMessageService;
constructor();
partitionPlankAsync(path: Vector2[], plankEntitys: Array, gap?: number, type?: string): Promise>;
private fetchBindingDecorateAsync;
onUndoAsync(): Promise>;
onRedoAsync(): Promise>;
}
}
declare module "sk/frame/logic/editor/base/display/C2dPartitionPlankDesignActionGizmo" {
import { Types } from 'cross/runtime/lang/collection/Types';
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { HotkeyService } from 'cross/editor/module/hotkey/HotkeyService';
import { TriggerHotkey } from 'cross/editor/module/hotkey/TriggerHotkey';
import { Line2 } from 'foundation/runtime/math/Line2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { SelectionService } from 'foundation/editor/base/selection/SelectionService';
import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
import { V2dGraphicContainer } from 'foundation/editor/view/view2d/render/V2dGraphicContainer';
import { V2dGraphicDrawing } from 'foundation/editor/view/view2d/render/V2dGraphicDrawing';
import { V2dHookEvent } from 'foundation/editor/view/view2d/render/V2dHookEvent';
import { V2dTemp } from 'foundation/editor/view/view2d/V2dTemp';
import { C2dLinearDimension } from 'sk/editor/scheme/floorplan/view/canvas2d/gizmo/C2dLinearDimension';
import { C2dAlignmentLines } from 'sk/editor/logic/view/canvas2d/gizmo/C2dAlignmentLines';
import { C2dCanvas } from 'sk/editor/logic/view/canvas2d/C2dCanvas';
import { C2dCanvasContext } from 'sk/editor/logic/view/canvas2d/C2dCanvasContext';
import { C2dLayer } from 'sk/editor/logic/view/canvas2d/C2dLayer';
import { PlankEntity } from 'sk/editor/logic/entity/PlankEntity';
import { StateControlService } from "sk/frame/logic/editor/base/base/StateControlService";
import { C2dPartitionPlankDesignAction } from "sk/frame/logic/editor/base/editor/C2dPartitionPlankDesignAction";
import { PointInference } from "sk/frame/logic/editor/base/editor/PointInference";
export class C2dPartitionPlankDesignActionGizmo extends V2dTemp {
view: C2dCanvas;
context: C2dCanvasContext;
action: C2dPartitionPlankDesignAction;
plankEntitys: Array;
private _dragLineGraphics;
snapPoints: Types;
snapLength: number;
protected snapLines: Types;
protected _pointValid: boolean;
protected _curMousePosCanvas: Vector2;
protected _alignmentLines: C2dAlignmentLines;
protected _alignmentLineGraphics: V2dGraphicDrawing;
inference: PointInference;
private _points;
protected _lengthDimension: C2dLinearDimension;
protected _traceDimension: C2dLinearDimension;
sceneContainer: V2dGraphicContainer;
layer: C2dLayer;
protected _isClose: boolean;
ignoreSnapOffset: any;
isSnapping: boolean;
protected _isTracing: boolean;
protected _tracingPosition: any;
protected _tracingTimer: any;
pointTracingStart: Vector2;
operateMode: string;
cutMode: string;
cutDistance: number;
minDistanceHorizen: number;
maxDistanceHorizen: number;
minDistanceVertical: number;
maxDistanceVertical: number;
leftCornerPoint: Vector2;
rightCornerPoint: Vector2;
upCornerPoint: Vector2;
downCornerPoint: Vector2;
cutPoint1: Vector2;
cutPoint2: Vector2;
xLinesPlank: Array;
yLinesPlank: Array;
_snapType: number;
protected _hotkeyService: HotkeyService;
protected showLineHotkey: TriggerHotkey;
protected _stateService: StateControlService;
protected _selectionService: SelectionService;
constructor();
setup(): void;
initSnapPoints(): void;
protected initDimension(): void;
protected onTraceValueChangeCommit(sender: ListenerContext, event: any): void;
onMouseMove(sender: ListenerContext, event: V2dHookEvent): void;
onMouseDown(sender: ListenerContext, event: V2dHookEvent): void;
onMove(sender: ListenerContext, event: ContentActionEvent): void;
private computeSelectPlankNodes;
protected addPoint(posX: number, posY: number): void;
protected tryCompleteAsync(points: Array): Promise;
doSnap(_point: Vector2): Vector2;
private filterSnapPts;
private getClosestSnapPt;
doTrace(point: Vector2): void;
draw(): void;
get scale(): number;
drawGraphic(): void;
drawingTriangle(graphics: V2dGraphicDrawing, point: Vector2, long: number, lineWidth?: number, color?: number): void;
updateLengthDimension(dimension: C2dLinearDimension, start: Vector2, end: Vector2): void;
removeFromView(): void;
onActivate(): void;
onDeactivate(): void;
dispose(): void;
onScaleChanged(): void;
addToView(): void;
}
}
declare module "sk/frame/logic/editor/base/editor/C2dOperateLineEditorController" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { C2dEditorActionEvent } from "sk/frame/logic/editor/base/editor/C2dEditorActionEvent";
import { C2dEditorController } from "sk/frame/logic/editor/base/editor/C2dEditorController";
export class C2dOperateLineEditorController extends C2dEditorController {
onDragStart(sender: ListenerContext, event: C2dEditorActionEvent): boolean;
}
}
declare module "sk/frame/logic/editor/base/display/C2dPlankOperateLine" {
import { ListenerContext } from 'cross/runtime/lang/ListenerContext';
import { NodeFieldEvent } from 'cross/runtime/framework/node/NodeFieldEvent';
import { CoordService } from 'foundation/runtime/math/coord/CoordService';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { OperateLineNode } from 'sk/data/family/model/assistant/operate/OperateLineNode';
import { SchemeBlueprintEntity } from 'sk/editor/scheme/entity/SchemeBlueprintEntity';
import { C2dBrep } from 'sk/editor/logic/view/canvas2d/C2dBrep';
export class C2dPlankOperateLine extends C2dBrep {
blueprint: SchemeBlueprintEntity;
entity: OperateLineNode;
private userMatrix;
private parantObjctMatrix;
protected _dragPoint: Vector2;
protected _lastPoint: Vector2;
protected _coordService: CoordService;
constructor();
setup(): void;
createNode(): any;
onEditOptionsChanged(sender: ListenerContext, event: NodeFieldEvent): void;
canDraw(): boolean;
onAddToView(): void;
private getWorldPosition;
protected updateShape(): void;
updateValidLine(start: Vector2, end: Vector2, lineWidth: number, color: number, lineAlpha: number): void;
updateInvalidLine(start: Vector2, end: Vector2, lineWidth: number, color: number, lineAlpha: number): void;
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomBaseDesignData" {
export class BathroomBaseDesignData {
static DEFAULT_FLOOR_EDGE_THICKNESS: number;
static DEFAULT_SURFACE_THICKNESS: number;
static DEFAULT_BASE_HEIGHT: number;
}
export class PlankTypeEnum {
static Tile: string;
static Iron: string;
static Stone: string;
}
export class PlankTypeCode {
static wallCode: number;
static doorCode: number;
static windowUpCode: number;
static windowDownCode: number;
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomCreateDesignData" {
import { Line2 } from 'foundation/runtime/math/Line2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
export class BathroomFamilyInfoDesignData {
floorData: FloorFamilyInfoData;
wallData: WallFamilyInfoData;
ceilingData: CeilingFamilyInfoData;
constructor();
}
export class FloorFamilyInfoData {
floorDryFamilyInfoId: string;
floorDryFamilyInfo?: ISpecificationFamilyInfo;
floorWetFamilyInfoId: string;
floorWetFamilyInfo?: ISpecificationFamilyInfo;
floorWetSymbolFamilyInfoId: string;
floorWetSymbolFamilyInfo?: ISpecificationFamilyInfo;
tileFamilyInfoId: string;
tileFamilyInfo?: ISpecificationFamilyInfo;
}
export class WallFamilyInfoData {
wallFamilyInfoId: string;
wallFamilyInfo?: ISpecificationFamilyInfo;
tileFamilyInfoId: string;
tileFamilyInfo?: ISpecificationFamilyInfo;
}
export class CeilingFamilyInfoData {
ceilingSymbolFamilyInfoId: string;
tileceilingSymbolFamilyInfo?: ISpecificationFamilyInfo;
tileFamilyInfoId: string;
tileFamilyInfo?: ISpecificationFamilyInfo;
}
export class BathroomCreateDesignData {
ceilingDownHeight: number;
floorData: FloorCreateDataInfo;
wallData: WallCreateDataInfo;
ceilingData: CeilingCreateDataInfo;
bathroomData: BathroomData;
static doorCenter: Vector2[];
outerDoorData: Array;
constructor();
getHoleCenter(createData: BathroomCreateDesignData): void;
}
export class ContentBase {
name: string;
type: string;
x: number;
y: number;
lengthX: number;
lengthY: number;
rotation: number;
doorFlag: boolean;
constructor();
getPoints(): Array;
}
export class BathroomData extends ContentBase {
z: number;
height: number;
floorFnish: number;
ceilingSpace: number;
constructor();
setBathroomData(x: number, y: number, lenghtX: number, lengthY: number): void;
}
export class FloorCreateDataInfo {
lengthZ: number;
z: number;
symbolWetPlanks: Array;
wetArea: Array;
dryArea: Array;
waterBar: Array;
baseTthickness: number;
surfaceThickness: number;
floorEdgeThickness: number;
constructor();
}
export class SymbolWetPlank extends ContentBase {
edgeThickness?: number;
edgeHeight?: number;
code?: string;
floorWetPlankPatternInfoId?: string;
floorWetPlankFamilyInfoId?: string;
floorWetId?: string;
}
export class FloorWetTile extends ContentBase {
edgeThickness?: number;
edgeHeight?: number;
code?: string;
floorWetTilePatternInfoId?: string;
floorWetTileFamilyInfoId?: string;
floorWetId?: string;
}
export class AreaLayoutData {
name: string;
type: AreaType;
outline: Array;
constructor(name?: string, type?: AreaType, outline?: AreaSingleLine[]);
setOutline(outline: AreaSingleLine[]): void;
getPoints(): Array;
}
export class AreaInfo extends ContentBase {
outline: Array;
constructor();
}
export enum WaterInterBarType {
doorBar = "doorBar",
dryWetConnectBar = "dryWetConnectBar"
}
export class AreaType {
static wetArea: string;
static dryArea: string;
static wallArea: string;
static ceilingArea: string;
}
export class AreaLineType {
static wetOutline: string;
static dryOutline: string;
static WaterInterBar: string;
static outerWllOutline: string;
static inerWllOutline: string;
static ceilingOutline: string;
}
export class WaterInletType {
static showerInlet: string;
static closestoolInlet: string;
static basinInlet: string;
}
export class WaterInterBarLayoutData extends AreaInfo {
waterIntertype: WaterInterBarType;
z: number;
constructor();
}
export class WallCreateDataInfo {
wallOutlines: Array;
indoorHoles: Array;
lines: Array;
z: number;
thickness: number;
height: number;
baseTthickness: number;
surfaceThickness: number;
floorEdgeThickness: number;
heightRule: boolean;
constructor();
}
export class WallAreaLine {
outline: Array;
constructor();
}
export class AreaSingleLine {
lineName: string;
lineType: AreaLineType;
line: Line2;
prevLine: AreaSingleLine;
nextLine: AreaSingleLine;
hole: Array;
inletWaterHole: Array;
constructor();
}
export class WallHoleData extends ContentBase {
holeType: string;
z: number;
line: Line2;
center: Vector2;
constructor();
}
export class WallWaterInletData {
type: string;
x: number;
height: number;
radius: number;
space: number;
constructor();
}
export enum CeilingSurfaceLayoutType {
entire = "ceilingSurface.entire",
areas = "ceilingSurface.areas"
}
export class CeilingCreateDataInfo {
ceilingLayout: CeilingSurfaceLayoutType;
ceilingAreas: Array;
ceilingSpace: number;
lengthZ: number;
area: Array;
z: number;
baseThickness: number;
surfaceThickness: number;
floorEdgeThickness: number;
arrangeDirection: string;
constructor();
}
export class DoorHoleInfo {
center: Vector2;
from: Vector2;
to: Vector2;
constructor();
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/walldesign/BathroomWallElementBuilderUtil" {
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { HoleStructure } from 'foundation/data/common/structure/HoleStructure';
import { FamilyInstanceElement } from 'sk/data/family/element/instance/FamilyInstanceElement';
import { WareElement } from 'sk/data/family/element/instance/WareElement';
import { FamilyStructure } from 'sk/data/family/library/FamilyStructure';
import { TechnologyHoleElement } from 'sk/data/scheme/database/technology/element/TechnologyHoleElement';
import { WallHoleData } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomCreateDesignData";
export class BathroomWallElementBuilderUtil {
static addPlankTechnologyHoleByAreaData(plankElement: FamilyInstanceElement, area: WallHoleData): void;
static addPlankTechnologyHoleByHoleData(plankElement: FamilyInstanceElement, hole: HoleStructure): void;
static addPlankTechnologyHoleByCutHole(plankElement: FamilyInstanceElement, hole: WareElement): void;
static createTechnologyHoleByPolygon(familyStructure: FamilyStructure, polygon: Vector2[], lengthX: number, lengthY: number, lengthZ: number): TechnologyHoleElement;
static createCircleTechnologyHole(familyStructure: FamilyStructure, center: Vector2, diameter: number, depth: number): TechnologyHoleElement;
}
}
declare module "sk/frame/logic/scheme/bathroom/util/BathroomDesignNodeUtil" {
import { TechnologyHoleNode } from 'sk/data/family/database/technology/model/TechnologyHoleNode';
import { ContainerNode } from 'sk/data/family/model/instance/ContainerNode';
import { PatternInstanceNode } from 'sk/data/family/model/instance/PatternInstanceNode';
import { WareNode } from 'sk/data/family/model/instance/WareNode';
import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
import { PlankNode } from 'sk/data/scheme/database/furniture/model/PlankNode';
import { AssembleBathroomNode } from 'sk/data/scheme/database/pattern/node/AssembleBathroomNode';
import { BathroomCeilingNode } from 'sk/data/scheme/database/pattern/node/BathroomCeilingNode';
import { BathroomWallNode } from 'sk/data/scheme/database/pattern/node/BathroomWallNode';
export class BathroomDesignNodeUtil {
static findSurfaceContainer(root: PatternInstanceNode): ContainerNode;
static findBaseContainer(root: PatternInstanceNode): ContainerNode;
static findSeamContainer(root: PatternInstanceNode): ContainerNode;
static findBasePlank(container: ContainerNode): PlankNode;
static findSeamPlank(container: ContainerNode): PlankNode;
static findPatternInstanceNodeCutHoleIn(hole: WareNode): PatternInstanceNode;
static findBathroomWalls(root: AssembleBathroomNode): BathroomWallNode[];
static getSurfacePlanks(root: PatternInstanceNode): PlankNode[];
static setFlagFacePlanks(root: PatternInstanceNode, flag: number, on: boolean): void;
static isCircleTechHole(node: TechnologyHoleNode): boolean;
static getBathroomCeilingNode(root: PatternInstanceNode): BathroomCeilingNode;
static getCurRoom(root: PatternInstanceNode): RoomNode;
static updateBathroomWallHoles(wall: BathroomWallNode): void;
}
}
declare module "sk/frame/logic/scheme/bathroom/util/bathroomwall/addtechhole/BathroomWallDesignTechHoleBusinessLogic" {
import { WareElement } from 'sk/data/family/element/instance/WareElement';
import { PlankElement } from 'sk/data/scheme/database/furniture/element/PlankElement';
import { TechnologyHoleElement } from 'sk/data/scheme/database/technology/element/TechnologyHoleElement';
import { WareEntity } from 'sk/editor/scheme/entity/WareEntity';
import { PlankEntity } from 'sk/editor/logic/entity/PlankEntity';
export enum TypeHoleEnum {
Circle = "Circle",
Square = "Square"
}
export enum BathroomEditorElementCodeEnum {
TechHoleForStandard = "hole.tech.standard"
}
export class BathroomWallDesignTechHoleBusinessLogic {
plankSurfaceElement: PlankElement;
cutHoleElement: WareElement;
plankBaseElement: PlankElement;
addTechHoleToSurfacePlankByCutHole(plank: PlankEntity, cutHole: WareEntity, typeHole: TypeHoleEnum): TechnologyHoleElement;
addTechHoleToBasePlankByCutHole(plank: PlankEntity, cutHole: WareEntity, typeHole: TypeHoleEnum): TechnologyHoleElement;
removeTechHolesFromSurfacePlank(plank: PlankEntity): TechnologyHoleElement[];
removeTechHolesFromBasePlankBySurfacePlank(plankBase: PlankEntity, plankSurface: PlankEntity): TechnologyHoleElement[];
removeAllTechHolesFromBasePlank(plank: PlankEntity): TechnologyHoleElement[];
existTechHolesInSurfacePlank(plank: PlankEntity): boolean;
private getPolygonHoleInPlank;
private getCenterHoleInPlank;
private createPolygonPointsByPosAndSize;
private addTechHoleToPlank;
private addCircleTechHoleToPlank;
private findTechHolesInBase;
private isCircleTechHoleRelative;
private isSquareTechHoleRelative;
private getCurvePointsSquareHole;
private getTechHolesElementByNode;
private removeTechHolesFromPlank;
private addTechHoleToSurfacePlankByOutline;
private addTechHoleToBasePlankByOutline;
}
}
declare module "sk/frame/logic/scheme/bathroom/event/BathroomFloorDryDesignActionEvent" {
import { ContentActionEvent } from 'foundation/editor/view/action/content/ContentActionEvent';
import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
import { BathroomFloorDryNode } from 'sk/data/scheme/database/pattern/node/BathroomFloorDryNode';
export class BathroomFloorDryDesignActionEvent extends ContentActionEvent {
entity: BathroomFloorDryNode;
element: BathroomFloorDryElement;
propName: string;
propValue: string;
propName2: string;
propValue2: string;
floorFlag: boolean;
constructor();
reset(): void;
free(): void;
}
}
declare module "sk/frame/logic/scheme/bathroom/util/BathroomDesignMath2dUtil" {
import { Types } from 'cross/runtime/lang/collection/Types';
import { Line2 } from 'foundation/runtime/math/Line2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
export class BathroomDesignMath2dUtil {
static getPointProjectionToLine(point: Vector2, from: Vector2, to: Vector2): Vector2;
static getPointProjectionToRay(point: Vector2, origin: Vector2, dir: Vector2): {
t: number;
res: Vector2;
};
static checkPointBetweenLine(point: Vector2, from: Vector2, to: Vector2): boolean;
static computeSegmentIntersection(line1From: Vector2, line1To: Vector2, line2From: Vector2, line2To: Vector2): {
from: Vector2;
to: Vector2;
};
static rayLineIntersection(rayStart: Vector2, rayDirection: Vector2, lineStart: Vector2, lineEnd: Vector2): Vector2;
static convertOutlineVectorToLine(points: Types): Types;
static convertOutlineVectorToLine2(points: Array): Array;
static isouterCorner(line1: Line2, line2: Line2): boolean;
static convertPointsRelativeOrigin(points: Array, origin: Vector2): Array;
static convertPointsGlobal(points: Array, origin: Vector2): Array;
static convertSinglePointReleativeOrigin(point: Vector2, origin: Vector2): Vector2;
static convertSinglePointToGlobal(point: Vector2, origin: Vector2): Vector2;
static getPointsOfBound(bound: number[]): Vector2[];
static getLineHorizonAndVerticalOfBound(bound: number[]): {
lineHor: Line2;
lineVer: Line2;
};
static makePointsClockwiseAndLeftUpFirst(points: Vector2[]): void;
static swapArrayVector2(arr: Vector2[], i: number, j: number): void;
static isPointRightHandLine(point: Vector2, from: Vector2, to: Vector2): boolean;
static isRectOfPolygon(polygon: Vector2[], tolerance?: number): boolean;
}
}
declare module "sk/frame/logic/storage/module/product/show/category/item/ProductShowCategoryItemUnit" {
import { StorageUnit } from 'foundation/data/common/storage/StorageUnit';
export class ProductShowCategoryItemUnit extends StorageUnit {
static CLASS_NAME: string;
categoryId: string;
productId: string;
code: string;
dataOrder: number;
name: string;
constructor();
}
}
declare module "sk/frame/logic/storage/module/product/show/category/item/ProductShowCategoryItemService" {
import { StorageUnitService } from 'foundation/data/common/storage/StorageUnitService';
import { ProductShowCategoryItemGetResponse } from 'sk/data/logic/module/message/ProductShowCategoryItemGetResponse';
import { ProductShowCategoryItemInsertResponse } from 'sk/data/logic/module/message/ProductShowCategoryItemInsertResponse';
import { ProductShowCategoryItemPageResponse } from 'sk/data/logic/module/message/ProductShowCategoryItemPageResponse';
import { ProductShowCategoryItemUnit } from "sk/frame/logic/storage/module/product/show/category/item/ProductShowCategoryItemUnit";
export class ProductShowCategoryItemService extends StorageUnitService {
constructor();
pageAsync(pageQuery: any): Promise;
getAsync(obj?: any): Promise;
insertAsync(unit: ProductShowCategoryItemUnit): Promise;
}
}
declare module "sk/frame/logic/storage/module/product/show/category/ProductShowCategoryUnit" {
import { StorageUnit } from 'foundation/data/common/storage/StorageUnit';
export class ProductShowCategoryUnit extends StorageUnit {
static CLASS_NAME: string;
id: string;
parentId: string;
code: string;
name: string;
dataOrder: number;
remark: string;
constructor();
}
}
declare module "sk/frame/logic/storage/module/product/show/category/ProductShowCategoryService" {
import { StorageUnitService } from 'foundation/data/common/storage/StorageUnitService';
import { ProductShowCategoryGetResponse } from 'sk/data/logic/module/message/ProductShowCategoryGetResponse';
import { ProductShowCategoryTreeResponse } from 'sk/data/logic/module/message/ProductShowCategoryTreeResponse';
import { ProductShowCategoryUnit } from "sk/frame/logic/storage/module/product/show/category/ProductShowCategoryUnit";
export class ProductShowCategoryService extends StorageUnitService {
constructor();
treeAsync(pageQuery?: any): Promise;
getAsync(obj?: any): Promise;
}
}
declare module "sk/frame/logic/storage/module/product/product/ProductUnit" {
import { StorageUnit } from 'foundation/data/common/storage/StorageUnit';
export class ProductUnit extends StorageUnit {
static CLASS_NAME: string;
categoryId: string;
familyId: string;
levelCd: string;
typeId: string;
code: string;
name: string;
constructor();
}
}
declare module "sk/frame/logic/storage/module/product/product/ProductService" {
import { StorageUnitService } from 'foundation/data/common/storage/StorageUnitService';
import { ProductProductGetResponse } from 'sk/data/logic/design/message/ProductProductGetResponse';
import { ProductProductPageResponse } from 'sk/data/logic/design/message/ProductProductPageResponse';
import { ProductProductInsertResponse } from 'sk/data/logic/module/message/ProductProductInsertResponse';
import { ProductProductUpdateResponse } from 'sk/data/logic/module/message/ProductProductUpdateResponse';
import { ProductUnit } from "sk/frame/logic/storage/module/product/product/ProductUnit";
export class ProductService extends StorageUnitService {
constructor();
pageAsync(pageQuery: any): Promise;
getAsync(obj?: any): Promise;
insertAsync(unit: ProductUnit): Promise;
updateAsync(unit: ProductUnit): Promise;
}
}
declare module "sk/frame/logic/service/FrameCatalogService" {
import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
import { ResultObject } from 'cross/runtime/lang/ResultObject';
import { Service } from 'cross/runtime/module/Service';
import { LoginLogicService } from 'cross/data/module/logic/login/LoginLogicService';
export class CatalogTypeEnum {
static Product: string;
static Merchandise: string;
static Digitization: string;
}
export class DesignShowTypeEnum {
static Sku: number;
static Spu: number;
static ColorCard: number;
}
export class MerchandiseTypeEnum {
static NoSale: number;
static Goods: number;
}
export class CatalogTreeData {
id: string;
code: string;
name: string;
icon: string;
parentTree: CatalogTreeData;
hierachy: number;
designShowTypeCd: Number;
catalogType: CatalogTypeEnum;
items: Array;
showFlag: string;
constructor();
findChildCatalogTreeDataById(id: string): CatalogTreeData;
private getChildCatalogTreeDataById;
}
export class CatalogPageData {
page: number;
pageCount: number;
pageSize: number;
total: number;
rows: Array;
constructor();
}
export class DetailData {
id: string;
productId: string;
code: string;
name: string;
icon: string;
salePrice: number;
mainUnitName: string;
specification: string;
brandName: string;
model: string;
collectFlag: string;
productSymbolId: string;
symbols: Array;
categoryCode: string;
categoryId: string;
skuCode: string;
skuId: string;
skuName: string;
ifSell: Number;
dataInfo: string;
constructor();
}
export class SymbolData {
id: string;
name: string;
familyInfoId: string;
features: string;
linkCd: string;
}
export class FrameCatalogService extends Service {
protected _loginLogicService: LoginLogicService;
protected _catalogTreeDataCaches: Dictionary;
protected _prdouctIdCaches: Dictionary;
onInitialize(): void;
onUnload(): void;
clearCache(): void;
pageAsync(catalogType: CatalogTypeEnum, categoryId: string, page?: number, pageSize?: number, searchName?: string, ifNoSaleCeq?: number, showFlag?: string): Promise>;
treeAsync(catalogType: CatalogTypeEnum, categoryCode?: string): Promise>;
detailDataAsync(catalogType: CatalogTypeEnum, id: string): Promise>;
collectAsync(catalogType: CatalogTypeEnum, data: DetailData): Promise>;
private merchandiseCollectAsync;
private productTreeAsync;
private productTreeToCatalogTreeData;
private merchandiseTreeAsync;
private merchandiseTreeToCatalogTreeData;
private digitizationTreeAsync;
private digitizationTreeToCatalogTreeData;
private productPageAsync;
private merchandisePageAsync;
private digitizationPageAsync;
private merchandiseDetailDataAsync;
getSymbolsAsync(productId: string): Promise>;
}
}
declare module "sk/frame/logic/scheme/bathroom/action/BathroomDesignContext" {
import { ContextObject } from 'cross/runtime/lang/ContextObject';
import { ResultObject } from 'cross/runtime/lang/ResultObject';
import { ISpecificationFamilyInfo } from 'sk/data/specification/base/ISpecificationFamilyInfo';
import { AssembleBathroomPatternElement } from 'sk/data/family/database/pattern/element/AssembleBathroomPatternElement';
import { BathroomCeilingPatternElement } from 'sk/data/family/database/pattern/element/BathroomCeilingPatternElement';
import { BathroomFloorDryPatternElement } from 'sk/data/family/database/pattern/element/BathroomFloorDryPatternElement';
import { BathroomFloorPatternElement } from 'sk/data/family/database/pattern/element/BathroomFloorPatternElement';
import { BathroomFloorWetPatternElement } from 'sk/data/family/database/pattern/element/BathroomFloorWetPatternElement';
import { BathroomFloorWetSlotPatternElement } from 'sk/data/family/database/pattern/element/BathroomFloorWetSlotPatternElement';
import { BathroomFloorWetWarePatternElement } from 'sk/data/family/database/pattern/element/BathroomFloorWetWarePatternElement';
import { BathroomWallPatternElement } from 'sk/data/family/database/pattern/element/BathroomWallPatternElement';
import { ParameterPropertyStructure } from 'sk/data/family/element/config/parameter/ParameterPropertyStructure';
import { RoomNode } from 'sk/data/scheme/database/floorplan/model/RoomNode';
import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
import { SchemeDocument } from 'sk/data/scheme/model/SchemeDocument';
import { FrameCatalogService } from "sk/frame/logic/service/FrameCatalogService";
export enum BathroomDesignPropertyCodeEnum {
EdgeThickness = "edgeThickness",
ModCategory = "modCategory"
}
export class BathroomDesignContext {
roomNode: RoomNode;
document: SchemeDocument;
bathroom: BathroomElement;
context: ContextObject;
assembleInfoId: string;
assemblePatternElement: AssembleBathroomPatternElement;
wallInfoId: string;
wallPatternElement: BathroomWallPatternElement;
wallPlankInfoId: string;
wallSurfaceInfoId: string;
floorWallThickness: number;
wallSeamInfoId: string;
wallBaseThickness: number;
wallSurfaceThickness: number;
wallIndentation: number;
wallExpansion: number;
surfacetype: string;
wallSeamGap: number;
floorInfoId: string;
floorPatternElement: BathroomFloorPatternElement;
floorEdgeThickness: number;
floorDryInfoId: string;
floorDryPatternElement: BathroomFloorDryPatternElement;
floorDryPlankInfoId: string;
floorDrySeamInfoId: string;
floorDrySurfaceInfoId: string;
wetType: string;
wetWareType: string;
floorWetInfoId: string;
floorWetPatternElement: BathroomFloorWetPatternElement;
floorWetWarePatternElement: BathroomFloorWetWarePatternElement;
floorWetSlotatternElement: BathroomFloorWetSlotPatternElement;
floorWetWareInfoId: string;
floorWetPlankInfoId: string;
floorWetSurfaceInfoId: string;
floorWetSeamInfoId: string;
floorWaterSpliterInfoId: string;
floorSymbolWetInfoId: string;
floorWetBaseThickness: number;
floorWetSurfaceThickness: number;
floorWetSeamGap: number;
floorWetOutlineGap: number;
floorWetSeamThickness: number;
floorDryBaseThickness: number;
floorDrySurfaceThickness: number;
floorDrySeamThickness: number;
floorDrySeamGap: number;
floorDryOutlineGap: number;
floorDryEdgeThickness: number;
floorWetEdgeThickness: number;
ceilingInfoId: string;
ceilingPatternElement: BathroomCeilingPatternElement;
ceilingPlankInfoId: string;
ceilingSurfaceInfoId: string;
ceilingBaseThickness: number;
ceilingSurfaceThickness: number;
ceilingThickness: number;
ceilingSeamGap: number;
options: any;
layoutData: any;
holeInnerWallInfo: ISpecificationFamilyInfo;
floorThickness: number;
floorWetThickness: number;
floorWetDrainInfoId: string;
floorWetStoneInfoId: string;
floorWetSlotInfoId: string;
floorWetDesignThickness: number;
wallModCategory: string;
ceilingModCategory: string;
floorDryModCategory: string;
floorWetModCategory: string;
wallTenantId: string;
dryTenantId: string;
wetTenantId: string;
ceilingTenantId: string;
protected _schemeConfigService: SchemeConfigService;
protected _categoryService: FrameCatalogService;
constructor(roomNode: RoomNode);
protected setValue(key: string, property: ParameterPropertyStructure): void;
loadAssembleBathroomParamsAsync(context: ContextObject, bathroom: BathroomElement): Promise;
loadBathroomParamsAsync(context: ContextObject, bathroom: BathroomElement): Promise;
loadAssembleBathroomParamsFromAssembleAsync(context: ContextObject, assembleBathroom: AssembleBathroomElement): Promise;
loadBathroomParamsFromAssembleAsync(context: ContextObject, assembleBathroom: AssembleBathroomElement): Promise;
loadBathroomWallParamsAsync(context: ContextObject, bathroomWall: BathroomWallPatternElement): Promise;
loadBathroomFloorDryParamsAsync(context: ContextObject, bathroomFloorDry: BathroomFloorDryPatternElement): Promise;
loadBathroomFloorWetParamsAsync(context: ContextObject, bathroomFloorWet: BathroomFloorWetPatternElement): Promise;
loadBathroomFloorWetWareParamsAsync(context: ContextObject, bathroomFloorWet: BathroomFloorWetWarePatternElement): Promise;
loadBathroomFloorWetSlotParamsAsync(context: ContextObject, bathroomFloorWet: BathroomFloorWetSlotPatternElement): Promise;
loadBathroomFloorParamsAsync(context: ContextObject, bathroomFloor: BathroomFloorPatternElement): Promise;
loadBathroomCeilingParamsAsync(context: ContextObject, bathroomCeiling: BathroomCeilingPatternElement): Promise;
}
}
declare module "sk/frame/logic/scheme/bathroom/util/AssembleBathroomElementDesignUtil" {
import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
import { AssembleBathroomElement } from 'sk/data/scheme/database/pattern/element/AssembleBathroomElement';
import { BathroomElement } from 'sk/data/scheme/database/pattern/element/BathroomElement';
import { CeilingCreateDataInfo } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomCreateDesignData";
import { BathroomDesignContext } from "sk/frame/logic/scheme/bathroom/action/BathroomDesignContext";
export class AssembleBathroomElementDesignUtil {
static createAssembleBathroomElement(context: ElementPerformerContext, roomContext: BathroomDesignContext, parentElement: BathroomElement, ceilingData: CeilingCreateDataInfo): AssembleBathroomElement;
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/floordesign/floorwetdesign/BathroomFloorWetAreaDesignData" {
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { BathroomFloorWetElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetElement';
import { BathroomDesignContext } from "sk/frame/logic/scheme/bathroom/action/BathroomDesignContext";
import { BathroomBaseDesignData } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomBaseDesignData";
import { AreaInfo, FloorCreateDataInfo } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomCreateDesignData";
export class BathroomFloorWetAreaDesignData extends BathroomBaseDesignData {
basePlankId: string;
tileInfoId: string;
x: number;
y: number;
z: number;
lengthX: number;
lengthY: number;
lengthZ: number;
polygon: Vector2[];
basethickness: number;
surfaceThickness: number;
floorEdgeThickness: number;
startX: number;
startY: number;
outlineGap: number;
gap: number;
type: string;
outline: Array;
extendOutline: Array;
seamThickness: number;
code: string;
name: string;
offsetX: number;
offsetY: number;
floorThickness: number;
floorWetModCategory: string;
tenantId: string;
constructor();
recalculation(roomContext: BathroomDesignContext, floorDataInfo: FloorCreateDataInfo, areData: AreaInfo): void;
rebuildFromElement(bathroomFloorWetElement: BathroomFloorWetElement): void;
setFloorWetData(floorWetElement: BathroomFloorWetElement): BathroomFloorWetAreaDesignData;
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/floordesign/floorwetdesign/BathroomFloorWetWareDesignData" {
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { BathroomFloorWetElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetElement';
import { BathroomFloorWetWareElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetWareElement';
import { BathroomDesignContext } from "sk/frame/logic/scheme/bathroom/action/BathroomDesignContext";
import { BathroomBaseDesignData } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomBaseDesignData";
import { AreaInfo, FloorCreateDataInfo } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomCreateDesignData";
export class BathroomFloorWetWareDesignData extends BathroomBaseDesignData {
basePlankId: string;
tileInfoId: string;
x: number;
y: number;
z: number;
lengthX: number;
lengthY: number;
lengthZ: number;
polygon: Vector2[];
floorEdgeThickness: number;
startX: number;
startY: number;
outlineGap: number;
gap: number;
type: string;
outline: Array;
extendOutline: Array;
seamThickness: number;
code: string;
name: string;
offsetX: number;
offsetY: number;
floorThickness: number;
constructor();
recalculation(roomContext: BathroomDesignContext, floorDataInfo: FloorCreateDataInfo, areData: AreaInfo): void;
rebuildFromElement(bathroomFloorWetElement: BathroomFloorWetWareElement): void;
setFloorWetData(floorWetElement: BathroomFloorWetElement): BathroomFloorWetWareDesignData;
}
}
declare module "sk/frame/logic/scheme/bathroom/base/BathroomGeometryUtil" {
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { PolygonSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/PolygonSurfaceStructure';
import { SectionSurfaceStructure } from 'foundation/data/common/structure/geometric/surface/SectionSurfaceStructure';
export class BathroomGeometryUtil {
static createSurfaceSectionUtil(points: Array, originx?: number, originy?: number): SectionSurfaceStructure;
static createPlaneSurfaceSectionUtil(points: Array, originx?: number, originy?: number): PolygonSurfaceStructure;
static polygonStructureToPoints(polygonStructure: PolygonSurfaceStructure): Array;
}
}
declare module "sk/frame/logic/scheme/bathroom/BathroomFloorWetWareElementDesignUtil" {
import { ResultObject } from 'cross/runtime/lang/ResultObject';
import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
import { BathroomFloorElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorElement';
import { BathroomFloorWetWareElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorWetWareElement';
import { BathroomFloorWetAreaDesignData } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/floordesign/floorwetdesign/BathroomFloorWetAreaDesignData";
import { FloorCreateDataInfo } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomCreateDesignData";
import { BathroomDesignContext } from "sk/frame/logic/scheme/bathroom/action/BathroomDesignContext";
export class BathroomFloorWetWareElementDesignUtil {
static createFloorWetElementAsync(context: ElementPerformerContext, roomContext: BathroomDesignContext, floorElement: BathroomFloorElement, floorData: FloorCreateDataInfo): Promise;
static createFloorWetWareEleAsync(context: ElementPerformerContext, roomContext: BathroomDesignContext, floorElement: BathroomFloorElement, floorDataInfo: FloorCreateDataInfo): Promise;
static setBathroomFloorProperty(bathroomFloorWetElement: BathroomFloorWetWareElement, areaDataDesignData: BathroomFloorWetAreaDesignData): void;
static createFloorWareElementAsync(context: ElementPerformerContext, roomContext: BathroomDesignContext, floorElement: BathroomFloorWetWareElement): Promise;
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/layout/BathroomLayoutDesignCalculator" {
import { Curve2 } from 'foundation/runtime/math/Curve2';
import { Vector2 } from 'foundation/runtime/math/Vector2';
export class TilePartData {
x: number;
y: number;
lengthX: number;
lengthY: number;
rotate: number;
type: string;
cutlines: Array;
constructor();
getPoints(): Array;
}
export class TileData {
location: number;
length: number;
constructor();
}
export class TileDatas {
datas: Array;
constructor();
}
export class LayoutPolygon {
name: string;
points: Array;
holes: Array>;
constructor();
}
export class LayoutInputData {
polygon: LayoutPolygon;
tileLengthX: number;
tileLengthY: number;
beginOffsetX: number;
beginOffsetY: number;
gap: number;
endXSlice: number;
endYSlice: number;
rotation: number;
endXJF: boolean;
endYJF: boolean;
reverseX: boolean;
reverseY: boolean;
isSlice: boolean;
standard: number;
xMain: boolean;
yMain: boolean;
modContent: string;
constructor();
}
export class LayoutOutputData {
tiles: Array;
constructor();
}
export class BathroomLayoutDesignCalculator {
constructor();
layoutDataCalculator(inputData: LayoutInputData, isFloor?: boolean): LayoutOutputData;
layoutDataCalcutatorByHorizenAndVerticalInfo(horizenLayout: number[], verticalLayout: number[], dir: string): LayoutOutputData;
layoutDataCalcutatorHorizen(start: number, end: number, verticalLayout: number[], tileLength: number, gap: number, minLength: number, endJF: boolean, reverse: boolean): TilePartData[];
layoutDataCalcutatorVertical(start: number, end: number, horizonLayout: number[], tileLength: number, gap: number, minLength: number, endJF: boolean, reverse: boolean): TilePartData[];
removeTiles(tileLists: Array, outline: Array): void;
removeTilesInnerPolygon(tileLists: Array, outline: Array): void;
processOriginPoint(inputData: LayoutInputData, bound: Array): void;
layoutCalculator(start: number, end: number, offset: number, tileLength: number, gap: number, minLength: number, endJF: boolean, isFloor?: boolean, mainDir?: boolean): TileDatas;
layoutColumn(tileLength: number, gap: number, start: number, end: number, minLength: number, endJF: boolean, revese?: boolean): TileDatas;
layoutTiles(xList: TileDatas, yList: TileDatas): Array;
sliceTiles(tileList: Array, outline: Array, clipType?: string): void;
modRuleLayoutCalculator(inputData: LayoutInputData): LayoutOutputData;
modRuleLayoutColumn(modContent: string, gap: number, start: number): TileDatas;
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/floordesign/floordrydesign/BathroomFloorDryAreaDesignData" {
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
import { BathroomDesignContext } from "sk/frame/logic/scheme/bathroom/action/BathroomDesignContext";
import { TilePartData } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/layout/BathroomLayoutDesignCalculator";
import { BathroomBaseDesignData } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomBaseDesignData";
import { AreaInfo, FloorCreateDataInfo } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/BathroomCreateDesignData";
export class LayoutDirectEnum {
static leftTop: string;
static rightTop: string;
static leftDown: string;
static rightDown: string;
}
export class BathroomFloorDryAreaDesignData extends BathroomBaseDesignData {
basePlankId: string;
tileInfoId: string;
tileDirect: string;
x: number;
y: number;
z: number;
lengthX: number;
lengthY: number;
lengthZ: number;
outline: Array;
basethickness: number;
surfaceThickness: number;
startX: number;
startY: number;
offsetX: number;
offsetY: number;
outlineGap: number;
gap: number;
type: string;
extendOutline: Array;
extendX: number;
extendY: number;
extendStartX: number;
extendStartY: number;
code: string;
name: string;
seamThickness: number;
floorThickness: number;
floorDryModCategory: string;
tenantId: string;
constructor();
recalculation(roomContext: BathroomDesignContext, floorDataInfo: FloorCreateDataInfo, dryData: AreaInfo): void;
getExtendsOutline(gap?: number): Array;
caluclateExtendsStartPoint(): Vector2;
setFloorDryData(floorDryElement: BathroomFloorDryElement, mark?: boolean): BathroomFloorDryAreaDesignData;
layoutOffsetX(parts: Array, gap: number, sliceY: number, offsetX: number): void;
layoutOffsetY(parts: Array, gap: number, sliceY: number, offsetY: number): void;
reLayoutOneX(parts: Array, gap: number, sliceY: number): void;
reLayoutOneY(parts: Array, gap: number, sliceY: number): void;
reLayoutTwoX(parts: Array, gap: number, sliceY: number): void;
reLayoutTwoY(parts: Array, gap: number, sliceY: number): void;
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/validation/BathroomValidationRuleConfig" {
import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
import { InstanceObject } from 'cross/runtime/lang/InstanceObject';
export class BathroomValidationRuleConfig extends InstanceObject {
tenants: Dictionary;
items: Dictionary;
constructor();
static loadFromConfig(jconfigs: Array): Dictionary>;
}
export class BathroomValidationRuleConfigTenant extends InstanceObject {
id: string;
name: string;
static loadFromConfig(jconfigs: Array): Dictionary;
static create(jconfig: any): BathroomValidationRuleConfigTenant;
}
export class BathroomValidationRuleConfigItem extends InstanceObject {
code: string;
name: string;
ranges: Array;
symbols: Array;
constructor();
static loadFromConfig(jconfigs: Array): Dictionary;
static create(jconfig: any): BathroomValidationRuleConfigItem;
}
export class BathroomValidationRuleConfigItmRange extends InstanceObject {
min: number;
max: number;
interval: number;
static loadFromConfig(jcontents: Array): Array;
private static create;
}
export class BathroomValidationRuleConfigItmSymbol extends InstanceObject {
length: number;
width: number;
static loadFromConfig(jcontents: Array): Array;
private static create;
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/validation/BathroomValidationRuleConfigService" {
import { Dictionary } from 'cross/runtime/lang/collection/Dictionary';
import { IContext } from 'cross/runtime/lang/IContext';
import { ResultObject } from 'cross/runtime/lang/ResultObject';
import { JsonService } from 'cross/core/module/json/JsonService';
import { DataCacheInvoker } from 'foundation/data/common/service/DataCacheInvoker';
import { DataService } from 'foundation/data/common/service/DataService';
import { BathroomValidationRuleConfigItem, BathroomValidationRuleConfigItmRange, BathroomValidationRuleConfigItmSymbol } from "sk/frame/logic/scheme/bathroom/rule/validation/BathroomValidationRuleConfig";
export class BathroomValidationRuleConfigService extends DataService {
protected _jsonService: JsonService;
getRangeRulesAsync(context: IContext, code: string, tenantId?: string): Promise>>;
getSymbolRulesAsync(context: IContext, code: string, tenantId?: string): Promise>>;
getRuleItemAsync(context: IContext, code: string, tenantId?: string): Promise>;
protected createInvoker(name: string, handleLoadAsync: any, handleGet: any): DataCacheInvoker;
protected loadRuleConfigAsync(context: IContext): Promise>>>;
protected handleRulesLoadAsync(context: IContext, service: BathroomValidationRuleConfigService, parameters: any): Promise;
protected handleRulesGet(context: IContext, parameters: any, content: Array): Dictionary>;
}
}
declare module "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/floordesign/floordrydesign/BathroomFloorDryDesignBuilder" {
import { ResultObject } from 'cross/runtime/lang/ResultObject';
import { Vector2 } from 'foundation/runtime/math/Vector2';
import { ContentElement } from 'sk/data/family/element/brep/ContentElement';
import { ElementPerformerContext } from 'sk/data/family/performer/element/ElementPerformerContext';
import { LayoutTypeEnum } from 'sk/data/family/enumeration/LayoutTypeEnum';
import { BathroomFloorDryElement } from 'sk/data/scheme/database/pattern/element/BathroomFloorDryElement';
import { SchemeConfigService } from 'sk/data/scheme/config/SchemeConfigService';
import { BathroomValidationRuleConfigService } from "sk/frame/logic/scheme/bathroom/rule/validation/BathroomValidationRuleConfigService";
import { LayoutInputData, TilePartData } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/layout/BathroomLayoutDesignCalculator";
import { BathroomFloorDryAreaDesignData } from "sk/frame/logic/scheme/bathroom/rule/bathroomlayout/floordesign/floordrydesign/BathroomFloorDryAreaDesignData";
export class BathroomFloorDryDesignBuilder {
protected static _schemeConfigService: SchemeConfigService;
protected static _configRulerService: BathroomValidationRuleConfigService;
static buildDryBaseDataAsync(context: ElementPerformerContext, parent: ContentElement, floorData: BathroomFloorDryAreaDesignData): Promise;
static buildDrySeamDataAsync(context: ElementPerformerContext, parent: ContentElement, floorData: BathroomFloorDryAreaDesignData): Promise;
static buildDryFaceDataAsync(context: ElementPerformerContext, parent: ContentElement, floorData: BathroomFloorDryAreaDesignData): Promise;
static recreateDryFaceDataAsync(context: ElementPerformerContext, parent: ContentElement, floorData: BathroomFloorDryAreaDesignData, layoutType?: LayoutTypeEnum): Promise;
static alignGapDryFaceDataAsync(context: ElementPerformerContext, parent: ContentElement): Promise