@babylonjs/gui-editor 5.0.0-alpha.9 → 5.0.0-beta.4

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.
Files changed (4) hide show
  1. package/babylon.guiEditor.max.js +34658 -40939
  2. package/babylon.guiEditor.max.js.map +1 -1
  3. package/babylon.guiEditor.module.d.ts +1824 -379
  4. package/package.json +3 -3
package/babylon.guiEditor.module.d.ts CHANGED
@@ -19,129 +19,759 @@ declare module "@babylonjs/gui-editor/components/log/logComponent" {
19
19
  render(): JSX.Element;
20
20
  }
21
21
  }
22
+ declare module "@babylonjs/gui-editor/tools" {
23
+ import { Control } from "@babylonjs/gui/2D/controls/control";
24
+ import { Grid } from "@babylonjs/gui/2D/controls/grid";
25
+ import { Vector2 } from "@babylonjs/core/Maths/math";
26
+ export class Tools {
27
+ static LookForItem(item: any, selectedEntity: any, firstIteration?: boolean): boolean;
28
+ private static _RecursiveRemoveHiddenMeshesAndHoistChildren;
29
+ static SortAndFilter(parent: any, items: any[]): any[];
30
+ static getCellInfo(grid: Grid, control: Control): Vector2;
31
+ static reorderGrid(grid: Grid, index: number, control: Control, cell: Vector2): void;
32
+ }
33
+ }
34
+ declare module "@babylonjs/gui-editor/diagram/GUIEditorNodeMaterial" {
35
+ export const GUIEditorNodeMaterial: {
36
+ tags: null;
37
+ ignoreAlpha: boolean;
38
+ maxSimultaneousLights: number;
39
+ mode: number;
40
+ id: string;
41
+ name: string;
42
+ checkReadyOnEveryCall: boolean;
43
+ checkReadyOnlyOnce: boolean;
44
+ state: string;
45
+ alpha: number;
46
+ backFaceCulling: boolean;
47
+ cullBackFaces: boolean;
48
+ sideOrientation: number;
49
+ alphaMode: number;
50
+ _needDepthPrePass: boolean;
51
+ disableDepthWrite: boolean;
52
+ disableColorWrite: boolean;
53
+ forceDepthWrite: boolean;
54
+ depthFunction: number;
55
+ separateCullingPass: boolean;
56
+ fogEnabled: boolean;
57
+ pointSize: number;
58
+ zOffset: number;
59
+ zOffsetUnits: number;
60
+ pointsCloud: boolean;
61
+ fillMode: number;
62
+ editorData: {
63
+ locations: {
64
+ blockId: number;
65
+ x: number;
66
+ y: number;
67
+ }[];
68
+ frames: {
69
+ x: number;
70
+ y: number;
71
+ width: number;
72
+ height: number;
73
+ color: number[];
74
+ name: string;
75
+ isCollapsed: boolean;
76
+ blocks: number[];
77
+ }[];
78
+ x: number;
79
+ y: number;
80
+ zoom: number;
81
+ };
82
+ customType: string;
83
+ outputNodes: number[];
84
+ blocks: ({
85
+ customType: string;
86
+ id: number;
87
+ name: string;
88
+ comments: string;
89
+ visibleInInspector: boolean;
90
+ visibleOnFrame: boolean;
91
+ target: number;
92
+ inputs: {
93
+ name: string;
94
+ inputName: string;
95
+ targetBlockId: number;
96
+ targetConnectionName: string;
97
+ isExposedOnFrame: boolean;
98
+ exposedPortPosition: number;
99
+ }[];
100
+ outputs: {
101
+ name: string;
102
+ }[];
103
+ complementZ: number;
104
+ complementW: number;
105
+ type?: undefined;
106
+ mode?: undefined;
107
+ animationType?: undefined;
108
+ min?: undefined;
109
+ max?: undefined;
110
+ isBoolean?: undefined;
111
+ matrixMode?: undefined;
112
+ isConstant?: undefined;
113
+ groupInInspector?: undefined;
114
+ convertToGammaSpace?: undefined;
115
+ convertToLinearSpace?: undefined;
116
+ systemValue?: undefined;
117
+ rSwizzle?: undefined;
118
+ gSwizzle?: undefined;
119
+ bSwizzle?: undefined;
120
+ aSwizzle?: undefined;
121
+ operation?: undefined;
122
+ xSwizzle?: undefined;
123
+ ySwizzle?: undefined;
124
+ zSwizzle?: undefined;
125
+ wSwizzle?: undefined;
126
+ valueType?: undefined;
127
+ value?: undefined;
128
+ fragmentOnly?: undefined;
129
+ disableLevelMultiplication?: undefined;
130
+ } | {
131
+ customType: string;
132
+ id: number;
133
+ name: string;
134
+ comments: string;
135
+ visibleInInspector: boolean;
136
+ visibleOnFrame: boolean;
137
+ target: number;
138
+ inputs: never[];
139
+ outputs: {
140
+ name: string;
141
+ }[];
142
+ type: number;
143
+ mode: number;
144
+ animationType: number;
145
+ min: number;
146
+ max: number;
147
+ isBoolean: boolean;
148
+ matrixMode: number;
149
+ isConstant: boolean;
150
+ groupInInspector: string;
151
+ convertToGammaSpace: boolean;
152
+ convertToLinearSpace: boolean;
153
+ complementZ?: undefined;
154
+ complementW?: undefined;
155
+ systemValue?: undefined;
156
+ rSwizzle?: undefined;
157
+ gSwizzle?: undefined;
158
+ bSwizzle?: undefined;
159
+ aSwizzle?: undefined;
160
+ operation?: undefined;
161
+ xSwizzle?: undefined;
162
+ ySwizzle?: undefined;
163
+ zSwizzle?: undefined;
164
+ wSwizzle?: undefined;
165
+ valueType?: undefined;
166
+ value?: undefined;
167
+ fragmentOnly?: undefined;
168
+ disableLevelMultiplication?: undefined;
169
+ } | {
170
+ customType: string;
171
+ id: number;
172
+ name: string;
173
+ comments: string;
174
+ visibleInInspector: boolean;
175
+ visibleOnFrame: boolean;
176
+ target: number;
177
+ inputs: never[];
178
+ outputs: {
179
+ name: string;
180
+ }[];
181
+ type: number;
182
+ mode: number;
183
+ systemValue: number;
184
+ animationType: number;
185
+ min: number;
186
+ max: number;
187
+ isBoolean: boolean;
188
+ matrixMode: number;
189
+ isConstant: boolean;
190
+ groupInInspector: string;
191
+ convertToGammaSpace: boolean;
192
+ convertToLinearSpace: boolean;
193
+ complementZ?: undefined;
194
+ complementW?: undefined;
195
+ rSwizzle?: undefined;
196
+ gSwizzle?: undefined;
197
+ bSwizzle?: undefined;
198
+ aSwizzle?: undefined;
199
+ operation?: undefined;
200
+ xSwizzle?: undefined;
201
+ ySwizzle?: undefined;
202
+ zSwizzle?: undefined;
203
+ wSwizzle?: undefined;
204
+ valueType?: undefined;
205
+ value?: undefined;
206
+ fragmentOnly?: undefined;
207
+ disableLevelMultiplication?: undefined;
208
+ } | {
209
+ customType: string;
210
+ id: number;
211
+ name: string;
212
+ comments: string;
213
+ visibleInInspector: boolean;
214
+ visibleOnFrame: boolean;
215
+ target: number;
216
+ inputs: ({
217
+ name: string;
218
+ displayName: string;
219
+ inputName?: undefined;
220
+ targetBlockId?: undefined;
221
+ targetConnectionName?: undefined;
222
+ isExposedOnFrame?: undefined;
223
+ exposedPortPosition?: undefined;
224
+ } | {
225
+ name: string;
226
+ displayName: string;
227
+ inputName: string;
228
+ targetBlockId: number;
229
+ targetConnectionName: string;
230
+ isExposedOnFrame: boolean;
231
+ exposedPortPosition: number;
232
+ })[];
233
+ outputs: never[];
234
+ convertToGammaSpace: boolean;
235
+ convertToLinearSpace: boolean;
236
+ complementZ?: undefined;
237
+ complementW?: undefined;
238
+ type?: undefined;
239
+ mode?: undefined;
240
+ animationType?: undefined;
241
+ min?: undefined;
242
+ max?: undefined;
243
+ isBoolean?: undefined;
244
+ matrixMode?: undefined;
245
+ isConstant?: undefined;
246
+ groupInInspector?: undefined;
247
+ systemValue?: undefined;
248
+ rSwizzle?: undefined;
249
+ gSwizzle?: undefined;
250
+ bSwizzle?: undefined;
251
+ aSwizzle?: undefined;
252
+ operation?: undefined;
253
+ xSwizzle?: undefined;
254
+ ySwizzle?: undefined;
255
+ zSwizzle?: undefined;
256
+ wSwizzle?: undefined;
257
+ valueType?: undefined;
258
+ value?: undefined;
259
+ fragmentOnly?: undefined;
260
+ disableLevelMultiplication?: undefined;
261
+ } | {
262
+ customType: string;
263
+ id: number;
264
+ name: string;
265
+ comments: string;
266
+ visibleInInspector: boolean;
267
+ visibleOnFrame: boolean;
268
+ target: number;
269
+ inputs: ({
270
+ name: string;
271
+ displayName: string;
272
+ inputName: string;
273
+ targetBlockId: number;
274
+ targetConnectionName: string;
275
+ isExposedOnFrame: boolean;
276
+ exposedPortPosition: number;
277
+ } | {
278
+ name: string;
279
+ displayName: string;
280
+ isExposedOnFrame: boolean;
281
+ exposedPortPosition: number;
282
+ inputName?: undefined;
283
+ targetBlockId?: undefined;
284
+ targetConnectionName?: undefined;
285
+ })[];
286
+ outputs: {
287
+ name: string;
288
+ displayName: string;
289
+ }[];
290
+ complementZ?: undefined;
291
+ complementW?: undefined;
292
+ type?: undefined;
293
+ mode?: undefined;
294
+ animationType?: undefined;
295
+ min?: undefined;
296
+ max?: undefined;
297
+ isBoolean?: undefined;
298
+ matrixMode?: undefined;
299
+ isConstant?: undefined;
300
+ groupInInspector?: undefined;
301
+ convertToGammaSpace?: undefined;
302
+ convertToLinearSpace?: undefined;
303
+ systemValue?: undefined;
304
+ rSwizzle?: undefined;
305
+ gSwizzle?: undefined;
306
+ bSwizzle?: undefined;
307
+ aSwizzle?: undefined;
308
+ operation?: undefined;
309
+ xSwizzle?: undefined;
310
+ ySwizzle?: undefined;
311
+ zSwizzle?: undefined;
312
+ wSwizzle?: undefined;
313
+ valueType?: undefined;
314
+ value?: undefined;
315
+ fragmentOnly?: undefined;
316
+ disableLevelMultiplication?: undefined;
317
+ } | {
318
+ customType: string;
319
+ id: number;
320
+ name: string;
321
+ comments: string;
322
+ visibleInInspector: boolean;
323
+ visibleOnFrame: boolean;
324
+ target: number;
325
+ inputs: ({
326
+ name: string;
327
+ displayName: string;
328
+ inputName?: undefined;
329
+ targetBlockId?: undefined;
330
+ targetConnectionName?: undefined;
331
+ isExposedOnFrame?: undefined;
332
+ exposedPortPosition?: undefined;
333
+ } | {
334
+ name: string;
335
+ displayName: string;
336
+ inputName: string;
337
+ targetBlockId: number;
338
+ targetConnectionName: string;
339
+ isExposedOnFrame: boolean;
340
+ exposedPortPosition: number;
341
+ })[];
342
+ outputs: {
343
+ name: string;
344
+ displayName: string;
345
+ }[];
346
+ rSwizzle: string;
347
+ gSwizzle: string;
348
+ bSwizzle: string;
349
+ aSwizzle: string;
350
+ complementZ?: undefined;
351
+ complementW?: undefined;
352
+ type?: undefined;
353
+ mode?: undefined;
354
+ animationType?: undefined;
355
+ min?: undefined;
356
+ max?: undefined;
357
+ isBoolean?: undefined;
358
+ matrixMode?: undefined;
359
+ isConstant?: undefined;
360
+ groupInInspector?: undefined;
361
+ convertToGammaSpace?: undefined;
362
+ convertToLinearSpace?: undefined;
363
+ systemValue?: undefined;
364
+ operation?: undefined;
365
+ xSwizzle?: undefined;
366
+ ySwizzle?: undefined;
367
+ zSwizzle?: undefined;
368
+ wSwizzle?: undefined;
369
+ valueType?: undefined;
370
+ value?: undefined;
371
+ fragmentOnly?: undefined;
372
+ disableLevelMultiplication?: undefined;
373
+ } | {
374
+ customType: string;
375
+ id: number;
376
+ name: string;
377
+ comments: string;
378
+ visibleInInspector: boolean;
379
+ visibleOnFrame: boolean;
380
+ target: number;
381
+ inputs: {
382
+ name: string;
383
+ inputName: string;
384
+ targetBlockId: number;
385
+ targetConnectionName: string;
386
+ isExposedOnFrame: boolean;
387
+ exposedPortPosition: number;
388
+ }[];
389
+ outputs: {
390
+ name: string;
391
+ }[];
392
+ operation: number;
393
+ complementZ?: undefined;
394
+ complementW?: undefined;
395
+ type?: undefined;
396
+ mode?: undefined;
397
+ animationType?: undefined;
398
+ min?: undefined;
399
+ max?: undefined;
400
+ isBoolean?: undefined;
401
+ matrixMode?: undefined;
402
+ isConstant?: undefined;
403
+ groupInInspector?: undefined;
404
+ convertToGammaSpace?: undefined;
405
+ convertToLinearSpace?: undefined;
406
+ systemValue?: undefined;
407
+ rSwizzle?: undefined;
408
+ gSwizzle?: undefined;
409
+ bSwizzle?: undefined;
410
+ aSwizzle?: undefined;
411
+ xSwizzle?: undefined;
412
+ ySwizzle?: undefined;
413
+ zSwizzle?: undefined;
414
+ wSwizzle?: undefined;
415
+ valueType?: undefined;
416
+ value?: undefined;
417
+ fragmentOnly?: undefined;
418
+ disableLevelMultiplication?: undefined;
419
+ } | {
420
+ customType: string;
421
+ id: number;
422
+ name: string;
423
+ comments: string;
424
+ visibleInInspector: boolean;
425
+ visibleOnFrame: boolean;
426
+ target: number;
427
+ inputs: ({
428
+ name: string;
429
+ inputName?: undefined;
430
+ targetBlockId?: undefined;
431
+ targetConnectionName?: undefined;
432
+ isExposedOnFrame?: undefined;
433
+ exposedPortPosition?: undefined;
434
+ } | {
435
+ name: string;
436
+ inputName: string;
437
+ targetBlockId: number;
438
+ targetConnectionName: string;
439
+ isExposedOnFrame: boolean;
440
+ exposedPortPosition: number;
441
+ })[];
442
+ outputs: {
443
+ name: string;
444
+ }[];
445
+ xSwizzle: string;
446
+ ySwizzle: string;
447
+ zSwizzle: string;
448
+ wSwizzle: string;
449
+ complementZ?: undefined;
450
+ complementW?: undefined;
451
+ type?: undefined;
452
+ mode?: undefined;
453
+ animationType?: undefined;
454
+ min?: undefined;
455
+ max?: undefined;
456
+ isBoolean?: undefined;
457
+ matrixMode?: undefined;
458
+ isConstant?: undefined;
459
+ groupInInspector?: undefined;
460
+ convertToGammaSpace?: undefined;
461
+ convertToLinearSpace?: undefined;
462
+ systemValue?: undefined;
463
+ rSwizzle?: undefined;
464
+ gSwizzle?: undefined;
465
+ bSwizzle?: undefined;
466
+ aSwizzle?: undefined;
467
+ operation?: undefined;
468
+ valueType?: undefined;
469
+ value?: undefined;
470
+ fragmentOnly?: undefined;
471
+ disableLevelMultiplication?: undefined;
472
+ } | {
473
+ customType: string;
474
+ id: number;
475
+ name: string;
476
+ comments: string;
477
+ visibleInInspector: boolean;
478
+ visibleOnFrame: boolean;
479
+ target: number;
480
+ inputs: ({
481
+ name: string;
482
+ inputName: string;
483
+ targetBlockId: number;
484
+ targetConnectionName: string;
485
+ isExposedOnFrame: boolean;
486
+ exposedPortPosition: number;
487
+ } | {
488
+ name: string;
489
+ isExposedOnFrame: boolean;
490
+ exposedPortPosition: number;
491
+ inputName?: undefined;
492
+ targetBlockId?: undefined;
493
+ targetConnectionName?: undefined;
494
+ } | {
495
+ name: string;
496
+ inputName?: undefined;
497
+ targetBlockId?: undefined;
498
+ targetConnectionName?: undefined;
499
+ isExposedOnFrame?: undefined;
500
+ exposedPortPosition?: undefined;
501
+ })[];
502
+ outputs: {
503
+ name: string;
504
+ }[];
505
+ complementZ?: undefined;
506
+ complementW?: undefined;
507
+ type?: undefined;
508
+ mode?: undefined;
509
+ animationType?: undefined;
510
+ min?: undefined;
511
+ max?: undefined;
512
+ isBoolean?: undefined;
513
+ matrixMode?: undefined;
514
+ isConstant?: undefined;
515
+ groupInInspector?: undefined;
516
+ convertToGammaSpace?: undefined;
517
+ convertToLinearSpace?: undefined;
518
+ systemValue?: undefined;
519
+ rSwizzle?: undefined;
520
+ gSwizzle?: undefined;
521
+ bSwizzle?: undefined;
522
+ aSwizzle?: undefined;
523
+ operation?: undefined;
524
+ xSwizzle?: undefined;
525
+ ySwizzle?: undefined;
526
+ zSwizzle?: undefined;
527
+ wSwizzle?: undefined;
528
+ valueType?: undefined;
529
+ value?: undefined;
530
+ fragmentOnly?: undefined;
531
+ disableLevelMultiplication?: undefined;
532
+ } | {
533
+ customType: string;
534
+ id: number;
535
+ name: string;
536
+ comments: string;
537
+ visibleInInspector: boolean;
538
+ visibleOnFrame: boolean;
539
+ target: number;
540
+ inputs: never[];
541
+ outputs: {
542
+ name: string;
543
+ }[];
544
+ type: number;
545
+ mode: number;
546
+ animationType: number;
547
+ min: number;
548
+ max: number;
549
+ isBoolean: boolean;
550
+ matrixMode: number;
551
+ isConstant: boolean;
552
+ groupInInspector: string;
553
+ convertToGammaSpace: boolean;
554
+ convertToLinearSpace: boolean;
555
+ valueType: string;
556
+ value: number[];
557
+ complementZ?: undefined;
558
+ complementW?: undefined;
559
+ systemValue?: undefined;
560
+ rSwizzle?: undefined;
561
+ gSwizzle?: undefined;
562
+ bSwizzle?: undefined;
563
+ aSwizzle?: undefined;
564
+ operation?: undefined;
565
+ xSwizzle?: undefined;
566
+ ySwizzle?: undefined;
567
+ zSwizzle?: undefined;
568
+ wSwizzle?: undefined;
569
+ fragmentOnly?: undefined;
570
+ disableLevelMultiplication?: undefined;
571
+ } | {
572
+ customType: string;
573
+ id: number;
574
+ name: string;
575
+ comments: string;
576
+ visibleInInspector: boolean;
577
+ visibleOnFrame: boolean;
578
+ target: number;
579
+ inputs: never[];
580
+ outputs: {
581
+ name: string;
582
+ }[];
583
+ type: number;
584
+ mode: number;
585
+ animationType: number;
586
+ min: number;
587
+ max: number;
588
+ isBoolean: boolean;
589
+ matrixMode: number;
590
+ isConstant: boolean;
591
+ groupInInspector: string;
592
+ convertToGammaSpace: boolean;
593
+ convertToLinearSpace: boolean;
594
+ valueType: string;
595
+ value: number;
596
+ complementZ?: undefined;
597
+ complementW?: undefined;
598
+ systemValue?: undefined;
599
+ rSwizzle?: undefined;
600
+ gSwizzle?: undefined;
601
+ bSwizzle?: undefined;
602
+ aSwizzle?: undefined;
603
+ operation?: undefined;
604
+ xSwizzle?: undefined;
605
+ ySwizzle?: undefined;
606
+ zSwizzle?: undefined;
607
+ wSwizzle?: undefined;
608
+ fragmentOnly?: undefined;
609
+ disableLevelMultiplication?: undefined;
610
+ } | {
611
+ customType: string;
612
+ id: number;
613
+ name: string;
614
+ comments: string;
615
+ visibleInInspector: boolean;
616
+ visibleOnFrame: boolean;
617
+ target: number;
618
+ inputs: ({
619
+ name: string;
620
+ displayName: string;
621
+ inputName: string;
622
+ targetBlockId: number;
623
+ targetConnectionName: string;
624
+ isExposedOnFrame: boolean;
625
+ exposedPortPosition: number;
626
+ } | {
627
+ name: string;
628
+ displayName: string;
629
+ inputName?: undefined;
630
+ targetBlockId?: undefined;
631
+ targetConnectionName?: undefined;
632
+ isExposedOnFrame?: undefined;
633
+ exposedPortPosition?: undefined;
634
+ })[];
635
+ outputs: {
636
+ name: string;
637
+ displayName: string;
638
+ }[];
639
+ convertToGammaSpace: boolean;
640
+ convertToLinearSpace: boolean;
641
+ fragmentOnly: boolean;
642
+ disableLevelMultiplication: boolean;
643
+ complementZ?: undefined;
644
+ complementW?: undefined;
645
+ type?: undefined;
646
+ mode?: undefined;
647
+ animationType?: undefined;
648
+ min?: undefined;
649
+ max?: undefined;
650
+ isBoolean?: undefined;
651
+ matrixMode?: undefined;
652
+ isConstant?: undefined;
653
+ groupInInspector?: undefined;
654
+ systemValue?: undefined;
655
+ rSwizzle?: undefined;
656
+ gSwizzle?: undefined;
657
+ bSwizzle?: undefined;
658
+ aSwizzle?: undefined;
659
+ operation?: undefined;
660
+ xSwizzle?: undefined;
661
+ ySwizzle?: undefined;
662
+ zSwizzle?: undefined;
663
+ wSwizzle?: undefined;
664
+ valueType?: undefined;
665
+ value?: undefined;
666
+ })[];
667
+ };
668
+ }
22
669
  declare module "@babylonjs/gui-editor/diagram/workbench" {
23
670
  import * as React from "react";
24
671
  import { GlobalState } from "@babylonjs/gui-editor/globalState";
25
- import { GUINode } from "@babylonjs/gui-editor/diagram/guiNode";
26
- import { Control } from '@babylonjs/gui/2D/controls/control';
672
+ import { Nullable } from "@babylonjs/core/types";
673
+ import { Control } from "@babylonjs/gui/2D/controls/control";
674
+ import { Vector2, Vector3 } from "@babylonjs/core/Maths/math.vector";
675
+ import { Scene } from "@babylonjs/core/scene";
676
+ import { ArcRotateCamera } from "@babylonjs/core/Cameras/arcRotateCamera";
677
+ import { Mesh } from "@babylonjs/core/Meshes/mesh";
678
+ import { Plane } from "@babylonjs/core/Maths/math.plane";
679
+ import { PointerInfo } from "@babylonjs/core/Events/pointerEvents";
680
+ import { EventState } from "@babylonjs/core/Misc/observable";
681
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
27
682
  export interface IWorkbenchComponentProps {
28
683
  globalState: GlobalState;
29
684
  }
30
- export type FramePortData = {};
31
- export const isFramePortData: (variableToCheck: any) => variableToCheck is FramePortData;
685
+ export enum ConstraintDirection {
686
+ NONE = 0,
687
+ X = 2,
688
+ Y = 3
689
+ }
32
690
  export class WorkbenchComponent extends React.Component<IWorkbenchComponentProps> {
33
- private readonly MinZoom;
34
- private readonly MaxZoom;
35
- private _hostCanvas;
36
- private _gridCanvas;
37
- private _selectionContainer;
38
- private _frameContainer;
39
- private _svgCanvas;
691
+ artBoardBackground: Rectangle;
40
692
  private _rootContainer;
41
- private _guiNodes;
693
+ private _setConstraintDirection;
42
694
  private _mouseStartPointX;
43
695
  private _mouseStartPointY;
44
- private _selectionStartX;
45
- private _selectionStartY;
46
- private _x;
47
- private _y;
48
- private _zoom;
696
+ _textureMesh: Mesh;
697
+ _scene: Scene;
49
698
  private _selectedGuiNodes;
50
- private _gridSize;
51
- private _selectionBox;
52
- private _frameCandidate;
53
- private _altKeyIsPressed;
54
699
  private _ctrlKeyIsPressed;
55
- private _oldY;
56
- _frameIsMoving: boolean;
57
- _isLoading: boolean;
58
- isOverGUINode: boolean;
59
- get gridSize(): number;
60
- set gridSize(value: number);
700
+ private _altKeyIsPressed;
701
+ private _constraintDirection;
702
+ private _forcePanning;
703
+ private _forceZooming;
704
+ private _forceSelecting;
705
+ private _outlines;
706
+ private _panning;
707
+ private _canvas;
708
+ private _responsive;
709
+ private _isOverGUINode;
710
+ private _clipboard;
711
+ private _selectAll;
712
+ _camera: ArcRotateCamera;
713
+ private _cameraRadias;
714
+ private _cameraMaxRadiasFactor;
715
+ private _pasted;
716
+ private _engine;
717
+ private _liveRenderObserver;
718
+ private _guiRenderObserver;
719
+ private _mainSelection;
720
+ private _selectionDepth;
721
+ private _doubleClick;
722
+ private _lockMainSelection;
723
+ _liveGuiTextureRerender: boolean;
61
724
  get globalState(): GlobalState;
62
- get nodes(): GUINode[];
63
- get zoom(): number;
64
- set zoom(value: number);
65
- get x(): number;
66
- set x(value: number);
67
- get y(): number;
68
- set y(value: number);
69
- get selectedGuiNodes(): GUINode[];
70
- get canvasContainer(): HTMLDivElement;
71
- get hostCanvas(): HTMLDivElement;
72
- get svgCanvas(): HTMLElement;
73
- get selectionContainer(): HTMLDivElement;
74
- get frameContainer(): HTMLDivElement;
725
+ get nodes(): Control[];
726
+ get selectedGuiNodes(): Control[];
727
+ private _getParentWithDepth;
728
+ private _getMaxParent;
75
729
  constructor(props: IWorkbenchComponentProps);
76
- getGridPosition(position: number, useCeil?: boolean): number;
77
- getGridPositionCeil(position: number): number;
78
- clearGuiTexture(): void;
730
+ determineMouseSelection(selection: Nullable<Control>): void;
731
+ keyEvent: (evt: KeyboardEvent) => void;
732
+ private updateHitTest;
733
+ private updateHitTestForSelection;
734
+ private setCameraRadius;
735
+ copyToClipboard(): void;
736
+ pasteFromClipboard(): void;
737
+ CopyGUIControl(original: Control): void;
738
+ private selectAllGUI;
739
+ blurEvent: () => void;
740
+ componentWillUnmount(): void;
79
741
  loadFromJson(serializationObject: any): void;
80
- loadFromSnippet(snippedID: string): Promise<void>;
81
- loadFromGuiTexture(): void;
82
- updateTransform(): void;
83
- onKeyUp(): void;
84
- findNodeFromGuiElement(guiControl: Control): GUINode;
85
- reset(): void;
86
- appendBlock(guiElement: Control): GUINode;
87
- distributeGraph(): void;
88
- componentDidMount(): void;
742
+ loadFromSnippet(snippetId: string): Promise<void>;
743
+ loadToEditor(): void;
744
+ changeSelectionHighlight(value: boolean): void;
745
+ resizeGuiTexture(newvalue: Vector2): void;
746
+ findNodeFromGuiElement(guiControl: Control): Control;
747
+ appendBlock(guiElement: Control): Control;
748
+ private _isMainSelectionParent;
749
+ createNewGuiNode(guiControl: Control): Control;
750
+ private parent;
751
+ private _convertToPixels;
752
+ private _reorderGrid;
753
+ private _isNotChildInsert;
754
+ private _adjustParentingIndex;
755
+ isSelected(value: boolean, guiNode: Control): void;
756
+ clicked: boolean;
757
+ _onMove(guiControl: Control, evt: Vector2, startPos: Vector2, ignorClick?: boolean): boolean;
758
+ convertToPercentage(guiControl: Control, includeScale: boolean): void;
89
759
  onMove(evt: React.PointerEvent): void;
760
+ getGroundPosition(): Nullable<Vector3>;
90
761
  onDown(evt: React.PointerEvent<HTMLElement>): void;
91
762
  isUp: boolean;
92
763
  onUp(evt: React.PointerEvent): void;
93
- onWheel(evt: React.WheelEvent): void;
94
- zoomToFit(): void;
95
764
  createGUICanvas(): void;
96
- updateGUIs(): void;
765
+ synchronizeLiveGUI(): void;
766
+ addControls(scene: Scene, camera: ArcRotateCamera): void;
767
+ getPosition(scene: Scene, camera: ArcRotateCamera, plane: Plane, x?: number, y?: number): Vector3;
768
+ panning(newPos: Vector3, initialPos: Vector3, inertia: number, ref: Vector3): Vector3;
769
+ zoomWheel(p: PointerInfo, e: EventState, camera: ArcRotateCamera): number;
770
+ zooming(delta: number, scene: Scene, camera: ArcRotateCamera, plane: Plane, ref: Vector3): void;
771
+ zeroIfClose(vec: Vector3): void;
97
772
  render(): JSX.Element;
98
773
  }
99
774
  }
