@babylonjs/gui-editor 5.0.0-rc.7 → 5.0.0-rc.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,2680 +1,2680 @@
1
1
 
2
2
  declare module "@babylonjs/gui-editor/components/commandBarComponent" {
3
- import * as React from "react";
4
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
5
- import "@babylonjs/gui-editor/scss/commandBar.scss";
6
- interface ICommandBarComponentProps {
7
- globalState: GlobalState;
8
- }
9
- export class CommandBarComponent extends React.Component<ICommandBarComponentProps> {
10
- private _panning;
11
- private _zooming;
12
- private _selecting;
13
- private _sizeOption;
14
- constructor(props: ICommandBarComponentProps);
15
- render(): JSX.Element;
16
- }
17
- export {};
3
+ import * as React from "react";
4
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
5
+ import "@babylonjs/gui-editor/scss/commandBar.scss";
6
+ interface ICommandBarComponentProps {
7
+ globalState: GlobalState;
8
+ }
9
+ export class CommandBarComponent extends React.Component<ICommandBarComponentProps> {
10
+ private _panning;
11
+ private _zooming;
12
+ private _selecting;
13
+ private _sizeOption;
14
+ constructor(props: ICommandBarComponentProps);
15
+ render(): JSX.Element;
16
+ }
17
+ export {};
18
18
 
19
19
  }
20
20
  declare module "@babylonjs/gui-editor/components/commandButtonComponent" {
21
- import * as React from "react";
22
- interface ICommandButtonComponentProps {
23
- tooltip: string;
24
- shortcut?: string;
25
- icon: string;
26
- iconLabel?: string;
27
- isActive: boolean;
28
- onClick: () => void;
29
- altStyle?: boolean;
30
- disabled?: boolean;
31
- }
32
- export class CommandButtonComponent extends React.Component<ICommandButtonComponentProps> {
33
- constructor(props: ICommandButtonComponentProps);
34
- render(): JSX.Element;
35
- }
36
- export {};
21
+ import * as React from "react";
22
+ interface ICommandButtonComponentProps {
23
+ tooltip: string;
24
+ shortcut?: string;
25
+ icon: string;
26
+ iconLabel?: string;
27
+ isActive: boolean;
28
+ onClick: () => void;
29
+ altStyle?: boolean;
30
+ disabled?: boolean;
31
+ }
32
+ export class CommandButtonComponent extends React.Component<ICommandButtonComponentProps> {
33
+ constructor(props: ICommandButtonComponentProps);
34
+ render(): JSX.Element;
35
+ }
36
+ export {};
37
37
 
38
38
  }
39
39
  declare module "@babylonjs/gui-editor/components/commandDropdownComponent" {
40
- import * as React from "react";
41
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
42
- interface ICommandDropdownComponentProps {
43
- globalState: GlobalState;
44
- icon?: string;
45
- tooltip: string;
46
- defaultValue?: string;
47
- items: {
48
- label: string;
49
- icon?: string;
50
- fileButton?: boolean;
51
- onClick?: () => void;
52
- onCheck?: (value: boolean) => void;
53
- storeKey?: string;
54
- isActive?: boolean;
55
- defaultValue?: boolean | string;
56
- subItems?: string[];
57
- }[];
58
- toRight?: boolean;
59
- }
60
- export class CommandDropdownComponent extends React.Component<ICommandDropdownComponentProps, {
61
- isExpanded: boolean;
62
- activeState: string;
63
- }> {
64
- constructor(props: ICommandDropdownComponentProps);
65
- render(): JSX.Element;
66
- }
67
- export {};
40
+ import * as React from "react";
41
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
42
+ interface ICommandDropdownComponentProps {
43
+ globalState: GlobalState;
44
+ icon?: string;
45
+ tooltip: string;
46
+ defaultValue?: string;
47
+ items: {
48
+ label: string;
49
+ icon?: string;
50
+ fileButton?: boolean;
51
+ onClick?: () => void;
52
+ onCheck?: (value: boolean) => void;
53
+ storeKey?: string;
54
+ isActive?: boolean;
55
+ defaultValue?: boolean | string;
56
+ subItems?: string[];
57
+ }[];
58
+ toRight?: boolean;
59
+ }
60
+ export class CommandDropdownComponent extends React.Component<ICommandDropdownComponentProps, {
61
+ isExpanded: boolean;
62
+ activeState: string;
63
+ }> {
64
+ constructor(props: ICommandDropdownComponentProps);
65
+ render(): JSX.Element;
66
+ }
67
+ export {};
68
68
 
69
69
  }
70
70
  declare module "@babylonjs/gui-editor/components/guiList/guiListComponent" {
71
- import * as React from "react";
72
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
73
- import "@babylonjs/gui-editor/components/guiList/guiList.scss";
74
- interface IGuiListComponentProps {
75
- globalState: GlobalState;
76
- }
77
- export class GuiListComponent extends React.Component<IGuiListComponentProps, {
78
- filter: string;
79
- }> {
80
- private _onResetRequiredObserver;
81
- private static _Tooltips;
82
- constructor(props: IGuiListComponentProps);
83
- componentWillUnmount(): void;
84
- filterContent(filter: string): void;
85
- render(): JSX.Element;
86
- }
87
- export {};
71
+ import * as React from "react";
72
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
73
+ import "@babylonjs/gui-editor/components/guiList/guiList.scss";
74
+ interface IGuiListComponentProps {
75
+ globalState: GlobalState;
76
+ }
77
+ export class GuiListComponent extends React.Component<IGuiListComponentProps, {
78
+ filter: string;
79
+ }> {
80
+ private _onResetRequiredObserver;
81
+ private static _Tooltips;
82
+ constructor(props: IGuiListComponentProps);
83
+ componentWillUnmount(): void;
84
+ filterContent(filter: string): void;
85
+ render(): JSX.Element;
86
+ }
87
+ export {};
88
88
 
89
89
  }
90
90
  declare module "@babylonjs/gui-editor/components/log/logComponent" {
91
- import * as React from "react";
92
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
93
- import "@babylonjs/gui-editor/components/log/log.scss";
94
- interface ILogComponentProps {
95
- globalState: GlobalState;
96
- }
97
- export class LogEntry {
98
- message: string;
99
- isError: boolean;
100
- constructor(message: string, isError: boolean);
101
- }
102
- export class LogComponent extends React.Component<ILogComponentProps, {
103
- logs: LogEntry[];
104
- }> {
105
- constructor(props: ILogComponentProps);
106
- componentDidMount(): void;
107
- componentDidUpdate(): void;
108
- render(): JSX.Element;
109
- }
110
- export {};
91
+ import * as React from "react";
92
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
93
+ import "@babylonjs/gui-editor/components/log/log.scss";
94
+ interface ILogComponentProps {
95
+ globalState: GlobalState;
96
+ }
97
+ export class LogEntry {
98
+ message: string;
99
+ isError: boolean;
100
+ constructor(message: string, isError: boolean);
101
+ }
102
+ export class LogComponent extends React.Component<ILogComponentProps, {
103
+ logs: LogEntry[];
104
+ }> {
105
+ constructor(props: ILogComponentProps);
106
+ componentDidMount(): void;
107
+ componentDidUpdate(): void;
108
+ render(): JSX.Element;
109
+ }
110
+ export {};
111
111
 
112
112
  }
113
113
  declare module "@babylonjs/gui-editor/components/parentingPropertyGridComponent" {
114
- import * as React from "react";
115
- import { Control } from "@babylonjs/gui/2D/controls/control";
116
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
117
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
118
- import { Observable } from "@babylonjs/core/Misc/observable";
119
- interface IParentingPropertyGridComponentProps {
120
- control: Control;
121
- lockObject: LockObject;
122
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
123
- }
124
- export class ParentingPropertyGridComponent extends React.Component<IParentingPropertyGridComponentProps> {
125
- constructor(props: IParentingPropertyGridComponentProps);
126
- private _columnNumber;
127
- private _rowNumber;
128
- updateGridPosition(): void;
129
- getCellInfo(): void;
130
- private _changeCell;
131
- render(): JSX.Element;
132
- }
133
- export {};
114
+ import * as React from "react";
115
+ import { Control } from "@babylonjs/gui/2D/controls/control";
116
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
117
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
118
+ import { Observable } from "@babylonjs/core/Misc/observable";
119
+ interface IParentingPropertyGridComponentProps {
120
+ control: Control;
121
+ lockObject: LockObject;
122
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
123
+ }
124
+ export class ParentingPropertyGridComponent extends React.Component<IParentingPropertyGridComponentProps> {
125
+ constructor(props: IParentingPropertyGridComponentProps);
126
+ private _columnNumber;
127
+ private _rowNumber;
128
+ updateGridPosition(): void;
129
+ getCellInfo(): void;
130
+ private _changeCell;
131
+ render(): JSX.Element;
132
+ }
133
+ export {};
134
134
 
135
135
  }
136
136
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/buttonPropertyGridComponent" {
137
- import * as React from "react";
138
- import { Observable } from "@babylonjs/core/Misc/observable";
139
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
140
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
141
- import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
142
- interface IButtonPropertyGridComponentProps {
143
- rectangles: Rectangle[];
144
- lockObject: LockObject;
145
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
146
- onAddComponent: (newComponent: string) => void;
147
- }
148
- export class ButtonPropertyGridComponent extends React.Component<IButtonPropertyGridComponentProps> {
149
- constructor(props: IButtonPropertyGridComponentProps);
150
- render(): JSX.Element;
151
- }
152
- export {};
137
+ import * as React from "react";
138
+ import { Observable } from "@babylonjs/core/Misc/observable";
139
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
140
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
141
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
142
+ interface IButtonPropertyGridComponentProps {
143
+ rectangles: Rectangle[];
144
+ lockObject: LockObject;
145
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
146
+ onAddComponent: (newComponent: string) => void;
147
+ }
148
+ export class ButtonPropertyGridComponent extends React.Component<IButtonPropertyGridComponentProps> {
149
+ constructor(props: IButtonPropertyGridComponentProps);
150
+ render(): JSX.Element;
151
+ }
152
+ export {};
153
153
 
154
154
  }
155
155
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/checkboxPropertyGridComponent" {
156
- import * as React from "react";
157
- import { Observable } from "@babylonjs/core/Misc/observable";
158
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
159
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
160
- import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
161
- interface ICheckboxPropertyGridComponentProps {
162
- checkboxes: Checkbox[];
163
- lockObject: LockObject;
164
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
165
- }
166
- export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
167
- constructor(props: ICheckboxPropertyGridComponentProps);
168
- render(): JSX.Element;
169
- }
170
- export {};
156
+ import * as React from "react";
157
+ import { Observable } from "@babylonjs/core/Misc/observable";
158
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
159
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
160
+ import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
161
+ interface ICheckboxPropertyGridComponentProps {
162
+ checkboxes: Checkbox[];
163
+ lockObject: LockObject;
164
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
165
+ }
166
+ export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
167
+ constructor(props: ICheckboxPropertyGridComponentProps);
168
+ render(): JSX.Element;
169
+ }
170
+ export {};
171
171
 
172
172
  }
173
173
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/colorPickerPropertyGridComponent" {
174
- import * as React from "react";
175
- import { Observable } from "@babylonjs/core/Misc/observable";
176
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
177
- import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
178
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
179
- interface IColorPickerPropertyGridComponentProps {
180
- colorPickers: ColorPicker[];
181
- lockObject: LockObject;
182
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
183
- }
184
- export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
185
- constructor(props: IColorPickerPropertyGridComponentProps);
186
- render(): JSX.Element;
187
- }
188
- export {};
174
+ import * as React from "react";
175
+ import { Observable } from "@babylonjs/core/Misc/observable";
176
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
177
+ import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
178
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
179
+ interface IColorPickerPropertyGridComponentProps {
180
+ colorPickers: ColorPicker[];
181
+ lockObject: LockObject;
182
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
183
+ }
184
+ export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
185
+ constructor(props: IColorPickerPropertyGridComponentProps);
186
+ render(): JSX.Element;
187
+ }
188
+ export {};
189
189
 
190
190
  }
191
191
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/commonControlPropertyGridComponent" {
192
- import * as React from "react";
193
- import { Observable } from "@babylonjs/core/Misc/observable";
194
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
195
- import { Control } from "@babylonjs/gui/2D/controls/control";
196
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
197
- interface ICommonControlPropertyGridComponentProps {
198
- controls: Control[];
199
- lockObject: LockObject;
200
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
201
- }
202
- export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
203
- private _onPropertyChangedObserver;
204
- constructor(props: ICommonControlPropertyGridComponentProps);
205
- private _getTransformedReferenceCoordinate;
206
- private _updateAlignment;
207
- private _checkAndUpdateValues;
208
- private _markChildrenAsDirty;
209
- componentWillUnmount(): void;
210
- render(): JSX.Element;
211
- }
212
- export {};
192
+ import * as React from "react";
193
+ import { Observable } from "@babylonjs/core/Misc/observable";
194
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
195
+ import { Control } from "@babylonjs/gui/2D/controls/control";
196
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
197
+ interface ICommonControlPropertyGridComponentProps {
198
+ controls: Control[];
199
+ lockObject: LockObject;
200
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
201
+ }
202
+ export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
203
+ private _onPropertyChangedObserver;
204
+ constructor(props: ICommonControlPropertyGridComponentProps);
205
+ private _getTransformedReferenceCoordinate;
206
+ private _updateAlignment;
207
+ private _checkAndUpdateValues;
208
+ private _markChildrenAsDirty;
209
+ componentWillUnmount(): void;
210
+ render(): JSX.Element;
211
+ }
212
+ export {};
213
213
 
214
214
  }
215
215
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/containerPropertyGridComponent" {
216
- import * as React from "react";
217
- import { Observable } from "@babylonjs/core/Misc/observable";
218
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
219
- import { Container } from "@babylonjs/gui/2D/controls/container";
220
- interface IContainerPropertyGridComponentProps {
221
- containers: Container[];
222
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
223
- }
224
- export class ContainerPropertyGridComponent extends React.Component<IContainerPropertyGridComponentProps> {
225
- render(): JSX.Element;
226
- }
227
- export {};
216
+ import * as React from "react";
217
+ import { Observable } from "@babylonjs/core/Misc/observable";
218
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
219
+ import { Container } from "@babylonjs/gui/2D/controls/container";
220
+ interface IContainerPropertyGridComponentProps {
221
+ containers: Container[];
222
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
223
+ }
224
+ export class ContainerPropertyGridComponent extends React.Component<IContainerPropertyGridComponentProps> {
225
+ render(): JSX.Element;
226
+ }
227
+ export {};
228
228
 
229
229
  }
230
230
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/controlPropertyGridComponent" {
231
- import * as React from "react";
232
- import { Observable } from "@babylonjs/core/Misc/observable";
233
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
234
- import { Control } from "@babylonjs/gui/2D/controls/control";
235
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
236
- interface IControlPropertyGridComponentProps {
237
- controls: Control[];
238
- lockObject: LockObject;
239
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
240
- }
241
- export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
242
- constructor(props: IControlPropertyGridComponentProps);
243
- render(): JSX.Element;
244
- }
245
- export {};
231
+ import * as React from "react";
232
+ import { Observable } from "@babylonjs/core/Misc/observable";
233
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
234
+ import { Control } from "@babylonjs/gui/2D/controls/control";
235
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
236
+ interface IControlPropertyGridComponentProps {
237
+ controls: Control[];
238
+ lockObject: LockObject;
239
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
240
+ }
241
+ export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
242
+ constructor(props: IControlPropertyGridComponentProps);
243
+ render(): JSX.Element;
244
+ }
245
+ export {};
246
246
 
247
247
  }
248
248
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/displayGridPropertyGridComponent" {
249
- import * as React from "react";
250
- import { Observable } from "@babylonjs/core/Misc/observable";
251
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
252
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
253
- import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
254
- interface IDisplayGridPropertyGridComponentProps {
255
- displayGrids: DisplayGrid[];
256
- lockObject: LockObject;
257
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
258
- }
259
- export class DisplayGridPropertyGridComponent extends React.Component<IDisplayGridPropertyGridComponentProps> {
260
- constructor(props: IDisplayGridPropertyGridComponentProps);
261
- render(): JSX.Element;
262
- }
263
- export {};
249
+ import * as React from "react";
250
+ import { Observable } from "@babylonjs/core/Misc/observable";
251
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
252
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
253
+ import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
254
+ interface IDisplayGridPropertyGridComponentProps {
255
+ displayGrids: DisplayGrid[];
256
+ lockObject: LockObject;
257
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
258
+ }
259
+ export class DisplayGridPropertyGridComponent extends React.Component<IDisplayGridPropertyGridComponentProps> {
260
+ constructor(props: IDisplayGridPropertyGridComponentProps);
261
+ render(): JSX.Element;
262
+ }
263
+ export {};
264
264
 
265
265
  }
266
266
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/ellipsePropertyGridComponent" {
267
- import * as React from "react";
268
- import { Observable } from "@babylonjs/core/Misc/observable";
269
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
270
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
271
- import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
272
- interface IEllipsePropertyGridComponentProps {
273
- ellipses: Ellipse[];
274
- lockObject: LockObject;
275
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
276
- }
277
- export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
278
- constructor(props: IEllipsePropertyGridComponentProps);
279
- render(): JSX.Element;
280
- }
281
- export {};
267
+ import * as React from "react";
268
+ import { Observable } from "@babylonjs/core/Misc/observable";
269
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
270
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
271
+ import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
272
+ interface IEllipsePropertyGridComponentProps {
273
+ ellipses: Ellipse[];
274
+ lockObject: LockObject;
275
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
276
+ }
277
+ export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
278
+ constructor(props: IEllipsePropertyGridComponentProps);
279
+ render(): JSX.Element;
280
+ }
281
+ export {};
282
282
 
283
283
  }
284
284
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/gridPropertyGridComponent" {
285
- import * as React from "react";
286
- import { Observable } from "@babylonjs/core/Misc/observable";
287
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
288
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
289
- import { Grid } from "@babylonjs/gui/2D/controls/grid";
290
- interface IGridPropertyGridComponentProps {
291
- grids: Grid[];
292
- lockObject: LockObject;
293
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
294
- }
295
- export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
296
- constructor(props: IGridPropertyGridComponentProps);
297
- private _removingColumn;
298
- private _removingRow;
299
- private _previousGrid;
300
- private _rowDefinitions;
301
- private _rowEditFlags;
302
- private _columnEditFlags;
303
- private _columnDefinitions;
304
- private _editedRow;
305
- private _editedColumn;
306
- private _rowChild;
307
- private _columnChild;
308
- renderRows(): JSX.Element[];
309
- setRowValues(): void;
310
- setColumnValues(): void;
311
- renderColumns(): JSX.Element[];
312
- resizeRow(): void;
313
- resizeColumn(): void;
314
- checkValue(value: string, percent: boolean): string;
315
- checkPercentage(value: string): boolean;
316
- resetValues(): void;
317
- render(): JSX.Element;
318
- }
319
- export {};
285
+ import * as React from "react";
286
+ import { Observable } from "@babylonjs/core/Misc/observable";
287
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
288
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
289
+ import { Grid } from "@babylonjs/gui/2D/controls/grid";
290
+ interface IGridPropertyGridComponentProps {
291
+ grids: Grid[];
292
+ lockObject: LockObject;
293
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
294
+ }
295
+ export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
296
+ constructor(props: IGridPropertyGridComponentProps);
297
+ private _removingColumn;
298
+ private _removingRow;
299
+ private _previousGrid;
300
+ private _rowDefinitions;
301
+ private _rowEditFlags;
302
+ private _columnEditFlags;
303
+ private _columnDefinitions;
304
+ private _editedRow;
305
+ private _editedColumn;
306
+ private _rowChild;
307
+ private _columnChild;
308
+ renderRows(): JSX.Element[];
309
+ setRowValues(): void;
310
+ setColumnValues(): void;
311
+ renderColumns(): JSX.Element[];
312
+ resizeRow(): void;
313
+ resizeColumn(): void;
314
+ checkValue(value: string, percent: boolean): string;
315
+ checkPercentage(value: string): boolean;
316
+ resetValues(): void;
317
+ render(): JSX.Element;
318
+ }
319
+ export {};
320
320
 
321
321
  }
322
322
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
323
- import * as React from "react";
324
- import { Observable } from "@babylonjs/core/Misc/observable";
325
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
326
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
327
- import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
328
- interface IImageBasedSliderPropertyGridComponentProps {
329
- imageBasedSliders: ImageBasedSlider[];
330
- lockObject: LockObject;
331
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
332
- }
333
- export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
334
- constructor(props: IImageBasedSliderPropertyGridComponentProps);
335
- render(): JSX.Element;
336
- }
337
- export {};
323
+ import * as React from "react";
324
+ import { Observable } from "@babylonjs/core/Misc/observable";
325
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
326
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
327
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
328
+ interface IImageBasedSliderPropertyGridComponentProps {
329
+ imageBasedSliders: ImageBasedSlider[];
330
+ lockObject: LockObject;
331
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
332
+ }
333
+ export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
334
+ constructor(props: IImageBasedSliderPropertyGridComponentProps);
335
+ render(): JSX.Element;
336
+ }
337
+ export {};
338
338
 
339
339
  }
340
340
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/imagePropertyGridComponent" {
341
- import * as React from "react";
342
- import { Observable } from "@babylonjs/core/Misc/observable";
343
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
344
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
345
- import { Image } from "@babylonjs/gui/2D/controls/image";
346
- interface IImagePropertyGridComponentProps {
347
- images: Image[];
348
- lockObject: LockObject;
349
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
350
- }
351
- export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
352
- constructor(props: IImagePropertyGridComponentProps);
353
- toggleAnimations(on: boolean): void;
354
- getMaxCells(): number;
355
- updateCellSize(): void;
356
- render(): JSX.Element;
357
- }
358
- export {};
341
+ import * as React from "react";
342
+ import { Observable } from "@babylonjs/core/Misc/observable";
343
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
344
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
345
+ import { Image } from "@babylonjs/gui/2D/controls/image";
346
+ interface IImagePropertyGridComponentProps {
347
+ images: Image[];
348
+ lockObject: LockObject;
349
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
350
+ }
351
+ export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
352
+ constructor(props: IImagePropertyGridComponentProps);
353
+ toggleAnimations(on: boolean): void;
354
+ getMaxCells(): number;
355
+ updateCellSize(): void;
356
+ render(): JSX.Element;
357
+ }
358
+ export {};
359
359
 
360
360
  }
361
361
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/inputTextPropertyGridComponent" {
362
- import * as React from "react";
363
- import { Observable } from "@babylonjs/core/Misc/observable";
364
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
365
- import { InputText } from "@babylonjs/gui/2D/controls/inputText";
366
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
367
- interface IInputTextPropertyGridComponentProps {
368
- inputTexts: InputText[];
369
- lockObject: LockObject;
370
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
371
- }
372
- export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
373
- constructor(props: IInputTextPropertyGridComponentProps);
374
- render(): JSX.Element;
375
- }
376
- export {};
362
+ import * as React from "react";
363
+ import { Observable } from "@babylonjs/core/Misc/observable";
364
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
365
+ import { InputText } from "@babylonjs/gui/2D/controls/inputText";
366
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
367
+ interface IInputTextPropertyGridComponentProps {
368
+ inputTexts: InputText[];
369
+ lockObject: LockObject;
370
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
371
+ }
372
+ export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
373
+ constructor(props: IInputTextPropertyGridComponentProps);
374
+ render(): JSX.Element;
375
+ }
376
+ export {};
377
377
 
