@babylonjs/gui-editor 5.9.0 → 5.11.0

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