100
- declare module "@babylonjs/gui-editor/diagram/guiNode" {
101
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
102
- import { Control } from "@babylonjs/gui/2D/controls/control";
103
- import { Vector2 } from "@babylonjs/core/Maths/math.vector";
104
- export class GUINode {
105
- guiControl: Control;
106
- private _x;
107
- private _y;
108
- private _gridAlignedX;
109
- private _gridAlignedY;
110
- private _globalState;
111
- private _onSelectionChangedObserver;
112
- private _onSelectionBoxMovedObserver;
113
- private _onUpdateRequiredObserver;
114
- private _ownerCanvas;
115
- private _isSelected;
116
- private _isVisible;
117
- private _enclosingFrameId;
118
- children: GUINode[];
119
- get isVisible(): boolean;
120
- set isVisible(value: boolean);
121
- get gridAlignedX(): number;
122
- get gridAlignedY(): number;
123
- get x(): number;
124
- set x(value: number);
125
- get y(): number;
126
- set y(value: number);
127
- get width(): number;
128
- get height(): number;
129
- get id(): number;
130
- get name(): string | undefined;
131
- get isSelected(): boolean;
132
- get enclosingFrameId(): number;
133
- set enclosingFrameId(value: number);
134
- set isSelected(value: boolean);
135
- constructor(globalState: GlobalState, guiControl: Control);
136
- cleanAccumulation(useCeil?: boolean): void;
137
- clicked: boolean;
138
- _onMove(evt: Vector2, startPos: Vector2, ignorClick?: boolean): boolean;
139
- updateVisual(): void;
140
- private _isContainer;
141
- addGui(childNode: GUINode): void;
142
- dispose(): void;
143
- }
144
- }
145
775
  declare module "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent" {
146
776
  export class PropertyChangedEvent {
147
777
  object: any;
@@ -151,93 +781,198 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent" {
151
781
  allowNullValue?: boolean;
152
782
  }
153
783
  }