378
378
  }
379
379
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/linePropertyGridComponent" {
380
- import * as React from "react";
381
- import { Observable } from "@babylonjs/core/Misc/observable";
382
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
383
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
384
- import { Line } from "@babylonjs/gui/2D/controls/line";
385
- interface ILinePropertyGridComponentProps {
386
- lines: Line[];
387
- lockObject: LockObject;
388
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
389
- }
390
- export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
391
- constructor(props: ILinePropertyGridComponentProps);
392
- onDashChange(value: string): void;
393
- render(): JSX.Element;
394
- }
395
- export {};
380
+ import * as React from "react";
381
+ import { Observable } from "@babylonjs/core/Misc/observable";
382
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
383
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
384
+ import { Line } from "@babylonjs/gui/2D/controls/line";
385
+ interface ILinePropertyGridComponentProps {
386
+ lines: Line[];
387
+ lockObject: LockObject;
388
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
389
+ }
390
+ export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
391
+ constructor(props: ILinePropertyGridComponentProps);
392
+ onDashChange(value: string): void;
393
+ render(): JSX.Element;
394
+ }
395
+ export {};
396
396
 
397
397
  }
398
398
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/radioButtonPropertyGridComponent" {
399
- import * as React from "react";
400
- import { Observable } from "@babylonjs/core/Misc/observable";
401
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
402
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
403
- import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
404
- interface IRadioButtonPropertyGridComponentProps {
405
- radioButtons: RadioButton[];
406
- lockObject: LockObject;
407
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
408
- }
409
- export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
410
- constructor(props: IRadioButtonPropertyGridComponentProps);
411
- render(): JSX.Element;
412
- }
413
- export {};
399
+ import * as React from "react";
400
+ import { Observable } from "@babylonjs/core/Misc/observable";
401
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
402
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
403
+ import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
404
+ interface IRadioButtonPropertyGridComponentProps {
405
+ radioButtons: RadioButton[];
406
+ lockObject: LockObject;
407
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
408
+ }
409
+ export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
410
+ constructor(props: IRadioButtonPropertyGridComponentProps);
411
+ render(): JSX.Element;
412
+ }
413
+ export {};
414
414
 
415
415
  }
416
416
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/rectanglePropertyGridComponent" {
417
- import * as React from "react";
418
- import { Observable } from "@babylonjs/core/Misc/observable";
419
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
420
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
421
- import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
422
- interface IRectanglePropertyGridComponentProps {
423
- rectangles: Rectangle[];
424
- lockObject: LockObject;
425
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
426
- }
427
- export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
428
- constructor(props: IRectanglePropertyGridComponentProps);
429
- render(): JSX.Element;
430
- }
431
- export {};
417
+ import * as React from "react";
418
+ import { Observable } from "@babylonjs/core/Misc/observable";
419
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
420
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
421
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
422
+ interface IRectanglePropertyGridComponentProps {
423
+ rectangles: Rectangle[];
424
+ lockObject: LockObject;
425
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
426
+ }
427
+ export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
428
+ constructor(props: IRectanglePropertyGridComponentProps);
429
+ render(): JSX.Element;
430
+ }
431
+ export {};
432
432
 
433
433
  }
434
434
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/scrollViewerPropertyGridComponent" {
435
- import * as React from "react";
436
- import { Observable } from "@babylonjs/core/Misc/observable";
437
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
438
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
439
- import { ScrollViewer } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewer";
440
- interface IScrollViewerPropertyGridComponentProps {
441
- scrollViewers: ScrollViewer[];
442
- lockObject: LockObject;
443
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
444
- }
445
- export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
446
- constructor(props: IScrollViewerPropertyGridComponentProps);
447
- render(): JSX.Element;
448
- }
449
- export {};
435
+ import * as React from "react";
436
+ import { Observable } from "@babylonjs/core/Misc/observable";
437
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
438
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
439
+ import { ScrollViewer } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewer";
440
+ interface IScrollViewerPropertyGridComponentProps {
441
+ scrollViewers: ScrollViewer[];
442
+ lockObject: LockObject;
443
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
444
+ }
445
+ export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
446
+ constructor(props: IScrollViewerPropertyGridComponentProps);
447
+ render(): JSX.Element;
448
+ }
449
+ export {};
450
450
 
451
451
  }
452
452
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/sliderGenericPropertyGridComponent" {
453
- import * as React from "react";
454
- import { Observable } from "@babylonjs/core/Misc/observable";
455
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
456
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
457
- import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
458
- interface ISliderGenericPropertyGridComponentProps {
459
- sliders: Slider[];
460
- lockObject: LockObject;
461
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
462
- }
463
- export class SliderGenericPropertyGridComponent extends React.Component<ISliderGenericPropertyGridComponentProps> {
464
- constructor(props: ISliderGenericPropertyGridComponentProps);
465
- render(): JSX.Element;
466
- }
467
- export {};
453
+ import * as React from "react";
454
+ import { Observable } from "@babylonjs/core/Misc/observable";
455
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
456
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
457
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
458
+ interface ISliderGenericPropertyGridComponentProps {
459
+ sliders: Slider[];
460
+ lockObject: LockObject;
461
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
462
+ }
463
+ export class SliderGenericPropertyGridComponent extends React.Component<ISliderGenericPropertyGridComponentProps> {
464
+ constructor(props: ISliderGenericPropertyGridComponentProps);
465
+ render(): JSX.Element;
466
+ }
467
+ export {};
468
468
 
469
469
  }
470
470
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/sliderPropertyGridComponent" {
471
- import * as React from "react";
472
- import { Observable } from "@babylonjs/core/Misc/observable";
473
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
474
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
475
- import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
476
- import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
477
- interface ISliderPropertyGridComponentProps {
478
- sliders: (Slider | ImageBasedSlider)[];
479
- lockObject: LockObject;
480
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
481
- }
482
- export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
483
- constructor(props: ISliderPropertyGridComponentProps);
484
- render(): JSX.Element;
485
- }
486
- export {};
471
+ import * as React from "react";
472
+ import { Observable } from "@babylonjs/core/Misc/observable";
473
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
474
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
475
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
476
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
477
+ interface ISliderPropertyGridComponentProps {
478
+ sliders: (Slider | ImageBasedSlider)[];
479
+ lockObject: LockObject;
480
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
481
+ }
482
+ export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
483
+ constructor(props: ISliderPropertyGridComponentProps);
484
+ render(): JSX.Element;
485
+ }
486
+ export {};
487
487
 
488
488
  }
489
489
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/stackPanelPropertyGridComponent" {
490
- import * as React from "react";
491
- import { Observable } from "@babylonjs/core/Misc/observable";
492
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
493
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
494
- import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
495
- interface IStackPanelPropertyGridComponentProps {
496
- stackPanels: StackPanel[];
497
- lockObject: LockObject;
498
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
499
- }
500
- export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
501
- constructor(props: IStackPanelPropertyGridComponentProps);
502
- render(): JSX.Element;
503
- }
504
- export {};
490
+ import * as React from "react";
491
+ import { Observable } from "@babylonjs/core/Misc/observable";
492
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
493
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
494
+ import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
495
+ interface IStackPanelPropertyGridComponentProps {
496
+ stackPanels: StackPanel[];
497
+ lockObject: LockObject;
498
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
499
+ }
500
+ export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
501
+ constructor(props: IStackPanelPropertyGridComponentProps);
502
+ render(): JSX.Element;
503
+ }
504
+ export {};
505
505
 
506
506
  }
507
507
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/textBlockPropertyGridComponent" {
508
- import * as React from "react";
509
- import { Observable } from "@babylonjs/core/Misc/observable";
510
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
511
- import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
512
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
513
- interface ITextBlockPropertyGridComponentProps {
514
- textBlocks: TextBlock[];
515
- lockObject: LockObject;
516
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
517
- }
518
- export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
519
- constructor(props: ITextBlockPropertyGridComponentProps);
520
- render(): JSX.Element;
521
- }
522
- export {};
508
+ import * as React from "react";
509
+ import { Observable } from "@babylonjs/core/Misc/observable";
510
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
511
+ import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
512
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
513
+ interface ITextBlockPropertyGridComponentProps {
514
+ textBlocks: TextBlock[];
515
+ lockObject: LockObject;
516
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
517
+ }
518
+ export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
519
+ constructor(props: ITextBlockPropertyGridComponentProps);
520
+ render(): JSX.Element;
521
+ }
522
+ export {};
523
523
 
524
524
  }
525
525
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyTabComponent" {
526
- import * as React from "react";
527
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
528
- import { Control } from "@babylonjs/gui/2D/controls/control";
529
- import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
530
- import "@babylonjs/gui-editor/components/propertyTab/propertyTab.scss";
531
- interface IPropertyTabComponentProps {
532
- globalState: GlobalState;
533
- }
534
- export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps> {
535
- private _onBuiltObserver;
536
- private _timerIntervalId;
537
- private _lockObject;
538
- constructor(props: IPropertyTabComponentProps);
539
- componentDidMount(): void;
540
- componentWillUnmount(): void;
541
- load(file: File): void;
542
- save(saveCallback: () => void): void;
543
- saveLocally: () => void;
544
- saveToSnippetServerHelper: (content: string, adt: AdvancedDynamicTexture) => Promise<string>;
545
- saveToSnippetServer: () => Promise<void>;
546
- loadFromSnippet(): void;
547
- renderNode(nodes: Control[]): JSX.Element;
548
- /**
549
- * returns the class name of a list of controls if they share a class, or an empty string if not
550
- * @param nodes
551
- */
552
- getControlsCommonClassName(nodes: Control[]): string;
553
- renderProperties(nodes: Control[]): JSX.Element | undefined;
554
- renderControlIcon(nodes: Control[]): string;
555
- render(): JSX.Element | null;
556
- }
557
- export {};
526
+ import * as React from "react";
527
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
528
+ import { Control } from "@babylonjs/gui/2D/controls/control";
529
+ import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
530
+ import "@babylonjs/gui-editor/components/propertyTab/propertyTab.scss";
531
+ interface IPropertyTabComponentProps {
532
+ globalState: GlobalState;
533
+ }
534
+ export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps> {
535
+ private _onBuiltObserver;
536
+ private _timerIntervalId;
537
+ private _lockObject;
538
+ constructor(props: IPropertyTabComponentProps);
539
+ componentDidMount(): void;
540
+ componentWillUnmount(): void;
541
+ load(file: File): void;
542
+ save(saveCallback: () => void): void;
543
+ saveLocally: () => void;
544
+ saveToSnippetServerHelper: (content: string, adt: AdvancedDynamicTexture) => Promise<string>;
545
+ saveToSnippetServer: () => Promise<void>;
546
+ loadFromSnippet(): void;
547
+ renderNode(nodes: Control[]): JSX.Element;
548
+ /**
549
+ * returns the class name of a list of controls if they share a class, or an empty string if not
550
+ * @param nodes
551
+ */
552
+ getControlsCommonClassName(nodes: Control[]): string;
553
+ renderProperties(nodes: Control[]): JSX.Element | undefined;
554
+ renderControlIcon(nodes: Control[]): string;
555
+ render(): JSX.Element | null;
556
+ }
557
+ export {};
558
558
 
559
559
  }
560
560
  declare module "@babylonjs/gui-editor/components/sceneExplorer/entities/gui/controlTreeItemComponent" {
561
- import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
562
- import { Control } from "@babylonjs/gui/2D/controls/control";
563
- import * as React from "react";
564
- import { DragOverLocation, GlobalState } from "@babylonjs/gui-editor/globalState";
565
- interface IControlTreeItemComponentProps {
566
- control: Control;
567
- extensibilityGroups?: IExplorerExtensibilityGroup[];
568
- onClick: () => void;
569
- globalState: GlobalState;
570
- isHovered: boolean;
571
- isDragOver: boolean;
572
- dragOverLocation: DragOverLocation;
573
- }
574
- export class ControlTreeItemComponent extends React.Component<IControlTreeItemComponentProps, {
575
- isActive: boolean;
576
- isVisible: boolean;
577
- isRenaming: boolean;
578
- }> {
579
- constructor(props: IControlTreeItemComponentProps);
580
- highlight(): void;
581
- switchVisibility(): void;
582
- onRename(name: string): void;
583
- render(): JSX.Element;
584
- }
585
- export {};
561
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
562
+ import { Control } from "@babylonjs/gui/2D/controls/control";
563
+ import * as React from "react";
564
+ import { DragOverLocation, GlobalState } from "@babylonjs/gui-editor/globalState";
565
+ interface IControlTreeItemComponentProps {
566
+ control: Control;
567
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
568
+ onClick: () => void;
569
+ globalState: GlobalState;
570
+ isHovered: boolean;
571
+ isDragOver: boolean;
572
+ dragOverLocation: DragOverLocation;
573
+ }
574
+ export class ControlTreeItemComponent extends React.Component<IControlTreeItemComponentProps, {
575
+ isActive: boolean;
576
+ isVisible: boolean;
577
+ isRenaming: boolean;
578
+ }> {
579
+ constructor(props: IControlTreeItemComponentProps);
580
+ highlight(): void;
581
+ switchVisibility(): void;
582
+ onRename(name: string): void;
583
+ render(): JSX.Element;
584
+ }
585
+ export {};
586
586
 
587
587
  }
588
588
  declare module "@babylonjs/gui-editor/components/sceneExplorer/extensionsComponent" {
589
- import * as React from "react";
590
- import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
591
- interface IExtensionsComponentProps {
592
- target: any;
593
- extensibilityGroups?: IExplorerExtensibilityGroup[];
594
- }
595
- export class ExtensionsComponent extends React.Component<IExtensionsComponentProps, {
596
- popupVisible: boolean;
597
- }> {
598
- private _popup;
599
- private _extensionRef;
600
- constructor(props: IExtensionsComponentProps);
601
- showPopup(): void;
602
- componentDidMount(): void;
603
- componentDidUpdate(): void;
604
- render(): JSX.Element | null;
605
- }
606
- export {};
589
+ import * as React from "react";
590
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
591
+ interface IExtensionsComponentProps {
592
+ target: any;
593
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
594
+ }
595
+ export class ExtensionsComponent extends React.Component<IExtensionsComponentProps, {
596
+ popupVisible: boolean;
597
+ }> {
598
+ private _popup;
599
+ private _extensionRef;
600
+ constructor(props: IExtensionsComponentProps);
601
+ showPopup(): void;
602
+ componentDidMount(): void;
603
+ componentDidUpdate(): void;
604
+ render(): JSX.Element | null;
605
+ }
606
+ export {};
607
607
 
608
608
  }
609
609
  declare module "@babylonjs/gui-editor/components/sceneExplorer/sceneExplorerComponent" {
610
- import * as React from "react";
611
- import { Nullable } from "@babylonjs/core/types";
612
- import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
613
- import { Scene } from "@babylonjs/core/scene";
614
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
615
- import "@babylonjs/gui-editor/components/sceneExplorer/sceneExplorer.scss";
616
- interface ISceneExplorerFilterComponentProps {
617
- onFilter: (filter: string) => void;
618
- }
619
- export class SceneExplorerFilterComponent extends React.Component<ISceneExplorerFilterComponentProps> {
620
- constructor(props: ISceneExplorerFilterComponentProps);
621
- render(): JSX.Element;
622
- }
623
- interface ISceneExplorerComponentProps {
624
- scene?: Scene;
625
- noCommands?: boolean;
626
- noHeader?: boolean;
627
- noExpand?: boolean;
628
- noClose?: boolean;
629
- extensibilityGroups?: IExplorerExtensibilityGroup[];
630
- globalState: GlobalState;
631
- popupMode?: boolean;
632
- onPopup?: () => void;
633
- onClose?: () => void;
634
- }
635
- export class SceneExplorerComponent extends React.Component<ISceneExplorerComponentProps, {
636
- filter: Nullable<string>;
637
- selectedEntity: any;
638
- scene: Nullable<Scene>;
639
- }> {
640
- private _onSelectionChangeObserver;
641
- private _onParrentingChangeObserver;
642
- private _onNewSceneObserver;
643
- private _onPropertyChangedObservable;
644
- constructor(props: ISceneExplorerComponentProps);
645
- componentDidMount(): void;
646
- componentWillUnmount(): void;
647
- filterContent(filter: string): void;
648
- findSiblings(parent: any, items: any[], target: any, goNext: boolean, data: {
649
- previousOne?: any;
650
- found?: boolean;
651
- }): boolean;
652
- processKeys(keyEvent: React.KeyboardEvent<HTMLDivElement>): void;
653
- renderContent(): JSX.Element | null;
654
- onClose(): void;
655
- onPopup(): void;
656
- render(): JSX.Element;
657
- }
658
- export {};
610
+ import * as React from "react";
611
+ import { Nullable } from "@babylonjs/core/types";
612
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
613
+ import { Scene } from "@babylonjs/core/scene";
614
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
615
+ import "@babylonjs/gui-editor/components/sceneExplorer/sceneExplorer.scss";
616
+ interface ISceneExplorerFilterComponentProps {
617
+ onFilter: (filter: string) => void;
618
+ }
619
+ export class SceneExplorerFilterComponent extends React.Component<ISceneExplorerFilterComponentProps> {
620
+ constructor(props: ISceneExplorerFilterComponentProps);
621
+ render(): JSX.Element;
622
+ }
623
+ interface ISceneExplorerComponentProps {
624
+ scene?: Scene;
625
+ noCommands?: boolean;
626
+ noHeader?: boolean;
627
+ noExpand?: boolean;
628
+ noClose?: boolean;
629
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
630
+ globalState: GlobalState;
631
+ popupMode?: boolean;
632
+ onPopup?: () => void;
633
+ onClose?: () => void;
634
+ }
635
+ export class SceneExplorerComponent extends React.Component<ISceneExplorerComponentProps, {
636
+ filter: Nullable<string>;
637
+ selectedEntity: any;
638
+ scene: Nullable<Scene>;
639
+ }> {
640
+ private _onSelectionChangeObserver;
641
+ private _onParrentingChangeObserver;
642
+ private _onNewSceneObserver;
643
+ private _onPropertyChangedObservable;
644
+ constructor(props: ISceneExplorerComponentProps);
645
+ componentDidMount(): void;
646
+ componentWillUnmount(): void;
647
+ filterContent(filter: string): void;
648
+ findSiblings(parent: any, items: any[], target: any, goNext: boolean, data: {
649
+ previousOne?: any;
650
+ found?: boolean;
651
+ }): boolean;
652
+ processKeys(keyEvent: React.KeyboardEvent<HTMLDivElement>): void;
653
+ renderContent(): JSX.Element | null;
654
+ onClose(): void;
655
+ onPopup(): void;
656
+ render(): JSX.Element;
657
+ }
658
+ export {};
659
659
 
660
660
  }
661
661
  declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemComponent" {
662
- import * as React from "react";
663
- import { Nullable } from "@babylonjs/core/types";
664
- import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
665
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
666
- export interface ITreeItemComponentProps {
667
- items?: Nullable<any[]>;
668
- label: string;
669
- offset: number;
670
- filter: Nullable<string>;
671
- forceSubitems?: boolean;
672
- globalState: GlobalState;
673
- entity?: any;
674
- selectedEntities: any[];
675
- extensibilityGroups?: IExplorerExtensibilityGroup[];
676
- contextMenuItems?: {
677
- label: string;
678
- action: () => void;
679
- }[];
680
- }
681
- export class TreeItemComponent extends React.Component<ITreeItemComponentProps, {
682
- isExpanded: boolean;
683
- mustExpand: boolean;
684
- }> {
685
- static _ContextMenuUniqueIdGenerator: number;
686
- constructor(props: ITreeItemComponentProps);
687
- switchExpandedState(): void;
688
- shouldComponentUpdate(nextProps: ITreeItemComponentProps, nextState: {
689
- isExpanded: boolean;
690
- }): boolean;
691
- expandAll(expand: boolean): void;
692
- renderContextMenu(): JSX.Element | null;
693
- render(): JSX.Element;
694
- }
662
+ import * as React from "react";
663
+ import { Nullable } from "@babylonjs/core/types";
664
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
665
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
666
+ export interface ITreeItemComponentProps {
667
+ items?: Nullable<any[]>;
668
+ label: string;
669
+ offset: number;
670
+ filter: Nullable<string>;
671
+ forceSubitems?: boolean;
672
+ globalState: GlobalState;
673
+ entity?: any;
674
+ selectedEntities: any[];
675
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
676
+ contextMenuItems?: {
677
+ label: string;
678
+ action: () => void;
679
+ }[];
680
+ }
681
+ export class TreeItemComponent extends React.Component<ITreeItemComponentProps, {
682
+ isExpanded: boolean;
683
+ mustExpand: boolean;
684
+ }> {
685
+ static _ContextMenuUniqueIdGenerator: number;
686
+ constructor(props: ITreeItemComponentProps);
687
+ switchExpandedState(): void;
688
+ shouldComponentUpdate(nextProps: ITreeItemComponentProps, nextState: {
689
+ isExpanded: boolean;
690
+ }): boolean;
691
+ expandAll(expand: boolean): void;
692
+ renderContextMenu(): JSX.Element | null;
693
+ render(): JSX.Element;
694
+ }
695
695
 
696
696
  }
697
697
  declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemLabelComponent" {
698
- import * as React from "react";
699
- interface ITreeItemLabelComponentProps {
700
- label?: string;
701
- onClick?: () => void;
702
- onChange: (newValue: string) => void;
703
- bracket: string;
704
- renaming: boolean;
705
- setRenaming: (renaming: boolean) => void;
706
- }
707
- interface ITreeItemLabelState {
708
- value: string;
709
- }
710
- export class TreeItemLabelComponent extends React.Component<ITreeItemLabelComponentProps, ITreeItemLabelState> {
711
- constructor(props: ITreeItemLabelComponentProps);
712
- onClick(): void;
713
- onBlur(): void;
714
- render(): JSX.Element;
715
- }
716
- export {};
698
+ import * as React from "react";
699
+ interface ITreeItemLabelComponentProps {
700
+ label?: string;
701
+ onClick?: () => void;
702
+ onChange: (newValue: string) => void;
703
+ bracket: string;
704
+ renaming: boolean;
705
+ setRenaming: (renaming: boolean) => void;
706
+ }
707
+ interface ITreeItemLabelState {
708
+ value: string;
709
+ }
710
+ export class TreeItemLabelComponent extends React.Component<ITreeItemLabelComponentProps, ITreeItemLabelState> {
711
+ constructor(props: ITreeItemLabelComponentProps);
712
+ onClick(): void;
713
+ onBlur(): void;
714
+ render(): JSX.Element;
715
+ }
716
+ export {};
717
717
 
718
718
  }
719
719
  declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemSelectableComponent" {
720
- import { Nullable } from "@babylonjs/core/types";
721
- import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
722
- import * as React from "react";
723
- import { DragOverLocation, GlobalState } from "@babylonjs/gui-editor/globalState";
724
- export interface ITreeItemSelectableComponentProps {
725
- entity: any;
726
- selectedEntities: any[];
727
- mustExpand?: boolean;
728
- offset: number;
729
- globalState: GlobalState;
730
- extensibilityGroups?: IExplorerExtensibilityGroup[];
731
- filter: Nullable<string>;
732
- }
733
- export interface ITreeItemSelectableComponentState {
734
- dragOver: boolean;
735
- isSelected: boolean;
736
- isHovered: boolean;
737
- dragOverLocation: DragOverLocation;
738
- }
739
- export class TreeItemSelectableComponent extends React.Component<ITreeItemSelectableComponentProps, ITreeItemSelectableComponentState> {
740
- private _onSelectionChangedObservable;
741
- private _onDraggingEndObservable;
742
- private _onDraggingStartObservable;
743
- /** flag flipped onDragEnter if dragOver is already true
744
- * prevents dragLeave from immediately setting dragOver to false
745
- * required to make dragging work as expected
746
- * see: see: https://github.com/transformation-dev/matrx/tree/master/packages/dragster
747
- */
748
- private _secondDragEnter;
749
- constructor(props: ITreeItemSelectableComponentProps);
750
- switchExpandedState(): void;
751
- shouldComponentUpdate(nextProps: ITreeItemSelectableComponentProps, nextState: {
752
- isSelected: boolean;
753
- }): boolean;
754
- scrollIntoView(): void;
755
- componentWillUnmount(): void;
756
- onSelect(): void;
757
- renderChildren(isExpanded: boolean, offset?: boolean): (JSX.Element | null)[] | null;
758
- render(): JSX.Element | (JSX.Element | null)[] | null;
759
- dragOver(event: React.DragEvent<HTMLDivElement>): void;
760
- updateDragOverLocation(event: React.DragEvent<HTMLDivElement>): void;
761
- drop(): void;
762
- }
720
+ import { Nullable } from "@babylonjs/core/types";
721
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
722
+ import * as React from "react";
723
+ import { DragOverLocation, GlobalState } from "@babylonjs/gui-editor/globalState";
724
+ export interface ITreeItemSelectableComponentProps {
725
+ entity: any;
726
+ selectedEntities: any[];
727
+ mustExpand?: boolean;
728
+ offset: number;
729
+ globalState: GlobalState;
730
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
731
+ filter: Nullable<string>;
732
+ }
733
+ export interface ITreeItemSelectableComponentState {
734
+ dragOver: boolean;
735
+ isSelected: boolean;
736
+ isHovered: boolean;
737
+ dragOverLocation: DragOverLocation;
738
+ }
739
+ export class TreeItemSelectableComponent extends React.Component<ITreeItemSelectableComponentProps, ITreeItemSelectableComponentState> {
740
+ private _onSelectionChangedObservable;
741
+ private _onDraggingEndObservable;
742
+ private _onDraggingStartObservable;
743
+ /** flag flipped onDragEnter if dragOver is already true
744
+ * prevents dragLeave from immediately setting dragOver to false
745
+ * required to make dragging work as expected
746
+ * see: see: https://github.com/transformation-dev/matrx/tree/master/packages/dragster
747
+ */
748
+ private _secondDragEnter;
749
+ constructor(props: ITreeItemSelectableComponentProps);
750
+ switchExpandedState(): void;
751
+ shouldComponentUpdate(nextProps: ITreeItemSelectableComponentProps, nextState: {
752
+ isSelected: boolean;
753
+ }): boolean;
754
+ scrollIntoView(): void;
755
+ componentWillUnmount(): void;
756
+ onSelect(): void;
757
+ renderChildren(isExpanded: boolean, offset?: boolean): (JSX.Element | null)[] | null;
758
+ render(): JSX.Element | (JSX.Element | null)[] | null;
759
+ dragOver(event: React.DragEvent<HTMLDivElement>): void;
760
+ updateDragOverLocation(event: React.DragEvent<HTMLDivElement>): void;
761
+ drop(): void;
762
+ }
763
763
 
764
764
  }
765
765
  declare module "@babylonjs/gui-editor/controlTypes" {
766
- export const ControlTypes: {
767
- className: string;
768
- icon: string;
769
- }[];
766
+ export const ControlTypes: {
767
+ className: string;
768
+ icon: string;
769
+ }[];
770
770
 
771
771
  }
772
772
  declare module "@babylonjs/gui-editor/diagram/artBoard" {
773
- import * as React from "react";
774
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
775
- import { Rect } from "@babylonjs/gui-editor/diagram/coordinateHelper";
776
- interface IArtBoardProps {
777
- globalState: GlobalState;
778
- }
779
- interface IArtBoardState {
780
- bounds: Rect;
781
- }
782
- export class ArtBoardComponent extends React.Component<IArtBoardProps, IArtBoardState> {
783
- constructor(props: IArtBoardProps);
784
- update(): void;
785
- render(): JSX.Element;
786
- }
787
- export {};
773
+ import * as React from "react";
774
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
775
+ import { Rect } from "@babylonjs/gui-editor/diagram/coordinateHelper";
776
+ interface IArtBoardProps {
777
+ globalState: GlobalState;
778
+ }
779
+ interface IArtBoardState {
780
+ bounds: Rect;
781
+ }
782
+ export class ArtBoardComponent extends React.Component<IArtBoardProps, IArtBoardState> {
783
+ constructor(props: IArtBoardProps);
784
+ update(): void;
785
+ render(): JSX.Element;
786
+ }
787
+ export {};
788
788
 
789
789
  }
790
790
  declare module "@babylonjs/gui-editor/diagram/coordinateHelper" {
791
- import { Control } from "@babylonjs/gui/2D/controls/control";
792
- import { Matrix2D } from "@babylonjs/gui/2D/math2D";
793
- import { Vector2 } from "@babylonjs/core/Maths/math.vector";
794
- import { Observable } from "@babylonjs/core/Misc/observable";
795
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
796
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
797
- export type DimensionProperties = "width" | "left" | "height" | "top" | "paddingLeft" | "paddingRight" | "paddingTop" | "paddingBottom" | "fontSize";
798
- export class Rect {
799
- top: number;
800
- left: number;
801
- right: number;
802
- bottom: number;
803
- constructor(left: number, top: number, right: number, bottom: number);
804
- clone(): Rect;
805
- get center(): Vector2;
806
- get width(): number;
807
- get height(): number;
808
- }
809
- export class CoordinateHelper {
810
- private static _MatrixCache;
811
- static GlobalState: GlobalState;
812
- /**
813
- * Get the scaling of a specific GUI control
814
- * @param node the node for which we are getting the scaling
815
- * @param relative should we return only the relative scaling (relative to the parent)
816
- * @returns an X,Y vector of the scaling
817
- */
818
- static GetScale(node: Control, relative?: boolean): Vector2;
819
- static GetRotation(node: Control, relative?: boolean): number;
820
- /**
821
- * This function calculates a local matrix for a node, including it's full transformation and pivot point
822
- *
823
- * @param node the node to calculate the matrix for
824
- * @param storedValues should the stored (cached) values be used to calculate the matrix
825
- * @returns a new matrix for the control
826
- */
827
- static GetNodeMatrix(node: Control, storedValues?: Rect): Matrix2D;
828
- /**
829
- * Using the node's tree, calculate its world matrix and return it
830
- * @param node the node to calculate the matrix for
831
- * @param storedValues used stored valued (cached when pointer down is clicked)
832
- * @param stopAt stop looking when this node is found
833
- * @returns the world matrix for this node
834
- */
835
- static NodeToRTTWorldMatrix(node: Control, storedValues?: Rect, stopAt?: Control): Matrix2D;
836
- static NodeToRTTSpace(node: Control, x: number, y: number, reference?: Vector2, storedValues?: Rect, stopAt?: Control): Vector2;
837
- static RttToLocalNodeSpace(node: Control, x: number, y: number, reference?: Vector2, storedValues?: Rect): Vector2;
838
- static RttToCanvasSpace(x: number, y: number): Vector2;
839
- static MousePointerToRTTSpace(node: Control, x?: number, y?: number): Vector2;
840
- private static _ResetMatrixArray;
841
- static ComputeLocalBounds(node: Control): Rect;
842
- /**
843
- * converts a node's dimensions to percentage, properties can be specified as a list, or can convert all
844
- * @param guiControl
845
- * @param properties
846
- * @param onPropertyChangedObservable
847
- */
848
- static ConvertToPercentage(guiControl: Control, properties?: DimensionProperties[], onPropertyChangedObservable?: Observable<PropertyChangedEvent>): void;
849
- static Round(value: number): number;
850
- static ConvertToPixels(guiControl: Control, properties?: DimensionProperties[]): void;
851
- }
791
+ import { Control } from "@babylonjs/gui/2D/controls/control";
792
+ import { Matrix2D } from "@babylonjs/gui/2D/math2D";
793
+ import { Vector2 } from "@babylonjs/core/Maths/math.vector";
794
+ import { Observable } from "@babylonjs/core/Misc/observable";
795
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
796
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
797
+ export type DimensionProperties = "width" | "left" | "height" | "top" | "paddingLeft" | "paddingRight" | "paddingTop" | "paddingBottom" | "fontSize";
798
+ export class Rect {
799
+ top: number;
800
+ left: number;
801
+ right: number;
802
+ bottom: number;
803
+ constructor(left: number, top: number, right: number, bottom: number);
804
+ clone(): Rect;
805
+ get center(): Vector2;
806
+ get width(): number;
807
+ get height(): number;
808
+ }
809
+ export class CoordinateHelper {
810
+ private static _MatrixCache;
811
+ static GlobalState: GlobalState;
812
+ /**
813
+ * Get the scaling of a specific GUI control
814
+ * @param node the node for which we are getting the scaling
815
+ * @param relative should we return only the relative scaling (relative to the parent)
816
+ * @returns an X,Y vector of the scaling
817
+ */
818
+ static GetScale(node: Control, relative?: boolean): Vector2;
819
+ static GetRotation(node: Control, relative?: boolean): number;
820
+ /**
821
+ * This function calculates a local matrix for a node, including it's full transformation and pivot point
822
+ *
823
+ * @param node the node to calculate the matrix for
824
+ * @param storedValues should the stored (cached) values be used to calculate the matrix
825
+ * @returns a new matrix for the control
826
+ */
827
+ static GetNodeMatrix(node: Control, storedValues?: Rect): Matrix2D;
828
+ /**
829
+ * Using the node's tree, calculate its world matrix and return it
830
+ * @param node the node to calculate the matrix for
831
+ * @param storedValues used stored valued (cached when pointer down is clicked)
832
+ * @param stopAt stop looking when this node is found
833
+ * @returns the world matrix for this node
834
+ */
835
+ static NodeToRTTWorldMatrix(node: Control, storedValues?: Rect, stopAt?: Control): Matrix2D;
836
+ static NodeToRTTSpace(node: Control, x: number, y: number, reference?: Vector2, storedValues?: Rect, stopAt?: Control): Vector2;
837
+ static RttToLocalNodeSpace(node: Control, x: number, y: number, reference?: Vector2, storedValues?: Rect): Vector2;
838
+ static RttToCanvasSpace(x: number, y: number): Vector2;
839
+ static MousePointerToRTTSpace(node: Control, x?: number, y?: number): Vector2;
840
+ private static _ResetMatrixArray;
841
+ static ComputeLocalBounds(node: Control): Rect;
842
+ /**
843
+ * converts a node's dimensions to percentage, properties can be specified as a list, or can convert all
844
+ * @param guiControl
845
+ * @param properties
846
+ * @param onPropertyChangedObservable
847
+ */
848
+ static ConvertToPercentage(guiControl: Control, properties?: DimensionProperties[], onPropertyChangedObservable?: Observable<PropertyChangedEvent>): void;
849
+ static Round(value: number): number;
850
+ static ConvertToPixels(guiControl: Control, properties?: DimensionProperties[]): void;
851
+ }
852
852
 
853
853
  }
854
854
  declare module "@babylonjs/gui-editor/diagram/guiGizmo" {
855
- import { Control } from "@babylonjs/gui/2D/controls/control";
856
- import { Vector2 } from "@babylonjs/core/Maths/math.vector";
857
- import * as React from "react";
858
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
859
- import { Rect } from "@babylonjs/gui-editor/diagram/coordinateHelper";
860
- import "@babylonjs/gui-editor/diagram/workbenchCanvas.scss";
861
- export interface IGuiGizmoProps {
862
- globalState: GlobalState;
863
- control: Control;
864
- }
865
- enum ScalePointPosition {
866
- Top = -1,
867
- Left = -1,
868
- Center = 0,
869
- Right = 1,
870
- Bottom = 1
871
- }
872
- interface IScalePoint {
873
- position: Vector2;
874
- horizontalPosition: ScalePointPosition;
875
- verticalPosition: ScalePointPosition;
876
- rotation: number;
877
- isPivot: boolean;
878
- }
879
- interface IGuiGizmoState {
880
- canvasBounds: Rect;
881
- scalePoints: IScalePoint[];
882
- scalePointDragging: number;
883
- isRotating: boolean;
884
- }
885
- export class GuiGizmoComponent extends React.Component<IGuiGizmoProps, IGuiGizmoState> {
886
- private _storedValues;
887
- private _localBounds;
888
- private _rotation;
889
- private _gizmoUpdateObserver;
890
- private _pointerUpObserver;
891
- private _pointerMoveObserver;
892
- constructor(props: IGuiGizmoProps);
893
- componentWillUnmount(): void;
894
- /**
895
- * Update the gizmo's positions
896
- */
897
- updateGizmo(): void;
898
- private _onUp;
899
- private _onMove;
900
- private _rotate;
901
- private _modulo;
902
- private _dragLocalBounds;
903
- private _updateNodeFromLocalBounds;
904
- private _beginDraggingScalePoint;
905
- private _beginRotate;
906
- render(): JSX.Element;
907
- }
908
- export {};
855
+ import { Control } from "@babylonjs/gui/2D/controls/control";
856
+ import { Vector2 } from "@babylonjs/core/Maths/math.vector";
857
+ import * as React from "react";
858
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
859
+ import { Rect } from "@babylonjs/gui-editor/diagram/coordinateHelper";
860
+ import "@babylonjs/gui-editor/diagram/workbenchCanvas.scss";
861
+ export interface IGuiGizmoProps {
862
+ globalState: GlobalState;
863
+ control: Control;
864
+ }
865
+ enum ScalePointPosition {
866
+ Top = -1,
867
+ Left = -1,
868
+ Center = 0,
869
+ Right = 1,
870
+ Bottom = 1
871
+ }
872
+ interface IScalePoint {
873
+ position: Vector2;
874
+ horizontalPosition: ScalePointPosition;
875
+ verticalPosition: ScalePointPosition;
876
+ rotation: number;
877
+ isPivot: boolean;
878
+ }
879
+ interface IGuiGizmoState {
880
+ canvasBounds: Rect;
881
+ scalePoints: IScalePoint[];
882
+ scalePointDragging: number;
883
+ isRotating: boolean;
884
+ }
885
+ export class GuiGizmoComponent extends React.Component<IGuiGizmoProps, IGuiGizmoState> {
886
+ private _storedValues;
887
+ private _localBounds;
888
+ private _rotation;
889
+ private _gizmoUpdateObserver;
890
+ private _pointerUpObserver;
891
+ private _pointerMoveObserver;
892
+ constructor(props: IGuiGizmoProps);
893
+ componentWillUnmount(): void;
894
+ /**
895
+ * Update the gizmo's positions
896
+ */
897
+ updateGizmo(): void;
898
+ private _onUp;
899
+ private _onMove;
900
+ private _rotate;
901
+ private _modulo;
902
+ private _dragLocalBounds;
903
+ private _updateNodeFromLocalBounds;
904
+ private _beginDraggingScalePoint;
905
+ private _beginRotate;
906
+ render(): JSX.Element;
907
+ }
908
+ export {};
909
909
 
910
910
  }
911
911
  declare module "@babylonjs/gui-editor/diagram/guiGizmoWrapper" {
912
- import { Nullable } from "@babylonjs/core/types";
913
- import { Observer } from "@babylonjs/core/Misc/observable";
914
- import * as React from "react";
915
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
916
- export interface IGizmoWrapperProps {
917
- globalState: GlobalState;
918
- }
919
- export class GizmoWrapper extends React.Component<IGizmoWrapperProps> {
920
- observer: Nullable<Observer<void>>;
921
- componentWillMount(): void;
922
- componentWillUnmount(): void;
923
- render(): JSX.Element;
924
- }
912
+ import { Nullable } from "@babylonjs/core/types";
913
+ import { Observer } from "@babylonjs/core/Misc/observable";
914
+ import * as React from "react";
915
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
916
+ export interface IGizmoWrapperProps {
917
+ globalState: GlobalState;
918
+ }
919
+ export class GizmoWrapper extends React.Component<IGizmoWrapperProps> {
920
+ observer: Nullable<Observer<void>>;
921
+ componentWillMount(): void;
922
+ componentWillUnmount(): void;
923
+ render(): JSX.Element;
924
+ }
925
925
 
926
926
  }