784
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject" {
785
+ /**
786
+ * Class used to provide lock mechanism
787
+ */
788
+ export class LockObject {
789
+ /**
790
+ * Gets or set if the lock is engaged
791
+ */
792
+ lock: boolean;
793
+ }
794
+ }
795
+ declare module "@babylonjs/gui-editor/diagram/guiGizmo" {
796
+ import { Control } from "@babylonjs/gui/2D/controls/control";
797
+ import { Vector2 } from "@babylonjs/core/Maths/math.vector";
798
+ import * as React from "react";
799
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
800
+ export interface IGuiGizmoProps {
801
+ globalState: GlobalState;
802
+ }
803
+ enum ScalePointPosition {
804
+ Top = -1,
805
+ Left = -1,
806
+ Center = 0,
807
+ Right = 1,
808
+ Bottom = 1
809
+ }
810
+ interface IScalePoint {
811
+ position: Vector2;
812
+ horizontalPosition: ScalePointPosition;
813
+ verticalPosition: ScalePointPosition;
814
+ rotation: number;
815
+ isPivot: boolean;
816
+ }
817
+ class Rect {
818
+ top: number;
819
+ left: number;
820
+ right: number;
821
+ bottom: number;
822
+ constructor(left: number, top: number, right: number, bottom: number);
823
+ get center(): Vector2;
824
+ get width(): number;
825
+ get height(): number;
826
+ }
827
+ interface IGuiGizmoState {
828
+ canvasBounds: Rect;
829
+ scalePoints: IScalePoint[];
830
+ scalePointDragging: number;
831
+ isRotating: boolean;
832
+ }
833
+ export class GuiGizmoComponent extends React.Component<IGuiGizmoProps, IGuiGizmoState> {
834
+ private _matrixCache;
835
+ private _responsive;
836
+ private _initH;
837
+ private _initW;
838
+ private _initX;
839
+ private _initY;
840
+ private _localBounds;
841
+ private _rotation;
842
+ constructor(props: IGuiGizmoProps);
843
+ componentDidMount(): void;
844
+ /**
845
+ * Update the gizmo's positions
846
+ * @param force should the update be forced. otherwise it will be updated only when the pointer is down
847
+ */
848
+ updateGizmo(force?: boolean): void;
849
+ private _resetMatrixArray;
850
+ /**
851
+ * This function calculates a local matrix for a node, including it's full transformation and pivot point
852
+ *
853
+ * @param node the node to calculate the matrix for
854
+ * @param useStoredValues should the stored (cached) values be used to calculate the matrix
855
+ * @returns a new matrix for the control
856
+ */
857
+ private _getNodeMatrix;
858
+ /**
859
+ * Using the node's tree, calculate its world matrix and return it
860
+ * @param node the node to calculate the matrix for
861
+ * @param useStoredValuesIfPossible used stored valued (cached when pointer down is clicked)
862
+ * @returns the world matrix for this node
863
+ */
864
+ private _nodeToRTTWorldMatrix;
865
+ private _nodeToRTTSpace;
866
+ private _rttToLocalNodeSpace;
867
+ private _rttToCanvasSpace;
868
+ private _plane;
869
+ private _mousePointerToRTTSpace;
870
+ /**
871
+ * Get the scaling of a specific GUI control
872
+ * @param node the node for which we are getting the scaling
873
+ * @param relative should we return only the relative scaling (relative to the parent)
874
+ * @returns an X,Y vector of the scaling
875
+ */
876
+ getScale(node: Control, relative?: boolean): Vector2;
877
+ getRotation(node: Control, relative?: boolean): number;
878
+ onUp(evt?: React.PointerEvent): void;
879
+ private _onUp;
880
+ onMove(evt: React.PointerEvent): void;
881
+ private _onMove;
882
+ private _rotate;
883
+ private _computeLocalBounds;
884
+ private _dragLocalBounds;
885
+ private _updateNodeFromLocalBounds;
886
+ private _beginDraggingScalePoint;
887
+ private _beginRotate;
888
+ render(): JSX.Element | null;
889
+ }
890
+ }
154
891
  declare module "@babylonjs/gui-editor/globalState" {
155
892
  import { Nullable } from "@babylonjs/core/types";
156
893
  import { Observable } from "@babylonjs/core/Misc/observable";
157
894
  import { LogEntry } from "@babylonjs/gui-editor/components/log/logComponent";
158
895
  import { Color4 } from "@babylonjs/core/Maths/math.color";
159
- import { GUINode } from "@babylonjs/gui-editor/diagram/guiNode";
160
896
  import { WorkbenchComponent } from "@babylonjs/gui-editor/diagram/workbench";
161
897
  import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
162
898
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
899
+ import { Vector2 } from "@babylonjs/core/Maths/math.vector";
900
+ import { Scene } from "@babylonjs/core/scene";
901
+ import { Control } from "@babylonjs/gui/2D/controls/control";
902
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
903
+ import { GuiGizmoComponent } from "@babylonjs/gui-editor/diagram/guiGizmo";
904
+ export enum DragOverLocation {
905
+ ABOVE = 0,
906
+ BELOW = 1,
907
+ CENTER = 2,
908
+ NONE = 3
909
+ }
163
910
  export class GlobalState {
911
+ [x: string]: any;
912
+ liveGuiTexture: Nullable<AdvancedDynamicTexture>;
164
913
  guiTexture: AdvancedDynamicTexture;
165
914
  hostElement: HTMLElement;
166
915
  hostDocument: HTMLDocument;
167
916
  hostWindow: Window;
168
- onSelectionChangedObservable: Observable<Nullable<GUINode>>;
169
- onRebuildRequiredObservable: Observable<void>;
917
+ onSelectionChangedObservable: Observable<Nullable<Control>>;
918
+ onResizeObservable: Observable<Vector2>;
170
919
  onBuiltObservable: Observable<void>;
171
920
  onResetRequiredObservable: Observable<void>;
172
921
  onUpdateRequiredObservable: Observable<void>;
173
- onReOrganizedRequiredObservable: Observable<void>;
174
922
  onLogRequiredObservable: Observable<LogEntry>;
175
923
  onErrorMessageDialogRequiredObservable: Observable<string>;
176
924
  onIsLoadingChanged: Observable<boolean>;
177
- onSelectionBoxMoved: Observable<DOMRect | ClientRect>;
178
- onGuiNodeRemovalObservable: Observable<GUINode>;
925
+ onSelectionBoxMoved: Observable<ClientRect | DOMRect>;
926
+ onNewSceneObservable: Observable<Nullable<Scene>>;
927
+ onGuiNodeRemovalObservable: Observable<Control>;
928
+ onPopupClosedObservable: Observable<void>;
179
929
  backgroundColor: Color4;
180
930
  blockKeyboardEvents: boolean;
181
931
  controlCamera: boolean;
932
+ selectionLock: boolean;
182
933
  workbench: WorkbenchComponent;
934
+ guiGizmo: GuiGizmoComponent;
183
935
  onPropertyChangedObservable: Observable<PropertyChangedEvent>;
936
+ onZoomObservable: Observable<void>;
937
+ onFitToWindowObservable: Observable<void>;
938
+ onPanObservable: Observable<void>;
939
+ onSelectionButtonObservable: Observable<void>;
940
+ onMoveObservable: Observable<void>;
941
+ onLoadObservable: Observable<File>;
942
+ onSaveObservable: Observable<void>;
943
+ onSnippetLoadObservable: Observable<void>;
944
+ onSnippetSaveObservable: Observable<void>;
945
+ onOutlinesObservable: Observable<void>;
946
+ onResponsiveChangeObservable: Observable<boolean>;
947
+ onParentingChangeObservable: Observable<Nullable<Control>>;
948
+ onPropertyGridUpdateRequiredObservable: Observable<void>;
949
+ onDraggingEndObservable: Observable<void>;
950
+ onDraggingStartObservable: Observable<void>;
951
+ onWindowResizeObservable: Observable<void>;
952
+ onGizmoUpdateRequireObservable: Observable<void>;
953
+ draggedControl: Nullable<Control>;
954
+ draggedControlDirection: DragOverLocation;
955
+ isSaving: boolean;
956
+ lockObject: LockObject;
184
957
  storeEditorData: (serializationObject: any) => void;
185
958
  customSave?: {
186
959
  label: string;
187
- action: (data: string) => Promise<void>;
960
+ action: (data: string) => Promise<string>;
961
+ };
962
+ customLoad?: {
963
+ label: string;
964
+ action: (data: string) => Promise<string>;
188
965
  };
189
966
  constructor();
190
967
  }
191
968
  }
192
- declare module "@babylonjs/gui-editor/sharedUiComponents/lines/lineContainerComponent" {
193
- import * as React from "react";
194
- interface ILineContainerComponentProps {
195
- title: string;
196
- children: any[] | any;
197
- closed?: boolean;
198
- }
199
- export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
200
- isExpanded: boolean;
201
- }> {
202
- constructor(props: ILineContainerComponentProps);
203
- switchExpandedState(): void;
204
- renderHeader(): JSX.Element;
205
- render(): JSX.Element;
206
- }
207
- }
208
- declare module "@babylonjs/gui-editor/sharedUiComponents/lines/draggableLineComponent" {
209
- import * as React from "react";
210
- export interface IButtonLineComponentProps {
211
- data: string;
212
- tooltip: string;
213
- }
214
- export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
215
- constructor(props: IButtonLineComponentProps);
216
- render(): JSX.Element;
217
- }
218
- }
219
- declare module "@babylonjs/gui-editor/components/guiList/guiListComponent" {
220
- import * as React from "react";
221
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
222
- interface IGuiListComponentProps {
223
- globalState: GlobalState;
224
- }
225
- export class GuiListComponent extends React.Component<IGuiListComponentProps, {
226
- filter: string;
227
- }> {
228
- private _onResetRequiredObserver;
229
- private static _Tooltips;
230
- constructor(props: IGuiListComponentProps);
231
- componentWillUnmount(): void;
232
- filterContent(filter: string): void;
233
- render(): JSX.Element;
234
- }
235
- }
236
969
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/buttonLineComponent" {
237
970
  import * as React from "react";
238
971
  export interface IButtonLineComponentProps {
239
972
  label: string;
240
973
  onClick: () => void;
974
+ icon?: string;
975
+ iconLabel?: string;
241
976
  }
242
977
  export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
243
978
  constructor(props: IButtonLineComponentProps);
@@ -250,6 +985,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/fileButtonLineCom
250
985
  label: string;
251
986
  onClick: (file: File) => void;
252
987
  accept: string;
988
+ icon?: string;
989
+ iconLabel?: string;
253
990
  }
254
991
  export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
255
992
  private static _IDGenerator;
@@ -265,7 +1002,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/checkBoxLineCompo
265
1002
  import { Observable } from "@babylonjs/core/Misc/observable";
266
1003
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
267
1004
  export interface ICheckBoxLineComponentProps {
268
- label: string;
1005
+ label?: string;
269
1006
  target?: any;
270
1007
  propertyName?: string;
271
1008
  isSelected?: () => boolean;
@@ -273,6 +1010,10 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/checkBoxLineCompo
273
1010
  onValueChanged?: () => void;
274
1011
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
275
1012
  disabled?: boolean;
1013
+ icon?: string;
1014
+ iconLabel?: string;
1015
+ faIcons?: {
1016
+ };
276
1017
  }
277
1018
  export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
278
1019
  isSelected: boolean;
@@ -301,6 +1042,9 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/textLineComponent
301
1042
  url?: string;
302
1043
  ignoreValue?: boolean;
303
1044
  additionalClass?: string;
1045
+ icon?: string;
1046
+ iconLabel?: string;
1047
+ tooltip?: string;
304
1048
  }
305
1049
  export class TextLineComponent extends React.Component<ITextLineComponentProps> {
306
1050
  constructor(props: ITextLineComponentProps);
@@ -320,17 +1064,6 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/stringTools" {
320
1064
  static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void;
321
1065
  }
322
1066
  }
323
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject" {
324
- /**
325
- * Class used to provide lock mechanism
326
- */
327
- export class LockObject {
328
- /**
329
- * Gets or set if the lock is engaged
330
- */
331
- lock: boolean;
332
- }
333
- }
334
1067
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/floatLineComponent" {
335
1068
  import * as React from "react";
336
1069
  import { Observable } from "@babylonjs/core/Misc/observable";
@@ -352,6 +1085,9 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/floatLineComponen
352
1085
  max?: number;
353
1086
  smallUI?: boolean;
354
1087
  onEnter?: (newValue: number) => void;
1088
+ icon?: string;
1089
+ iconLabel?: string;
1090
+ defaultValue?: number;
355
1091
  }
356
1092
  export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
357
1093
  value: string;
@@ -374,6 +1110,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/sliderLineCompone
374
1110
  import * as React from "react";
375
1111
  import { Observable } from "@babylonjs/core/Misc/observable";
376
1112
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1113
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
377
1114
  interface ISliderLineComponentProps {
378
1115
  label: string;
379
1116
  target?: any;
@@ -388,6 +1125,9 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/sliderLineCompone
388
1125
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
389
1126
  decimalCount?: number;
390
1127
  margin?: boolean;
1128
+ icon?: string;
1129
+ iconLabel?: string;
1130
+ lockObject?: LockObject;
391
1131
  }
392
1132
  export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
393
1133
  value: number;
@@ -416,6 +1156,11 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/textInputLineComp
416
1156
  value?: string;
417
1157
  onChange?: (value: string) => void;
418
1158
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1159
+ icon?: string;
1160
+ iconLabel?: string;
1161
+ noUnderline?: boolean;
1162
+ numbersOnly?: boolean;
1163
+ delayInput?: boolean;
419
1164
  }
420
1165
  export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
421
1166
  value: string;
@@ -431,137 +1176,20 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/textInputLineComp
431
1176
  render(): JSX.Element;
432
1177
  }
433
1178
  }
434
- declare module "@babylonjs/gui-editor/sharedUiComponents/lines/optionsLineComponent" {
435
- import * as React from "react";
436
- import { Observable } from "@babylonjs/core/Misc/observable";
437
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
438
- export const Null_Value: number;
439
- export class ListLineOption {
440
- label: string;
441
- value: number;
442
- selected?: boolean;
443
- }
444
- export interface IOptionsLineComponentProps {
445
- label: string;
446
- target: any;
447
- propertyName: string;
448
- options: ListLineOption[];
449
- noDirectUpdate?: boolean;
450
- onSelect?: (value: number) => void;
451
- extractValue?: () => number;
452
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
453
- allowNullValue?: boolean;
454
- }
455
- export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
456
- value: number;
457
- }> {
458
- private _localChange;
459
- private remapValueIn;
460
- private remapValueOut;
461
- constructor(props: IOptionsLineComponentProps);
462
- shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
463
- value: number;
464
- }): boolean;
465
- raiseOnPropertyChanged(newValue: number, previousValue: number): void;
466
- updateValue(valueString: string): void;
467
- render(): JSX.Element;
468
- }
469
- }
470
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/commonControlPropertyGridComponent" {
471
- import * as React from "react";
472
- import { Observable } from "@babylonjs/core/Misc/observable";
473
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
474
- import { Control } from "@babylonjs/gui/2D/controls/control";
475
- import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
476
- interface ICommonControlPropertyGridComponentProps {
477
- control: Control;
478
- lockObject: LockObject;
479
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
480
- }
481
- export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
482
- constructor(props: ICommonControlPropertyGridComponentProps);
483
- renderGridInformation(): JSX.Element | null;
484
- render(): JSX.Element;
485
- }
486
- }
487
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/sliderPropertyGridComponent" {
488
- import * as React from "react";
489
- import { Observable } from "@babylonjs/core/Misc/observable";
490
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
491
- import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
492
- import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
493
- interface ISliderPropertyGridComponentProps {
494
- slider: Slider;
495
- lockObject: LockObject;
496
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
497
- }
498
- export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
499
- constructor(props: ISliderPropertyGridComponentProps);
500
- render(): JSX.Element;
501
- }
502
- }
503
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/linePropertyGridComponent" {
504
- import * as React from "react";
505
- import { Observable } from "@babylonjs/core/Misc/observable";
506
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
507
- import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
508
- import { Line } from "@babylonjs/gui/2D/controls/line";
509
- interface ILinePropertyGridComponentProps {
510
- line: Line;
511
- lockObject: LockObject;
512
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
513
- }
514
- export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
515
- constructor(props: ILinePropertyGridComponentProps);
516
- onDashChange(value: string): void;
517
- render(): JSX.Element;
518
- }
519
- }
520
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/radioButtonPropertyGridComponent" {
521
- import * as React from "react";
522
- import { Observable } from "@babylonjs/core/Misc/observable";
523
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
524
- import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
525
- import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
526
- interface IRadioButtonPropertyGridComponentProps {
527
- radioButton: RadioButton;
528
- lockObject: LockObject;
529
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
530
- }
531
- export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
532
- constructor(props: IRadioButtonPropertyGridComponentProps);
533
- render(): JSX.Element;
534
- }
535
- }
536
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/textBlockPropertyGridComponent" {
537
- import * as React from "react";
538
- import { Observable } from "@babylonjs/core/Misc/observable";
539
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
540
- import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
541
- import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
542
- interface ITextBlockPropertyGridComponentProps {
543
- textBlock: TextBlock;
544
- lockObject: LockObject;
545
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
546
- }
547
- export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
548
- constructor(props: ITextBlockPropertyGridComponentProps);
549
- render(): JSX.Element;
550
- }
551
- }
552
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/inputTextPropertyGridComponent" {
1179
+ declare module "@babylonjs/gui-editor/components/commandButtonComponent" {
553
1180
  import * as React from "react";
554
- import { Observable } from "@babylonjs/core/Misc/observable";
555
- import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
556
- import { InputText } from "@babylonjs/gui/2D/controls/inputText";
557
- import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
558
- interface IInputTextPropertyGridComponentProps {
559
- inputText: InputText;
560
- lockObject: LockObject;
561
- onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1181
+ interface ICommandButtonComponentProps {
1182
+ tooltip: string;
1183
+ shortcut?: string;
1184
+ icon: string;
1185
+ iconLabel?: string;
1186
+ isActive: boolean;
1187
+ onClick: () => void;
1188
+ altStyle?: boolean;
1189
+ disabled?: boolean;
562
1190
  }
563
- export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
564
- constructor(props: IInputTextPropertyGridComponentProps);
1191
+ export class CommandButtonComponent extends React.Component<ICommandButtonComponentProps> {
1192
+ constructor(props: ICommandButtonComponentProps);
565
1193
  render(): JSX.Element;
566
1194
  }
567
1195
  }
@@ -573,6 +1201,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/numericInputCompo
573
1201
  step?: number;
574
1202
  onChange: (value: number) => void;
575
1203
  precision?: number;
1204
+ icon?: string;
1205
+ iconLabel?: string;
576
1206
  }