927
927
  declare module "@babylonjs/gui-editor/diagram/workbench" {
928
- import * as React from "react";
929
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
930
- import { Control } from "@babylonjs/gui/2D/controls/control";
931
- import { Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector";
932
- import { Scene } from "@babylonjs/core/scene";
933
- import { Container } from "@babylonjs/gui/2D/controls/container";
934
- import { ISize } from "@babylonjs/core/Maths/math";
935
- import "@babylonjs/gui-editor/diagram/workbenchCanvas.scss";
936
- export interface IWorkbenchComponentProps {
937
- globalState: GlobalState;
938
- }
939
- export enum ConstraintDirection {
940
- NONE = 0,
941
- X = 2,
942
- Y = 3
943
- }
944
- export class WorkbenchComponent extends React.Component<IWorkbenchComponentProps> {
945
- private _rootContainer;
946
- private _setConstraintDirection;
947
- private _mouseStartPoint;
948
- _scene: Scene;
949
- private _ctrlKeyIsPressed;
950
- private _altKeyIsPressed;
951
- private _constraintDirection;
952
- private _forcePanning;
953
- private _forceZooming;
954
- private _forceSelecting;
955
- private _panning;
956
- private _canvas;
957
- private _responsive;
958
- private _isOverGUINode;
959
- private _engine;
960
- private _liveRenderObserver;
961
- private _guiRenderObserver;
962
- private _doubleClick;
963
- _liveGuiTextureRerender: boolean;
964
- private _controlsHit;
965
- private _pointerTravelDistance;
966
- private _processSelectionOnUp;
967
- private _visibleRegionContainer;
968
- get visibleRegionContainer(): Container;
969
- private _panAndZoomContainer;
970
- get panAndZoomContainer(): Container;
971
- private _trueRootContainer;
972
- set trueRootContainer(value: Container);
973
- get trueRootContainer(): Container;
974
- private _nextLiveGuiRender;
975
- private _liveGuiRerenderDelay;
976
- private _defaultGUISize;
977
- private _initialPanningOffset;
978
- private _panningOffset;
979
- private _zoomFactor;
980
- private _zoomModeIncrement;
981
- private _guiSize;
982
- get guiSize(): ISize;
983
- set guiSize(value: ISize);
984
- applyEditorTransformation(): void;
985
- removeEditorTransformation(): void;
986
- constructor(props: IWorkbenchComponentProps);
987
- keyEvent: (evt: KeyboardEvent) => void;
988
- copyToClipboard(copyFn: (content: string) => void): void;
989
- cutToClipboard(copyFn: (content: string) => void): void;
990
- pasteFromClipboard(clipboardContents: string): boolean;
991
- CopyGUIControl(original: Control): void;
992
- blurEvent: () => void;
993
- componentWillUnmount(): void;
994
- loadFromJson(serializationObject: any): void;
995
- loadFromSnippet(snippetId: string): Promise<void>;
996
- loadToEditor(): void;
997
- updateNodeOutlines(): void;
998
- appendBlock(guiElement: Control): Control;
999
- createNewGuiNode(guiControl: Control): Control;
1000
- private parent;
1001
- private _convertToPixels;
1002
- private _reorderGrid;
1003
- private _isNotChildInsert;
1004
- private _adjustParentingIndex;
1005
- isSelected(value: boolean, guiNode: Control): void;
1006
- clicked: boolean;
1007
- _onMove(guiControl: Control, evt: Vector2, startPos: Vector2): boolean;
1008
- onMove(evt: React.PointerEvent): void;
1009
- private _screenToTexturePosition;
1010
- private getScaledPointerPosition;
1011
- startPanning(): void;
1012
- endPanning(): void;
1013
- processSelection(): void;
1014
- onDown(evt: React.PointerEvent<HTMLElement>): void;
1015
- onUp(evt: React.PointerEvent): void;
1016
- createGUICanvas(): void;
1017
- synchronizeLiveGUI(): void;
1018
- addControls(scene: Scene): void;
1019
- panning(): void;
1020
- moveControls(moveHorizontal: boolean, amount: number): void;
1021
- zoomWheel(event: React.WheelEvent): void;
1022
- zooming(delta: number): void;
1023
- zeroIfClose(vec: Vector3): void;
1024
- render(): JSX.Element;
1025
- }
928
+ import * as React from "react";
929
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
930
+ import { Control } from "@babylonjs/gui/2D/controls/control";
931
+ import { Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector";
932
+ import { Scene } from "@babylonjs/core/scene";
933
+ import { Container } from "@babylonjs/gui/2D/controls/container";
934
+ import { ISize } from "@babylonjs/core/Maths/math";
935
+ import "@babylonjs/gui-editor/diagram/workbenchCanvas.scss";
936
+ export interface IWorkbenchComponentProps {
937
+ globalState: GlobalState;
938
+ }
939
+ export enum ConstraintDirection {
940
+ NONE = 0,
941
+ X = 2,
942
+ Y = 3
943
+ }
944
+ export class WorkbenchComponent extends React.Component<IWorkbenchComponentProps> {
945
+ private _rootContainer;
946
+ private _setConstraintDirection;
947
+ private _mouseStartPoint;
948
+ _scene: Scene;
949
+ private _ctrlKeyIsPressed;
950
+ private _altKeyIsPressed;
951
+ private _constraintDirection;
952
+ private _forcePanning;
953
+ private _forceZooming;
954
+ private _forceSelecting;
955
+ private _panning;
956
+ private _canvas;
957
+ private _responsive;
958
+ private _isOverGUINode;
959
+ private _engine;
960
+ private _liveRenderObserver;
961
+ private _guiRenderObserver;
962
+ private _doubleClick;
963
+ _liveGuiTextureRerender: boolean;
964
+ private _controlsHit;
965
+ private _pointerTravelDistance;
966
+ private _processSelectionOnUp;
967
+ private _visibleRegionContainer;
968
+ get visibleRegionContainer(): Container;
969
+ private _panAndZoomContainer;
970
+ get panAndZoomContainer(): Container;
971
+ private _trueRootContainer;
972
+ set trueRootContainer(value: Container);
973
+ get trueRootContainer(): Container;
974
+ private _nextLiveGuiRender;
975
+ private _liveGuiRerenderDelay;
976
+ private _defaultGUISize;
977
+ private _initialPanningOffset;
978
+ private _panningOffset;
979
+ private _zoomFactor;
980
+ private _zoomModeIncrement;
981
+ private _guiSize;
982
+ get guiSize(): ISize;
983
+ set guiSize(value: ISize);
984
+ applyEditorTransformation(): void;
985
+ removeEditorTransformation(): void;
986
+ constructor(props: IWorkbenchComponentProps);
987
+ keyEvent: (evt: KeyboardEvent) => void;
988
+ copyToClipboard(copyFn: (content: string) => void): void;
989
+ cutToClipboard(copyFn: (content: string) => void): void;
990
+ pasteFromClipboard(clipboardContents: string): boolean;
991
+ CopyGUIControl(original: Control): void;
992
+ blurEvent: () => void;
993
+ componentWillUnmount(): void;
994
+ loadFromJson(serializationObject: any): void;
995
+ loadFromSnippet(snippetId: string): Promise<void>;
996
+ loadToEditor(): void;
997
+ updateNodeOutlines(): void;
998
+ appendBlock(guiElement: Control): Control;
999
+ createNewGuiNode(guiControl: Control): Control;
1000
+ private parent;
1001
+ private _convertToPixels;
1002
+ private _reorderGrid;
1003
+ private _isNotChildInsert;
1004
+ private _adjustParentingIndex;
1005
+ isSelected(value: boolean, guiNode: Control): void;
1006
+ clicked: boolean;
1007
+ _onMove(guiControl: Control, evt: Vector2, startPos: Vector2): boolean;
1008
+ onMove(evt: React.PointerEvent): void;
1009
+ private _screenToTexturePosition;
1010
+ private getScaledPointerPosition;
1011
+ startPanning(): void;
1012
+ endPanning(): void;
1013
+ processSelection(): void;
1014
+ onDown(evt: React.PointerEvent<HTMLElement>): void;
1015
+ onUp(evt: React.PointerEvent): void;
1016
+ createGUICanvas(): void;
1017
+ synchronizeLiveGUI(): void;
1018
+ addControls(scene: Scene): void;
1019
+ panning(): void;
1020
+ moveControls(moveHorizontal: boolean, amount: number): void;
1021
+ zoomWheel(event: React.WheelEvent): void;
1022
+ zooming(delta: number): void;
1023
+ zeroIfClose(vec: Vector3): void;
1024
+ render(): JSX.Element;
1025
+ }
1026
1026
 
1027
1027
  }
1028
1028
  declare module "@babylonjs/gui-editor/globalState" {
1029
- /// <reference types="react" />
1030
- import { Nullable } from "@babylonjs/core/types";
1031
- import { Observable } from "@babylonjs/core/Misc/observable";
1032
- import { LogEntry } from "@babylonjs/gui-editor/components/log/logComponent";
1033
- import { Color3 } from "@babylonjs/core/Maths/math.color";
1034
- import { WorkbenchComponent } from "@babylonjs/gui-editor/diagram/workbench";
1035
- import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
1036
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1037
- import { Scene } from "@babylonjs/core/scene";
1038
- import { Control } from "@babylonjs/gui/2D/controls/control";
1039
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1040
- import { ISize } from "@babylonjs/core/Maths/math";
1041
- export enum DragOverLocation {
1042
- ABOVE = 0,
1043
- BELOW = 1,
1044
- CENTER = 2,
1045
- NONE = 3
1046
- }
1047
- export class GlobalState {
1048
- liveGuiTexture: Nullable<AdvancedDynamicTexture>;
1049
- guiTexture: AdvancedDynamicTexture;
1050
- hostElement: HTMLElement;
1051
- hostDocument: HTMLDocument;
1052
- hostWindow: Window;
1053
- selectedControls: Control[];
1054
- onSelectionChangedObservable: Observable<void>;
1055
- onResizeObservable: Observable<ISize>;
1056
- onBuiltObservable: Observable<void>;
1057
- onResetRequiredObservable: Observable<void>;
1058
- onUpdateRequiredObservable: Observable<void>;
1059
- onLogRequiredObservable: Observable<LogEntry>;
1060
- onErrorMessageDialogRequiredObservable: Observable<string>;
1061
- onIsLoadingChanged: Observable<boolean>;
1062
- onSelectionBoxMoved: Observable<ClientRect | DOMRect>;
1063
- onNewSceneObservable: Observable<Nullable<Scene>>;
1064
- onGuiNodeRemovalObservable: Observable<Control>;
1065
- onPopupClosedObservable: Observable<void>;
1066
- private _backgroundColor;
1067
- private _outlines;
1068
- isMultiSelecting: boolean;
1069
- onOutlineChangedObservable: Observable<void>;
1070
- blockKeyboardEvents: boolean;
1071
- controlCamera: boolean;
1072
- selectionLock: boolean;
1073
- workbench: WorkbenchComponent;
1074
- onPropertyChangedObservable: Observable<PropertyChangedEvent>;
1075
- onZoomObservable: Observable<void>;
1076
- onFitToWindowObservable: Observable<void>;
1077
- onPanObservable: Observable<void>;
1078
- onSelectionButtonObservable: Observable<void>;
1079
- onLoadObservable: Observable<File>;
1080
- onSaveObservable: Observable<void>;
1081
- onSnippetLoadObservable: Observable<void>;
1082
- onSnippetSaveObservable: Observable<void>;
1083
- onResponsiveChangeObservable: Observable<boolean>;
1084
- onParentingChangeObservable: Observable<Nullable<Control>>;
1085
- onDropObservable: Observable<void>;
1086
- onPropertyGridUpdateRequiredObservable: Observable<void>;
1087
- onDraggingEndObservable: Observable<void>;
1088
- onDraggingStartObservable: Observable<void>;
1089
- onWindowResizeObservable: Observable<void>;
1090
- onGizmoUpdateRequireObservable: Observable<void>;
1091
- onArtBoardUpdateRequiredObservable: Observable<void>;
1092
- onBackgroundColorChangeObservable: Observable<void>;
1093
- onPointerMoveObservable: Observable<import("react").PointerEvent<HTMLCanvasElement>>;
1094
- onPointerUpObservable: Observable<Nullable<PointerEvent | import("react").PointerEvent<HTMLCanvasElement>>>;
1095
- draggedControl: Nullable<Control>;
1096
- draggedControlDirection: DragOverLocation;
1097
- onCopyObservable: Observable<(content: string) => void>;
1098
- onCutObservable: Observable<(content: string) => void>;
1099
- onPasteObservable: Observable<string>;
1100
- isSaving: boolean;
1101
- lockObject: LockObject;
1102
- storeEditorData: (serializationObject: any) => void;
1103
- customSave?: {
1104
- label: string;
1105
- action: (data: string) => Promise<string>;
1106
- };
1107
- customLoad?: {
1108
- label: string;
1109
- action: (data: string) => Promise<string>;
1110
- };
1111
- constructor();
1112
- /** adds copy, cut and paste listeners to the host window */
1113
- registerEventListeners(): void;
1114
- private _updateKeys;
1115
- get backgroundColor(): Color3;
1116
- set backgroundColor(value: Color3);
1117
- get outlines(): boolean;
1118
- set outlines(value: boolean);
1119
- select(control: Control): void;
1120
- setSelection(controls: Control[]): void;
1121
- deleteSelectedNodes(): void;
1122
- isMultiSelectable(control: Control): boolean;
1123
- }
1029
+ /// <reference types="react" />
1030
+ import { Nullable } from "@babylonjs/core/types";
1031
+ import { Observable } from "@babylonjs/core/Misc/observable";
1032
+ import { LogEntry } from "@babylonjs/gui-editor/components/log/logComponent";
1033
+ import { Color3 } from "@babylonjs/core/Maths/math.color";
1034
+ import { WorkbenchComponent } from "@babylonjs/gui-editor/diagram/workbench";
1035
+ import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
1036
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1037
+ import { Scene } from "@babylonjs/core/scene";
1038
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1039
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1040
+ import { ISize } from "@babylonjs/core/Maths/math";
1041
+ export enum DragOverLocation {
1042
+ ABOVE = 0,
1043
+ BELOW = 1,
1044
+ CENTER = 2,
1045
+ NONE = 3
1046
+ }
1047
+ export class GlobalState {
1048
+ liveGuiTexture: Nullable<AdvancedDynamicTexture>;
1049
+ guiTexture: AdvancedDynamicTexture;
1050
+ hostElement: HTMLElement;
1051
+ hostDocument: HTMLDocument;
1052
+ hostWindow: Window;
1053
+ selectedControls: Control[];
1054
+ onSelectionChangedObservable: Observable<void>;
1055
+ onResizeObservable: Observable<ISize>;
1056
+ onBuiltObservable: Observable<void>;
1057
+ onResetRequiredObservable: Observable<void>;
1058
+ onUpdateRequiredObservable: Observable<void>;
1059
+ onLogRequiredObservable: Observable<LogEntry>;
1060
+ onErrorMessageDialogRequiredObservable: Observable<string>;
1061
+ onIsLoadingChanged: Observable<boolean>;
1062
+ onSelectionBoxMoved: Observable<ClientRect | DOMRect>;
1063
+ onNewSceneObservable: Observable<Nullable<Scene>>;
1064
+ onGuiNodeRemovalObservable: Observable<Control>;
1065
+ onPopupClosedObservable: Observable<void>;
1066
+ private _backgroundColor;
1067
+ private _outlines;
1068
+ isMultiSelecting: boolean;
1069
+ onOutlineChangedObservable: Observable<void>;
1070
+ blockKeyboardEvents: boolean;
1071
+ controlCamera: boolean;
1072
+ selectionLock: boolean;
1073
+ workbench: WorkbenchComponent;
1074
+ onPropertyChangedObservable: Observable<PropertyChangedEvent>;
1075
+ onZoomObservable: Observable<void>;
1076
+ onFitToWindowObservable: Observable<void>;
1077
+ onPanObservable: Observable<void>;
1078
+ onSelectionButtonObservable: Observable<void>;
1079
+ onLoadObservable: Observable<File>;
1080
+ onSaveObservable: Observable<void>;
1081
+ onSnippetLoadObservable: Observable<void>;
1082
+ onSnippetSaveObservable: Observable<void>;
1083
+ onResponsiveChangeObservable: Observable<boolean>;
1084
+ onParentingChangeObservable: Observable<Nullable<Control>>;
1085
+ onDropObservable: Observable<void>;
1086
+ onPropertyGridUpdateRequiredObservable: Observable<void>;
1087
+ onDraggingEndObservable: Observable<void>;
1088
+ onDraggingStartObservable: Observable<void>;
1089
+ onWindowResizeObservable: Observable<void>;
1090
+ onGizmoUpdateRequireObservable: Observable<void>;
1091
+ onArtBoardUpdateRequiredObservable: Observable<void>;
1092
+ onBackgroundColorChangeObservable: Observable<void>;
1093
+ onPointerMoveObservable: Observable<import("react").PointerEvent<HTMLCanvasElement>>;
1094
+ onPointerUpObservable: Observable<Nullable<PointerEvent | import("react").PointerEvent<HTMLCanvasElement>>>;
1095
+ draggedControl: Nullable<Control>;
1096
+ draggedControlDirection: DragOverLocation;
1097
+ onCopyObservable: Observable<(content: string) => void>;
1098
+ onCutObservable: Observable<(content: string) => void>;
1099
+ onPasteObservable: Observable<string>;
1100
+ isSaving: boolean;
1101
+ lockObject: LockObject;
1102
+ storeEditorData: (serializationObject: any) => void;
1103
+ customSave?: {
1104
+ label: string;
1105
+ action: (data: string) => Promise<string>;
1106
+ };
1107
+ customLoad?: {
1108
+ label: string;
1109
+ action: (data: string) => Promise<string>;
1110
+ };
1111
+ constructor();
1112
+ /** adds copy, cut and paste listeners to the host window */
1113
+ registerEventListeners(): void;
1114
+ private _updateKeys;
1115
+ get backgroundColor(): Color3;
1116
+ set backgroundColor(value: Color3);
1117
+ get outlines(): boolean;
1118
+ set outlines(value: boolean);
1119
+ select(control: Control): void;
1120
+ setSelection(controls: Control[]): void;
1121
+ deleteSelectedNodes(): void;
1122
+ isMultiSelectable(control: Control): boolean;
1123
+ }
1124
1124
 
1125
1125
  }
1126
1126
  declare module "@babylonjs/gui-editor/guiEditor" {
1127
- import { Observable } from "@babylonjs/core/Misc/observable";
1128
- import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
1129
- /**
1130
- * Interface used to specify creation options for the gui editor
1131
- */
1132
- export interface IGUIEditorOptions {
1133
- liveGuiTexture?: AdvancedDynamicTexture;
1134
- customLoad: {
1135
- label: string;
1136
- action: (data: string) => Promise<string>;
1137
- } | undefined;
1138
- hostElement?: HTMLElement;
1139
- customSave?: {
1140
- label: string;
1141
- action: (data: string) => Promise<string>;
1142
- };
1143
- currentSnippetToken?: string;
1144
- customLoadObservable?: Observable<any>;
1145
- }
1146
- /**
1147
- * Class used to create a gui editor
1148
- */
1149
- export class GUIEditor {
1150
- private static _CurrentState;
1151
- /**
1152
- * Show the gui editor
1153
- * @param options defines the options to use to configure the gui editor
1154
- */
1155
- static Show(options: IGUIEditorOptions): Promise<void>;
1156
- }
1127
+ import { Observable } from "@babylonjs/core/Misc/observable";
1128
+ import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
1129
+ /**
1130
+ * Interface used to specify creation options for the gui editor
1131
+ */
1132
+ export interface IGUIEditorOptions {
1133
+ liveGuiTexture?: AdvancedDynamicTexture;
1134
+ customLoad: {
1135
+ label: string;
1136
+ action: (data: string) => Promise<string>;
1137
+ } | undefined;
1138
+ hostElement?: HTMLElement;
1139
+ customSave?: {
1140
+ label: string;
1141
+ action: (data: string) => Promise<string>;
1142
+ };
1143
+ currentSnippetToken?: string;
1144
+ customLoadObservable?: Observable<any>;
1145
+ }
1146
+ /**
1147
+ * Class used to create a gui editor
1148
+ */
1149
+ export class GUIEditor {
1150
+ private static _CurrentState;
1151
+ /**
1152
+ * Show the gui editor
1153
+ * @param options defines the options to use to configure the gui editor
1154
+ */
1155
+ static Show(options: IGUIEditorOptions): Promise<void>;
1156
+ }
1157
1157
 
1158
1158
  }
1159
1159
  declare module "@babylonjs/gui-editor/guiNodeTools" {
1160
- import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
1161
- import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
1162
- import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
1163
- import { Line } from "@babylonjs/gui/2D/controls/line";
1164
- import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
1165
- import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
1166
- import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
1167
- import { Image } from "@babylonjs/gui/2D/controls/image";
1168
- import { InputText } from "@babylonjs/gui/2D/controls/inputText";
1169
- import { Grid } from "@babylonjs/gui/2D/controls/grid";
1170
- import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
1171
- import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
1172
- import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
1173
- import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
1174
- export class GUINodeTools {
1175
- static ImageControlDefaultUrl: string;
1176
- static CreateControlFromString(data: string): Grid | Rectangle | Line | TextBlock | Image | Slider | ImageBasedSlider | RadioButton | InputText | ColorPicker | StackPanel | Ellipse | Checkbox | DisplayGrid;
1177
- }
1160
+ import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
1161
+ import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
1162
+ import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
1163
+ import { Line } from "@babylonjs/gui/2D/controls/line";
1164
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
1165
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
1166
+ import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
1167
+ import { Image } from "@babylonjs/gui/2D/controls/image";
1168
+ import { InputText } from "@babylonjs/gui/2D/controls/inputText";
1169
+ import { Grid } from "@babylonjs/gui/2D/controls/grid";
1170
+ import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
1171
+ import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
1172
+ import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
1173
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
1174
+ export class GUINodeTools {
1175
+ static ImageControlDefaultUrl: string;
1176
+ static CreateControlFromString(data: string): Grid | Rectangle | Line | TextBlock | Image | Slider | ImageBasedSlider | RadioButton | InputText | ColorPicker | StackPanel | Ellipse | Checkbox | DisplayGrid;
1177
+ }
1178
1178
 
1179
1179
  }
1180
1180
  declare module "@babylonjs/gui-editor/index" {
1181
- export * from "@babylonjs/gui-editor/guiEditor";
1181
+ export * from "@babylonjs/gui-editor/guiEditor";
1182
1182
 
1183
1183
  }
1184
1184
  declare module "@babylonjs/gui-editor/legacy/legacy" {
1185
- export * from "@babylonjs/gui-editor/index";
1185
+ export * from "@babylonjs/gui-editor/index";
1186
1186
 
1187
1187
  }
1188
1188
  declare module "@babylonjs/gui-editor/nodeLocationInfo" {
1189
- export interface INodeLocationInfo {
1190
- blockId: number;
1191
- x: number;
1192
- y: number;
1193
- }
1194
- export interface IFrameData {
1195
- x: number;
1196
- y: number;
1197
- width: number;
1198
- height: number;
1199
- color: number[];
1200
- name: string;
1201
- isCollapsed: boolean;
1202
- blocks: number[];
1203
- comments: string;
1204
- }
1205
- export interface IEditorData {
1206
- locations: INodeLocationInfo[];
1207
- x: number;
1208
- y: number;
1209
- zoom: number;
1210
- frames?: IFrameData[];
1211
- map?: {
1212
- [key: number]: number;
1213
- };
1214
- }
1189
+ export interface INodeLocationInfo {
1190
+ blockId: number;
1191
+ x: number;
1192
+ y: number;
1193
+ }
1194
+ export interface IFrameData {
1195
+ x: number;
1196
+ y: number;
1197
+ width: number;
1198
+ height: number;
1199
+ color: number[];
1200
+ name: string;
1201
+ isCollapsed: boolean;
1202
+ blocks: number[];
1203
+ comments: string;
1204
+ }
1205
+ export interface IEditorData {
1206
+ locations: INodeLocationInfo[];
1207
+ x: number;
1208
+ y: number;
1209
+ zoom: number;
1210
+ frames?: IFrameData[];
1211
+ map?: {
1212
+ [key: number]: number;
1213
+ };
1214
+ }
1215
1215
 
1216
1216
  }
1217
1217
  declare module "@babylonjs/gui-editor/portal" {
1218
- import * as React from "react";
1219
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
1220
- interface IPortalProps {
1221
- globalState: GlobalState;
1222
- }
1223
- export class Portal extends React.Component<IPortalProps> {
1224
- render(): React.ReactPortal;
1225
- }
1226
- export {};
1218
+ import * as React from "react";
1219
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1220
+ interface IPortalProps {
1221
+ globalState: GlobalState;
1222
+ }
1223
+ export class Portal extends React.Component<IPortalProps> {
1224
+ render(): React.ReactPortal;
1225
+ }
1226
+ export {};
1227
1227
 
1228
1228
  }
1229
1229
  declare module "@babylonjs/gui-editor/sharedComponents/floatLineComponent" {
1230
- import * as React from "react";
1231
- import { Observable } from "@babylonjs/core/Misc/observable";
1232
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedComponents/propertyChangedEvent";
1233
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
1234
- interface IFloatLineComponentProps {
1235
- label: string;
1236
- target: any;
1237
- propertyName: string;
1238
- onChange?: (newValue: number) => void;
1239
- isInteger?: boolean;
1240
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1241
- additionalClass?: string;
1242
- step?: string;
1243
- digits?: number;
1244
- globalState: GlobalState;
1245
- min?: number;
1246
- max?: number;
1247
- smallUI?: boolean;
1248
- onEnter?: (newValue: number) => void;
1249
- }
1250
- export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
1251
- value: string;
1252
- }> {
1253
- private _localChange;
1254
- private _store;
1255
- private _regExp;
1256
- private _digits;
1257
- constructor(props: IFloatLineComponentProps);
1258
- shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
1259
- value: string;
1260
- }): boolean;
1261
- raiseOnPropertyChanged(newValue: number, previousValue: number): void;
1262
- updateValue(valueString: string): void;
1263
- render(): JSX.Element;
1264
- }
1265
- export {};
1230
+ import * as React from "react";
1231
+ import { Observable } from "@babylonjs/core/Misc/observable";
1232
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedComponents/propertyChangedEvent";
1233
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1234
+ interface IFloatLineComponentProps {
1235
+ label: string;
1236
+ target: any;
1237
+ propertyName: string;
1238
+ onChange?: (newValue: number) => void;
1239
+ isInteger?: boolean;
1240
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1241
+ additionalClass?: string;
1242
+ step?: string;
1243
+ digits?: number;
1244
+ globalState: GlobalState;
1245
+ min?: number;
1246
+ max?: number;
1247
+ smallUI?: boolean;
1248
+ onEnter?: (newValue: number) => void;
1249
+ }
1250
+ export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
1251
+ value: string;
1252
+ }> {
1253
+ private _localChange;
1254
+ private _store;
1255
+ private _regExp;
1256
+ private _digits;
1257
+ constructor(props: IFloatLineComponentProps);
1258
+ shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
1259
+ value: string;
1260
+ }): boolean;
1261
+ raiseOnPropertyChanged(newValue: number, previousValue: number): void;
1262
+ updateValue(valueString: string): void;
1263
+ render(): JSX.Element;
1264
+ }
1265
+ export {};
1266
1266
 
1267
1267
  }
1268
1268
  declare module "@babylonjs/gui-editor/sharedComponents/lineWithFileButtonComponent" {
1269
- import * as React from "react";
1270
- interface ILineWithFileButtonComponentProps {
1271
- title: string;
1272
- closed?: boolean;
1273
- label: string;
1274
- iconImage: any;
1275
- onIconClick: (file: File) => void;
1276
- accept: string;
1277
- uploadName?: string;
1278
- }
1279
- export class LineWithFileButtonComponent extends React.Component<ILineWithFileButtonComponentProps, {
1280
- isExpanded: boolean;
1281
- }> {
1282
- private _uploadRef;
1283
- constructor(props: ILineWithFileButtonComponentProps);
1284
- onChange(evt: any): void;
1285
- switchExpandedState(): void;
1286
- render(): JSX.Element;
1287
- }
1288
- export {};
1269
+ import * as React from "react";
1270
+ interface ILineWithFileButtonComponentProps {
1271
+ title: string;
1272
+ closed?: boolean;
1273
+ label: string;
1274
+ iconImage: any;
1275
+ onIconClick: (file: File) => void;
1276
+ accept: string;
1277
+ uploadName?: string;
1278
+ }
1279
+ export class LineWithFileButtonComponent extends React.Component<ILineWithFileButtonComponentProps, {
1280
+ isExpanded: boolean;
1281
+ }> {
1282
+ private _uploadRef;
1283
+ constructor(props: ILineWithFileButtonComponentProps);
1284
+ onChange(evt: any): void;
1285
+ switchExpandedState(): void;
1286
+ render(): JSX.Element;
1287
+ }
1288
+ export {};
1289
1289
 
1290
1290
  }