577
1207
  export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
578
1208
  value: string;
@@ -631,6 +1261,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/colorPicker/colorPicker
631
1261
  */
632
1262
  export interface IColorPickerProps {
633
1263
  color: Color3 | Color4;
1264
+ linearhint?: boolean;
634
1265
  debugMode?: boolean;
635
1266
  onColorChanged?: (color: Color3 | Color4) => void;
636
1267
  }
@@ -650,6 +1281,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/colorPicker/colorPicker
650
1281
  private _isSaturationPointerDown;
651
1282
  private _isHuePointerDown;
652
1283
  constructor(props: IColorPickerProps);
1284
+ shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean;
653
1285
  onSaturationPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
654
1286
  onSaturationPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
655
1287
  onSaturationPointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
@@ -665,10 +1297,14 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/colorPicker/colorPicker
665
1297
  }
666
1298
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/colorPickerComponent" {
667
1299
  import * as React from "react";
668
- import { Color4, Color3 } from '@babylonjs/core/Maths/math.color';
1300
+ import { Color4, Color3 } from "@babylonjs/core/Maths/math.color";
669
1301
  export interface IColorPickerComponentProps {
670
1302
  value: Color4 | Color3;
1303
+ linearHint?: boolean;
671
1304
  onColorChanged: (newOne: string) => void;
1305
+ icon?: string;
1306
+ iconLabel?: string;
1307
+ shouldPopRight?: boolean;
672
1308
  }
673
1309
  interface IColorPickerComponentState {
674
1310
  pickerEnabled: boolean;
@@ -690,35 +1326,200 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/color3LineCompone
690
1326
  import * as React from "react";
691
1327
  import { Observable } from "@babylonjs/core/Misc/observable";
692
1328
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
693
- import { Color3 } from '@babylonjs/core/Maths/math.color';
1329
+ import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
1330
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
694
1331
  export interface IColor3LineComponentProps {
695
1332
  label: string;
696
1333
  target: any;
697
1334
  propertyName: string;
698
1335
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
699
1336
  isLinear?: boolean;
1337
+ icon?: string;
1338
+ lockObject?: LockObject;
1339
+ iconLabel?: string;
1340
+ onValueChange?: (value: string) => void;
700
1341
  }
701
1342
  export class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
702
1343
  isExpanded: boolean;
703
- color: Color3;
1344
+ color: Color3 | Color4;
1345
+ colorText: string;
704
1346
  }> {
705
1347
  private _localChange;
706
1348
  constructor(props: IColor3LineComponentProps);
1349
+ private convertToColor3;
707
1350
  shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
708
- color: Color3;
1351
+ color: Color3 | Color4;
1352
+ colorText: string;
709
1353
  }): boolean;
710
- setPropertyValue(newColor: Color3): void;
1354
+ setPropertyValue(newColor: Color3 | Color4, newColorText: string): void;
711
1355
  onChange(newValue: string): void;
712
1356
  switchExpandState(): void;
713
- raiseOnPropertyChanged(previousValue: Color3): void;
1357
+ raiseOnPropertyChanged(previousValue: Color3 | Color4): void;
714
1358
  updateStateR(value: number): void;
715
1359
  updateStateG(value: number): void;
716
1360
  updateStateB(value: number): void;
717
1361
  copyToClipboard(): void;
1362
+ convert(colorString: string): void;
1363
+ private _colorStringSaved;
1364
+ private _colorPickerOpen;
1365
+ private _colorString;
718
1366
  render(): JSX.Element;
719
1367
  }
720
1368
  }
721
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/colorPickerPropertyGridComponent" {
1369
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/commonControlPropertyGridComponent" {
1370
+ import * as React from "react";
1371
+ import { Observable } from "@babylonjs/core/Misc/observable";
1372
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1373
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1374
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1375
+ interface ICommonControlPropertyGridComponentProps {
1376
+ control: Control;
1377
+ lockObject: LockObject;
1378
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1379
+ }
1380
+ export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
1381
+ private _width;
1382
+ private _height;
1383
+ constructor(props: ICommonControlPropertyGridComponentProps);
1384
+ private _updateAlignment;
1385
+ private _checkAndUpdateValues;
1386
+ private _markChildrenAsDirty;
1387
+ render(): JSX.Element;
1388
+ }
1389
+ }
1390
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/sliderPropertyGridComponent" {
1391
+ import * as React from "react";
1392
+ import { Observable } from "@babylonjs/core/Misc/observable";
1393
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1394
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1395
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
1396
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
1397
+ interface ISliderPropertyGridComponentProps {
1398
+ slider: Slider | ImageBasedSlider;
1399
+ lockObject: LockObject;
1400
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1401
+ }
1402
+ export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
1403
+ constructor(props: ISliderPropertyGridComponentProps);
1404
+ render(): JSX.Element;
1405
+ }
1406
+ }
1407
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/sliderGenericPropertyGridComponent" {
1408
+ import * as React from "react";
1409
+ import { Observable } from "@babylonjs/core/Misc/observable";
1410
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1411
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1412
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
1413
+ interface ISliderGenericPropertyGridComponentProps {
1414
+ slider: Slider;
1415
+ lockObject: LockObject;
1416
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1417
+ }
1418
+ export class SliderGenericPropertyGridComponent extends React.Component<ISliderGenericPropertyGridComponentProps> {
1419
+ constructor(props: ISliderGenericPropertyGridComponentProps);
1420
+ render(): JSX.Element;
1421
+ }
1422
+ }
1423
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/linePropertyGridComponent" {
1424
+ import * as React from "react";
1425
+ import { Observable } from "@babylonjs/core/Misc/observable";
1426
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1427
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1428
+ import { Line } from "@babylonjs/gui/2D/controls/line";
1429
+ interface ILinePropertyGridComponentProps {
1430
+ line: Line;
1431
+ lockObject: LockObject;
1432
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1433
+ }
1434
+ export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
1435
+ constructor(props: ILinePropertyGridComponentProps);
1436
+ onDashChange(value: string): void;
1437
+ render(): JSX.Element;
1438
+ }
1439
+ }
1440
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/radioButtonPropertyGridComponent" {
1441
+ import * as React from "react";
1442
+ import { Observable } from "@babylonjs/core/Misc/observable";
1443
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1444
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1445
+ import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
1446
+ interface IRadioButtonPropertyGridComponentProps {
1447
+ radioButton: RadioButton;
1448
+ lockObject: LockObject;
1449
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1450
+ }
1451
+ export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
1452
+ constructor(props: IRadioButtonPropertyGridComponentProps);
1453
+ render(): JSX.Element;
1454
+ }
1455
+ }
1456
+ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/optionsLineComponent" {
1457
+ import * as React from "react";
1458
+ import { Observable } from "@babylonjs/core/Misc/observable";
1459
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1460
+ import { IInspectableOptions } from "@babylonjs/core/Misc/iInspectable";
1461
+ export const Null_Value: number;
1462
+ export interface IOptionsLineComponentProps {
1463
+ label: string;
1464
+ target: any;
1465
+ propertyName: string;
1466
+ options: IInspectableOptions[];
1467
+ noDirectUpdate?: boolean;
1468
+ onSelect?: (value: number) => void;
1469
+ extractValue?: () => number;
1470
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1471
+ allowNullValue?: boolean;
1472
+ icon?: string;
1473
+ iconLabel?: string;
1474
+ }
1475
+ export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
1476
+ value: number;
1477
+ }> {
1478
+ private _localChange;
1479
+ private remapValueIn;
1480
+ private remapValueOut;
1481
+ constructor(props: IOptionsLineComponentProps);
1482
+ shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
1483
+ value: number;
1484
+ }): boolean;
1485
+ raiseOnPropertyChanged(newValue: number, previousValue: number): void;
1486
+ updateValue(valueString: string): void;
1487
+ render(): JSX.Element;
1488
+ }
1489
+ }
1490
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/textBlockPropertyGridComponent" {
1491
+ import * as React from "react";
1492
+ import { Observable } from "@babylonjs/core/Misc/observable";
1493
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1494
+ import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
1495
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1496
+ interface ITextBlockPropertyGridComponentProps {
1497
+ textBlock: TextBlock;
1498
+ lockObject: LockObject;
1499
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1500
+ }
1501
+ export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
1502
+ constructor(props: ITextBlockPropertyGridComponentProps);
1503
+ render(): JSX.Element;
1504
+ }
1505
+ }
1506
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/inputTextPropertyGridComponent" {
1507
+ import * as React from "react";
1508
+ import { Observable } from "@babylonjs/core/Misc/observable";
1509
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1510
+ import { InputText } from "@babylonjs/gui/2D/controls/inputText";
1511
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1512
+ interface IInputTextPropertyGridComponentProps {
1513
+ inputText: InputText;
1514
+ lockObject: LockObject;
1515
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1516
+ }
1517
+ export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
1518
+ constructor(props: IInputTextPropertyGridComponentProps);
1519
+ render(): JSX.Element;
1520
+ }
1521
+ }
1522
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/colorPickerPropertyGridComponent" {
722
1523
  import * as React from "react";
723
1524
  import { Observable } from "@babylonjs/core/Misc/observable";
724
1525
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -734,7 +1535,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
734
1535
  render(): JSX.Element;
735
1536
  }
736
1537
  }
737
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/imagePropertyGridComponent" {
1538
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/imagePropertyGridComponent" {
738
1539
  import * as React from "react";
739
1540
  import { Observable } from "@babylonjs/core/Misc/observable";
740
1541
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -750,7 +1551,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
750
1551
  render(): JSX.Element;
751
1552
  }
752
1553
  }
753
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
1554
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
754
1555
  import * as React from "react";
755
1556
  import { Observable } from "@babylonjs/core/Misc/observable";
756
1557
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -766,7 +1567,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
766
1567
  render(): JSX.Element;
767
1568
  }
768
1569
  }
769
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/rectanglePropertyGridComponent" {
1570
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/rectanglePropertyGridComponent" {
770
1571
  import * as React from "react";
771
1572
  import { Observable } from "@babylonjs/core/Misc/observable";
772
1573
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -782,7 +1583,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
782
1583
  render(): JSX.Element;
783
1584
  }
784
1585
  }
785
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" {
1586
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/stackPanelPropertyGridComponent" {
786
1587
  import * as React from "react";
787
1588
  import { Observable } from "@babylonjs/core/Misc/observable";
788
1589
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -798,7 +1599,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
798
1599
  render(): JSX.Element;
799
1600
  }
800
1601
  }
801
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/gridPropertyGridComponent" {
1602
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/gridPropertyGridComponent" {
802
1603
  import * as React from "react";
803
1604
  import { Observable } from "@babylonjs/core/Misc/observable";
804
1605
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -811,12 +1612,30 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
811
1612
  }
812
1613
  export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
813
1614
  constructor(props: IGridPropertyGridComponentProps);
1615
+ private _removingColumn;
1616
+ private _removingRow;
1617
+ private _previousGrid;
1618
+ private _rowDefinitions;
1619
+ private _rowEditFlags;
1620
+ private _columnEditFlags;
1621
+ private _columnDefinitions;
1622
+ private _editedRow;
1623
+ private _editedColumn;
1624
+ private _rowChild;
1625
+ private _columnChild;
814
1626
  renderRows(): JSX.Element[];
1627
+ setRowValues(): void;
1628
+ setColumnValues(): void;
815
1629
  renderColumns(): JSX.Element[];
1630
+ resizeRow(): void;
1631
+ resizeColumn(): void;
1632
+ checkValue(value: string, percent: boolean): string;
1633
+ checkPercentage(value: string): boolean;
1634
+ resetValues(): void;
816
1635
  render(): JSX.Element;
817
1636
  }
818
1637
  }
819
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/scrollViewerPropertyGridComponent" {
1638
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/scrollViewerPropertyGridComponent" {
820
1639
  import * as React from "react";
821
1640
  import { Observable } from "@babylonjs/core/Misc/observable";
822
1641
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -832,7 +1651,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
832
1651
  render(): JSX.Element;
833
1652
  }
834
1653
  }
835
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/ellipsePropertyGridComponent" {
1654
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/ellipsePropertyGridComponent" {
836
1655
  import * as React from "react";
837
1656
  import { Observable } from "@babylonjs/core/Misc/observable";
838
1657
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -848,7 +1667,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
848
1667
  render(): JSX.Element;
849
1668
  }
850
1669
  }
851
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/checkboxPropertyGridComponent" {
1670
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/checkboxPropertyGridComponent" {
852
1671
  import * as React from "react";
853
1672
  import { Observable } from "@babylonjs/core/Misc/observable";
854
1673
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -864,7 +1683,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
864
1683
  render(): JSX.Element;
865
1684
  }
866
1685
  }
867
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/controlPropertyGridComponent" {
1686
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/controlPropertyGridComponent" {
868
1687
  import * as React from "react";
869
1688
  import { Observable } from "@babylonjs/core/Misc/observable";
870
1689
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -880,31 +1699,109 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
880
1699
  render(): JSX.Element;
881
1700
  }
882
1701
  }
1702
+ declare module "@babylonjs/gui-editor/components/parentingPropertyGridComponent" {
1703
+ import * as React from "react";
1704
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1705
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1706
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1707
+ import { Observable } from "@babylonjs/core/Misc/observable";
1708
+ interface IParentingPropertyGridComponentProps {
1709
+ control: Control;
1710
+ lockObject: LockObject;
1711
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1712
+ }
1713
+ export class ParentingPropertyGridComponent extends React.Component<IParentingPropertyGridComponentProps> {
1714
+ constructor(props: IParentingPropertyGridComponentProps);
1715
+ private _columnNumber;
1716
+ private _rowNumber;
1717
+ updateGridPosition(): void;
1718
+ getCellInfo(): void;
1719
+ private _changeCell;
1720
+ render(): JSX.Element;
1721
+ }
1722
+ }
1723
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/displayGridPropertyGridComponent" {
1724
+ import * as React from "react";
1725
+ import { Observable } from "@babylonjs/core/Misc/observable";
1726
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1727
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1728
+ import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
1729
+ interface IDisplayGridPropertyGridComponentProps {
1730
+ displayGrid: DisplayGrid;
1731
+ lockObject: LockObject;
1732
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1733
+ }
1734
+ export class DisplayGridPropertyGridComponent extends React.Component<IDisplayGridPropertyGridComponentProps> {
1735
+ constructor(props: IDisplayGridPropertyGridComponentProps);
1736
+ render(): JSX.Element;
1737
+ }
1738
+ }
1739
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/buttonPropertyGridComponent" {
1740
+ import * as React from "react";
1741
+ import { Observable } from "@babylonjs/core/Misc/observable";
1742
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1743
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1744
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
1745
+ interface IButtonPropertyGridComponentProps {
1746
+ rectangle: Rectangle;
1747
+ lockObject: LockObject;
1748
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1749
+ onAddComponent: (newComponent: string) => void;
1750
+ }
1751
+ export class ButtonPropertyGridComponent extends React.Component<IButtonPropertyGridComponentProps> {
1752
+ constructor(props: IButtonPropertyGridComponentProps);
1753
+ render(): JSX.Element;
1754
+ }
1755
+ }
1756
+ declare module "@babylonjs/gui-editor/guiNodeTools" {
1757
+ import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
1758
+ import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
1759
+ import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
1760
+ import { Line } from "@babylonjs/gui/2D/controls/line";
1761
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
1762
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
1763
+ import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
1764
+ import { Image } from "@babylonjs/gui/2D/controls/image";
1765
+ import { InputText } from "@babylonjs/gui/2D/controls/inputText";
1766
+ import { Grid } from "@babylonjs/gui/2D/controls/grid";
1767
+ import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
1768
+ import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
1769
+ import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
1770
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
1771
+ export class GUINodeTools {
1772
+ static ImageControlDefaultUrl: string;
1773
+ static CreateControlFromString(data: string): Grid | Rectangle | Line | Image | TextBlock | Slider | ImageBasedSlider | RadioButton | InputText | ColorPicker | StackPanel | Ellipse | Checkbox | DisplayGrid;
1774
+ }
1775
+ }
883
1776
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyTabComponent" {
884
1777
  import * as React from "react";
885
1778
  import { GlobalState } from "@babylonjs/gui-editor/globalState";
886
1779
  import { Nullable } from "@babylonjs/core/types";
887
- import { GUINode } from "@babylonjs/gui-editor/diagram/guiNode";
1780
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1781
+ import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
888
1782
  interface IPropertyTabComponentProps {
889
1783
  globalState: GlobalState;
890
1784
  }
891
1785
  interface IPropertyTabComponentState {
892
- currentNode: Nullable<GUINode>;
1786
+ currentNode: Nullable<Control>;
893
1787
  }
894
1788
  export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, IPropertyTabComponentState> {
895
1789
  private _onBuiltObserver;
896
1790
  private _timerIntervalId;
897
1791
  private _lockObject;
1792
+ private _sizeOption;
898
1793
  constructor(props: IPropertyTabComponentProps);
899
- timerRefresh(): void;
900
1794
  componentDidMount(): void;
901
1795
  componentWillUnmount(): void;
902
1796
  load(file: File): void;
903
- save(): void;
904
- saveToSnippetServer(): void;
1797
+ save(saveCallback: () => void): void;
1798
+ saveLocally: () => void;
1799
+ saveToSnippetServerHelper: (content: string, adt: AdvancedDynamicTexture) => Promise<string>;
1800
+ saveToSnippetServer: () => Promise<void>;
905
1801
  loadFromSnippet(): void;
906
1802
  renderProperties(): JSX.Element | null;
907
- render(): JSX.Element;
1803
+ renderControlIcon(): string;
1804
+ render(): JSX.Element | null;
908
1805
  }
909
1806
  }
910
1807
  declare module "@babylonjs/gui-editor/portal" {
@@ -917,51 +1814,6 @@ declare module "@babylonjs/gui-editor/portal" {
917
1814
  render(): React.ReactPortal;
918
1815
  }
919
1816
  }
920
- declare module "@babylonjs/gui-editor/guiNodeTools" {
921
- import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
922
- import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
923
- import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
924
- import { Line } from "@babylonjs/gui/2D/controls/line";
925
- import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
926
- import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
927
- import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
928
- import { VirtualKeyboard } from "@babylonjs/gui/2D/controls/virtualKeyboard";
929
- import { Image } from "@babylonjs/gui/2D/controls/image";
930
- import { InputText } from "@babylonjs/gui/2D/controls/inputText";
931
- import { Grid } from "@babylonjs/gui/2D/controls/grid";
932
- import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
933
- export class GUINodeTools {
934
- static CreateControlFromString(data: string): Grid | Slider | Line | TextBlock | InputText | ColorPicker | Image | Rectangle | Ellipse | Checkbox | DisplayGrid | VirtualKeyboard;
935
- }
936
- }
937
- declare module "@babylonjs/gui-editor/nodeLocationInfo" {
938
- export interface INodeLocationInfo {
939
- blockId: number;
940
- x: number;
941
- y: number;
942
- }
943
- export interface IFrameData {
944
- x: number;
945
- y: number;
946
- width: number;
947
- height: number;
948
- color: number[];
949
- name: string;
950
- isCollapsed: boolean;
951
- blocks: number[];
952
- comments: string;
953
- }
954
- export interface IEditorData {
955
- locations: INodeLocationInfo[];
956
- x: number;
957
- y: number;
958
- zoom: number;
959
- frames?: IFrameData[];
960
- map?: {
961
- [key: number]: number;
962
- };
963
- }
964
- }
965
1817
  declare module "@babylonjs/gui-editor/sharedComponents/messageDialog" {
966
1818
  import * as React from "react";
967
1819
  import { GlobalState } from "@babylonjs/gui-editor/globalState";
@@ -976,45 +1828,272 @@ declare module "@babylonjs/gui-editor/sharedComponents/messageDialog" {
976
1828
  render(): JSX.Element | null;
977
1829
  }
978
1830
  }