1291
1291
  declare module "@babylonjs/gui-editor/sharedComponents/messageDialog" {
1292
- import * as React from "react";
1293
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
1294
- interface IMessageDialogComponentProps {
1295
- globalState: GlobalState;
1296
- }
1297
- export class MessageDialogComponent extends React.Component<IMessageDialogComponentProps, {
1298
- message: string;
1299
- isError: boolean;
1300
- }> {
1301
- constructor(props: IMessageDialogComponentProps);
1302
- render(): JSX.Element | null;
1303
- }
1304
- export {};
1292
+ import * as React from "react";
1293
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1294
+ interface IMessageDialogComponentProps {
1295
+ globalState: GlobalState;
1296
+ }
1297
+ export class MessageDialogComponent extends React.Component<IMessageDialogComponentProps, {
1298
+ message: string;
1299
+ isError: boolean;
1300
+ }> {
1301
+ constructor(props: IMessageDialogComponentProps);
1302
+ render(): JSX.Element | null;
1303
+ }
1304
+ export {};
1305
1305
 
1306
1306
  }
1307
1307
  declare module "@babylonjs/gui-editor/sharedComponents/numericInputComponent" {
1308
- import * as React from "react";
1309
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
1310
- interface INumericInputComponentProps {
1311
- label: string;
1312
- value: number;
1313
- step?: number;
1314
- onChange: (value: number) => void;
1315
- globalState: GlobalState;
1316
- }
1317
- export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
1318
- value: string;
1319
- }> {
1320
- static defaultProps: {
1321
- step: number;
1322
- };
1323
- private _localChange;
1324
- constructor(props: INumericInputComponentProps);
1325
- shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
1326
- value: string;
1327
- }): boolean;
1328
- updateValue(evt: any): void;
1329
- render(): JSX.Element;
1330
- }
1331
- export {};
1308
+ import * as React from "react";
1309
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1310
+ interface INumericInputComponentProps {
1311
+ label: string;
1312
+ value: number;
1313
+ step?: number;
1314
+ onChange: (value: number) => void;
1315
+ globalState: GlobalState;
1316
+ }
1317
+ export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
1318
+ value: string;
1319
+ }> {
1320
+ static defaultProps: {
1321
+ step: number;
1322
+ };
1323
+ private _localChange;
1324
+ constructor(props: INumericInputComponentProps);
1325
+ shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
1326
+ value: string;
1327
+ }): boolean;
1328
+ updateValue(evt: any): void;
1329
+ render(): JSX.Element;
1330
+ }
1331
+ export {};
1332
1332
 
1333
1333
  }
1334
1334
  declare module "@babylonjs/gui-editor/sharedComponents/propertyChangedEvent" {
1335
- export class PropertyChangedEvent {
1336
- object: any;
1337
- property: string;
1338
- value: any;
1339
- initialValue: any;
1340
- }
1335
+ export class PropertyChangedEvent {
1336
+ object: any;
1337
+ property: string;
1338
+ value: any;
1339
+ initialValue: any;
1340
+ }
1341
1341
 
1342
1342
  }
1343
1343
  declare module "@babylonjs/gui-editor/sharedComponents/sliderLineComponent" {
1344
- import * as React from "react";
1345
- import { Observable } from "@babylonjs/core/Misc/observable";
1346
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedComponents/propertyChangedEvent";
1347
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
1348
- interface ISliderLineComponentProps {
1349
- label: string;
1350
- target?: any;
1351
- propertyName?: string;
1352
- minimum: number;
1353
- maximum: number;
1354
- step: number;
1355
- directValue?: number;
1356
- useEuler?: boolean;
1357
- onChange?: (value: number) => void;
1358
- onInput?: (value: number) => void;
1359
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1360
- decimalCount?: number;
1361
- globalState: GlobalState;
1362
- }
1363
- export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
1364
- value: number;
1365
- }> {
1366
- private _localChange;
1367
- constructor(props: ISliderLineComponentProps);
1368
- shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
1369
- value: number;
1370
- }): boolean;
1371
- onChange(newValueString: any): void;
1372
- onInput(newValueString: any): void;
1373
- prepareDataToRead(value: number): number;
1374
- render(): JSX.Element;
1375
- }
1376
- export {};
1344
+ import * as React from "react";
1345
+ import { Observable } from "@babylonjs/core/Misc/observable";
1346
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedComponents/propertyChangedEvent";
1347
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1348
+ interface ISliderLineComponentProps {
1349
+ label: string;
1350
+ target?: any;
1351
+ propertyName?: string;
1352
+ minimum: number;
1353
+ maximum: number;
1354
+ step: number;
1355
+ directValue?: number;
1356
+ useEuler?: boolean;
1357
+ onChange?: (value: number) => void;
1358
+ onInput?: (value: number) => void;
1359
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1360
+ decimalCount?: number;
1361
+ globalState: GlobalState;
1362
+ }
1363
+ export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
1364
+ value: number;
1365
+ }> {
1366
+ private _localChange;
1367
+ constructor(props: ISliderLineComponentProps);
1368
+ shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
1369
+ value: number;
1370
+ }): boolean;
1371
+ onChange(newValueString: any): void;
1372
+ onInput(newValueString: any): void;
1373
+ prepareDataToRead(value: number): number;
1374
+ render(): JSX.Element;
1375
+ }
1376
+ export {};
1377
1377
 
1378
1378
  }
1379
1379
  declare module "@babylonjs/gui-editor/sharedComponents/textInputLineComponent" {
1380
- import * as React from "react";
1381
- import { Observable } from "@babylonjs/core/Misc/observable";
1382
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedComponents/propertyChangedEvent";
1383
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
1384
- interface ITextInputLineComponentProps {
1385
- label: string;
1386
- globalState: GlobalState;
1387
- target?: any;
1388
- propertyName?: string;
1389
- value?: string;
1390
- multilines?: boolean;
1391
- onChange?: (value: string) => void;
1392
- validator?: (value: string) => boolean;
1393
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1394
- }
1395
- export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
1396
- value: string;
1397
- }> {
1398
- private _localChange;
1399
- constructor(props: ITextInputLineComponentProps);
1400
- shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
1401
- value: string;
1402
- }): boolean;
1403
- raiseOnPropertyChanged(newValue: string, previousValue: string): void;
1404
- updateValue(value: string, raisePropertyChanged: boolean): void;
1405
- render(): JSX.Element;
1406
- }
1407
- export {};
1380
+ import * as React from "react";
1381
+ import { Observable } from "@babylonjs/core/Misc/observable";
1382
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedComponents/propertyChangedEvent";
1383
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1384
+ interface ITextInputLineComponentProps {
1385
+ label: string;
1386
+ globalState: GlobalState;
1387
+ target?: any;
1388
+ propertyName?: string;
1389
+ value?: string;
1390
+ multilines?: boolean;
1391
+ onChange?: (value: string) => void;
1392
+ validator?: (value: string) => boolean;
1393
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1394
+ }
1395
+ export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
1396
+ value: string;
1397
+ }> {
1398
+ private _localChange;
1399
+ constructor(props: ITextInputLineComponentProps);
1400
+ shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
1401
+ value: string;
1402
+ }): boolean;
1403
+ raiseOnPropertyChanged(newValue: string, previousValue: string): void;
1404
+ updateValue(value: string, raisePropertyChanged: boolean): void;
1405
+ render(): JSX.Element;
1406
+ }
1407
+ export {};
1408
1408
 
1409
1409
  }
1410
1410
  declare module "@babylonjs/gui-editor/tools" {
1411
- import { Control } from "@babylonjs/gui/2D/controls/control";
1412
- import { Grid } from "@babylonjs/gui/2D/controls/grid";
1413
- import { Vector2 } from "@babylonjs/core/Maths/math";
1414
- export class Tools {
1415
- static LookForItems(item: any, selectedEntities: any[], firstIteration?: boolean): boolean;
1416
- private static _RecursiveRemoveHiddenMeshesAndHoistChildren;
1417
- static SortAndFilter(parent: any, items: any[]): any[];
1418
- static GetCellInfo(grid: Grid, control: Control): Vector2;
1419
- static ReorderGrid(grid: Grid, index: number, control: Control, cell: Vector2): void;
1420
- }
1411
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1412
+ import { Grid } from "@babylonjs/gui/2D/controls/grid";
1413
+ import { Vector2 } from "@babylonjs/core/Maths/math";
1414
+ export class Tools {
1415
+ static LookForItems(item: any, selectedEntities: any[], firstIteration?: boolean): boolean;
1416
+ private static _RecursiveRemoveHiddenMeshesAndHoistChildren;
1417
+ static SortAndFilter(parent: any, items: any[]): any[];
1418
+ static GetCellInfo(grid: Grid, control: Control): Vector2;
1419
+ static ReorderGrid(grid: Grid, index: number, control: Control, cell: Vector2): void;
1420
+ }
1421
1421
 
1422
1422
  }
1423
1423
  declare module "@babylonjs/gui-editor/workbenchEditor" {
1424
- import * as React from "react";
1425
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
1426
- import { Control } from "@babylonjs/gui/2D/controls/control";
1427
- import "@babylonjs/gui-editor/main.scss";
1428
- import "@babylonjs/gui-editor/scss/header.scss";
1429
- interface IGraphEditorProps {
1430
- globalState: GlobalState;
1431
- }
1432
- interface IGraphEditorState {
1433
- showPreviewPopUp: boolean;
1434
- }
1435
- export class WorkbenchEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
1436
- private _moveInProgress;
1437
- private _leftWidth;
1438
- private _rightWidth;
1439
- private _popUpWindow;
1440
- private _draggedItem;
1441
- private _rootRef;
1442
- componentDidMount(): void;
1443
- constructor(props: IGraphEditorProps);
1444
- showWaitScreen(): void;
1445
- hideWaitScreen(): void;
1446
- onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
1447
- onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
1448
- resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
1449
- buildColumnLayout(): string;
1450
- handlePopUp: () => void;
1451
- handleClosingPopUp: () => void;
1452
- createPopupWindow: (title: string, windowVariableName: string, width?: number, height?: number) => Window | null;
1453
- copyStyles: (sourceDoc: HTMLDocument, targetDoc: HTMLDocument) => void;
1454
- render(): JSX.Element;
1455
- onCreate(value: string): Control;
1456
- createToolbar(): JSX.Element;
1457
- }
1458
- export {};
1424
+ import * as React from "react";
1425
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1426
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1427
+ import "@babylonjs/gui-editor/main.scss";
1428
+ import "@babylonjs/gui-editor/scss/header.scss";
1429
+ interface IGraphEditorProps {
1430
+ globalState: GlobalState;
1431
+ }
1432
+ interface IGraphEditorState {
1433
+ showPreviewPopUp: boolean;
1434
+ }
1435
+ export class WorkbenchEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
1436
+ private _moveInProgress;
1437
+ private _leftWidth;
1438
+ private _rightWidth;
1439
+ private _popUpWindow;
1440
+ private _draggedItem;
1441
+ private _rootRef;
1442
+ componentDidMount(): void;
1443
+ constructor(props: IGraphEditorProps);
1444
+ showWaitScreen(): void;
1445
+ hideWaitScreen(): void;
1446
+ onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
1447
+ onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
1448
+ resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
1449
+ buildColumnLayout(): string;
1450
+ handlePopUp: () => void;
1451
+ handleClosingPopUp: () => void;
1452
+ createPopupWindow: (title: string, windowVariableName: string, width?: number, height?: number) => Window | null;
1453
+ copyStyles: (sourceDoc: HTMLDocument, targetDoc: HTMLDocument) => void;
1454
+ render(): JSX.Element;
1455
+ onCreate(value: string): Control;
1456
+ createToolbar(): JSX.Element;
1457
+ }
1458
+ export {};
1459
1459
 
1460
1460
  }
1461
1461
  declare module "shared-ui-components/colorPicker/colorComponentEntry" {
1462
- import * as React from "react";
1463
- export interface IColorComponentEntryProps {
1464
- value: number;
1465
- label: string;
1466
- max?: number;
1467
- min?: number;
1468
- onChange: (value: number) => void;
1469
- disabled?: boolean;
1470
- }
1471
- export class ColorComponentEntry extends React.Component<IColorComponentEntryProps> {
1472
- constructor(props: IColorComponentEntryProps);
1473
- updateValue(valueString: string): void;
1474
- render(): JSX.Element;
1475
- }
1462
+ import * as React from "react";
1463
+ export interface IColorComponentEntryProps {
1464
+ value: number;
1465
+ label: string;
1466
+ max?: number;
1467
+ min?: number;
1468
+ onChange: (value: number) => void;
1469
+ disabled?: boolean;
1470
+ }
1471
+ export class ColorComponentEntry extends React.Component<IColorComponentEntryProps> {
1472
+ constructor(props: IColorComponentEntryProps);
1473
+ updateValue(valueString: string): void;
1474
+ render(): JSX.Element;
1475
+ }
1476
1476
 
1477
1477
  }
1478
1478
  declare module "shared-ui-components/colorPicker/colorPicker" {
1479
- import * as React from "react";
1480
- import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
1481
- import "shared-ui-components/colorPicker/colorPicker.scss";
1482
- /**
1483
- * Interface used to specify creation options for color picker
1484
- */
1485
- export interface IColorPickerProps {
1486
- color: Color3 | Color4;
1487
- linearhint?: boolean;
1488
- debugMode?: boolean;
1489
- onColorChanged?: (color: Color3 | Color4) => void;
1490
- }
1491
- /**
1492
- * Interface used to specify creation options for color picker
1493
- */
1494
- export interface IColorPickerState {
1495
- color: Color3;
1496
- alpha: number;
1497
- }
1498
- /**
1499
- * Class used to create a color picker
1500
- */
1501
- export class ColorPicker extends React.Component<IColorPickerProps, IColorPickerState> {
1502
- private _saturationRef;
1503
- private _hueRef;
1504
- private _isSaturationPointerDown;
1505
- private _isHuePointerDown;
1506
- constructor(props: IColorPickerProps);
1507
- shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean;
1508
- onSaturationPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
1509
- onSaturationPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
1510
- onSaturationPointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
1511
- onHuePointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
1512
- onHuePointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
1513
- onHuePointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
1514
- private _evaluateSaturation;
1515
- private _evaluateHue;
1516
- componentDidUpdate(): void;
1517
- raiseOnColorChanged(): void;
1518
- render(): JSX.Element;
1519
- }
1479
+ import * as React from "react";
1480
+ import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
1481
+ import "shared-ui-components/colorPicker/colorPicker.scss";
1482
+ /**
1483
+ * Interface used to specify creation options for color picker
1484
+ */
1485
+ export interface IColorPickerProps {
1486
+ color: Color3 | Color4;
1487
+ linearhint?: boolean;
1488
+ debugMode?: boolean;
1489
+ onColorChanged?: (color: Color3 | Color4) => void;
1490
+ }
1491
+ /**
1492
+ * Interface used to specify creation options for color picker
1493
+ */
1494
+ export interface IColorPickerState {
1495
+ color: Color3;
1496
+ alpha: number;
1497
+ }
1498
+ /**
1499
+ * Class used to create a color picker
1500
+ */
1501
+ export class ColorPicker extends React.Component<IColorPickerProps, IColorPickerState> {
1502
+ private _saturationRef;
1503
+ private _hueRef;
1504
+ private _isSaturationPointerDown;
1505
+ private _isHuePointerDown;
1506
+ constructor(props: IColorPickerProps);
1507
+ shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean;
1508
+ onSaturationPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
1509
+ onSaturationPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
1510
+ onSaturationPointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
1511
+ onHuePointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
1512
+ onHuePointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
1513
+ onHuePointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
1514
+ private _evaluateSaturation;
1515
+ private _evaluateHue;
1516
+ componentDidUpdate(): void;
1517
+ raiseOnColorChanged(): void;
1518
+ render(): JSX.Element;
1519
+ }
1520
1520
 
1521
1521
  }
1522
1522
  declare module "shared-ui-components/colorPicker/hexColor" {
1523
- import * as React from "react";
1524
- export interface IHexColorProps {
1525
- value: string;
1526
- expectedLength: number;
1527
- onChange: (value: string) => void;
1528
- }
1529
- export class HexColor extends React.Component<IHexColorProps, {
1530
- hex: string;
1531
- }> {
1532
- constructor(props: IHexColorProps);
1533
- shouldComponentUpdate(nextProps: IHexColorProps, nextState: {
1534
- hex: string;
1535
- }): boolean;
1536
- updateHexValue(valueString: string): void;
1537
- render(): JSX.Element;
1538
- }
1523
+ import * as React from "react";
1524
+ export interface IHexColorProps {
1525
+ value: string;
1526
+ expectedLength: number;
1527
+ onChange: (value: string) => void;
1528
+ }
1529
+ export class HexColor extends React.Component<IHexColorProps, {
1530
+ hex: string;
1531
+ }> {
1532
+ constructor(props: IHexColorProps);
1533
+ shouldComponentUpdate(nextProps: IHexColorProps, nextState: {
1534
+ hex: string;
1535
+ }): boolean;
1536
+ updateHexValue(valueString: string): void;
1537
+ render(): JSX.Element;
1538
+ }
1539
1539
 
1540
1540
  }
1541
1541
  declare module "shared-ui-components/lines/booleanLineComponent" {
1542
- import * as React from "react";
1543
- export interface IBooleanLineComponentProps {
1544
- label: string;
1545
- value: boolean;
1546
- icon?: string;
1547
- iconLabel?: string;
1548
- }
1549
- export class BooleanLineComponent extends React.Component<IBooleanLineComponentProps> {
1550
- constructor(props: IBooleanLineComponentProps);
1551
- render(): JSX.Element;
1552
- }
1542
+ import * as React from "react";
1543
+ export interface IBooleanLineComponentProps {
1544
+ label: string;
1545
+ value: boolean;
1546
+ icon?: string;
1547
+ iconLabel?: string;
1548
+ }
1549
+ export class BooleanLineComponent extends React.Component<IBooleanLineComponentProps> {
1550
+ constructor(props: IBooleanLineComponentProps);
1551
+ render(): JSX.Element;
1552
+ }
1553
1553
 
1554
1554
  }
1555
1555
  declare module "shared-ui-components/lines/buttonLineComponent" {
1556
- import * as React from "react";
1557
- export interface IButtonLineComponentProps {
1558
- label: string;
1559
- onClick: () => void;
1560
- icon?: string;
1561
- iconLabel?: string;
1562
- }
1563
- export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
1564
- constructor(props: IButtonLineComponentProps);
1565
- render(): JSX.Element;
1566
- }
1556
+ import * as React from "react";
1557
+ export interface IButtonLineComponentProps {
1558
+ label: string;
1559
+ onClick: () => void;
1560
+ icon?: string;
1561
+ iconLabel?: string;
1562
+ }
1563
+ export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
1564
+ constructor(props: IButtonLineComponentProps);
1565
+ render(): JSX.Element;
1566
+ }
1567
1567
 
1568
1568
  }
1569
1569
  declare module "shared-ui-components/lines/checkBoxLineComponent" {
1570
- import * as React from "react";
1571
- import { Observable } from "@babylonjs/core/Misc/observable";
1572
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1573
- import { IconDefinition } from "@fortawesome/fontawesome-common-types";
1574
- export interface ICheckBoxLineComponentProps {
1575
- label?: string;
1576
- target?: any;
1577
- propertyName?: string;
1578
- isSelected?: () => boolean;
1579
- onSelect?: (value: boolean) => void;
1580
- onValueChanged?: () => void;
1581
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1582
- disabled?: boolean;
1583
- icon?: string;
1584
- iconLabel?: string;
1585
- faIcons?: {
1586
- enabled: IconDefinition;
1587
- disabled: IconDefinition;
1588
- };
1589
- }
1590
- export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
1591
- isSelected: boolean;
1592
- isDisabled?: boolean;
1593
- isConflict: boolean;
1594
- }> {
1595
- private _localChange;
1596
- constructor(props: ICheckBoxLineComponentProps);
1597
- shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
1598
- isSelected: boolean;
1599
- isDisabled: boolean;
1600
- isConflict: boolean;
1601
- }): boolean;
1602
- onChange(): void;
1603
- render(): JSX.Element;
1604
- }
1570
+ import * as React from "react";
1571
+ import { Observable } from "@babylonjs/core/Misc/observable";
1572
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1573
+ import { IconDefinition } from "@fortawesome/fontawesome-common-types";
1574
+ export interface ICheckBoxLineComponentProps {
1575
+ label?: string;
1576
+ target?: any;
1577
+ propertyName?: string;
1578
+ isSelected?: () => boolean;
1579
+ onSelect?: (value: boolean) => void;
1580
+ onValueChanged?: () => void;
1581
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1582
+ disabled?: boolean;
1583
+ icon?: string;
1584
+ iconLabel?: string;
1585
+ faIcons?: {
1586
+ enabled: IconDefinition;
1587
+ disabled: IconDefinition;
1588
+ };
1589
+ }
1590
+ export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
1591
+ isSelected: boolean;
1592
+ isDisabled?: boolean;
1593
+ isConflict: boolean;
1594
+ }> {
1595
+ private _localChange;
1596
+ constructor(props: ICheckBoxLineComponentProps);
1597
+ shouldComponentUpdate(nextProps: ICheckBoxLineComponentProps, nextState: {
1598
+ isSelected: boolean;
1599
+ isDisabled: boolean;
1600
+ isConflict: boolean;
1601
+ }): boolean;
1602
+ onChange(): void;
1603
+ render(): JSX.Element;
1604
+ }
1605
1605
 
1606
1606
  }
1607
1607
  declare module "shared-ui-components/lines/color3LineComponent" {
1608
- import * as React from "react";
1609
- import { Observable } from "@babylonjs/core/Misc/observable";
1610
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1611
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1612
- export interface IColor3LineComponentProps {
1613
- label: string;
1614
- target: any;
1615
- propertyName: string;
1616
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1617
- isLinear?: boolean;
1618
- icon?: string;
1619
- lockObject?: LockObject;
1620
- iconLabel?: string;
1621
- onValueChange?: (value: string) => void;
1622
- }
1623
- export class Color3LineComponent extends React.Component<IColor3LineComponentProps> {
1624
- render(): JSX.Element;
1625
- }
1608
+ import * as React from "react";
1609
+ import { Observable } from "@babylonjs/core/Misc/observable";
1610
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1611
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1612
+ export interface IColor3LineComponentProps {
1613
+ label: string;
1614
+ target: any;
1615
+ propertyName: string;
1616
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1617
+ isLinear?: boolean;
1618
+ icon?: string;
1619
+ lockObject?: LockObject;
1620
+ iconLabel?: string;
1621
+ onValueChange?: (value: string) => void;
1622
+ }
1623
+ export class Color3LineComponent extends React.Component<IColor3LineComponentProps> {
1624
+ render(): JSX.Element;
1625
+ }
1626
1626
 
1627
1627
  }
1628
1628
  declare module "shared-ui-components/lines/color4LineComponent" {
1629
- import * as React from "react";
1630
- import { Observable } from "@babylonjs/core/Misc/observable";
1631
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1632
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1633
- export interface IColor4LineComponentProps {
1634
- label: string;
1635
- target?: any;
1636
- propertyName: string;
1637
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1638
- onChange?: () => void;
1639
- isLinear?: boolean;
1640
- icon?: string;
1641
- iconLabel?: string;
1642
- lockObject?: LockObject;
1643
- }
1644
- export class Color4LineComponent extends React.Component<IColor4LineComponentProps> {
1645
- render(): JSX.Element;
1646
- }
1629
+ import * as React from "react";
1630
+ import { Observable } from "@babylonjs/core/Misc/observable";
1631
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1632
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1633
+ export interface IColor4LineComponentProps {
1634
+ label: string;
1635
+ target?: any;
1636
+ propertyName: string;
1637
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1638
+ onChange?: () => void;
1639
+ isLinear?: boolean;
1640
+ icon?: string;
1641
+ iconLabel?: string;
1642
+ lockObject?: LockObject;
1643
+ }
1644
+ export class Color4LineComponent extends React.Component<IColor4LineComponentProps> {
1645
+ render(): JSX.Element;
1646
+ }
1647
1647
 
1648
1648
  }
1649
1649
  declare module "shared-ui-components/lines/colorLineComponent" {
1650
- import * as React from "react";
1651
- import { Observable } from "@babylonjs/core/Misc/observable";
1652
- import { Color4 } from "@babylonjs/core/Maths/math.color";
1653
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1654
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1655
- export interface IColorLineComponentProps {
1656
- label: string;
1657
- target?: any;
1658
- propertyName: string;
1659
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1660
- onChange?: () => void;
1661
- isLinear?: boolean;
1662
- icon?: string;
1663
- iconLabel?: string;
1664
- lockObject?: LockObject;
1665
- disableAlpha?: boolean;
1666
- }
1667
- interface IColorLineComponentState {
1668
- isExpanded: boolean;
1669
- color: Color4;
1670
- }
1671
- export class ColorLineComponent extends React.Component<IColorLineComponentProps, IColorLineComponentState> {
1672
- constructor(props: IColorLineComponentProps);
1673
- shouldComponentUpdate(nextProps: IColorLineComponentProps, nextState: IColorLineComponentState): boolean;
1674
- getValue(props?: Readonly<IColorLineComponentProps> & Readonly<{
1675
- children?: React.ReactNode;
1676
- }>): Color4;
1677
- setColorFromString(colorString: string): void;
1678
- setColor(newColor: Color4): void;
1679
- switchExpandState(): void;
1680
- updateStateR(value: number): void;
1681
- updateStateG(value: number): void;
1682
- updateStateB(value: number): void;
1683
- updateStateA(value: number): void;
1684
- copyToClipboard(): void;
1685
- private _convertToColor;
1686
- private _toColor3;
1687
- render(): JSX.Element;
1688
- }
1689
- export {};
1650
+ import * as React from "react";
1651
+ import { Observable } from "@babylonjs/core/Misc/observable";
1652
+ import { Color4 } from "@babylonjs/core/Maths/math.color";
1653
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1654
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1655
+ export interface IColorLineComponentProps {
1656
+ label: string;
1657
+ target?: any;
1658
+ propertyName: string;
1659
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1660
+ onChange?: () => void;
1661
+ isLinear?: boolean;
1662
+ icon?: string;
1663
+ iconLabel?: string;
1664
+ lockObject?: LockObject;
1665
+ disableAlpha?: boolean;
1666
+ }
1667
+ interface IColorLineComponentState {
1668
+ isExpanded: boolean;
1669
+ color: Color4;
1670
+ }
1671
+ export class ColorLineComponent extends React.Component<IColorLineComponentProps, IColorLineComponentState> {
1672
+ constructor(props: IColorLineComponentProps);
1673
+ shouldComponentUpdate(nextProps: IColorLineComponentProps, nextState: IColorLineComponentState): boolean;
1674
+ getValue(props?: Readonly<IColorLineComponentProps> & Readonly<{
1675
+ children?: React.ReactNode;
1676
+ }>): Color4;
1677
+ setColorFromString(colorString: string): void;
1678
+ setColor(newColor: Color4): void;
1679
+ switchExpandState(): void;
1680
+ updateStateR(value: number): void;
1681
+ updateStateG(value: number): void;
1682
+ updateStateB(value: number): void;
1683
+ updateStateA(value: number): void;
1684
+ copyToClipboard(): void;
1685
+ private _convertToColor;
1686
+ private _toColor3;
1687
+ render(): JSX.Element;
1688
+ }
1689
+ export {};
1690
1690
 
1691
1691
  }
1692
1692
  declare module "shared-ui-components/lines/colorPickerComponent" {
1693
- import * as React from "react";
1694
- import { Color4, Color3 } from "@babylonjs/core/Maths/math.color";
1695
- export interface IColorPickerComponentProps {
1696
- value: Color4 | Color3;
1697
- linearHint?: boolean;
1698
- onColorChanged: (newOne: string) => void;
1699
- icon?: string;
1700
- iconLabel?: string;
1701
- shouldPopRight?: boolean;
1702
- }
1703
- interface IColorPickerComponentState {
1704
- pickerEnabled: boolean;
1705
- color: Color3 | Color4;
1706
- hex: string;
1707
- }
1708
- export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
1709
- private _floatRef;
1710
- private _floatHostRef;
1711
- constructor(props: IColorPickerComponentProps);
1712
- syncPositions(): void;
1713
- shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerComponentState): boolean;
1714
- getHexString(props?: Readonly<IColorPickerComponentProps> & Readonly<{
1715
- children?: React.ReactNode;
1716
- }>): string;
1717
- componentDidUpdate(): void;
1718
- componentDidMount(): void;
1719
- render(): JSX.Element;
1720
- }
1721
- export {};
1693
+ import * as React from "react";
1694
+ import { Color4, Color3 } from "@babylonjs/core/Maths/math.color";
1695
+ export interface IColorPickerComponentProps {
1696
+ value: Color4 | Color3;
1697
+ linearHint?: boolean;
1698
+ onColorChanged: (newOne: string) => void;
1699
+ icon?: string;
1700
+ iconLabel?: string;
1701
+ shouldPopRight?: boolean;
1702
+ }
1703
+ interface IColorPickerComponentState {
1704
+ pickerEnabled: boolean;
1705
+ color: Color3 | Color4;
1706
+ hex: string;
1707
+ }
1708
+ export class ColorPickerLineComponent extends React.Component<IColorPickerComponentProps, IColorPickerComponentState> {
1709
+ private _floatRef;
1710
+ private _floatHostRef;
1711
+ constructor(props: IColorPickerComponentProps);
1712
+ syncPositions(): void;
1713
+ shouldComponentUpdate(nextProps: IColorPickerComponentProps, nextState: IColorPickerComponentState): boolean;
1714
+ getHexString(props?: Readonly<IColorPickerComponentProps> & Readonly<{
1715
+ children?: React.ReactNode;
1716
+ }>): string;
1717
+ componentDidUpdate(): void;
1718
+ componentDidMount(): void;
1719
+ render(): JSX.Element;
1720
+ }
1721
+ export {};
1722
1722
 
1723
1723
  }
1724
1724
  declare module "shared-ui-components/lines/draggableLineComponent" {
1725
- import * as React from "react";
1726
- export interface IButtonLineComponentProps {
1727
- data: string;
1728
- tooltip: string;
1729
- }
1730
- export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
1731
- constructor(props: IButtonLineComponentProps);
1732
- render(): JSX.Element;
1733
- }
1725
+ import * as React from "react";
1726
+ export interface IButtonLineComponentProps {
1727
+ data: string;
1728
+ tooltip: string;
1729
+ }
1730
+ export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
1731
+ constructor(props: IButtonLineComponentProps);
1732
+ render(): JSX.Element;
1733
+ }
1734
1734
 
1735
1735
  }
1736
1736
  declare module "shared-ui-components/lines/fileButtonLineComponent" {
1737
- import * as React from "react";
1738
- interface IFileButtonLineComponentProps {
1739
- label: string;
1740
- onClick: (file: File) => void;
1741
- accept: string;
1742
- icon?: string;
1743
- iconLabel?: string;
1744
- }
1745
- export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
1746
- private static _IDGenerator;
1747
- private _id;
1748
- private _uploadInputRef;
1749
- constructor(props: IFileButtonLineComponentProps);
1750
- onChange(evt: any): void;
1751
- render(): JSX.Element;
1752
- }
1753
- export {};
1737
+ import * as React from "react";
1738
+ interface IFileButtonLineComponentProps {
1739
+ label: string;
1740
+ onClick: (file: File) => void;
1741
+ accept: string;
1742
+ icon?: string;
1743
+ iconLabel?: string;
1744
+ }
1745
+ export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
1746
+ private static _IDGenerator;
1747
+ private _id;
1748
+ private _uploadInputRef;
1749
+ constructor(props: IFileButtonLineComponentProps);
1750
+ onChange(evt: any): void;
1751
+ render(): JSX.Element;
1752
+ }
1753
+ export {};
1754
1754
 
1755
1755
  }
1756
1756
  declare module "shared-ui-components/lines/fileMultipleButtonLineComponent" {
1757
- import * as React from "react";
1758
- interface IFileMultipleButtonLineComponentProps {
1759
- label: string;
1760
- onClick: (event: any) => void;
1761
- accept: string;
1762
- icon?: string;
1763
- iconLabel?: string;
1764
- }
1765
- export class FileMultipleButtonLineComponent extends React.Component<IFileMultipleButtonLineComponentProps> {
1766
- private static _IDGenerator;
1767
- private _id;
1768
- private _uploadInputRef;
1769
- constructor(props: IFileMultipleButtonLineComponentProps);
1770
- onChange(evt: any): void;
1771
- render(): JSX.Element;
1772
- }
1773
- export {};
1757
+ import * as React from "react";
1758
+ interface IFileMultipleButtonLineComponentProps {
1759
+ label: string;
1760
+ onClick: (event: any) => void;
1761
+ accept: string;
1762
+ icon?: string;
1763
+ iconLabel?: string;
1764
+ }
1765
+ export class FileMultipleButtonLineComponent extends React.Component<IFileMultipleButtonLineComponentProps> {
1766
+ private static _IDGenerator;
1767
+ private _id;
1768
+ private _uploadInputRef;
1769
+ constructor(props: IFileMultipleButtonLineComponentProps);
1770
+ onChange(evt: any): void;
1771
+ render(): JSX.Element;
1772
+ }
1773
+ export {};
1774
1774
 
1775
1775
  }
1776
1776
  declare module "shared-ui-components/lines/floatLineComponent" {
1777
- import * as React from "react";
1778
- import { Observable } from "@babylonjs/core/Misc/observable";
1779
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1780
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1781
- interface IFloatLineComponentProps {
1782
- label: string;
1783
- target: any;
1784
- propertyName: string;
1785
- lockObject?: LockObject;
1786
- onChange?: (newValue: number) => void;
1787
- isInteger?: boolean;
1788
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1789
- additionalClass?: string;
1790
- step?: string;
1791
- digits?: number;
1792
- useEuler?: boolean;
1793
- min?: number;
1794
- max?: number;
1795
- smallUI?: boolean;
1796
- onEnter?: (newValue: number) => void;
1797
- icon?: string;
1798
- iconLabel?: string;
1799
- defaultValue?: number;
1800
- unit?: string;
1801
- onUnitClicked?: () => void;
1802
- unitLocked?: boolean;
1803
- }
1804
- export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
1805
- value: string;
1806
- }> {
1807
- private _localChange;
1808
- private _store;
1809
- constructor(props: IFloatLineComponentProps);
1810
- componentWillUnmount(): void;
1811
- getValueString(value: any): string;
1812
- shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
1813
- value: string;
1814
- }): boolean;
1815
- raiseOnPropertyChanged(newValue: number, previousValue: number): void;
1816
- updateValue(valueString: string): void;
1817
- lock(): void;
1818
- unlock(): void;
1819
- render(): JSX.Element;
1820
- }
1821
- export {};
1777
+ import * as React from "react";
1778
+ import { Observable } from "@babylonjs/core/Misc/observable";
1779
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1780
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1781
+ interface IFloatLineComponentProps {
1782
+ label: string;
1783
+ target: any;
1784
+ propertyName: string;
1785
+ lockObject?: LockObject;
1786
+ onChange?: (newValue: number) => void;
1787
+ isInteger?: boolean;
1788
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1789
+ additionalClass?: string;
1790
+ step?: string;
1791
+ digits?: number;
1792
+ useEuler?: boolean;
1793
+ min?: number;
1794
+ max?: number;
1795
+ smallUI?: boolean;
1796
+ onEnter?: (newValue: number) => void;
1797
+ icon?: string;
1798
+ iconLabel?: string;
1799
+ defaultValue?: number;
1800
+ unit?: string;
1801
+ onUnitClicked?: () => void;
1802
+ unitLocked?: boolean;
1803
+ }
1804
+ export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
1805
+ value: string;
1806
+ }> {
1807
+ private _localChange;
1808
+ private _store;
1809
+ constructor(props: IFloatLineComponentProps);
1810
+ componentWillUnmount(): void;
1811
+ getValueString(value: any): string;
1812
+ shouldComponentUpdate(nextProps: IFloatLineComponentProps, nextState: {
1813
+ value: string;
1814
+ }): boolean;
1815
+ raiseOnPropertyChanged(newValue: number, previousValue: number): void;
1816
+ updateValue(valueString: string): void;
1817
+ lock(): void;
1818
+ unlock(): void;
1819
+ render(): JSX.Element;
1820
+ }
1821
+ export {};
1822
1822
 
1823
1823
  }
1824
1824
  declare module "shared-ui-components/lines/hexLineComponent" {
1825
- import * as React from "react";
1826
- import { Observable } from "@babylonjs/core/Misc/observable";
1827
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1828
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1829
- interface IHexLineComponentProps {
1830
- label: string;
1831
- target: any;
1832
- propertyName: string;
1833
- lockObject?: LockObject;
1834
- onChange?: (newValue: number) => void;
1835
- isInteger?: boolean;
1836
- replaySourceReplacement?: string;
1837
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1838
- additionalClass?: string;
1839
- step?: string;
1840
- digits?: number;
1841
- useEuler?: boolean;
1842
- min?: number;
1843
- icon?: string;
1844
- iconLabel?: string;
1845
- }
1846
- export class HexLineComponent extends React.Component<IHexLineComponentProps, {
1847
- value: string;
1848
- }> {
1849
- private _localChange;
1850
- private _store;
1851
- private _propertyChange;
1852
- constructor(props: IHexLineComponentProps);
1853
- componentWillUnmount(): void;
1854
- shouldComponentUpdate(nextProps: IHexLineComponentProps, nextState: {
1855
- value: string;
1856
- }): boolean;
1857
- raiseOnPropertyChanged(newValue: number, previousValue: number): void;
1858
- convertToHexString(valueString: string): string;
1859
- updateValue(valueString: string, raisePropertyChanged: boolean): void;
1860
- lock(): void;
1861
- unlock(): void;
1862
- render(): JSX.Element;
1863
- }
1864
- export {};
1825
+ import * as React from "react";
1826
+ import { Observable } from "@babylonjs/core/Misc/observable";
1827
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
1828
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
1829
+ interface IHexLineComponentProps {
1830
+ label: string;
1831
+ target: any;
1832
+ propertyName: string;
1833
+ lockObject?: LockObject;
1834
+ onChange?: (newValue: number) => void;
1835
+ isInteger?: boolean;
1836
+ replaySourceReplacement?: string;
1837
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1838
+ additionalClass?: string;
1839
+ step?: string;
1840
+ digits?: number;
1841
+ useEuler?: boolean;
1842
+ min?: number;
1843
+ icon?: string;
1844
+ iconLabel?: string;
1845
+ }
1846
+ export class HexLineComponent extends React.Component<IHexLineComponentProps, {
1847
+ value: string;
1848
+ }> {
1849
+ private _localChange;
1850
+ private _store;
1851
+ private _propertyChange;
1852
+ constructor(props: IHexLineComponentProps);
1853
+ componentWillUnmount(): void;
1854
+ shouldComponentUpdate(nextProps: IHexLineComponentProps, nextState: {
1855
+ value: string;
1856
+ }): boolean;
1857
+ raiseOnPropertyChanged(newValue: number, previousValue: number): void;
1858
+ convertToHexString(valueString: string): string;
1859
+ updateValue(valueString: string, raisePropertyChanged: boolean): void;
1860
+ lock(): void;
1861
+ unlock(): void;
1862
+ render(): JSX.Element;
1863
+ }
1864
+ export {};
1865
1865
 
1866
1866
  }
1867
1867
  declare module "shared-ui-components/lines/iconButtonLineComponent" {
1868
- import * as React from "react";
1869
- export interface IIconButtonLineComponentProps {
1870
- icon: string;
1871
- onClick: () => void;
1872
- tooltip: string;
1873
- active?: boolean;
1874
- }
1875
- export class IconButtonLineComponent extends React.Component<IIconButtonLineComponentProps> {
1876
- constructor(props: IIconButtonLineComponentProps);
1877
- render(): JSX.Element;
1878
- }
1868
+ import * as React from "react";
1869
+ export interface IIconButtonLineComponentProps {
1870
+ icon: string;
1871
+ onClick: () => void;
1872
+ tooltip: string;
1873
+ active?: boolean;
1874
+ }
1875
+ export class IconButtonLineComponent extends React.Component<IIconButtonLineComponentProps> {
1876
+ constructor(props: IIconButtonLineComponentProps);
1877
+ render(): JSX.Element;
1878
+ }
1879
1879
 
1880
1880
  }
1881
1881
  declare module "shared-ui-components/lines/iconComponent" {
1882
- import * as React from "react";
1883
- interface IIconComponentProps {
1884
- icon: string;
1885
- label?: string;
1886
- }
1887
- export class IconComponent extends React.Component<IIconComponentProps> {
1888
- render(): JSX.Element;
1889
- }
1890
- export {};
1882
+ import * as React from "react";
1883
+ interface IIconComponentProps {
1884
+ icon: string;
1885
+ label?: string;
1886
+ }
1887
+ export class IconComponent extends React.Component<IIconComponentProps> {
1888
+ render(): JSX.Element;
1889
+ }
1890
+ export {};
1891
1891
 
1892
1892
  }
1893
1893
  declare module "shared-ui-components/lines/indentedTextLineComponent" {
1894
- import * as React from "react";
1895
- interface IIndentedTextLineComponentProps {
1896
- value?: string;
1897
- color?: string;
1898
- underline?: boolean;
1899
- onLink?: () => void;
1900
- url?: string;
1901
- additionalClass?: string;
1902
- }
1903
- export class IndentedTextLineComponent extends React.Component<IIndentedTextLineComponentProps> {
1904
- constructor(props: IIndentedTextLineComponentProps);
1905
- onLink(): void;
1906
- renderContent(): JSX.Element;
1907
- render(): JSX.Element;
1908
- }
1909
- export {};
1894
+ import * as React from "react";
1895
+ interface IIndentedTextLineComponentProps {
1896
+ value?: string;
1897
+ color?: string;
1898
+ underline?: boolean;
1899
+ onLink?: () => void;
1900
+ url?: string;
1901
+ additionalClass?: string;
1902
+ }
1903
+ export class IndentedTextLineComponent extends React.Component<IIndentedTextLineComponentProps> {
1904
+ constructor(props: IIndentedTextLineComponentProps);
1905
+ onLink(): void;
1906
+ renderContent(): JSX.Element;
1907
+ render(): JSX.Element;
1908
+ }
1909
+ export {};
1910
1910
 
1911
1911
  }
1912
1912
  declare module "shared-ui-components/lines/inputArrowsComponent" {
1913
- import * as React from "react";
1914
- interface IInputArrowsComponentProps {
1915
- incrementValue: (amount: number) => void;
1916
- setDragging: (dragging: boolean) => void;
1917
- }
1918
- export class InputArrowsComponent extends React.Component<IInputArrowsComponentProps> {
1919
- private _arrowsRef;
1920
- private _drag;
1921
- private _releaseListener;
1922
- render(): JSX.Element;
1923
- }
1924
- export {};
1913
+ import * as React from "react";
1914
+ interface IInputArrowsComponentProps {
1915
+ incrementValue: (amount: number) => void;
1916
+ setDragging: (dragging: boolean) => void;
1917
+ }
1918
+ export class InputArrowsComponent extends React.Component<IInputArrowsComponentProps> {
1919
+ private _arrowsRef;
1920
+ private _drag;
1921
+ private _releaseListener;
1922
+ render(): JSX.Element;
1923
+ }
1924
+ export {};
1925
1925
 
1926
1926
  }
1927
1927
  declare module "shared-ui-components/lines/iSelectedLineContainer" {
1928
- export interface ISelectedLineContainer {
1929
- selectedLineContainerTitles: Array<string>;
1930
- selectedLineContainerTitlesNoFocus: Array<string>;
1931
- }
1928
+ export interface ISelectedLineContainer {
1929
+ selectedLineContainerTitles: Array<string>;
1930
+ selectedLineContainerTitlesNoFocus: Array<string>;
1931
+ }
1932
1932
 
1933
1933
  }
1934
1934
  declare module "shared-ui-components/lines/lineContainerComponent" {
1935
- import * as React from "react";
1936
- import { ISelectedLineContainer } from "shared-ui-components/lines/iSelectedLineContainer";
1937
- interface ILineContainerComponentProps {
1938
- selection?: ISelectedLineContainer;
1939
- title: string;
1940
- children: any[] | any;
1941
- closed?: boolean;
1942
- }
1943
- export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
1944
- isExpanded: boolean;
1945
- isHighlighted: boolean;
1946
- }> {
1947
- constructor(props: ILineContainerComponentProps);
1948
- switchExpandedState(): void;
1949
- renderHeader(): JSX.Element;
1950
- componentDidMount(): void;
1951
- render(): JSX.Element;
1952
- }
1953
- export {};
1935
+ import * as React from "react";
1936
+ import { ISelectedLineContainer } from "shared-ui-components/lines/iSelectedLineContainer";
1937
+ interface ILineContainerComponentProps {
1938
+ selection?: ISelectedLineContainer;
1939
+ title: string;
1940
+ children: any[] | any;
1941
+ closed?: boolean;
1942
+ }
1943
+ export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
1944
+ isExpanded: boolean;
1945
+ isHighlighted: boolean;
1946
+ }> {
1947
+ constructor(props: ILineContainerComponentProps);
1948
+ switchExpandedState(): void;
1949
+ renderHeader(): JSX.Element;
1950
+ componentDidMount(): void;
1951
+ render(): JSX.Element;
1952
+ }
1953
+ export {};
1954
1954
 
1955
1955
  }
1956
1956
  declare module "shared-ui-components/lines/linkButtonComponent" {
1957
- import * as React from "react";
1958
- import { IconProp } from "@fortawesome/fontawesome-svg-core";
1959
- interface ILinkButtonComponentProps {
1960
- label: string;
1961
- buttonLabel: string;
1962
- url?: string;
1963
- onClick: () => void;
1964
- icon?: IconProp;
1965
- onIconClick?: () => void;
1966
- }
1967
- export class LinkButtonComponent extends React.Component<ILinkButtonComponentProps> {
1968
- constructor(props: ILinkButtonComponentProps);
1969
- onLink(): void;
1970
- render(): JSX.Element;
1971
- }
1972
- export {};
1957
+ import * as React from "react";
1958
+ import { IconProp } from "@fortawesome/fontawesome-svg-core";
1959
+ interface ILinkButtonComponentProps {
1960
+ label: string;
1961
+ buttonLabel: string;
1962
+ url?: string;
1963
+ onClick: () => void;
1964
+ icon?: IconProp;
1965
+ onIconClick?: () => void;
1966
+ }
1967
+ export class LinkButtonComponent extends React.Component<ILinkButtonComponentProps> {
1968
+ constructor(props: ILinkButtonComponentProps);
1969
+ onLink(): void;
1970
+ render(): JSX.Element;
1971
+ }
1972
+ export {};
1973
1973
 
1974
1974
  }