979
- declare module "@babylonjs/gui-editor/workbenchEditor" {
1831
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemLabelComponent" {
980
1832
  import * as React from "react";
981
- import { GlobalState } from "@babylonjs/gui-editor/globalState";
982
- import { Nullable } from "@babylonjs/core/types";
983
- import { IEditorData } from "@babylonjs/gui-editor/nodeLocationInfo";
984
- import { GUINode } from "@babylonjs/gui-editor/diagram/guiNode";
985
- interface IGraphEditorProps {
986
- globalState: GlobalState;
1833
+ interface ITreeItemLabelComponentProps {
1834
+ label: string;
1835
+ onClick?: () => void;
1836
+ color: string;
987
1837
  }
988
- interface IGraphEditorState {
989
- showPreviewPopUp: boolean;
1838
+ export class TreeItemLabelComponent extends React.Component<ITreeItemLabelComponentProps> {
1839
+ constructor(props: ITreeItemLabelComponentProps);
1840
+ onClick(): void;
1841
+ render(): JSX.Element;
1842
+ }
1843
+ }
1844
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/extensionsComponent" {
1845
+ import * as React from "react";
1846
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1847
+ interface IExtensionsComponentProps {
1848
+ target: any;
1849
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1850
+ }
1851
+ export class ExtensionsComponent extends React.Component<IExtensionsComponentProps, {
1852
+ popupVisible: boolean;
1853
+ }> {
1854
+ private _popup;
1855
+ private extensionRef;
1856
+ constructor(props: IExtensionsComponentProps);
1857
+ showPopup(): void;
1858
+ componentDidMount(): void;
1859
+ componentDidUpdate(): void;
1860
+ render(): JSX.Element | null;
1861
+ }
1862
+ }
1863
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/entities/gui/controlTreeItemComponent" {
1864
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1865
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1866
+ import * as React from "react";
1867
+ import { DragOverLocation, GlobalState } from "@babylonjs/gui-editor/globalState";
1868
+ interface IControlTreeItemComponentProps {
1869
+ control: Control;
1870
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1871
+ onClick: () => void;
1872
+ globalState: GlobalState;
1873
+ isHovered: boolean;
1874
+ dragOverHover: boolean;
1875
+ dragOverLocation: DragOverLocation;
1876
+ }
1877
+ export class ControlTreeItemComponent extends React.Component<IControlTreeItemComponentProps, {
1878
+ isActive: boolean;
1879
+ isVisible: boolean;
1880
+ }> {
1881
+ constructor(props: IControlTreeItemComponentProps);
1882
+ highlight(): void;
1883
+ switchVisibility(): void;
1884
+ render(): JSX.Element;
1885
+ }
1886
+ }
1887
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemSelectableComponent" {
1888
+ import { Nullable } from "@babylonjs/core/types";
1889
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1890
+ import * as React from "react";
1891
+ import { DragOverLocation, GlobalState } from "@babylonjs/gui-editor/globalState";
1892
+ export interface ITreeItemSelectableComponentProps {
1893
+ entity: any;
1894
+ selectedEntity?: any;
1895
+ mustExpand?: boolean;
1896
+ offset: number;
1897
+ globalState: GlobalState;
1898
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1899
+ filter: Nullable<string>;
1900
+ }
1901
+ export class TreeItemSelectableComponent extends React.Component<ITreeItemSelectableComponentProps, {
1902
+ isSelected: boolean;
1903
+ isHovered: boolean;
1904
+ dragOverLocation: DragOverLocation;
1905
+ }> {
1906
+ dragOverHover: boolean;
1907
+ private _onSelectionChangedObservable;
1908
+ private _onDraggingEndObservable;
1909
+ private _onDraggingStartObservable;
1910
+ constructor(props: ITreeItemSelectableComponentProps);
1911
+ switchExpandedState(): void;
1912
+ shouldComponentUpdate(nextProps: ITreeItemSelectableComponentProps, nextState: {
1913
+ isSelected: boolean;
1914
+ }): boolean;
1915
+ scrollIntoView(): void;
1916
+ componentWillUnmount(): void;
1917
+ onSelect(): void;
1918
+ renderChildren(isExpanded: boolean): (JSX.Element | null)[] | null;
1919
+ render(): JSX.Element | null;
1920
+ dragOver(event: React.DragEvent<HTMLDivElement>): void;
1921
+ drop(): void;
1922
+ }
1923
+ }
1924
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemComponent" {
1925
+ import * as React from "react";
1926
+ import { Nullable } from "@babylonjs/core/types";
1927
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1928
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1929
+ export interface ITreeItemComponentProps {
1930
+ items?: Nullable<any[]>;
1931
+ label: string;
1932
+ offset: number;
1933
+ filter: Nullable<string>;
1934
+ forceSubitems?: boolean;
1935
+ globalState: GlobalState;
1936
+ entity?: any;
1937
+ selectedEntity: any;
1938
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1939
+ contextMenuItems?: {
1940
+ label: string;
1941
+ action: () => void;
1942
+ }[];
1943
+ }
1944
+ export class TreeItemComponent extends React.Component<ITreeItemComponentProps, {
1945
+ isExpanded: boolean;
1946
+ mustExpand: boolean;
1947
+ }> {
1948
+ static _ContextMenuUniqueIdGenerator: number;
1949
+ constructor(props: ITreeItemComponentProps);
1950
+ switchExpandedState(): void;
1951
+ shouldComponentUpdate(nextProps: ITreeItemComponentProps, nextState: {
1952
+ isExpanded: boolean;
1953
+ }): boolean;
1954
+ expandAll(expand: boolean): void;
1955
+ renderContextMenu(): JSX.Element | null;
1956
+ render(): JSX.Element;
1957
+ }
1958
+ }
1959
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/sceneExplorerComponent" {
1960
+ import * as React from "react";
1961
+ import { Nullable } from "@babylonjs/core/types";
1962
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1963
+ import { Scene } from "@babylonjs/core/scene";
1964
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1965
+ interface ISceneExplorerFilterComponentProps {
1966
+ onFilter: (filter: string) => void;
1967
+ }
1968
+ export class SceneExplorerFilterComponent extends React.Component<ISceneExplorerFilterComponentProps> {
1969
+ constructor(props: ISceneExplorerFilterComponentProps);
1970
+ render(): JSX.Element;
1971
+ }
1972
+ interface ISceneExplorerComponentProps {
1973
+ scene?: Scene;
1974
+ noCommands?: boolean;
1975
+ noHeader?: boolean;
1976
+ noExpand?: boolean;
1977
+ noClose?: boolean;
1978
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1979
+ globalState: GlobalState;
1980
+ popupMode?: boolean;
1981
+ onPopup?: () => void;
1982
+ onClose?: () => void;
1983
+ }
1984
+ export class SceneExplorerComponent extends React.Component<ISceneExplorerComponentProps, {
1985
+ filter: Nullable<string>;
1986
+ selectedEntity: any;
1987
+ scene: Nullable<Scene>;
1988
+ }> {
1989
+ private _onSelectionChangeObserver;
1990
+ private _onParrentingChangeObserver;
1991
+ private _onNewSceneObserver;
1992
+ private _onPropertyChangedObservable;
1993
+ constructor(props: ISceneExplorerComponentProps);
1994
+ componentDidMount(): void;
1995
+ componentWillUnmount(): void;
1996
+ filterContent(filter: string): void;
1997
+ findSiblings(parent: any, items: any[], target: any, goNext: boolean, data: {
1998
+ previousOne?: any;
1999
+ found?: boolean;
2000
+ }): boolean;
2001
+ processKeys(keyEvent: React.KeyboardEvent<HTMLDivElement>): void;
2002
+ renderContent(): JSX.Element | null;
2003
+ onClose(): void;
2004
+ onPopup(): void;
2005
+ render(): JSX.Element;
2006
+ }
2007
+ }
2008
+ declare module "@babylonjs/gui-editor/components/commandDropdownComponent" {
2009
+ import * as React from "react";
2010
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
2011
+ interface ICommandDropdownComponentProps {
2012
+ globalState: GlobalState;
2013
+ icon?: string;
2014
+ tooltip: string;
2015
+ defaultValue?: string;
2016
+ items: {
2017
+ label: string;
2018
+ icon?: string;
2019
+ fileButton?: boolean;
2020
+ onClick?: () => void;
2021
+ onCheck?: (value: boolean) => void;
2022
+ storeKey?: string;
2023
+ isActive?: boolean;
2024
+ defaultValue?: boolean | string;
2025
+ subItems?: string[];
2026
+ }[];
2027
+ toRight?: boolean;
2028
+ }
2029
+ export class CommandDropdownComponent extends React.Component<ICommandDropdownComponentProps, {
2030
+ isExpanded: boolean;
2031
+ activeState: string;
2032
+ }> {
2033
+ constructor(props: ICommandDropdownComponentProps);
2034
+ render(): JSX.Element;
2035
+ }
2036
+ }
2037
+ declare module "@babylonjs/gui-editor/components/commandBarComponent" {
2038
+ import * as React from "react";
2039
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
2040
+ interface ICommandBarComponentProps {
2041
+ globalState: GlobalState;
2042
+ }
2043
+ export class CommandBarComponent extends React.Component<ICommandBarComponentProps> {
2044
+ private _panning;
2045
+ private _zooming;
2046
+ private _selecting;
2047
+ private _outlines;
2048
+ constructor(props: ICommandBarComponentProps);
2049
+ private updateNodeOutline;
2050
+ render(): JSX.Element;
2051
+ }
2052
+ }
2053
+ declare module "@babylonjs/gui-editor/workbenchEditor" {
2054
+ import * as React from "react";
2055
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
2056
+ interface IGraphEditorProps {
2057
+ globalState: GlobalState;
2058
+ }
2059
+ interface IGraphEditorState {
2060
+ showPreviewPopUp: boolean;
990
2061
  }
991
2062
  export class WorkbenchEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
992
- private _workbenchCanvas;
993
2063
  private _startX;
994
2064
  private _moveInProgress;
995
2065
  private _leftWidth;
996
2066
  private _rightWidth;
997
- private _onWidgetKeyUpPointer;
2067
+ private _toolBarIconSize;
998
2068
  private _popUpWindow;
2069
+ private _draggedItem;
999
2070
  componentDidMount(): void;
1000
- componentWillUnmount(): void;
1001
2071
  constructor(props: IGraphEditorProps);
1002
- pasteSelection(copiedNodes: GUINode[], currentX: number, currentY: number, selectNew?: boolean): GUINode[];
1003
- zoomToFit(): void;
1004
2072
  showWaitScreen(): void;
1005
2073
  hideWaitScreen(): void;
1006
- reOrganize(editorData?: Nullable<IEditorData>, isImportingAFrame?: boolean): void;
1007
2074
  onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
1008
2075
  onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
1009
2076
  resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
1010
2077
  buildColumnLayout(): string;
1011
- emitNewBlock(event: React.DragEvent<HTMLDivElement>): void;
1012
2078
  handlePopUp: () => void;
1013
2079
  handleClosingPopUp: () => void;
1014
2080
  createPopupWindow: (title: string, windowVariableName: string, width?: number, height?: number) => Window | null;
1015
2081
  copyStyles: (sourceDoc: HTMLDocument, targetDoc: HTMLDocument) => void;
1016
- fixPopUpStyles: (document: Document) => void;
1017
2082
  render(): JSX.Element;
2083
+ _items: {
2084
+ label: string;
2085
+ icon?: string;
2086
+ fileButton?: boolean;
2087
+ onClick?: () => void;
2088
+ onCheck?: (value: boolean) => void;
2089
+ storeKey?: string;
2090
+ isActive?: boolean;
2091
+ defaultValue?: boolean | string;
2092
+ subItems?: string[];
2093
+ }[];
2094
+ createItems(): void;
2095
+ onCreate(value: string): void;
2096
+ createToolbar(): JSX.Element;
1018
2097
  }
1019
2098
  }
1020
2099
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/popup" {
@@ -1025,14 +2104,20 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/popup" {
1025
2104
  }
1026
2105
  declare module "@babylonjs/gui-editor/guiEditor" {
1027
2106
  import { Observable } from "@babylonjs/core/Misc/observable";
2107
+ import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
1028
2108
  /**
1029
2109
  * Interface used to specify creation options for the gui editor
1030
2110
  */
1031
2111
  export interface IGUIEditorOptions {
2112
+ liveGuiTexture?: AdvancedDynamicTexture;
2113
+ customLoad: {
2114
+ label: string;
2115
+ action: (data: string) => Promise<string>;
2116
+ } | undefined;
1032
2117
  hostElement?: HTMLElement;
1033
2118
  customSave?: {
1034
2119
  label: string;
1035
- action: (data: string) => Promise<void>;
2120
+ action: (data: string) => Promise<string>;
1036
2121
  };
1037
2122
  currentSnippetToken?: string;
1038
2123
  customLoadObservable?: Observable<any>;
@@ -1046,12 +2131,94 @@ declare module "@babylonjs/gui-editor/guiEditor" {
1046
2131
  * Show the gui editor
1047
2132
  * @param options defines the options to use to configure the gui editor
1048
2133
  */
1049
- static Show(options: IGUIEditorOptions): void;
2134
+ static Show(options: IGUIEditorOptions): Promise<void>;
1050
2135
  }
1051
2136
  }
1052
2137
  declare module "@babylonjs/gui-editor/index" {
1053
2138
  export * from "@babylonjs/gui-editor/guiEditor";
1054
2139
  }
2140
+ declare module "@babylonjs/gui-editor/nodeLocationInfo" {
2141
+ export interface INodeLocationInfo {
2142
+ blockId: number;
2143
+ x: number;
2144
+ y: number;
2145
+ }
2146
+ export interface IFrameData {
2147
+ x: number;
2148
+ y: number;
2149
+ width: number;
2150
+ height: number;
2151
+ color: number[];
2152
+ name: string;
2153
+ isCollapsed: boolean;
2154
+ blocks: number[];
2155
+ comments: string;
2156
+ }
2157
+ export interface IEditorData {
2158
+ locations: INodeLocationInfo[];
2159
+ x: number;
2160
+ y: number;
2161
+ zoom: number;
2162
+ frames?: IFrameData[];
2163
+ map?: {
2164
+ [key: number]: number;
2165
+ };
2166
+ }
2167
+ }
2168
+ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/iSelectedLineContainer" {
2169
+ export interface ISelectedLineContainer {
2170
+ selectedLineContainerTitles: Array<string>;
2171
+ selectedLineContainerTitlesNoFocus: Array<string>;
2172
+ }
2173
+ }
2174
+ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/lineContainerComponent" {
2175
+ import * as React from "react";
2176
+ import { ISelectedLineContainer } from "@babylonjs/gui-editor/sharedUiComponents/lines/iSelectedLineContainer";
2177
+ interface ILineContainerComponentProps {
2178
+ selection?: ISelectedLineContainer;
2179
+ title: string;
2180
+ children: any[] | any;
2181
+ closed?: boolean;
2182
+ }
2183
+ export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
2184
+ isExpanded: boolean;
2185
+ isHighlighted: boolean;
2186
+ }> {
2187
+ constructor(props: ILineContainerComponentProps);
2188
+ switchExpandedState(): void;
2189
+ renderHeader(): JSX.Element;
2190
+ componentDidMount(): void;
2191
+ render(): JSX.Element;
2192
+ }
2193
+ }
2194
+ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/draggableLineComponent" {
2195
+ import * as React from "react";
2196
+ export interface IButtonLineComponentProps {
2197
+ data: string;
2198
+ tooltip: string;
2199
+ }
2200
+ export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
2201
+ constructor(props: IButtonLineComponentProps);
2202
+ render(): JSX.Element;
2203
+ }
2204
+ }
2205
+ declare module "@babylonjs/gui-editor/components/guiList/guiListComponent" {
2206
+ import * as React from "react";
2207
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
2208
+ interface IGuiListComponentProps {
2209
+ globalState: GlobalState;
2210
+ }
2211
+ export class GuiListComponent extends React.Component<IGuiListComponentProps, {
2212
+ filter: string;
2213
+ }> {
2214
+ private _onResetRequiredObserver;
2215
+ private static _Tooltips;
2216
+ constructor(props: IGuiListComponentProps);
2217
+ componentWillUnmount(): void;
2218
+ filterContent(filter: string): void;
2219
+ render(): JSX.Element;
2220
+ }
2221
+ }
1055
2222
  declare module "@babylonjs/gui-editor/legacy/legacy" {
1056
2223
  export * from "@babylonjs/gui-editor/index";
1057
2224
  }
@@ -1214,6 +2381,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/booleanLineCompon
1214
2381
  export interface IBooleanLineComponentProps {
1215
2382
  label: string;
1216
2383
  value: boolean;
2384
+ icon?: string;
2385
+ iconLabel?: string;
1217
2386
  }
1218
2387
  export class BooleanLineComponent extends React.Component<IBooleanLineComponentProps> {
1219
2388
  constructor(props: IBooleanLineComponentProps);
@@ -1232,6 +2401,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/color4LineCompone
1232
2401
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1233
2402
  onChange?: () => void;
1234
2403
  isLinear?: boolean;
2404
+ icon?: string;
2405
+ iconLabel?: string;
1235
2406
  }