1975
1975
  declare module "shared-ui-components/lines/messageLineComponent" {
1976
- import * as React from "react";
1977
- import { IconProp } from "@fortawesome/fontawesome-svg-core";
1978
- interface IMessageLineComponentProps {
1979
- text: string;
1980
- color?: string;
1981
- icon?: IconProp;
1982
- }
1983
- export class MessageLineComponent extends React.Component<IMessageLineComponentProps> {
1984
- constructor(props: IMessageLineComponentProps);
1985
- render(): JSX.Element;
1986
- }
1987
- export {};
1976
+ import * as React from "react";
1977
+ import { IconProp } from "@fortawesome/fontawesome-svg-core";
1978
+ interface IMessageLineComponentProps {
1979
+ text: string;
1980
+ color?: string;
1981
+ icon?: IconProp;
1982
+ }
1983
+ export class MessageLineComponent extends React.Component<IMessageLineComponentProps> {
1984
+ constructor(props: IMessageLineComponentProps);
1985
+ render(): JSX.Element;
1986
+ }
1987
+ export {};
1988
1988
 
1989
1989
  }
1990
1990
  declare module "shared-ui-components/lines/numericInputComponent" {
1991
- import * as React from "react";
1992
- interface INumericInputComponentProps {
1993
- label: string;
1994
- value: number;
1995
- step?: number;
1996
- onChange: (value: number) => void;
1997
- precision?: number;
1998
- icon?: string;
1999
- iconLabel?: string;
2000
- }
2001
- export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
2002
- value: string;
2003
- }> {
2004
- static defaultProps: {
2005
- step: number;
2006
- };
2007
- private _localChange;
2008
- constructor(props: INumericInputComponentProps);
2009
- shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
2010
- value: string;
2011
- }): boolean;
2012
- updateValue(evt: any): void;
2013
- onBlur(): void;
2014
- render(): JSX.Element;
2015
- }
2016
- export {};
1991
+ import * as React from "react";
1992
+ interface INumericInputComponentProps {
1993
+ label: string;
1994
+ value: number;
1995
+ step?: number;
1996
+ onChange: (value: number) => void;
1997
+ precision?: number;
1998
+ icon?: string;
1999
+ iconLabel?: string;
2000
+ }
2001
+ export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
2002
+ value: string;
2003
+ }> {
2004
+ static defaultProps: {
2005
+ step: number;
2006
+ };
2007
+ private _localChange;
2008
+ constructor(props: INumericInputComponentProps);
2009
+ shouldComponentUpdate(nextProps: INumericInputComponentProps, nextState: {
2010
+ value: string;
2011
+ }): boolean;
2012
+ updateValue(evt: any): void;
2013
+ onBlur(): void;
2014
+ render(): JSX.Element;
2015
+ }
2016
+ export {};
2017
2017
 
2018
2018
  }
2019
2019
  declare module "shared-ui-components/lines/optionsLineComponent" {
2020
- import * as React from "react";
2021
- import { Observable } from "@babylonjs/core/Misc/observable";
2022
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2023
- import { IInspectableOptions } from "@babylonjs/core/Misc/iInspectable";
2024
- export const Null_Value: number;
2025
- export interface IOptionsLineComponentProps {
2026
- label: string;
2027
- target: any;
2028
- propertyName: string;
2029
- options: IInspectableOptions[];
2030
- noDirectUpdate?: boolean;
2031
- onSelect?: (value: number) => void;
2032
- extractValue?: () => number;
2033
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2034
- allowNullValue?: boolean;
2035
- icon?: string;
2036
- iconLabel?: string;
2037
- }
2038
- export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
2039
- value: number;
2040
- }> {
2041
- private _localChange;
2042
- private _remapValueIn;
2043
- private _remapValueOut;
2044
- constructor(props: IOptionsLineComponentProps);
2045
- shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
2046
- value: number;
2047
- }): boolean;
2048
- raiseOnPropertyChanged(newValue: number, previousValue: number): void;
2049
- updateValue(valueString: string): void;
2050
- render(): JSX.Element;
2051
- }
2020
+ import * as React from "react";
2021
+ import { Observable } from "@babylonjs/core/Misc/observable";
2022
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2023
+ import { IInspectableOptions } from "@babylonjs/core/Misc/iInspectable";
2024
+ export const Null_Value: number;
2025
+ export interface IOptionsLineComponentProps {
2026
+ label: string;
2027
+ target: any;
2028
+ propertyName: string;
2029
+ options: IInspectableOptions[];
2030
+ noDirectUpdate?: boolean;
2031
+ onSelect?: (value: number) => void;
2032
+ extractValue?: () => number;
2033
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2034
+ allowNullValue?: boolean;
2035
+ icon?: string;
2036
+ iconLabel?: string;
2037
+ }
2038
+ export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
2039
+ value: number;
2040
+ }> {
2041
+ private _localChange;
2042
+ private _remapValueIn;
2043
+ private _remapValueOut;
2044
+ constructor(props: IOptionsLineComponentProps);
2045
+ shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
2046
+ value: number;
2047
+ }): boolean;
2048
+ raiseOnPropertyChanged(newValue: number, previousValue: number): void;
2049
+ updateValue(valueString: string): void;
2050
+ render(): JSX.Element;
2051
+ }
2052
2052
 
2053
2053
  }
2054
2054
  declare module "shared-ui-components/lines/popup" {
2055
- export class Popup {
2056
- static CreatePopup(title: string, windowVariableName: string, width?: number, height?: number): HTMLDivElement | null;
2057
- private static _CopyStyles;
2058
- }
2055
+ export class Popup {
2056
+ static CreatePopup(title: string, windowVariableName: string, width?: number, height?: number): HTMLDivElement | null;
2057
+ private static _CopyStyles;
2058
+ }
2059
2059
 
2060
2060
  }
2061
2061
  declare module "shared-ui-components/lines/radioLineComponent" {
2062
- import * as React from "react";
2063
- import { Observable } from "@babylonjs/core/Misc/observable";
2064
- interface IRadioButtonLineComponentProps {
2065
- onSelectionChangedObservable: Observable<RadioButtonLineComponent>;
2066
- label: string;
2067
- isSelected: () => boolean;
2068
- onSelect: () => void;
2069
- icon?: string;
2070
- iconLabel?: string;
2071
- }
2072
- export class RadioButtonLineComponent extends React.Component<IRadioButtonLineComponentProps, {
2073
- isSelected: boolean;
2074
- }> {
2075
- private _onSelectionChangedObserver;
2076
- constructor(props: IRadioButtonLineComponentProps);
2077
- componentDidMount(): void;
2078
- componentWillUnmount(): void;
2079
- onChange(): void;
2080
- render(): JSX.Element;
2081
- }
2082
- export {};
2062
+ import * as React from "react";
2063
+ import { Observable } from "@babylonjs/core/Misc/observable";
2064
+ interface IRadioButtonLineComponentProps {
2065
+ onSelectionChangedObservable: Observable<RadioButtonLineComponent>;
2066
+ label: string;
2067
+ isSelected: () => boolean;
2068
+ onSelect: () => void;
2069
+ icon?: string;
2070
+ iconLabel?: string;
2071
+ }
2072
+ export class RadioButtonLineComponent extends React.Component<IRadioButtonLineComponentProps, {
2073
+ isSelected: boolean;
2074
+ }> {
2075
+ private _onSelectionChangedObserver;
2076
+ constructor(props: IRadioButtonLineComponentProps);
2077
+ componentDidMount(): void;
2078
+ componentWillUnmount(): void;
2079
+ onChange(): void;
2080
+ render(): JSX.Element;
2081
+ }
2082
+ export {};
2083
2083
 
2084
2084
  }
2085
2085
  declare module "shared-ui-components/lines/sliderLineComponent" {
2086
- import * as React from "react";
2087
- import { Observable } from "@babylonjs/core/Misc/observable";
2088
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2089
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2090
- interface ISliderLineComponentProps {
2091
- label: string;
2092
- target?: any;
2093
- propertyName?: string;
2094
- minimum: number;
2095
- maximum: number;
2096
- step: number;
2097
- directValue?: number;
2098
- useEuler?: boolean;
2099
- onChange?: (value: number) => void;
2100
- onInput?: (value: number) => void;
2101
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2102
- decimalCount?: number;
2103
- margin?: boolean;
2104
- icon?: string;
2105
- iconLabel?: string;
2106
- lockObject?: LockObject;
2107
- }
2108
- export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
2109
- value: number;
2110
- }> {
2111
- private _localChange;
2112
- constructor(props: ISliderLineComponentProps);
2113
- shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
2114
- value: number;
2115
- }): boolean;
2116
- onChange(newValueString: any): void;
2117
- onInput(newValueString: any): void;
2118
- prepareDataToRead(value: number): number;
2119
- render(): JSX.Element;
2120
- }
2121
- export {};
2086
+ import * as React from "react";
2087
+ import { Observable } from "@babylonjs/core/Misc/observable";
2088
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2089
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2090
+ interface ISliderLineComponentProps {
2091
+ label: string;
2092
+ target?: any;
2093
+ propertyName?: string;
2094
+ minimum: number;
2095
+ maximum: number;
2096
+ step: number;
2097
+ directValue?: number;
2098
+ useEuler?: boolean;
2099
+ onChange?: (value: number) => void;
2100
+ onInput?: (value: number) => void;
2101
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2102
+ decimalCount?: number;
2103
+ margin?: boolean;
2104
+ icon?: string;
2105
+ iconLabel?: string;
2106
+ lockObject?: LockObject;
2107
+ }
2108
+ export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
2109
+ value: number;
2110
+ }> {
2111
+ private _localChange;
2112
+ constructor(props: ISliderLineComponentProps);
2113
+ shouldComponentUpdate(nextProps: ISliderLineComponentProps, nextState: {
2114
+ value: number;
2115
+ }): boolean;
2116
+ onChange(newValueString: any): void;
2117
+ onInput(newValueString: any): void;
2118
+ prepareDataToRead(value: number): number;
2119
+ render(): JSX.Element;
2120
+ }
2121
+ export {};
2122
2122
 
2123
2123
  }
2124
2124
  declare module "shared-ui-components/lines/targetsProxy" {
2125
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2126
- import { Observable } from "@babylonjs/core/Misc/observable";
2127
- export const conflictingValuesPlaceholder = "\u2014";
2128
- /**
2129
- *
2130
- * @param targets a list of selected targets
2131
- * @param onPropertyChangedObservable
2132
- * @param getProperty
2133
- * @returns a proxy object that can be passed as a target into the input
2134
- */
2135
- export function makeTargetsProxy<Type>(targets: Type[], onPropertyChangedObservable?: Observable<PropertyChangedEvent>, getProperty?: (target: Type, property: keyof Type) => any): any;
2125
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2126
+ import { Observable } from "@babylonjs/core/Misc/observable";
2127
+ export const conflictingValuesPlaceholder = "\u2014";
2128
+ /**
2129
+ *
2130
+ * @param targets a list of selected targets
2131
+ * @param onPropertyChangedObservable
2132
+ * @param getProperty
2133
+ * @returns a proxy object that can be passed as a target into the input
2134
+ */
2135
+ export function makeTargetsProxy<Type>(targets: Type[], onPropertyChangedObservable?: Observable<PropertyChangedEvent>, getProperty?: (target: Type, property: keyof Type) => any): any;
2136
2136
 
2137
2137
  }
2138
2138
  declare module "shared-ui-components/lines/textInputLineComponent" {
2139
- import * as React from "react";
2140
- import { Observable } from "@babylonjs/core/Misc/observable";
2141
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2142
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2143
- interface ITextInputLineComponentProps {
2144
- label?: string;
2145
- lockObject?: LockObject;
2146
- target?: any;
2147
- propertyName?: string;
2148
- value?: string;
2149
- onChange?: (value: string) => void;
2150
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2151
- icon?: string;
2152
- iconLabel?: string;
2153
- noUnderline?: boolean;
2154
- numbersOnly?: boolean;
2155
- delayInput?: boolean;
2156
- unit?: string;
2157
- onUnitClicked?: (unit: string) => void;
2158
- unitLocked?: boolean;
2159
- arrows?: boolean;
2160
- arrowsIncrement?: (amount: number) => void;
2161
- step?: number;
2162
- numeric?: boolean;
2163
- roundValues?: boolean;
2164
- min?: number;
2165
- max?: number;
2166
- placeholder?: string;
2167
- }
2168
- export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
2169
- value: string;
2170
- dragging: boolean;
2171
- }> {
2172
- private _localChange;
2173
- constructor(props: ITextInputLineComponentProps);
2174
- componentWillUnmount(): void;
2175
- shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
2176
- value: string;
2177
- dragging: boolean;
2178
- }): boolean;
2179
- raiseOnPropertyChanged(newValue: string, previousValue: string): void;
2180
- updateValue(value: string): void;
2181
- incrementValue(amount: number): void;
2182
- onKeyDown(event: React.KeyboardEvent): void;
2183
- render(): JSX.Element;
2184
- }
2185
- export {};
2139
+ import * as React from "react";
2140
+ import { Observable } from "@babylonjs/core/Misc/observable";
2141
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2142
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2143
+ interface ITextInputLineComponentProps {
2144
+ label?: string;
2145
+ lockObject?: LockObject;
2146
+ target?: any;
2147
+ propertyName?: string;
2148
+ value?: string;
2149
+ onChange?: (value: string) => void;
2150
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2151
+ icon?: string;
2152
+ iconLabel?: string;
2153
+ noUnderline?: boolean;
2154
+ numbersOnly?: boolean;
2155
+ delayInput?: boolean;
2156
+ unit?: string;
2157
+ onUnitClicked?: (unit: string) => void;
2158
+ unitLocked?: boolean;
2159
+ arrows?: boolean;
2160
+ arrowsIncrement?: (amount: number) => void;
2161
+ step?: number;
2162
+ numeric?: boolean;
2163
+ roundValues?: boolean;
2164
+ min?: number;
2165
+ max?: number;
2166
+ placeholder?: string;
2167
+ }
2168
+ export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
2169
+ value: string;
2170
+ dragging: boolean;
2171
+ }> {
2172
+ private _localChange;
2173
+ constructor(props: ITextInputLineComponentProps);
2174
+ componentWillUnmount(): void;
2175
+ shouldComponentUpdate(nextProps: ITextInputLineComponentProps, nextState: {
2176
+ value: string;
2177
+ dragging: boolean;
2178
+ }): boolean;
2179
+ raiseOnPropertyChanged(newValue: string, previousValue: string): void;
2180
+ updateValue(value: string): void;
2181
+ incrementValue(amount: number): void;
2182
+ onKeyDown(event: React.KeyboardEvent): void;
2183
+ render(): JSX.Element;
2184
+ }
2185
+ export {};
2186
2186
 
2187
2187
  }
2188
2188
  declare module "shared-ui-components/lines/textLineComponent" {
2189
- import * as React from "react";
2190
- interface ITextLineComponentProps {
2191
- label?: string;
2192
- value?: string;
2193
- color?: string;
2194
- underline?: boolean;
2195
- onLink?: () => void;
2196
- url?: string;
2197
- ignoreValue?: boolean;
2198
- additionalClass?: string;
2199
- icon?: string;
2200
- iconLabel?: string;
2201
- tooltip?: string;
2202
- }
2203
- export class TextLineComponent extends React.Component<ITextLineComponentProps> {
2204
- constructor(props: ITextLineComponentProps);
2205
- onLink(): void;
2206
- renderContent(): JSX.Element | null;
2207
- render(): JSX.Element;
2208
- }
2209
- export {};
2189
+ import * as React from "react";
2190
+ interface ITextLineComponentProps {
2191
+ label?: string;
2192
+ value?: string;
2193
+ color?: string;
2194
+ underline?: boolean;
2195
+ onLink?: () => void;
2196
+ url?: string;
2197
+ ignoreValue?: boolean;
2198
+ additionalClass?: string;
2199
+ icon?: string;
2200
+ iconLabel?: string;
2201
+ tooltip?: string;
2202
+ }
2203
+ export class TextLineComponent extends React.Component<ITextLineComponentProps> {
2204
+ constructor(props: ITextLineComponentProps);
2205
+ onLink(): void;
2206
+ renderContent(): JSX.Element | null;
2207
+ render(): JSX.Element;
2208
+ }
2209
+ export {};
2210
2210
 
2211
2211
  }
2212
2212
  declare module "shared-ui-components/lines/valueLineComponent" {
2213
- import * as React from "react";
2214
- interface IValueLineComponentProps {
2215
- label: string;
2216
- value: number;
2217
- color?: string;
2218
- fractionDigits?: number;
2219
- units?: string;
2220
- icon?: string;
2221
- iconLabel?: string;
2222
- }
2223
- export class ValueLineComponent extends React.Component<IValueLineComponentProps> {
2224
- constructor(props: IValueLineComponentProps);
2225
- render(): JSX.Element;
2226
- }
2227
- export {};
2213
+ import * as React from "react";
2214
+ interface IValueLineComponentProps {
2215
+ label: string;
2216
+ value: number;
2217
+ color?: string;
2218
+ fractionDigits?: number;
2219
+ units?: string;
2220
+ icon?: string;
2221
+ iconLabel?: string;
2222
+ }
2223
+ export class ValueLineComponent extends React.Component<IValueLineComponentProps> {
2224
+ constructor(props: IValueLineComponentProps);
2225
+ render(): JSX.Element;
2226
+ }
2227
+ export {};
2228
2228
 
2229
2229
  }
2230
2230
  declare module "shared-ui-components/lines/vector2LineComponent" {
2231
- import * as React from "react";
2232
- import { Vector2 } from "@babylonjs/core/Maths/math.vector";
2233
- import { Observable } from "@babylonjs/core/Misc/observable";
2234
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2235
- interface IVector2LineComponentProps {
2236
- label: string;
2237
- target: any;
2238
- propertyName: string;
2239
- step?: number;
2240
- onChange?: (newvalue: Vector2) => void;
2241
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2242
- icon?: string;
2243
- iconLabel?: string;
2244
- }
2245
- export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
2246
- isExpanded: boolean;
2247
- value: Vector2;
2248
- }> {
2249
- static defaultProps: {
2250
- step: number;
2251
- };
2252
- private _localChange;
2253
- constructor(props: IVector2LineComponentProps);
2254
- shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
2255
- isExpanded: boolean;
2256
- value: Vector2;
2257
- }): boolean;
2258
- switchExpandState(): void;
2259
- raiseOnPropertyChanged(previousValue: Vector2): void;
2260
- updateStateX(value: number): void;
2261
- updateStateY(value: number): void;
2262
- render(): JSX.Element;
2263
- }
2264
- export {};
2231
+ import * as React from "react";
2232
+ import { Vector2 } from "@babylonjs/core/Maths/math.vector";
2233
+ import { Observable } from "@babylonjs/core/Misc/observable";
2234
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2235
+ interface IVector2LineComponentProps {
2236
+ label: string;
2237
+ target: any;
2238
+ propertyName: string;
2239
+ step?: number;
2240
+ onChange?: (newvalue: Vector2) => void;
2241
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2242
+ icon?: string;
2243
+ iconLabel?: string;
2244
+ }
2245
+ export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
2246
+ isExpanded: boolean;
2247
+ value: Vector2;
2248
+ }> {
2249
+ static defaultProps: {
2250
+ step: number;
2251
+ };
2252
+ private _localChange;
2253
+ constructor(props: IVector2LineComponentProps);
2254
+ shouldComponentUpdate(nextProps: IVector2LineComponentProps, nextState: {
2255
+ isExpanded: boolean;
2256
+ value: Vector2;
2257
+ }): boolean;
2258
+ switchExpandState(): void;
2259
+ raiseOnPropertyChanged(previousValue: Vector2): void;
2260
+ updateStateX(value: number): void;
2261
+ updateStateY(value: number): void;
2262
+ render(): JSX.Element;
2263
+ }
2264
+ export {};
2265
2265
 
2266
2266
  }
2267
2267
  declare module "shared-ui-components/lines/vector3LineComponent" {
2268
- import * as React from "react";
2269
- import { Vector3 } from "@babylonjs/core/Maths/math.vector";
2270
- import { Observable } from "@babylonjs/core/Misc/observable";
2271
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2272
- interface IVector3LineComponentProps {
2273
- label: string;
2274
- target: any;
2275
- propertyName: string;
2276
- step?: number;
2277
- onChange?: (newvalue: Vector3) => void;
2278
- useEuler?: boolean;
2279
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2280
- noSlider?: boolean;
2281
- icon?: string;
2282
- iconLabel?: string;
2283
- }
2284
- export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
2285
- isExpanded: boolean;
2286
- value: Vector3;
2287
- }> {
2288
- static defaultProps: {
2289
- step: number;
2290
- };
2291
- private _localChange;
2292
- constructor(props: IVector3LineComponentProps);
2293
- getCurrentValue(): any;
2294
- shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
2295
- isExpanded: boolean;
2296
- value: Vector3;
2297
- }): boolean;
2298
- switchExpandState(): void;
2299
- raiseOnPropertyChanged(previousValue: Vector3): void;
2300
- updateVector3(): void;
2301
- updateStateX(value: number): void;
2302
- updateStateY(value: number): void;
2303
- updateStateZ(value: number): void;
2304
- render(): JSX.Element;
2305
- }
2306
- export {};
2268
+ import * as React from "react";
2269
+ import { Vector3 } from "@babylonjs/core/Maths/math.vector";
2270
+ import { Observable } from "@babylonjs/core/Misc/observable";
2271
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2272
+ interface IVector3LineComponentProps {
2273
+ label: string;
2274
+ target: any;
2275
+ propertyName: string;
2276
+ step?: number;
2277
+ onChange?: (newvalue: Vector3) => void;
2278
+ useEuler?: boolean;
2279
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2280
+ noSlider?: boolean;
2281
+ icon?: string;
2282
+ iconLabel?: string;
2283
+ }
2284
+ export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
2285
+ isExpanded: boolean;
2286
+ value: Vector3;
2287
+ }> {
2288
+ static defaultProps: {
2289
+ step: number;
2290
+ };
2291
+ private _localChange;
2292
+ constructor(props: IVector3LineComponentProps);
2293
+ getCurrentValue(): any;
2294
+ shouldComponentUpdate(nextProps: IVector3LineComponentProps, nextState: {
2295
+ isExpanded: boolean;
2296
+ value: Vector3;
2297
+ }): boolean;
2298
+ switchExpandState(): void;
2299
+ raiseOnPropertyChanged(previousValue: Vector3): void;
2300
+ updateVector3(): void;
2301
+ updateStateX(value: number): void;
2302
+ updateStateY(value: number): void;
2303
+ updateStateZ(value: number): void;
2304
+ render(): JSX.Element;
2305
+ }
2306
+ export {};
2307
2307
 
2308
2308
  }
2309
2309
  declare module "shared-ui-components/lines/vector4LineComponent" {
2310
- import * as React from "react";
2311
- import { Vector4 } from "@babylonjs/core/Maths/math.vector";
2312
- import { Observable } from "@babylonjs/core/Misc/observable";
2313
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2314
- interface IVector4LineComponentProps {
2315
- label: string;
2316
- target: any;
2317
- propertyName: string;
2318
- step?: number;
2319
- onChange?: (newvalue: Vector4) => void;
2320
- useEuler?: boolean;
2321
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2322
- icon?: string;
2323
- iconLabel?: string;
2324
- }
2325
- export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
2326
- isExpanded: boolean;
2327
- value: Vector4;
2328
- }> {
2329
- static defaultProps: {
2330
- step: number;
2331
- };
2332
- private _localChange;
2333
- constructor(props: IVector4LineComponentProps);
2334
- getCurrentValue(): any;
2335
- shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
2336
- isExpanded: boolean;
2337
- value: Vector4;
2338
- }): boolean;
2339
- switchExpandState(): void;
2340
- raiseOnPropertyChanged(previousValue: Vector4): void;
2341
- updateVector4(): void;
2342
- updateStateX(value: number): void;
2343
- updateStateY(value: number): void;
2344
- updateStateZ(value: number): void;
2345
- updateStateW(value: number): void;
2346
- render(): JSX.Element;
2347
- }
2348
- export {};
2310
+ import * as React from "react";
2311
+ import { Vector4 } from "@babylonjs/core/Maths/math.vector";
2312
+ import { Observable } from "@babylonjs/core/Misc/observable";
2313
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2314
+ interface IVector4LineComponentProps {
2315
+ label: string;
2316
+ target: any;
2317
+ propertyName: string;
2318
+ step?: number;
2319
+ onChange?: (newvalue: Vector4) => void;
2320
+ useEuler?: boolean;
2321
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2322
+ icon?: string;
2323
+ iconLabel?: string;
2324
+ }
2325
+ export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
2326
+ isExpanded: boolean;
2327
+ value: Vector4;
2328
+ }> {
2329
+ static defaultProps: {
2330
+ step: number;
2331
+ };
2332
+ private _localChange;
2333
+ constructor(props: IVector4LineComponentProps);
2334
+ getCurrentValue(): any;
2335
+ shouldComponentUpdate(nextProps: IVector4LineComponentProps, nextState: {
2336
+ isExpanded: boolean;
2337
+ value: Vector4;
2338
+ }): boolean;
2339
+ switchExpandState(): void;
2340
+ raiseOnPropertyChanged(previousValue: Vector4): void;
2341
+ updateVector4(): void;
2342
+ updateStateX(value: number): void;
2343
+ updateStateY(value: number): void;
2344
+ updateStateZ(value: number): void;
2345
+ updateStateW(value: number): void;
2346
+ render(): JSX.Element;
2347
+ }
2348
+ export {};
2349
2349
 
2350
2350
  }
2351
2351
  declare module "shared-ui-components/propertyChangedEvent" {
2352
- export class PropertyChangedEvent {
2353
- object: any;
2354
- property: string;
2355
- value: any;
2356
- initialValue: any;
2357
- allowNullValue?: boolean;
2358
- }
2352
+ export class PropertyChangedEvent {
2353
+ object: any;
2354
+ property: string;
2355
+ value: any;
2356
+ initialValue: any;
2357
+ allowNullValue?: boolean;
2358
+ }
2359
2359
 
2360
2360
  }
2361
2361
  declare module "shared-ui-components/stringTools" {
2362
- export class StringTools {
2363
- private static _SaveAs;
2364
- private static _Click;
2365
- /**
2366
- * Download a string into a file that will be saved locally by the browser
2367
- * @param document
2368
- * @param content defines the string to download locally as a file
2369
- * @param filename
2370
- */
2371
- static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void;
2372
- }
2362
+ export class StringTools {
2363
+ private static _SaveAs;
2364
+ private static _Click;
2365
+ /**
2366
+ * Download a string into a file that will be saved locally by the browser
2367
+ * @param document
2368
+ * @param content defines the string to download locally as a file
2369
+ * @param filename
2370
+ */
2371
+ static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void;
2372
+ }
2373
2373
 
2374
2374
  }
2375
2375
  declare module "shared-ui-components/tabs/propertyGrids/gui/checkboxPropertyGridComponent" {
2376
- import * as React from "react";
2377
- import { Observable } from "@babylonjs/core/Misc/observable";
2378
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2379
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2380
- import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
2381
- interface ICheckboxPropertyGridComponentProps {
2382
- checkbox: Checkbox;
2383
- lockObject: LockObject;
2384
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2385
- }
2386
- export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
2387
- constructor(props: ICheckboxPropertyGridComponentProps);
2388
- render(): JSX.Element;
2389
- }
2390
- export {};
2376
+ import * as React from "react";
2377
+ import { Observable } from "@babylonjs/core/Misc/observable";
2378
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2379
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2380
+ import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
2381
+ interface ICheckboxPropertyGridComponentProps {
2382
+ checkbox: Checkbox;
2383
+ lockObject: LockObject;
2384
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2385
+ }
2386
+ export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
2387
+ constructor(props: ICheckboxPropertyGridComponentProps);
2388
+ render(): JSX.Element;
2389
+ }
2390
+ export {};
2391
2391
 
2392
2392
  }
2393
2393
  declare module "shared-ui-components/tabs/propertyGrids/gui/colorPickerPropertyGridComponent" {
2394
- import * as React from "react";
2395
- import { Observable } from "@babylonjs/core/Misc/observable";
2396
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2397
- import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
2398
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2399
- interface IColorPickerPropertyGridComponentProps {
2400
- colorPicker: ColorPicker;
2401
- lockObject: LockObject;
2402
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2403
- }
2404
- export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
2405
- constructor(props: IColorPickerPropertyGridComponentProps);
2406
- render(): JSX.Element;
2407
- }
2408
- export {};
2394
+ import * as React from "react";
2395
+ import { Observable } from "@babylonjs/core/Misc/observable";
2396
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2397
+ import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
2398
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2399
+ interface IColorPickerPropertyGridComponentProps {
2400
+ colorPicker: ColorPicker;
2401
+ lockObject: LockObject;
2402
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2403
+ }
2404
+ export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
2405
+ constructor(props: IColorPickerPropertyGridComponentProps);
2406
+ render(): JSX.Element;
2407
+ }
2408
+ export {};
2409
2409
 
2410
2410
  }
2411
2411
  declare module "shared-ui-components/tabs/propertyGrids/gui/commonControlPropertyGridComponent" {
2412
- import * as React from "react";
2413
- import { Observable } from "@babylonjs/core/Misc/observable";
2414
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2415
- import { Control } from "@babylonjs/gui/2D/controls/control";
2416
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2417
- interface ICommonControlPropertyGridComponentProps {
2418
- controls?: Control[];
2419
- control?: Control;
2420
- lockObject: LockObject;
2421
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2422
- }
2423
- export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
2424
- constructor(props: ICommonControlPropertyGridComponentProps);
2425
- renderGridInformation(control: Control): JSX.Element | null;
2426
- render(): JSX.Element | undefined;
2427
- }
2428
- export {};
2412
+ import * as React from "react";
2413
+ import { Observable } from "@babylonjs/core/Misc/observable";
2414
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2415
+ import { Control } from "@babylonjs/gui/2D/controls/control";
2416
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2417
+ interface ICommonControlPropertyGridComponentProps {
2418
+ controls?: Control[];
2419
+ control?: Control;
2420
+ lockObject: LockObject;
2421
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2422
+ }
2423
+ export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
2424
+ constructor(props: ICommonControlPropertyGridComponentProps);
2425
+ renderGridInformation(control: Control): JSX.Element | null;
2426
+ render(): JSX.Element | undefined;
2427
+ }
2428
+ export {};
2429
2429
 
2430
2430
  }
2431
2431
  declare module "shared-ui-components/tabs/propertyGrids/gui/controlPropertyGridComponent" {
2432
- import * as React from "react";
2433
- import { Observable } from "@babylonjs/core/Misc/observable";
2434
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2435
- import { Control } from "@babylonjs/gui/2D/controls/control";
2436
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2437
- interface IControlPropertyGridComponentProps {
2438
- control: Control;
2439
- lockObject: LockObject;
2440
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2441
- }
2442
- export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
2443
- constructor(props: IControlPropertyGridComponentProps);
2444
- render(): JSX.Element;
2445
- }
2446
- export {};
2432
+ import * as React from "react";
2433
+ import { Observable } from "@babylonjs/core/Misc/observable";
2434
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2435
+ import { Control } from "@babylonjs/gui/2D/controls/control";
2436
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2437
+ interface IControlPropertyGridComponentProps {
2438
+ control: Control;
2439
+ lockObject: LockObject;
2440
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2441
+ }
2442
+ export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
2443
+ constructor(props: IControlPropertyGridComponentProps);
2444
+ render(): JSX.Element;
2445
+ }
2446
+ export {};
2447
2447
 
2448
2448
  }
2449
2449
  declare module "shared-ui-components/tabs/propertyGrids/gui/ellipsePropertyGridComponent" {
2450
- import * as React from "react";
2451
- import { Observable } from "@babylonjs/core/Misc/observable";
2452
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2453
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2454
- import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
2455
- interface IEllipsePropertyGridComponentProps {
2456
- ellipse: Ellipse;
2457
- lockObject: LockObject;
2458
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2459
- }
2460
- export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
2461
- constructor(props: IEllipsePropertyGridComponentProps);
2462
- render(): JSX.Element;
2463
- }
2464
- export {};
2450
+ import * as React from "react";
2451
+ import { Observable } from "@babylonjs/core/Misc/observable";
2452
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2453
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2454
+ import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
2455
+ interface IEllipsePropertyGridComponentProps {
2456
+ ellipse: Ellipse;
2457
+ lockObject: LockObject;
2458
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2459
+ }
2460
+ export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
2461
+ constructor(props: IEllipsePropertyGridComponentProps);
2462
+ render(): JSX.Element;
2463
+ }
2464
+ export {};
2465
2465
 
2466
2466
  }
2467
2467
  declare module "shared-ui-components/tabs/propertyGrids/gui/gridPropertyGridComponent" {
2468
- import * as React from "react";
2469
- import { Observable } from "@babylonjs/core/Misc/observable";
2470
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2471
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2472
- import { Grid } from "@babylonjs/gui/2D/controls/grid";
2473
- interface IGridPropertyGridComponentProps {
2474
- grid: Grid;
2475
- lockObject: LockObject;
2476
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2477
- }
2478
- export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
2479
- constructor(props: IGridPropertyGridComponentProps);
2480
- renderRows(): JSX.Element[];
2481
- renderColumns(): JSX.Element[];
2482
- render(): JSX.Element;
2483
- }
2484
- export {};
2468
+ import * as React from "react";
2469
+ import { Observable } from "@babylonjs/core/Misc/observable";
2470
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2471
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2472
+ import { Grid } from "@babylonjs/gui/2D/controls/grid";
2473
+ interface IGridPropertyGridComponentProps {
2474
+ grid: Grid;
2475
+ lockObject: LockObject;
2476
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2477
+ }
2478
+ export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
2479
+ constructor(props: IGridPropertyGridComponentProps);
2480
+ renderRows(): JSX.Element[];
2481
+ renderColumns(): JSX.Element[];
2482
+ render(): JSX.Element;
2483
+ }
2484
+ export {};
2485
2485
 
2486
2486
  }
2487
2487
  declare module "shared-ui-components/tabs/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
2488
- import * as React from "react";
2489
- import { Observable } from "@babylonjs/core/Misc/observable";
2490
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2491
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2492
- import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
2493
- interface IImageBasedSliderPropertyGridComponentProps {
2494
- imageBasedSlider: ImageBasedSlider;
2495
- lockObject: LockObject;
2496
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2497
- }
2498
- export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
2499
- constructor(props: IImageBasedSliderPropertyGridComponentProps);
2500
- render(): JSX.Element;
2501
- }
2502
- export {};
2488
+ import * as React from "react";
2489
+ import { Observable } from "@babylonjs/core/Misc/observable";
2490
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2491
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2492
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
2493
+ interface IImageBasedSliderPropertyGridComponentProps {
2494
+ imageBasedSlider: ImageBasedSlider;
2495
+ lockObject: LockObject;
2496
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2497
+ }
2498
+ export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
2499
+ constructor(props: IImageBasedSliderPropertyGridComponentProps);
2500
+ render(): JSX.Element;
2501
+ }
2502
+ export {};
2503
2503
 
2504
2504
  }
2505
2505
  declare module "shared-ui-components/tabs/propertyGrids/gui/imagePropertyGridComponent" {
2506
- import * as React from "react";
2507
- import { Observable } from "@babylonjs/core/Misc/observable";
2508
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2509
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2510
- import { Image } from "@babylonjs/gui/2D/controls/image";
2511
- interface IImagePropertyGridComponentProps {
2512
- image: Image;
2513
- lockObject: LockObject;
2514
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2515
- }
2516
- export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
2517
- constructor(props: IImagePropertyGridComponentProps);
2518
- render(): JSX.Element;
2519
- }
2520
- export {};
2506
+ import * as React from "react";
2507
+ import { Observable } from "@babylonjs/core/Misc/observable";
2508
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2509
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2510
+ import { Image } from "@babylonjs/gui/2D/controls/image";
2511
+ interface IImagePropertyGridComponentProps {
2512
+ image: Image;
2513
+ lockObject: LockObject;
2514
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2515
+ }
2516
+ export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
2517
+ constructor(props: IImagePropertyGridComponentProps);
2518
+ render(): JSX.Element;
2519
+ }
2520
+ export {};
2521
2521
 
2522
2522
  }
2523
2523
  declare module "shared-ui-components/tabs/propertyGrids/gui/inputTextPropertyGridComponent" {
2524
- import * as React from "react";
2525
- import { Observable } from "@babylonjs/core/Misc/observable";
2526
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2527
- import { InputText } from "@babylonjs/gui/2D/controls/inputText";
2528
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2529
- interface IInputTextPropertyGridComponentProps {
2530
- inputText: InputText;
2531
- lockObject: LockObject;
2532
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2533
- }
2534
- export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
2535
- constructor(props: IInputTextPropertyGridComponentProps);
2536
- render(): JSX.Element;
2537
- }
2538
- export {};
2524
+ import * as React from "react";
2525
+ import { Observable } from "@babylonjs/core/Misc/observable";
2526
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2527
+ import { InputText } from "@babylonjs/gui/2D/controls/inputText";
2528
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2529
+ interface IInputTextPropertyGridComponentProps {
2530
+ inputText: InputText;
2531
+ lockObject: LockObject;
2532
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2533
+ }
2534
+ export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
2535
+ constructor(props: IInputTextPropertyGridComponentProps);
2536
+ render(): JSX.Element;
2537
+ }
2538
+ export {};
2539
2539
 
2540
2540
  }
2541
2541
  declare module "shared-ui-components/tabs/propertyGrids/gui/linePropertyGridComponent" {
2542
- import * as React from "react";
2543
- import { Observable } from "@babylonjs/core/Misc/observable";
2544
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2545
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2546
- import { Line } from "@babylonjs/gui/2D/controls/line";
2547
- interface ILinePropertyGridComponentProps {
2548
- line: Line;
2549
- lockObject: LockObject;
2550
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2551
- }
2552
- export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
2553
- constructor(props: ILinePropertyGridComponentProps);
2554
- onDashChange(value: string): void;
2555
- render(): JSX.Element;
2556
- }
2557
- export {};
2542
+ import * as React from "react";
2543
+ import { Observable } from "@babylonjs/core/Misc/observable";
2544
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2545
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2546
+ import { Line } from "@babylonjs/gui/2D/controls/line";
2547
+ interface ILinePropertyGridComponentProps {
2548
+ line: Line;
2549
+ lockObject: LockObject;
2550
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2551
+ }
2552
+ export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
2553
+ constructor(props: ILinePropertyGridComponentProps);
2554
+ onDashChange(value: string): void;
2555
+ render(): JSX.Element;
2556
+ }
2557
+ export {};
2558
2558
 
2559
2559
  }
2560
2560
  declare module "shared-ui-components/tabs/propertyGrids/gui/radioButtonPropertyGridComponent" {
2561
- import * as React from "react";
2562
- import { Observable } from "@babylonjs/core/Misc/observable";
2563
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2564
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2565
- import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
2566
- interface IRadioButtonPropertyGridComponentProps {
2567
- radioButtons: RadioButton[];
2568
- lockObject: LockObject;
2569
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2570
- }
2571
- export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
2572
- constructor(props: IRadioButtonPropertyGridComponentProps);
2573
- render(): JSX.Element;
2574
- }
2575
- export {};
2561
+ import * as React from "react";
2562
+ import { Observable } from "@babylonjs/core/Misc/observable";
2563
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2564
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2565
+ import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
2566
+ interface IRadioButtonPropertyGridComponentProps {
2567
+ radioButtons: RadioButton[];
2568
+ lockObject: LockObject;
2569
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2570
+ }
2571
+ export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
2572
+ constructor(props: IRadioButtonPropertyGridComponentProps);
2573
+ render(): JSX.Element;
2574
+ }
2575
+ export {};
2576
2576
 
2577
2577
  }
2578
2578
  declare module "shared-ui-components/tabs/propertyGrids/gui/rectanglePropertyGridComponent" {
2579
- import * as React from "react";
2580
- import { Observable } from "@babylonjs/core/Misc/observable";
2581
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2582
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2583
- import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
2584
- interface IRectanglePropertyGridComponentProps {
2585
- rectangle: Rectangle;
2586
- lockObject: LockObject;
2587
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2588
- }
2589
- export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
2590
- constructor(props: IRectanglePropertyGridComponentProps);
2591
- render(): JSX.Element;
2592
- }
2593
- export {};
2579
+ import * as React from "react";
2580
+ import { Observable } from "@babylonjs/core/Misc/observable";
2581
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2582
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2583
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
2584
+ interface IRectanglePropertyGridComponentProps {
2585
+ rectangle: Rectangle;
2586
+ lockObject: LockObject;
2587
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2588
+ }
2589
+ export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
2590
+ constructor(props: IRectanglePropertyGridComponentProps);
2591
+ render(): JSX.Element;
2592
+ }
2593
+ export {};
2594
2594
 
2595
2595
  }
2596
2596
  declare module "shared-ui-components/tabs/propertyGrids/gui/scrollViewerPropertyGridComponent" {
2597
- import * as React from "react";
2598
- import { Observable } from "@babylonjs/core/Misc/observable";
2599
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2600
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2601
- import { ScrollViewer } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewer";
2602
- interface IScrollViewerPropertyGridComponentProps {
2603
- scrollViewer: ScrollViewer;
2604
- lockObject: LockObject;
2605
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2606
- }
2607
- export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
2608
- constructor(props: IScrollViewerPropertyGridComponentProps);
2609
- render(): JSX.Element;
2610
- }
2611
- export {};
2597
+ import * as React from "react";
2598
+ import { Observable } from "@babylonjs/core/Misc/observable";
2599
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2600
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2601
+ import { ScrollViewer } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewer";
2602
+ interface IScrollViewerPropertyGridComponentProps {
2603
+ scrollViewer: ScrollViewer;
2604
+ lockObject: LockObject;
2605
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2606
+ }
2607
+ export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
2608
+ constructor(props: IScrollViewerPropertyGridComponentProps);
2609
+ render(): JSX.Element;
2610
+ }
2611
+ export {};
2612
2612
 
2613
2613
  }
2614
2614
  declare module "shared-ui-components/tabs/propertyGrids/gui/sliderPropertyGridComponent" {
2615
- import * as React from "react";
2616
- import { Observable } from "@babylonjs/core/Misc/observable";
2617
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2618
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2619
- import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
2620
- interface ISliderPropertyGridComponentProps {
2621
- slider: Slider;
2622
- lockObject: LockObject;
2623
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2624
- }
2625
- export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
2626
- constructor(props: ISliderPropertyGridComponentProps);
2627
- render(): JSX.Element;
2628
- }
2629
- export {};
2615
+ import * as React from "react";
2616
+ import { Observable } from "@babylonjs/core/Misc/observable";
2617
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2618
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2619
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
2620
+ interface ISliderPropertyGridComponentProps {
2621
+ slider: Slider;
2622
+ lockObject: LockObject;
2623
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2624
+ }
2625
+ export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
2626
+ constructor(props: ISliderPropertyGridComponentProps);
2627
+ render(): JSX.Element;
2628
+ }
2629
+ export {};
2630
2630
 
2631
2631
  }
2632
2632
  declare module "shared-ui-components/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" {
2633
- import * as React from "react";
2634
- import { Observable } from "@babylonjs/core/Misc/observable";
2635
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2636
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2637
- import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
2638
- interface IStackPanelPropertyGridComponentProps {
2639
- stackPanel: StackPanel;
2640
- lockObject: LockObject;
2641
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2642
- }
2643
- export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
2644
- constructor(props: IStackPanelPropertyGridComponentProps);
2645
- render(): JSX.Element;
2646
- }
2647
- export {};
2633
+ import * as React from "react";
2634
+ import { Observable } from "@babylonjs/core/Misc/observable";
2635
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2636
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2637
+ import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
2638
+ interface IStackPanelPropertyGridComponentProps {
2639
+ stackPanel: StackPanel;
2640
+ lockObject: LockObject;
2641
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2642
+ }
2643
+ export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
2644
+ constructor(props: IStackPanelPropertyGridComponentProps);
2645
+ render(): JSX.Element;
2646
+ }
2647
+ export {};
2648
2648
 
2649
2649
  }
2650
2650
  declare module "shared-ui-components/tabs/propertyGrids/gui/textBlockPropertyGridComponent" {
2651
- import * as React from "react";
2652
- import { Observable } from "@babylonjs/core/Misc/observable";
2653
- import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2654
- import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
2655
- import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2656
- interface ITextBlockPropertyGridComponentProps {
2657
- textBlock: TextBlock;
2658
- lockObject: LockObject;
2659
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2660
- }
2661
- export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
2662
- constructor(props: ITextBlockPropertyGridComponentProps);
2663
- render(): JSX.Element;
2664
- }
2665
- export {};
2651
+ import * as React from "react";
2652
+ import { Observable } from "@babylonjs/core/Misc/observable";
2653
+ import { PropertyChangedEvent } from "shared-ui-components/propertyChangedEvent";
2654
+ import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
2655
+ import { LockObject } from "shared-ui-components/tabs/propertyGrids/lockObject";
2656
+ interface ITextBlockPropertyGridComponentProps {
2657
+ textBlock: TextBlock;
2658
+ lockObject: LockObject;
2659
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2660
+ }
2661
+ export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
2662
+ constructor(props: ITextBlockPropertyGridComponentProps);
2663
+ render(): JSX.Element;
2664
+ }
2665
+ export {};
2666
2666
 
2667
2667
  }
2668
2668
  declare module "shared-ui-components/tabs/propertyGrids/lockObject" {
2669
- /**
2670
- * Class used to provide lock mechanism
2671
- */
2672
- export class LockObject {
2673
- /**
2674
- * Gets or set if the lock is engaged
2675
- */
2676
- lock: boolean;
2677
- }
2669
+ /**
2670
+ * Class used to provide lock mechanism
2671
+ */
2672
+ export class LockObject {
2673
+ /**
2674
+ * Gets or set if the lock is engaged
2675
+ */
2676
+ lock: boolean;
2677
+ }
2678
2678
 
2679
2679
  }
2680
2680