1236
2407
  export class Color4LineComponent extends React.Component<IColor4LineComponentProps, {
1237
2408
  isExpanded: boolean;
@@ -1260,6 +2431,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/fileMultipleButto
1260
2431
  label: string;
1261
2432
  onClick: (event: any) => void;
1262
2433
  accept: string;
2434
+ icon?: string;
2435
+ iconLabel?: string;
1263
2436
  }
1264
2437
  export class FileMultipleButtonLineComponent extends React.Component<IFileMultipleButtonLineComponentProps> {
1265
2438
  private static _IDGenerator;
@@ -1289,6 +2462,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/hexLineComponent"
1289
2462
  digits?: number;
1290
2463
  useEuler?: boolean;
1291
2464
  min?: number;
2465
+ icon?: string;
2466
+ iconLabel?: string;
1292
2467
  }
1293
2468
  export class HexLineComponent extends React.Component<IHexLineComponentProps, {
1294
2469
  value: string;
@@ -1310,7 +2485,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/hexLineComponent"
1310
2485
  }
1311
2486
  }
1312
2487
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/iconButtonLineComponent" {
1313
- import * as React from 'react';
2488
+ import * as React from "react";
1314
2489
  export interface IIconButtonLineComponentProps {
1315
2490
  icon: string;
1316
2491
  onClick: () => void;
@@ -1373,6 +2548,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/radioLineComponen
1373
2548
  label: string;
1374
2549
  isSelected: () => boolean;
1375
2550
  onSelect: () => void;
2551
+ icon?: string;
2552
+ iconLabel?: string;
1376
2553
  }
1377
2554
  export class RadioButtonLineComponent extends React.Component<IRadioButtonLineComponentProps, {
1378
2555
  isSelected: boolean;
@@ -1393,6 +2570,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/valueLineComponen
1393
2570
  color?: string;
1394
2571
  fractionDigits?: number;
1395
2572
  units?: string;
2573
+ icon?: string;
2574
+ iconLabel?: string;
1396
2575
  }
1397
2576
  export class ValueLineComponent extends React.Component<IValueLineComponentProps> {
1398
2577
  constructor(props: IValueLineComponentProps);
@@ -1411,6 +2590,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/vector2LineCompon
1411
2590
  step?: number;
1412
2591
  onChange?: (newvalue: Vector2) => void;
1413
2592
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2593
+ icon?: string;
2594
+ iconLabel?: string;
1414
2595
  }
1415
2596
  export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
1416
2597
  isExpanded: boolean;
@@ -1446,6 +2627,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/vector3LineCompon
1446
2627
  useEuler?: boolean;
1447
2628
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1448
2629
  noSlider?: boolean;
2630
+ icon?: string;
2631
+ iconLabel?: string;
1449
2632
  }
1450
2633
  export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
1451
2634
  isExpanded: boolean;
@@ -1483,6 +2666,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/vector4LineCompon
1483
2666
  onChange?: (newvalue: Vector4) => void;
1484
2667
  useEuler?: boolean;
1485
2668
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2669
+ icon?: string;
2670
+ iconLabel?: string;
1486
2671
  }
1487
2672
  export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
1488
2673
  isExpanded: boolean;
@@ -1508,6 +2693,266 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/vector4LineCompon
1508
2693
  render(): JSX.Element;
1509
2694
  }
1510
2695
  }
2696
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/commonControlPropertyGridComponent" {
2697
+ import * as React from "react";
2698
+ import { Observable } from "@babylonjs/core/Misc/observable";
2699
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2700
+ import { Control } from "@babylonjs/gui/2D/controls/control";
2701
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2702
+ interface ICommonControlPropertyGridComponentProps {
2703
+ control: Control;
2704
+ lockObject: LockObject;
2705
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2706
+ }
2707
+ export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
2708
+ constructor(props: ICommonControlPropertyGridComponentProps);
2709
+ renderGridInformation(): JSX.Element | null;
2710
+ render(): JSX.Element;
2711
+ }
2712
+ }
2713
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/checkboxPropertyGridComponent" {
2714
+ import * as React from "react";
2715
+ import { Observable } from "@babylonjs/core/Misc/observable";
2716
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2717
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2718
+ import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
2719
+ interface ICheckboxPropertyGridComponentProps {
2720
+ checkbox: Checkbox;
2721
+ lockObject: LockObject;
2722
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2723
+ }
2724
+ export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
2725
+ constructor(props: ICheckboxPropertyGridComponentProps);
2726
+ render(): JSX.Element;
2727
+ }
2728
+ }
2729
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/colorPickerPropertyGridComponent" {
2730
+ import * as React from "react";
2731
+ import { Observable } from "@babylonjs/core/Misc/observable";
2732
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2733
+ import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
2734
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2735
+ interface IColorPickerPropertyGridComponentProps {
2736
+ colorPicker: ColorPicker;
2737
+ lockObject: LockObject;
2738
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2739
+ }
2740
+ export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
2741
+ constructor(props: IColorPickerPropertyGridComponentProps);
2742
+ render(): JSX.Element;
2743
+ }
2744
+ }
2745
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/controlPropertyGridComponent" {
2746
+ import * as React from "react";
2747
+ import { Observable } from "@babylonjs/core/Misc/observable";
2748
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2749
+ import { Control } from "@babylonjs/gui/2D/controls/control";
2750
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2751
+ interface IControlPropertyGridComponentProps {
2752
+ control: Control;
2753
+ lockObject: LockObject;
2754
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2755
+ }
2756
+ export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
2757
+ constructor(props: IControlPropertyGridComponentProps);
2758
+ render(): JSX.Element;
2759
+ }
2760
+ }
2761
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/ellipsePropertyGridComponent" {
2762
+ import * as React from "react";
2763
+ import { Observable } from "@babylonjs/core/Misc/observable";
2764
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2765
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2766
+ import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
2767
+ interface IEllipsePropertyGridComponentProps {
2768
+ ellipse: Ellipse;
2769
+ lockObject: LockObject;
2770
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2771
+ }
2772
+ export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
2773
+ constructor(props: IEllipsePropertyGridComponentProps);
2774
+ render(): JSX.Element;
2775
+ }
2776
+ }
2777
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/gridPropertyGridComponent" {
2778
+ import * as React from "react";
2779
+ import { Observable } from "@babylonjs/core/Misc/observable";
2780
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2781
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2782
+ import { Grid } from "@babylonjs/gui/2D/controls/grid";
2783
+ interface IGridPropertyGridComponentProps {
2784
+ grid: Grid;
2785
+ lockObject: LockObject;
2786
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2787
+ }
2788
+ export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
2789
+ constructor(props: IGridPropertyGridComponentProps);
2790
+ renderRows(): JSX.Element[];
2791
+ renderColumns(): JSX.Element[];
2792
+ render(): JSX.Element;
2793
+ }
2794
+ }
2795
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
2796
+ import * as React from "react";
2797
+ import { Observable } from "@babylonjs/core/Misc/observable";
2798
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2799
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2800
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
2801
+ interface IImageBasedSliderPropertyGridComponentProps {
2802
+ imageBasedSlider: ImageBasedSlider;
2803
+ lockObject: LockObject;
2804
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2805
+ }
2806
+ export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
2807
+ constructor(props: IImageBasedSliderPropertyGridComponentProps);
2808
+ render(): JSX.Element;
2809
+ }
2810
+ }
2811
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/imagePropertyGridComponent" {
2812
+ import * as React from "react";
2813
+ import { Observable } from "@babylonjs/core/Misc/observable";
2814
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2815
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2816
+ import { Image } from "@babylonjs/gui/2D/controls/image";
2817
+ interface IImagePropertyGridComponentProps {
2818
+ image: Image;
2819
+ lockObject: LockObject;
2820
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2821
+ }
2822
+ export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
2823
+ constructor(props: IImagePropertyGridComponentProps);
2824
+ render(): JSX.Element;
2825
+ }
2826
+ }
2827
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/inputTextPropertyGridComponent" {
2828
+ import * as React from "react";
2829
+ import { Observable } from "@babylonjs/core/Misc/observable";
2830
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2831
+ import { InputText } from "@babylonjs/gui/2D/controls/inputText";
2832
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2833
+ interface IInputTextPropertyGridComponentProps {
2834
+ inputText: InputText;
2835
+ lockObject: LockObject;
2836
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2837
+ }
2838
+ export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
2839
+ constructor(props: IInputTextPropertyGridComponentProps);
2840
+ render(): JSX.Element;
2841
+ }
2842
+ }
2843
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/linePropertyGridComponent" {
2844
+ import * as React from "react";
2845
+ import { Observable } from "@babylonjs/core/Misc/observable";
2846
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2847
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2848
+ import { Line } from "@babylonjs/gui/2D/controls/line";
2849
+ interface ILinePropertyGridComponentProps {
2850
+ line: Line;
2851
+ lockObject: LockObject;
2852
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2853
+ }
2854
+ export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
2855
+ constructor(props: ILinePropertyGridComponentProps);
2856
+ onDashChange(value: string): void;
2857
+ render(): JSX.Element;
2858
+ }
2859
+ }
2860
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/radioButtonPropertyGridComponent" {
2861
+ import * as React from "react";
2862
+ import { Observable } from "@babylonjs/core/Misc/observable";
2863
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2864
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2865
+ import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
2866
+ interface IRadioButtonPropertyGridComponentProps {
2867
+ radioButton: RadioButton;
2868
+ lockObject: LockObject;
2869
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2870
+ }
2871
+ export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
2872
+ constructor(props: IRadioButtonPropertyGridComponentProps);
2873
+ render(): JSX.Element;
2874
+ }
2875
+ }
2876
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/rectanglePropertyGridComponent" {
2877
+ import * as React from "react";
2878
+ import { Observable } from "@babylonjs/core/Misc/observable";
2879
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2880
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2881
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
2882
+ interface IRectanglePropertyGridComponentProps {
2883
+ rectangle: Rectangle;
2884
+ lockObject: LockObject;
2885
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2886
+ }
2887
+ export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
2888
+ constructor(props: IRectanglePropertyGridComponentProps);
2889
+ render(): JSX.Element;
2890
+ }
2891
+ }
2892
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/scrollViewerPropertyGridComponent" {
2893
+ import * as React from "react";
2894
+ import { Observable } from "@babylonjs/core/Misc/observable";
2895
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2896
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2897
+ import { ScrollViewer } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewer";
2898
+ interface IScrollViewerPropertyGridComponentProps {
2899
+ scrollViewer: ScrollViewer;
2900
+ lockObject: LockObject;
2901
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2902
+ }
2903
+ export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
2904
+ constructor(props: IScrollViewerPropertyGridComponentProps);
2905
+ render(): JSX.Element;
2906
+ }
2907
+ }
2908
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/sliderPropertyGridComponent" {
2909
+ import * as React from "react";
2910
+ import { Observable } from "@babylonjs/core/Misc/observable";
2911
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2912
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2913
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
2914
+ interface ISliderPropertyGridComponentProps {
2915
+ slider: Slider;
2916
+ lockObject: LockObject;
2917
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2918
+ }
2919
+ export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
2920
+ constructor(props: ISliderPropertyGridComponentProps);
2921
+ render(): JSX.Element;
2922
+ }
2923
+ }
2924
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" {
2925
+ import * as React from "react";
2926
+ import { Observable } from "@babylonjs/core/Misc/observable";
2927
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2928
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2929
+ import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
2930
+ interface IStackPanelPropertyGridComponentProps {
2931
+ stackPanel: StackPanel;
2932
+ lockObject: LockObject;
2933
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2934
+ }
2935
+ export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
2936
+ constructor(props: IStackPanelPropertyGridComponentProps);
2937
+ render(): JSX.Element;
2938
+ }
2939
+ }
2940
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/textBlockPropertyGridComponent" {
2941
+ import * as React from "react";
2942
+ import { Observable } from "@babylonjs/core/Misc/observable";
2943
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2944
+ import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
2945
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2946
+ interface ITextBlockPropertyGridComponentProps {
2947
+ textBlock: TextBlock;
2948
+ lockObject: LockObject;
2949
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2950
+ }
2951
+ export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
2952
+ constructor(props: ITextBlockPropertyGridComponentProps);
2953
+ render(): JSX.Element;
2954
+ }
2955
+ }
1511
2956
  declare module "@babylonjs/gui-editor" {
1512
2957
  export * from "@babylonjs/gui-editor/legacy/legacy";
1513
2958
  }