@babylonjs/gui-editor 5.0.0-alpha.8 → 5.0.0-beta.3

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 +25452 -31906
  2. package/babylon.guiEditor.max.js.map +1 -1
  3. package/babylon.guiEditor.module.d.ts +1805 -380
  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,178 @@ 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
+ export class GuiGizmoComponent extends React.Component<IGuiGizmoProps> {
804
+ scalePoints: HTMLDivElement[];
805
+ private _scalePointIndex;
806
+ private _pointerData;
807
+ private _htmlPoints;
808
+ private _matrixCache;
809
+ private _responsive;
810
+ constructor(props: IGuiGizmoProps);
811
+ componentDidMount(): void;
812
+ /**
813
+ * Update the gizmo's corners positions
814
+ * @param force should the update be forced. otherwise it will be updated only when the pointer is down
815
+ */
816
+ updateGizmo(force?: boolean): void;
817
+ private _resetMatrixArray;
818
+ /**
819
+ * This function calculates a local matrix for a node, including it's full transformation and pivot point
820
+ *
821
+ * @param node the node to calculate the matrix for
822
+ * @param useStoredValues should the stored (cached) values be used to calculate the matrix
823
+ * @returns a new matrix for the control
824
+ */
825
+ private _getNodeMatrix;
826
+ /**
827
+ * Using the node's tree, calculate its world matrix and return it
828
+ * @param node the node to calculate the matrix for
829
+ * @param useStoredValuesIfPossible used stored valued (cached when pointer down is clicked)
830
+ * @returns the world matrix for this node
831
+ */
832
+ private _nodeToRTTWorldMatrix;
833
+ private _nodeToRTTSpace;
834
+ private _rttToLocalNodeSpace;
835
+ private _rttToCanvasSpace;
836
+ private _plane;
837
+ private _mousePointerToRTTSpace;
838
+ /**
839
+ * Get the scaling of a specific GUI control
840
+ * @param node the node for which we are getting the scaling
841
+ * @param relative should we return only the relative scaling (relative to the parent)
842
+ * @returns an X,Y vector of the scaling
843
+ */
844
+ getScale(node: Control, relative?: boolean): Vector2;
845
+ getRotation(node: Control, relative?: boolean): number;
846
+ createBaseGizmo(): void;
847
+ onUp(evt?: React.PointerEvent): void;
848
+ private _onUp;
849
+ onMove(evt: React.PointerEvent): void;
850
+ private _initH;
851
+ private _initW;
852
+ private _initX;
853
+ private _initY;
854
+ private _onMove;
855
+ /**
856
+ * Calculate the 4 corners in node space
857
+ * @param node The node to use
858
+ */
859
+ private _nodeToCorners;
860
+ /**
861
+ * Computer the node's width, height, top and left, using the 4 corners
862
+ * @param node the node we use
863
+ */
864
+ private _updateNodeFromCorners;
865
+ private _rotate;
866
+ private _setNodeCorner;
867
+ private _setMousePosition;
868
+ render(): null;
869
+ }
870
+ }
154
871
  declare module "@babylonjs/gui-editor/globalState" {
155
872
  import { Nullable } from "@babylonjs/core/types";
156
873
  import { Observable } from "@babylonjs/core/Misc/observable";
157
874
  import { LogEntry } from "@babylonjs/gui-editor/components/log/logComponent";
158
875
  import { Color4 } from "@babylonjs/core/Maths/math.color";
159
- import { GUINode } from "@babylonjs/gui-editor/diagram/guiNode";
160
876
  import { WorkbenchComponent } from "@babylonjs/gui-editor/diagram/workbench";
161
877
  import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
162
878
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
879
+ import { Vector2 } from "@babylonjs/core/Maths/math.vector";
880
+ import { Scene } from "@babylonjs/core/scene";
881
+ import { Control } from "@babylonjs/gui/2D/controls/control";
882
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
883
+ import { GuiGizmoComponent } from "@babylonjs/gui-editor/diagram/guiGizmo";
884
+ export enum DragOverLocation {
885
+ ABOVE = 0,
886
+ BELOW = 1,
887
+ CENTER = 2,
888
+ NONE = 3
889
+ }
163
890
  export class GlobalState {
891
+ [x: string]: any;
892
+ liveGuiTexture: Nullable<AdvancedDynamicTexture>;
164
893
  guiTexture: AdvancedDynamicTexture;
165
894
  hostElement: HTMLElement;
166
895
  hostDocument: HTMLDocument;
167
896
  hostWindow: Window;
168
- onSelectionChangedObservable: Observable<Nullable<GUINode>>;
169
- onRebuildRequiredObservable: Observable<void>;
897
+ onSelectionChangedObservable: Observable<Nullable<Control>>;
898
+ onResizeObservable: Observable<Vector2>;
170
899
  onBuiltObservable: Observable<void>;
171
900
  onResetRequiredObservable: Observable<void>;
172
901
  onUpdateRequiredObservable: Observable<void>;
173
- onReOrganizedRequiredObservable: Observable<void>;
174
902
  onLogRequiredObservable: Observable<LogEntry>;
175
903
  onErrorMessageDialogRequiredObservable: Observable<string>;
176
904
  onIsLoadingChanged: Observable<boolean>;
177
- onSelectionBoxMoved: Observable<DOMRect | ClientRect>;
178
- onGuiNodeRemovalObservable: Observable<GUINode>;
905
+ onSelectionBoxMoved: Observable<ClientRect | DOMRect>;
906
+ onNewSceneObservable: Observable<Nullable<Scene>>;
907
+ onGuiNodeRemovalObservable: Observable<Control>;
908
+ onPopupClosedObservable: Observable<void>;
179
909
  backgroundColor: Color4;
180
910
  blockKeyboardEvents: boolean;
181
911
  controlCamera: boolean;
912
+ selectionLock: boolean;
182
913
  workbench: WorkbenchComponent;
914
+ guiGizmo: GuiGizmoComponent;
183
915
  onPropertyChangedObservable: Observable<PropertyChangedEvent>;
916
+ onZoomObservable: Observable<void>;
917
+ onFitToWindowObservable: Observable<void>;
918
+ onPanObservable: Observable<void>;
919
+ onSelectionButtonObservable: Observable<void>;
920
+ onMoveObservable: Observable<void>;
921
+ onLoadObservable: Observable<File>;
922
+ onSaveObservable: Observable<void>;
923
+ onSnippetLoadObservable: Observable<void>;
924
+ onSnippetSaveObservable: Observable<void>;
925
+ onOutlinesObservable: Observable<void>;
926
+ onResponsiveChangeObservable: Observable<boolean>;
927
+ onParentingChangeObservable: Observable<Nullable<Control>>;
928
+ onPropertyGridUpdateRequiredObservable: Observable<void>;
929
+ onDraggingEndObservable: Observable<void>;
930
+ onDraggingStartObservable: Observable<void>;
931
+ onWindowResizeObservable: Observable<void>;
932
+ onGizmoUpdateRequireObservable: Observable<void>;
933
+ draggedControl: Nullable<Control>;
934
+ draggedControlDirection: DragOverLocation;
935
+ isSaving: boolean;
936
+ lockObject: LockObject;
184
937
  storeEditorData: (serializationObject: any) => void;
185
938
  customSave?: {
186
939
  label: string;
187
- action: (data: string) => Promise<void>;
940
+ action: (data: string) => Promise<string>;
941
+ };
942
+ customLoad?: {
943
+ label: string;
944
+ action: (data: string) => Promise<string>;
188
945
  };
189
946
  constructor();
190
947
  }
191
948
  }
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
949
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/buttonLineComponent" {
237
950
  import * as React from "react";
238
951
  export interface IButtonLineComponentProps {
239
952
  label: string;
240
953
  onClick: () => void;
954
+ icon?: string;
955
+ iconLabel?: string;
241
956
  }
242
957
  export class ButtonLineComponent extends React.Component<IButtonLineComponentProps> {
243
958
  constructor(props: IButtonLineComponentProps);
@@ -250,6 +965,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/fileButtonLineCom
250
965
  label: string;
251
966
  onClick: (file: File) => void;
252
967
  accept: string;
968
+ icon?: string;
969
+ iconLabel?: string;
253
970
  }
254
971
  export class FileButtonLineComponent extends React.Component<IFileButtonLineComponentProps> {
255
972
  private static _IDGenerator;
@@ -265,7 +982,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/checkBoxLineCompo
265
982
  import { Observable } from "@babylonjs/core/Misc/observable";
266
983
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
267
984
  export interface ICheckBoxLineComponentProps {
268
- label: string;
985
+ label?: string;
269
986
  target?: any;
270
987
  propertyName?: string;
271
988
  isSelected?: () => boolean;
@@ -273,6 +990,10 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/checkBoxLineCompo
273
990
  onValueChanged?: () => void;
274
991
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
275
992
  disabled?: boolean;
993
+ icon?: string;
994
+ iconLabel?: string;
995
+ faIcons?: {
996
+ };
276
997
  }
277
998
  export class CheckBoxLineComponent extends React.Component<ICheckBoxLineComponentProps, {
278
999
  isSelected: boolean;
@@ -301,6 +1022,9 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/textLineComponent
301
1022
  url?: string;
302
1023
  ignoreValue?: boolean;
303
1024
  additionalClass?: string;
1025
+ icon?: string;
1026
+ iconLabel?: string;
1027
+ tooltip?: string;
304
1028
  }
305
1029
  export class TextLineComponent extends React.Component<ITextLineComponentProps> {
306
1030
  constructor(props: ITextLineComponentProps);
@@ -320,17 +1044,6 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/stringTools" {
320
1044
  static DownloadAsFile(document: HTMLDocument, content: string, filename: string): void;
321
1045
  }
322
1046
  }
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
1047
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/floatLineComponent" {
335
1048
  import * as React from "react";
336
1049
  import { Observable } from "@babylonjs/core/Misc/observable";
@@ -352,6 +1065,9 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/floatLineComponen
352
1065
  max?: number;
353
1066
  smallUI?: boolean;
354
1067
  onEnter?: (newValue: number) => void;
1068
+ icon?: string;
1069
+ iconLabel?: string;
1070
+ defaultValue?: number;
355
1071
  }
356
1072
  export class FloatLineComponent extends React.Component<IFloatLineComponentProps, {
357
1073
  value: string;
@@ -374,6 +1090,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/sliderLineCompone
374
1090
  import * as React from "react";
375
1091
  import { Observable } from "@babylonjs/core/Misc/observable";
376
1092
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1093
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
377
1094
  interface ISliderLineComponentProps {
378
1095
  label: string;
379
1096
  target?: any;
@@ -388,6 +1105,9 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/sliderLineCompone
388
1105
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
389
1106
  decimalCount?: number;
390
1107
  margin?: boolean;
1108
+ icon?: string;
1109
+ iconLabel?: string;
1110
+ lockObject?: LockObject;
391
1111
  }
392
1112
  export class SliderLineComponent extends React.Component<ISliderLineComponentProps, {
393
1113
  value: number;
@@ -416,6 +1136,11 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/textInputLineComp
416
1136
  value?: string;
417
1137
  onChange?: (value: string) => void;
418
1138
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1139
+ icon?: string;
1140
+ iconLabel?: string;
1141
+ noUnderline?: boolean;
1142
+ numbersOnly?: boolean;
1143
+ delayInput?: boolean;
419
1144
  }
420
1145
  export class TextInputLineComponent extends React.Component<ITextInputLineComponentProps, {
421
1146
  value: string;
@@ -431,137 +1156,20 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/textInputLineComp
431
1156
  render(): JSX.Element;
432
1157
  }
433
1158
  }
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" {
1159
+ declare module "@babylonjs/gui-editor/components/commandButtonComponent" {
553
1160
  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>;
1161
+ interface ICommandButtonComponentProps {
1162
+ tooltip: string;
1163
+ shortcut?: string;
1164
+ icon: string;
1165
+ iconLabel?: string;
1166
+ isActive: boolean;
1167
+ onClick: () => void;
1168
+ altStyle?: boolean;
1169
+ disabled?: boolean;
562
1170
  }
563
- export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
564
- constructor(props: IInputTextPropertyGridComponentProps);
1171
+ export class CommandButtonComponent extends React.Component<ICommandButtonComponentProps> {
1172
+ constructor(props: ICommandButtonComponentProps);
565
1173
  render(): JSX.Element;
566
1174
  }
567
1175
  }
@@ -573,6 +1181,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/numericInputCompo
573
1181
  step?: number;
574
1182
  onChange: (value: number) => void;
575
1183
  precision?: number;
1184
+ icon?: string;
1185
+ iconLabel?: string;
576
1186
  }
577
1187
  export class NumericInputComponent extends React.Component<INumericInputComponentProps, {
578
1188
  value: string;
@@ -631,6 +1241,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/colorPicker/colorPicker
631
1241
  */
632
1242
  export interface IColorPickerProps {
633
1243
  color: Color3 | Color4;
1244
+ linearhint?: boolean;
634
1245
  debugMode?: boolean;
635
1246
  onColorChanged?: (color: Color3 | Color4) => void;
636
1247
  }
@@ -650,6 +1261,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/colorPicker/colorPicker
650
1261
  private _isSaturationPointerDown;
651
1262
  private _isHuePointerDown;
652
1263
  constructor(props: IColorPickerProps);
1264
+ shouldComponentUpdate(nextProps: IColorPickerProps, nextState: IColorPickerState): boolean;
653
1265
  onSaturationPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
654
1266
  onSaturationPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
655
1267
  onSaturationPointerMove(evt: React.PointerEvent<HTMLDivElement>): void;
@@ -665,10 +1277,14 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/colorPicker/colorPicker
665
1277
  }
666
1278
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/colorPickerComponent" {
667
1279
  import * as React from "react";
668
- import { Color4, Color3 } from '@babylonjs/core/Maths/math.color';
1280
+ import { Color4, Color3 } from "@babylonjs/core/Maths/math.color";
669
1281
  export interface IColorPickerComponentProps {
670
1282
  value: Color4 | Color3;
1283
+ linearHint?: boolean;
671
1284
  onColorChanged: (newOne: string) => void;
1285
+ icon?: string;
1286
+ iconLabel?: string;
1287
+ shouldPopRight?: boolean;
672
1288
  }
673
1289
  interface IColorPickerComponentState {
674
1290
  pickerEnabled: boolean;
@@ -690,35 +1306,200 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/color3LineCompone
690
1306
  import * as React from "react";
691
1307
  import { Observable } from "@babylonjs/core/Misc/observable";
692
1308
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
693
- import { Color3 } from '@babylonjs/core/Maths/math.color';
1309
+ import { Color3, Color4 } from "@babylonjs/core/Maths/math.color";
1310
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
694
1311
  export interface IColor3LineComponentProps {
695
1312
  label: string;
696
1313
  target: any;
697
1314
  propertyName: string;
698
1315
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
699
1316
  isLinear?: boolean;
1317
+ icon?: string;
1318
+ lockObject?: LockObject;
1319
+ iconLabel?: string;
1320
+ onValueChange?: (value: string) => void;
700
1321
  }
701
1322
  export class Color3LineComponent extends React.Component<IColor3LineComponentProps, {
702
1323
  isExpanded: boolean;
703
- color: Color3;
1324
+ color: Color3 | Color4;
1325
+ colorText: string;
704
1326
  }> {
705
1327
  private _localChange;
706
1328
  constructor(props: IColor3LineComponentProps);
1329
+ private convertToColor3;
707
1330
  shouldComponentUpdate(nextProps: IColor3LineComponentProps, nextState: {
708
- color: Color3;
1331
+ color: Color3 | Color4;
1332
+ colorText: string;
709
1333
  }): boolean;
710
- setPropertyValue(newColor: Color3): void;
1334
+ setPropertyValue(newColor: Color3 | Color4, newColorText: string): void;
711
1335
  onChange(newValue: string): void;
712
1336
  switchExpandState(): void;
713
- raiseOnPropertyChanged(previousValue: Color3): void;
1337
+ raiseOnPropertyChanged(previousValue: Color3 | Color4): void;
714
1338
  updateStateR(value: number): void;
715
1339
  updateStateG(value: number): void;
716
1340
  updateStateB(value: number): void;
717
1341
  copyToClipboard(): void;
1342
+ convert(colorString: string): void;
1343
+ private _colorStringSaved;
1344
+ private _colorPickerOpen;
1345
+ private _colorString;
718
1346
  render(): JSX.Element;
719
1347
  }
720
1348
  }
721
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/colorPickerPropertyGridComponent" {
1349
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/commonControlPropertyGridComponent" {
1350
+ import * as React from "react";
1351
+ import { Observable } from "@babylonjs/core/Misc/observable";
1352
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1353
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1354
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1355
+ interface ICommonControlPropertyGridComponentProps {
1356
+ control: Control;
1357
+ lockObject: LockObject;
1358
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1359
+ }
1360
+ export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
1361
+ private _width;
1362
+ private _height;
1363
+ constructor(props: ICommonControlPropertyGridComponentProps);
1364
+ private _updateAlignment;
1365
+ private _checkAndUpdateValues;
1366
+ private _markChildrenAsDirty;
1367
+ render(): JSX.Element;
1368
+ }
1369
+ }
1370
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/sliderPropertyGridComponent" {
1371
+ import * as React from "react";
1372
+ import { Observable } from "@babylonjs/core/Misc/observable";
1373
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1374
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1375
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
1376
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
1377
+ interface ISliderPropertyGridComponentProps {
1378
+ slider: Slider | ImageBasedSlider;
1379
+ lockObject: LockObject;
1380
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1381
+ }
1382
+ export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
1383
+ constructor(props: ISliderPropertyGridComponentProps);
1384
+ render(): JSX.Element;
1385
+ }
1386
+ }
1387
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/sliderGenericPropertyGridComponent" {
1388
+ import * as React from "react";
1389
+ import { Observable } from "@babylonjs/core/Misc/observable";
1390
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1391
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1392
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
1393
+ interface ISliderGenericPropertyGridComponentProps {
1394
+ slider: Slider;
1395
+ lockObject: LockObject;
1396
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1397
+ }
1398
+ export class SliderGenericPropertyGridComponent extends React.Component<ISliderGenericPropertyGridComponentProps> {
1399
+ constructor(props: ISliderGenericPropertyGridComponentProps);
1400
+ render(): JSX.Element;
1401
+ }
1402
+ }
1403
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/linePropertyGridComponent" {
1404
+ import * as React from "react";
1405
+ import { Observable } from "@babylonjs/core/Misc/observable";
1406
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1407
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1408
+ import { Line } from "@babylonjs/gui/2D/controls/line";
1409
+ interface ILinePropertyGridComponentProps {
1410
+ line: Line;
1411
+ lockObject: LockObject;
1412
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1413
+ }
1414
+ export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
1415
+ constructor(props: ILinePropertyGridComponentProps);
1416
+ onDashChange(value: string): void;
1417
+ render(): JSX.Element;
1418
+ }
1419
+ }
1420
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/radioButtonPropertyGridComponent" {
1421
+ import * as React from "react";
1422
+ import { Observable } from "@babylonjs/core/Misc/observable";
1423
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1424
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1425
+ import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
1426
+ interface IRadioButtonPropertyGridComponentProps {
1427
+ radioButton: RadioButton;
1428
+ lockObject: LockObject;
1429
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1430
+ }
1431
+ export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
1432
+ constructor(props: IRadioButtonPropertyGridComponentProps);
1433
+ render(): JSX.Element;
1434
+ }
1435
+ }
1436
+ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/optionsLineComponent" {
1437
+ import * as React from "react";
1438
+ import { Observable } from "@babylonjs/core/Misc/observable";
1439
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1440
+ import { IInspectableOptions } from "@babylonjs/core/Misc/iInspectable";
1441
+ export const Null_Value: number;
1442
+ export interface IOptionsLineComponentProps {
1443
+ label: string;
1444
+ target: any;
1445
+ propertyName: string;
1446
+ options: IInspectableOptions[];
1447
+ noDirectUpdate?: boolean;
1448
+ onSelect?: (value: number) => void;
1449
+ extractValue?: () => number;
1450
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1451
+ allowNullValue?: boolean;
1452
+ icon?: string;
1453
+ iconLabel?: string;
1454
+ }
1455
+ export class OptionsLineComponent extends React.Component<IOptionsLineComponentProps, {
1456
+ value: number;
1457
+ }> {
1458
+ private _localChange;
1459
+ private remapValueIn;
1460
+ private remapValueOut;
1461
+ constructor(props: IOptionsLineComponentProps);
1462
+ shouldComponentUpdate(nextProps: IOptionsLineComponentProps, nextState: {
1463
+ value: number;
1464
+ }): boolean;
1465
+ raiseOnPropertyChanged(newValue: number, previousValue: number): void;
1466
+ updateValue(valueString: string): void;
1467
+ render(): JSX.Element;
1468
+ }
1469
+ }
1470
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/textBlockPropertyGridComponent" {
1471
+ import * as React from "react";
1472
+ import { Observable } from "@babylonjs/core/Misc/observable";
1473
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1474
+ import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
1475
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1476
+ interface ITextBlockPropertyGridComponentProps {
1477
+ textBlock: TextBlock;
1478
+ lockObject: LockObject;
1479
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1480
+ }
1481
+ export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
1482
+ constructor(props: ITextBlockPropertyGridComponentProps);
1483
+ render(): JSX.Element;
1484
+ }
1485
+ }
1486
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/inputTextPropertyGridComponent" {
1487
+ import * as React from "react";
1488
+ import { Observable } from "@babylonjs/core/Misc/observable";
1489
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1490
+ import { InputText } from "@babylonjs/gui/2D/controls/inputText";
1491
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1492
+ interface IInputTextPropertyGridComponentProps {
1493
+ inputText: InputText;
1494
+ lockObject: LockObject;
1495
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1496
+ }
1497
+ export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
1498
+ constructor(props: IInputTextPropertyGridComponentProps);
1499
+ render(): JSX.Element;
1500
+ }
1501
+ }
1502
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/colorPickerPropertyGridComponent" {
722
1503
  import * as React from "react";
723
1504
  import { Observable } from "@babylonjs/core/Misc/observable";
724
1505
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -734,7 +1515,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
734
1515
  render(): JSX.Element;
735
1516
  }
736
1517
  }
737
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/imagePropertyGridComponent" {
1518
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/imagePropertyGridComponent" {
738
1519
  import * as React from "react";
739
1520
  import { Observable } from "@babylonjs/core/Misc/observable";
740
1521
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -750,7 +1531,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
750
1531
  render(): JSX.Element;
751
1532
  }
752
1533
  }
753
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
1534
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
754
1535
  import * as React from "react";
755
1536
  import { Observable } from "@babylonjs/core/Misc/observable";
756
1537
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -766,7 +1547,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
766
1547
  render(): JSX.Element;
767
1548
  }
768
1549
  }
769
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/rectanglePropertyGridComponent" {
1550
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/rectanglePropertyGridComponent" {
770
1551
  import * as React from "react";
771
1552
  import { Observable } from "@babylonjs/core/Misc/observable";
772
1553
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -782,7 +1563,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
782
1563
  render(): JSX.Element;
783
1564
  }
784
1565
  }
785
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" {
1566
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/stackPanelPropertyGridComponent" {
786
1567
  import * as React from "react";
787
1568
  import { Observable } from "@babylonjs/core/Misc/observable";
788
1569
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -798,7 +1579,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
798
1579
  render(): JSX.Element;
799
1580
  }
800
1581
  }
801
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/gridPropertyGridComponent" {
1582
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/gridPropertyGridComponent" {
802
1583
  import * as React from "react";
803
1584
  import { Observable } from "@babylonjs/core/Misc/observable";
804
1585
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -811,12 +1592,30 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
811
1592
  }
812
1593
  export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
813
1594
  constructor(props: IGridPropertyGridComponentProps);
1595
+ private _removingColumn;
1596
+ private _removingRow;
1597
+ private _previousGrid;
1598
+ private _rowDefinitions;
1599
+ private _rowEditFlags;
1600
+ private _columnEditFlags;
1601
+ private _columnDefinitions;
1602
+ private _editedRow;
1603
+ private _editedColumn;
1604
+ private _rowChild;
1605
+ private _columnChild;
814
1606
  renderRows(): JSX.Element[];
1607
+ setRowValues(): void;
1608
+ setColumnValues(): void;
815
1609
  renderColumns(): JSX.Element[];
1610
+ resizeRow(): void;
1611
+ resizeColumn(): void;
1612
+ checkValue(value: string, percent: boolean): string;
1613
+ checkPercentage(value: string): boolean;
1614
+ resetValues(): void;
816
1615
  render(): JSX.Element;
817
1616
  }
818
1617
  }
819
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/scrollViewerPropertyGridComponent" {
1618
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/scrollViewerPropertyGridComponent" {
820
1619
  import * as React from "react";
821
1620
  import { Observable } from "@babylonjs/core/Misc/observable";
822
1621
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -832,7 +1631,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
832
1631
  render(): JSX.Element;
833
1632
  }
834
1633
  }
835
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/ellipsePropertyGridComponent" {
1634
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/ellipsePropertyGridComponent" {
836
1635
  import * as React from "react";
837
1636
  import { Observable } from "@babylonjs/core/Misc/observable";
838
1637
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -848,7 +1647,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
848
1647
  render(): JSX.Element;
849
1648
  }
850
1649
  }
851
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/checkboxPropertyGridComponent" {
1650
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/checkboxPropertyGridComponent" {
852
1651
  import * as React from "react";
853
1652
  import { Observable } from "@babylonjs/core/Misc/observable";
854
1653
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -864,7 +1663,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
864
1663
  render(): JSX.Element;
865
1664
  }
866
1665
  }
867
- declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/controlPropertyGridComponent" {
1666
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/controlPropertyGridComponent" {
868
1667
  import * as React from "react";
869
1668
  import { Observable } from "@babylonjs/core/Misc/observable";
870
1669
  import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
@@ -880,31 +1679,109 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/
880
1679
  render(): JSX.Element;
881
1680
  }
882
1681
  }
1682
+ declare module "@babylonjs/gui-editor/components/parentingPropertyGridComponent" {
1683
+ import * as React from "react";
1684
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1685
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1686
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1687
+ import { Observable } from "@babylonjs/core/Misc/observable";
1688
+ interface IParentingPropertyGridComponentProps {
1689
+ control: Control;
1690
+ lockObject: LockObject;
1691
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1692
+ }
1693
+ export class ParentingPropertyGridComponent extends React.Component<IParentingPropertyGridComponentProps> {
1694
+ constructor(props: IParentingPropertyGridComponentProps);
1695
+ private _columnNumber;
1696
+ private _rowNumber;
1697
+ updateGridPosition(): void;
1698
+ getCellInfo(): void;
1699
+ private _changeCell;
1700
+ render(): JSX.Element;
1701
+ }
1702
+ }
1703
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/displayGridPropertyGridComponent" {
1704
+ import * as React from "react";
1705
+ import { Observable } from "@babylonjs/core/Misc/observable";
1706
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1707
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1708
+ import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
1709
+ interface IDisplayGridPropertyGridComponentProps {
1710
+ displayGrid: DisplayGrid;
1711
+ lockObject: LockObject;
1712
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1713
+ }
1714
+ export class DisplayGridPropertyGridComponent extends React.Component<IDisplayGridPropertyGridComponentProps> {
1715
+ constructor(props: IDisplayGridPropertyGridComponentProps);
1716
+ render(): JSX.Element;
1717
+ }
1718
+ }
1719
+ declare module "@babylonjs/gui-editor/components/propertyTab/propertyGrids/gui/buttonPropertyGridComponent" {
1720
+ import * as React from "react";
1721
+ import { Observable } from "@babylonjs/core/Misc/observable";
1722
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
1723
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
1724
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
1725
+ interface IButtonPropertyGridComponentProps {
1726
+ rectangle: Rectangle;
1727
+ lockObject: LockObject;
1728
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1729
+ onAddComponent: (newComponent: string) => void;
1730
+ }
1731
+ export class ButtonPropertyGridComponent extends React.Component<IButtonPropertyGridComponentProps> {
1732
+ constructor(props: IButtonPropertyGridComponentProps);
1733
+ render(): JSX.Element;
1734
+ }
1735
+ }
1736
+ declare module "@babylonjs/gui-editor/guiNodeTools" {
1737
+ import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
1738
+ import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
1739
+ import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
1740
+ import { Line } from "@babylonjs/gui/2D/controls/line";
1741
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
1742
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
1743
+ import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
1744
+ import { Image } from "@babylonjs/gui/2D/controls/image";
1745
+ import { InputText } from "@babylonjs/gui/2D/controls/inputText";
1746
+ import { Grid } from "@babylonjs/gui/2D/controls/grid";
1747
+ import { DisplayGrid } from "@babylonjs/gui/2D/controls/displayGrid";
1748
+ import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
1749
+ import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
1750
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
1751
+ export class GUINodeTools {
1752
+ static ImageControlDefaultUrl: string;
1753
+ static CreateControlFromString(data: string): Grid | Rectangle | Line | Image | TextBlock | Slider | ImageBasedSlider | RadioButton | InputText | ColorPicker | StackPanel | Ellipse | Checkbox | DisplayGrid;
1754
+ }
1755
+ }
883
1756
  declare module "@babylonjs/gui-editor/components/propertyTab/propertyTabComponent" {
884
1757
  import * as React from "react";
885
1758
  import { GlobalState } from "@babylonjs/gui-editor/globalState";
886
1759
  import { Nullable } from "@babylonjs/core/types";
887
- import { GUINode } from "@babylonjs/gui-editor/diagram/guiNode";
1760
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1761
+ import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
888
1762
  interface IPropertyTabComponentProps {
889
1763
  globalState: GlobalState;
890
1764
  }
891
1765
  interface IPropertyTabComponentState {
892
- currentNode: Nullable<GUINode>;
1766
+ currentNode: Nullable<Control>;
893
1767
  }
894
1768
  export class PropertyTabComponent extends React.Component<IPropertyTabComponentProps, IPropertyTabComponentState> {
895
1769
  private _onBuiltObserver;
896
1770
  private _timerIntervalId;
897
1771
  private _lockObject;
1772
+ private _sizeOption;
898
1773
  constructor(props: IPropertyTabComponentProps);
899
- timerRefresh(): void;
900
1774
  componentDidMount(): void;
901
1775
  componentWillUnmount(): void;
902
1776
  load(file: File): void;
903
- save(): void;
904
- saveToSnippetServer(): void;
1777
+ save(saveCallback: () => void): void;
1778
+ saveLocally: () => void;
1779
+ saveToSnippetServerHelper: (content: string, adt: AdvancedDynamicTexture) => Promise<string>;
1780
+ saveToSnippetServer: () => Promise<void>;
905
1781
  loadFromSnippet(): void;
906
1782
  renderProperties(): JSX.Element | null;
907
- render(): JSX.Element;
1783
+ renderControlIcon(): string;
1784
+ render(): JSX.Element | null;
908
1785
  }
909
1786
  }
910
1787
  declare module "@babylonjs/gui-editor/portal" {
@@ -917,51 +1794,6 @@ declare module "@babylonjs/gui-editor/portal" {
917
1794
  render(): React.ReactPortal;
918
1795
  }
919
1796
  }
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
1797
  declare module "@babylonjs/gui-editor/sharedComponents/messageDialog" {
966
1798
  import * as React from "react";
967
1799
  import { GlobalState } from "@babylonjs/gui-editor/globalState";
@@ -976,45 +1808,272 @@ declare module "@babylonjs/gui-editor/sharedComponents/messageDialog" {
976
1808
  render(): JSX.Element | null;
977
1809
  }
978
1810
  }
979
- declare module "@babylonjs/gui-editor/workbenchEditor" {
1811
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemLabelComponent" {
980
1812
  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;
1813
+ interface ITreeItemLabelComponentProps {
1814
+ label: string;
1815
+ onClick?: () => void;
1816
+ color: string;
987
1817
  }
988
- interface IGraphEditorState {
989
- showPreviewPopUp: boolean;
1818
+ export class TreeItemLabelComponent extends React.Component<ITreeItemLabelComponentProps> {
1819
+ constructor(props: ITreeItemLabelComponentProps);
1820
+ onClick(): void;
1821
+ render(): JSX.Element;
990
1822
  }
991
- export class WorkbenchEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
992
- private _workbenchCanvas;
1823
+ }
1824
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/extensionsComponent" {
1825
+ import * as React from "react";
1826
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1827
+ interface IExtensionsComponentProps {
1828
+ target: any;
1829
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1830
+ }
1831
+ export class ExtensionsComponent extends React.Component<IExtensionsComponentProps, {
1832
+ popupVisible: boolean;
1833
+ }> {
1834
+ private _popup;
1835
+ private extensionRef;
1836
+ constructor(props: IExtensionsComponentProps);
1837
+ showPopup(): void;
1838
+ componentDidMount(): void;
1839
+ componentDidUpdate(): void;
1840
+ render(): JSX.Element | null;
1841
+ }
1842
+ }
1843
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/entities/gui/controlTreeItemComponent" {
1844
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1845
+ import { Control } from "@babylonjs/gui/2D/controls/control";
1846
+ import * as React from "react";
1847
+ import { DragOverLocation, GlobalState } from "@babylonjs/gui-editor/globalState";
1848
+ interface IControlTreeItemComponentProps {
1849
+ control: Control;
1850
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1851
+ onClick: () => void;
1852
+ globalState: GlobalState;
1853
+ isHovered: boolean;
1854
+ dragOverHover: boolean;
1855
+ dragOverLocation: DragOverLocation;
1856
+ }
1857
+ export class ControlTreeItemComponent extends React.Component<IControlTreeItemComponentProps, {
1858
+ isActive: boolean;
1859
+ isVisible: boolean;
1860
+ }> {
1861
+ constructor(props: IControlTreeItemComponentProps);
1862
+ highlight(): void;
1863
+ switchVisibility(): void;
1864
+ render(): JSX.Element;
1865
+ }
1866
+ }
1867
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemSelectableComponent" {
1868
+ import { Nullable } from "@babylonjs/core/types";
1869
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1870
+ import * as React from "react";
1871
+ import { DragOverLocation, GlobalState } from "@babylonjs/gui-editor/globalState";
1872
+ export interface ITreeItemSelectableComponentProps {
1873
+ entity: any;
1874
+ selectedEntity?: any;
1875
+ mustExpand?: boolean;
1876
+ offset: number;
1877
+ globalState: GlobalState;
1878
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1879
+ filter: Nullable<string>;
1880
+ }
1881
+ export class TreeItemSelectableComponent extends React.Component<ITreeItemSelectableComponentProps, {
1882
+ isSelected: boolean;
1883
+ isHovered: boolean;
1884
+ dragOverLocation: DragOverLocation;
1885
+ }> {
1886
+ dragOverHover: boolean;
1887
+ private _onSelectionChangedObservable;
1888
+ private _onDraggingEndObservable;
1889
+ private _onDraggingStartObservable;
1890
+ constructor(props: ITreeItemSelectableComponentProps);
1891
+ switchExpandedState(): void;
1892
+ shouldComponentUpdate(nextProps: ITreeItemSelectableComponentProps, nextState: {
1893
+ isSelected: boolean;
1894
+ }): boolean;
1895
+ scrollIntoView(): void;
1896
+ componentWillUnmount(): void;
1897
+ onSelect(): void;
1898
+ renderChildren(isExpanded: boolean): (JSX.Element | null)[] | null;
1899
+ render(): JSX.Element | null;
1900
+ dragOver(event: React.DragEvent<HTMLDivElement>): void;
1901
+ drop(): void;
1902
+ }
1903
+ }
1904
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/treeItemComponent" {
1905
+ import * as React from "react";
1906
+ import { Nullable } from "@babylonjs/core/types";
1907
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1908
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1909
+ export interface ITreeItemComponentProps {
1910
+ items?: Nullable<any[]>;
1911
+ label: string;
1912
+ offset: number;
1913
+ filter: Nullable<string>;
1914
+ forceSubitems?: boolean;
1915
+ globalState: GlobalState;
1916
+ entity?: any;
1917
+ selectedEntity: any;
1918
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1919
+ contextMenuItems?: {
1920
+ label: string;
1921
+ action: () => void;
1922
+ }[];
1923
+ }
1924
+ export class TreeItemComponent extends React.Component<ITreeItemComponentProps, {
1925
+ isExpanded: boolean;
1926
+ mustExpand: boolean;
1927
+ }> {
1928
+ static _ContextMenuUniqueIdGenerator: number;
1929
+ constructor(props: ITreeItemComponentProps);
1930
+ switchExpandedState(): void;
1931
+ shouldComponentUpdate(nextProps: ITreeItemComponentProps, nextState: {
1932
+ isExpanded: boolean;
1933
+ }): boolean;
1934
+ expandAll(expand: boolean): void;
1935
+ renderContextMenu(): JSX.Element | null;
1936
+ render(): JSX.Element;
1937
+ }
1938
+ }
1939
+ declare module "@babylonjs/gui-editor/components/sceneExplorer/sceneExplorerComponent" {
1940
+ import * as React from "react";
1941
+ import { Nullable } from "@babylonjs/core/types";
1942
+ import { IExplorerExtensibilityGroup } from "@babylonjs/core/Debug/debugLayer";
1943
+ import { Scene } from "@babylonjs/core/scene";
1944
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1945
+ interface ISceneExplorerFilterComponentProps {
1946
+ onFilter: (filter: string) => void;
1947
+ }
1948
+ export class SceneExplorerFilterComponent extends React.Component<ISceneExplorerFilterComponentProps> {
1949
+ constructor(props: ISceneExplorerFilterComponentProps);
1950
+ render(): JSX.Element;
1951
+ }
1952
+ interface ISceneExplorerComponentProps {
1953
+ scene?: Scene;
1954
+ noCommands?: boolean;
1955
+ noHeader?: boolean;
1956
+ noExpand?: boolean;
1957
+ noClose?: boolean;
1958
+ extensibilityGroups?: IExplorerExtensibilityGroup[];
1959
+ globalState: GlobalState;
1960
+ popupMode?: boolean;
1961
+ onPopup?: () => void;
1962
+ onClose?: () => void;
1963
+ }
1964
+ export class SceneExplorerComponent extends React.Component<ISceneExplorerComponentProps, {
1965
+ filter: Nullable<string>;
1966
+ selectedEntity: any;
1967
+ scene: Nullable<Scene>;
1968
+ }> {
1969
+ private _onSelectionChangeObserver;
1970
+ private _onParrentingChangeObserver;
1971
+ private _onNewSceneObserver;
1972
+ private _onPropertyChangedObservable;
1973
+ constructor(props: ISceneExplorerComponentProps);
1974
+ componentDidMount(): void;
1975
+ componentWillUnmount(): void;
1976
+ filterContent(filter: string): void;
1977
+ findSiblings(parent: any, items: any[], target: any, goNext: boolean, data: {
1978
+ previousOne?: any;
1979
+ found?: boolean;
1980
+ }): boolean;
1981
+ processKeys(keyEvent: React.KeyboardEvent<HTMLDivElement>): void;
1982
+ renderContent(): JSX.Element | null;
1983
+ onClose(): void;
1984
+ onPopup(): void;
1985
+ render(): JSX.Element;
1986
+ }
1987
+ }
1988
+ declare module "@babylonjs/gui-editor/components/commandDropdownComponent" {
1989
+ import * as React from "react";
1990
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
1991
+ interface ICommandDropdownComponentProps {
1992
+ globalState: GlobalState;
1993
+ icon?: string;
1994
+ tooltip: string;
1995
+ defaultValue?: string;
1996
+ items: {
1997
+ label: string;
1998
+ icon?: string;
1999
+ fileButton?: boolean;
2000
+ onClick?: () => void;
2001
+ onCheck?: (value: boolean) => void;
2002
+ storeKey?: string;
2003
+ isActive?: boolean;
2004
+ defaultValue?: boolean | string;
2005
+ subItems?: string[];
2006
+ }[];
2007
+ toRight?: boolean;
2008
+ }
2009
+ export class CommandDropdownComponent extends React.Component<ICommandDropdownComponentProps, {
2010
+ isExpanded: boolean;
2011
+ activeState: string;
2012
+ }> {
2013
+ constructor(props: ICommandDropdownComponentProps);
2014
+ render(): JSX.Element;
2015
+ }
2016
+ }
2017
+ declare module "@babylonjs/gui-editor/components/commandBarComponent" {
2018
+ import * as React from "react";
2019
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
2020
+ interface ICommandBarComponentProps {
2021
+ globalState: GlobalState;
2022
+ }
2023
+ export class CommandBarComponent extends React.Component<ICommandBarComponentProps> {
2024
+ private _panning;
2025
+ private _zooming;
2026
+ private _selecting;
2027
+ private _outlines;
2028
+ constructor(props: ICommandBarComponentProps);
2029
+ private updateNodeOutline;
2030
+ render(): JSX.Element;
2031
+ }
2032
+ }
2033
+ declare module "@babylonjs/gui-editor/workbenchEditor" {
2034
+ import * as React from "react";
2035
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
2036
+ interface IGraphEditorProps {
2037
+ globalState: GlobalState;
2038
+ }
2039
+ interface IGraphEditorState {
2040
+ showPreviewPopUp: boolean;
2041
+ }
2042
+ export class WorkbenchEditor extends React.Component<IGraphEditorProps, IGraphEditorState> {
993
2043
  private _startX;
994
2044
  private _moveInProgress;
995
2045
  private _leftWidth;
996
2046
  private _rightWidth;
997
- private _onWidgetKeyUpPointer;
2047
+ private _toolBarIconSize;
998
2048
  private _popUpWindow;
2049
+ private _draggedItem;
999
2050
  componentDidMount(): void;
1000
- componentWillUnmount(): void;
1001
2051
  constructor(props: IGraphEditorProps);
1002
- pasteSelection(copiedNodes: GUINode[], currentX: number, currentY: number, selectNew?: boolean): GUINode[];
1003
- zoomToFit(): void;
1004
2052
  showWaitScreen(): void;
1005
2053
  hideWaitScreen(): void;
1006
- reOrganize(editorData?: Nullable<IEditorData>, isImportingAFrame?: boolean): void;
1007
2054
  onPointerDown(evt: React.PointerEvent<HTMLDivElement>): void;
1008
2055
  onPointerUp(evt: React.PointerEvent<HTMLDivElement>): void;
1009
2056
  resizeColumns(evt: React.PointerEvent<HTMLDivElement>, forLeft?: boolean): void;
1010
2057
  buildColumnLayout(): string;
1011
- emitNewBlock(event: React.DragEvent<HTMLDivElement>): void;
1012
2058
  handlePopUp: () => void;
1013
2059
  handleClosingPopUp: () => void;
1014
2060
  createPopupWindow: (title: string, windowVariableName: string, width?: number, height?: number) => Window | null;
1015
2061
  copyStyles: (sourceDoc: HTMLDocument, targetDoc: HTMLDocument) => void;
1016
- fixPopUpStyles: (document: Document) => void;
1017
2062
  render(): JSX.Element;
2063
+ _items: {
2064
+ label: string;
2065
+ icon?: string;
2066
+ fileButton?: boolean;
2067
+ onClick?: () => void;
2068
+ onCheck?: (value: boolean) => void;
2069
+ storeKey?: string;
2070
+ isActive?: boolean;
2071
+ defaultValue?: boolean | string;
2072
+ subItems?: string[];
2073
+ }[];
2074
+ createItems(): void;
2075
+ onCreate(value: string): void;
2076
+ createToolbar(): JSX.Element;
1018
2077
  }
1019
2078
  }
1020
2079
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/popup" {
@@ -1025,14 +2084,20 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/popup" {
1025
2084
  }
1026
2085
  declare module "@babylonjs/gui-editor/guiEditor" {
1027
2086
  import { Observable } from "@babylonjs/core/Misc/observable";
2087
+ import { AdvancedDynamicTexture } from "@babylonjs/gui/2D/advancedDynamicTexture";
1028
2088
  /**
1029
2089
  * Interface used to specify creation options for the gui editor
1030
2090
  */
1031
2091
  export interface IGUIEditorOptions {
2092
+ liveGuiTexture?: AdvancedDynamicTexture;
2093
+ customLoad: {
2094
+ label: string;
2095
+ action: (data: string) => Promise<string>;
2096
+ } | undefined;
1032
2097
  hostElement?: HTMLElement;
1033
2098
  customSave?: {
1034
2099
  label: string;
1035
- action: (data: string) => Promise<void>;
2100
+ action: (data: string) => Promise<string>;
1036
2101
  };
1037
2102
  currentSnippetToken?: string;
1038
2103
  customLoadObservable?: Observable<any>;
@@ -1046,12 +2111,94 @@ declare module "@babylonjs/gui-editor/guiEditor" {
1046
2111
  * Show the gui editor
1047
2112
  * @param options defines the options to use to configure the gui editor
1048
2113
  */
1049
- static Show(options: IGUIEditorOptions): void;
2114
+ static Show(options: IGUIEditorOptions): Promise<void>;
1050
2115
  }
1051
2116
  }
1052
2117
  declare module "@babylonjs/gui-editor/index" {
1053
2118
  export * from "@babylonjs/gui-editor/guiEditor";
1054
2119
  }
2120
+ declare module "@babylonjs/gui-editor/nodeLocationInfo" {
2121
+ export interface INodeLocationInfo {
2122
+ blockId: number;
2123
+ x: number;
2124
+ y: number;
2125
+ }
2126
+ export interface IFrameData {
2127
+ x: number;
2128
+ y: number;
2129
+ width: number;
2130
+ height: number;
2131
+ color: number[];
2132
+ name: string;
2133
+ isCollapsed: boolean;
2134
+ blocks: number[];
2135
+ comments: string;
2136
+ }
2137
+ export interface IEditorData {
2138
+ locations: INodeLocationInfo[];
2139
+ x: number;
2140
+ y: number;
2141
+ zoom: number;
2142
+ frames?: IFrameData[];
2143
+ map?: {
2144
+ [key: number]: number;
2145
+ };
2146
+ }
2147
+ }
2148
+ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/iSelectedLineContainer" {
2149
+ export interface ISelectedLineContainer {
2150
+ selectedLineContainerTitles: Array<string>;
2151
+ selectedLineContainerTitlesNoFocus: Array<string>;
2152
+ }
2153
+ }
2154
+ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/lineContainerComponent" {
2155
+ import * as React from "react";
2156
+ import { ISelectedLineContainer } from "@babylonjs/gui-editor/sharedUiComponents/lines/iSelectedLineContainer";
2157
+ interface ILineContainerComponentProps {
2158
+ selection?: ISelectedLineContainer;
2159
+ title: string;
2160
+ children: any[] | any;
2161
+ closed?: boolean;
2162
+ }
2163
+ export class LineContainerComponent extends React.Component<ILineContainerComponentProps, {
2164
+ isExpanded: boolean;
2165
+ isHighlighted: boolean;
2166
+ }> {
2167
+ constructor(props: ILineContainerComponentProps);
2168
+ switchExpandedState(): void;
2169
+ renderHeader(): JSX.Element;
2170
+ componentDidMount(): void;
2171
+ render(): JSX.Element;
2172
+ }
2173
+ }
2174
+ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/draggableLineComponent" {
2175
+ import * as React from "react";
2176
+ export interface IButtonLineComponentProps {
2177
+ data: string;
2178
+ tooltip: string;
2179
+ }
2180
+ export class DraggableLineComponent extends React.Component<IButtonLineComponentProps> {
2181
+ constructor(props: IButtonLineComponentProps);
2182
+ render(): JSX.Element;
2183
+ }
2184
+ }
2185
+ declare module "@babylonjs/gui-editor/components/guiList/guiListComponent" {
2186
+ import * as React from "react";
2187
+ import { GlobalState } from "@babylonjs/gui-editor/globalState";
2188
+ interface IGuiListComponentProps {
2189
+ globalState: GlobalState;
2190
+ }
2191
+ export class GuiListComponent extends React.Component<IGuiListComponentProps, {
2192
+ filter: string;
2193
+ }> {
2194
+ private _onResetRequiredObserver;
2195
+ private static _Tooltips;
2196
+ constructor(props: IGuiListComponentProps);
2197
+ componentWillUnmount(): void;
2198
+ filterContent(filter: string): void;
2199
+ render(): JSX.Element;
2200
+ }
2201
+ }
1055
2202
  declare module "@babylonjs/gui-editor/legacy/legacy" {
1056
2203
  export * from "@babylonjs/gui-editor/index";
1057
2204
  }
@@ -1214,6 +2361,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/booleanLineCompon
1214
2361
  export interface IBooleanLineComponentProps {
1215
2362
  label: string;
1216
2363
  value: boolean;
2364
+ icon?: string;
2365
+ iconLabel?: string;
1217
2366
  }
1218
2367
  export class BooleanLineComponent extends React.Component<IBooleanLineComponentProps> {
1219
2368
  constructor(props: IBooleanLineComponentProps);
@@ -1232,6 +2381,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/color4LineCompone
1232
2381
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1233
2382
  onChange?: () => void;
1234
2383
  isLinear?: boolean;
2384
+ icon?: string;
2385
+ iconLabel?: string;
1235
2386
  }
1236
2387
  export class Color4LineComponent extends React.Component<IColor4LineComponentProps, {
1237
2388
  isExpanded: boolean;
@@ -1260,6 +2411,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/fileMultipleButto
1260
2411
  label: string;
1261
2412
  onClick: (event: any) => void;
1262
2413
  accept: string;
2414
+ icon?: string;
2415
+ iconLabel?: string;
1263
2416
  }
1264
2417
  export class FileMultipleButtonLineComponent extends React.Component<IFileMultipleButtonLineComponentProps> {
1265
2418
  private static _IDGenerator;
@@ -1289,6 +2442,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/hexLineComponent"
1289
2442
  digits?: number;
1290
2443
  useEuler?: boolean;
1291
2444
  min?: number;
2445
+ icon?: string;
2446
+ iconLabel?: string;
1292
2447
  }
1293
2448
  export class HexLineComponent extends React.Component<IHexLineComponentProps, {
1294
2449
  value: string;
@@ -1310,7 +2465,7 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/hexLineComponent"
1310
2465
  }
1311
2466
  }
1312
2467
  declare module "@babylonjs/gui-editor/sharedUiComponents/lines/iconButtonLineComponent" {
1313
- import * as React from 'react';
2468
+ import * as React from "react";
1314
2469
  export interface IIconButtonLineComponentProps {
1315
2470
  icon: string;
1316
2471
  onClick: () => void;
@@ -1373,6 +2528,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/radioLineComponen
1373
2528
  label: string;
1374
2529
  isSelected: () => boolean;
1375
2530
  onSelect: () => void;
2531
+ icon?: string;
2532
+ iconLabel?: string;
1376
2533
  }
1377
2534
  export class RadioButtonLineComponent extends React.Component<IRadioButtonLineComponentProps, {
1378
2535
  isSelected: boolean;
@@ -1393,6 +2550,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/valueLineComponen
1393
2550
  color?: string;
1394
2551
  fractionDigits?: number;
1395
2552
  units?: string;
2553
+ icon?: string;
2554
+ iconLabel?: string;
1396
2555
  }
1397
2556
  export class ValueLineComponent extends React.Component<IValueLineComponentProps> {
1398
2557
  constructor(props: IValueLineComponentProps);
@@ -1411,6 +2570,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/vector2LineCompon
1411
2570
  step?: number;
1412
2571
  onChange?: (newvalue: Vector2) => void;
1413
2572
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2573
+ icon?: string;
2574
+ iconLabel?: string;
1414
2575
  }
1415
2576
  export class Vector2LineComponent extends React.Component<IVector2LineComponentProps, {
1416
2577
  isExpanded: boolean;
@@ -1446,6 +2607,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/vector3LineCompon
1446
2607
  useEuler?: boolean;
1447
2608
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
1448
2609
  noSlider?: boolean;
2610
+ icon?: string;
2611
+ iconLabel?: string;
1449
2612
  }
1450
2613
  export class Vector3LineComponent extends React.Component<IVector3LineComponentProps, {
1451
2614
  isExpanded: boolean;
@@ -1483,6 +2646,8 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/vector4LineCompon
1483
2646
  onChange?: (newvalue: Vector4) => void;
1484
2647
  useEuler?: boolean;
1485
2648
  onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2649
+ icon?: string;
2650
+ iconLabel?: string;
1486
2651
  }
1487
2652
  export class Vector4LineComponent extends React.Component<IVector4LineComponentProps, {
1488
2653
  isExpanded: boolean;
@@ -1508,6 +2673,266 @@ declare module "@babylonjs/gui-editor/sharedUiComponents/lines/vector4LineCompon
1508
2673
  render(): JSX.Element;
1509
2674
  }
1510
2675
  }
2676
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/commonControlPropertyGridComponent" {
2677
+ import * as React from "react";
2678
+ import { Observable } from "@babylonjs/core/Misc/observable";
2679
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2680
+ import { Control } from "@babylonjs/gui/2D/controls/control";
2681
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2682
+ interface ICommonControlPropertyGridComponentProps {
2683
+ control: Control;
2684
+ lockObject: LockObject;
2685
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2686
+ }
2687
+ export class CommonControlPropertyGridComponent extends React.Component<ICommonControlPropertyGridComponentProps> {
2688
+ constructor(props: ICommonControlPropertyGridComponentProps);
2689
+ renderGridInformation(): JSX.Element | null;
2690
+ render(): JSX.Element;
2691
+ }
2692
+ }
2693
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/checkboxPropertyGridComponent" {
2694
+ import * as React from "react";
2695
+ import { Observable } from "@babylonjs/core/Misc/observable";
2696
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2697
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2698
+ import { Checkbox } from "@babylonjs/gui/2D/controls/checkbox";
2699
+ interface ICheckboxPropertyGridComponentProps {
2700
+ checkbox: Checkbox;
2701
+ lockObject: LockObject;
2702
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2703
+ }
2704
+ export class CheckboxPropertyGridComponent extends React.Component<ICheckboxPropertyGridComponentProps> {
2705
+ constructor(props: ICheckboxPropertyGridComponentProps);
2706
+ render(): JSX.Element;
2707
+ }
2708
+ }
2709
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/colorPickerPropertyGridComponent" {
2710
+ import * as React from "react";
2711
+ import { Observable } from "@babylonjs/core/Misc/observable";
2712
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2713
+ import { ColorPicker } from "@babylonjs/gui/2D/controls/colorpicker";
2714
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2715
+ interface IColorPickerPropertyGridComponentProps {
2716
+ colorPicker: ColorPicker;
2717
+ lockObject: LockObject;
2718
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2719
+ }
2720
+ export class ColorPickerPropertyGridComponent extends React.Component<IColorPickerPropertyGridComponentProps> {
2721
+ constructor(props: IColorPickerPropertyGridComponentProps);
2722
+ render(): JSX.Element;
2723
+ }
2724
+ }
2725
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/controlPropertyGridComponent" {
2726
+ import * as React from "react";
2727
+ import { Observable } from "@babylonjs/core/Misc/observable";
2728
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2729
+ import { Control } from "@babylonjs/gui/2D/controls/control";
2730
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2731
+ interface IControlPropertyGridComponentProps {
2732
+ control: Control;
2733
+ lockObject: LockObject;
2734
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2735
+ }
2736
+ export class ControlPropertyGridComponent extends React.Component<IControlPropertyGridComponentProps> {
2737
+ constructor(props: IControlPropertyGridComponentProps);
2738
+ render(): JSX.Element;
2739
+ }
2740
+ }
2741
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/ellipsePropertyGridComponent" {
2742
+ import * as React from "react";
2743
+ import { Observable } from "@babylonjs/core/Misc/observable";
2744
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2745
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2746
+ import { Ellipse } from "@babylonjs/gui/2D/controls/ellipse";
2747
+ interface IEllipsePropertyGridComponentProps {
2748
+ ellipse: Ellipse;
2749
+ lockObject: LockObject;
2750
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2751
+ }
2752
+ export class EllipsePropertyGridComponent extends React.Component<IEllipsePropertyGridComponentProps> {
2753
+ constructor(props: IEllipsePropertyGridComponentProps);
2754
+ render(): JSX.Element;
2755
+ }
2756
+ }
2757
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/gridPropertyGridComponent" {
2758
+ import * as React from "react";
2759
+ import { Observable } from "@babylonjs/core/Misc/observable";
2760
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2761
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2762
+ import { Grid } from "@babylonjs/gui/2D/controls/grid";
2763
+ interface IGridPropertyGridComponentProps {
2764
+ grid: Grid;
2765
+ lockObject: LockObject;
2766
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2767
+ }
2768
+ export class GridPropertyGridComponent extends React.Component<IGridPropertyGridComponentProps> {
2769
+ constructor(props: IGridPropertyGridComponentProps);
2770
+ renderRows(): JSX.Element[];
2771
+ renderColumns(): JSX.Element[];
2772
+ render(): JSX.Element;
2773
+ }
2774
+ }
2775
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/imageBasedSliderPropertyGridComponent" {
2776
+ import * as React from "react";
2777
+ import { Observable } from "@babylonjs/core/Misc/observable";
2778
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2779
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2780
+ import { ImageBasedSlider } from "@babylonjs/gui/2D/controls/sliders/imageBasedSlider";
2781
+ interface IImageBasedSliderPropertyGridComponentProps {
2782
+ imageBasedSlider: ImageBasedSlider;
2783
+ lockObject: LockObject;
2784
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2785
+ }
2786
+ export class ImageBasedSliderPropertyGridComponent extends React.Component<IImageBasedSliderPropertyGridComponentProps> {
2787
+ constructor(props: IImageBasedSliderPropertyGridComponentProps);
2788
+ render(): JSX.Element;
2789
+ }
2790
+ }
2791
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/imagePropertyGridComponent" {
2792
+ import * as React from "react";
2793
+ import { Observable } from "@babylonjs/core/Misc/observable";
2794
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2795
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2796
+ import { Image } from "@babylonjs/gui/2D/controls/image";
2797
+ interface IImagePropertyGridComponentProps {
2798
+ image: Image;
2799
+ lockObject: LockObject;
2800
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2801
+ }
2802
+ export class ImagePropertyGridComponent extends React.Component<IImagePropertyGridComponentProps> {
2803
+ constructor(props: IImagePropertyGridComponentProps);
2804
+ render(): JSX.Element;
2805
+ }
2806
+ }
2807
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/inputTextPropertyGridComponent" {
2808
+ import * as React from "react";
2809
+ import { Observable } from "@babylonjs/core/Misc/observable";
2810
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2811
+ import { InputText } from "@babylonjs/gui/2D/controls/inputText";
2812
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2813
+ interface IInputTextPropertyGridComponentProps {
2814
+ inputText: InputText;
2815
+ lockObject: LockObject;
2816
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2817
+ }
2818
+ export class InputTextPropertyGridComponent extends React.Component<IInputTextPropertyGridComponentProps> {
2819
+ constructor(props: IInputTextPropertyGridComponentProps);
2820
+ render(): JSX.Element;
2821
+ }
2822
+ }
2823
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/linePropertyGridComponent" {
2824
+ import * as React from "react";
2825
+ import { Observable } from "@babylonjs/core/Misc/observable";
2826
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2827
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2828
+ import { Line } from "@babylonjs/gui/2D/controls/line";
2829
+ interface ILinePropertyGridComponentProps {
2830
+ line: Line;
2831
+ lockObject: LockObject;
2832
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2833
+ }
2834
+ export class LinePropertyGridComponent extends React.Component<ILinePropertyGridComponentProps> {
2835
+ constructor(props: ILinePropertyGridComponentProps);
2836
+ onDashChange(value: string): void;
2837
+ render(): JSX.Element;
2838
+ }
2839
+ }
2840
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/radioButtonPropertyGridComponent" {
2841
+ import * as React from "react";
2842
+ import { Observable } from "@babylonjs/core/Misc/observable";
2843
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2844
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2845
+ import { RadioButton } from "@babylonjs/gui/2D/controls/radioButton";
2846
+ interface IRadioButtonPropertyGridComponentProps {
2847
+ radioButton: RadioButton;
2848
+ lockObject: LockObject;
2849
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2850
+ }
2851
+ export class RadioButtonPropertyGridComponent extends React.Component<IRadioButtonPropertyGridComponentProps> {
2852
+ constructor(props: IRadioButtonPropertyGridComponentProps);
2853
+ render(): JSX.Element;
2854
+ }
2855
+ }
2856
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/rectanglePropertyGridComponent" {
2857
+ import * as React from "react";
2858
+ import { Observable } from "@babylonjs/core/Misc/observable";
2859
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2860
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2861
+ import { Rectangle } from "@babylonjs/gui/2D/controls/rectangle";
2862
+ interface IRectanglePropertyGridComponentProps {
2863
+ rectangle: Rectangle;
2864
+ lockObject: LockObject;
2865
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2866
+ }
2867
+ export class RectanglePropertyGridComponent extends React.Component<IRectanglePropertyGridComponentProps> {
2868
+ constructor(props: IRectanglePropertyGridComponentProps);
2869
+ render(): JSX.Element;
2870
+ }
2871
+ }
2872
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/scrollViewerPropertyGridComponent" {
2873
+ import * as React from "react";
2874
+ import { Observable } from "@babylonjs/core/Misc/observable";
2875
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2876
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2877
+ import { ScrollViewer } from "@babylonjs/gui/2D/controls/scrollViewers/scrollViewer";
2878
+ interface IScrollViewerPropertyGridComponentProps {
2879
+ scrollViewer: ScrollViewer;
2880
+ lockObject: LockObject;
2881
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2882
+ }
2883
+ export class ScrollViewerPropertyGridComponent extends React.Component<IScrollViewerPropertyGridComponentProps> {
2884
+ constructor(props: IScrollViewerPropertyGridComponentProps);
2885
+ render(): JSX.Element;
2886
+ }
2887
+ }
2888
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/sliderPropertyGridComponent" {
2889
+ import * as React from "react";
2890
+ import { Observable } from "@babylonjs/core/Misc/observable";
2891
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2892
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2893
+ import { Slider } from "@babylonjs/gui/2D/controls/sliders/slider";
2894
+ interface ISliderPropertyGridComponentProps {
2895
+ slider: Slider;
2896
+ lockObject: LockObject;
2897
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2898
+ }
2899
+ export class SliderPropertyGridComponent extends React.Component<ISliderPropertyGridComponentProps> {
2900
+ constructor(props: ISliderPropertyGridComponentProps);
2901
+ render(): JSX.Element;
2902
+ }
2903
+ }
2904
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/stackPanelPropertyGridComponent" {
2905
+ import * as React from "react";
2906
+ import { Observable } from "@babylonjs/core/Misc/observable";
2907
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2908
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2909
+ import { StackPanel } from "@babylonjs/gui/2D/controls/stackPanel";
2910
+ interface IStackPanelPropertyGridComponentProps {
2911
+ stackPanel: StackPanel;
2912
+ lockObject: LockObject;
2913
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2914
+ }
2915
+ export class StackPanelPropertyGridComponent extends React.Component<IStackPanelPropertyGridComponentProps> {
2916
+ constructor(props: IStackPanelPropertyGridComponentProps);
2917
+ render(): JSX.Element;
2918
+ }
2919
+ }
2920
+ declare module "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/gui/textBlockPropertyGridComponent" {
2921
+ import * as React from "react";
2922
+ import { Observable } from "@babylonjs/core/Misc/observable";
2923
+ import { PropertyChangedEvent } from "@babylonjs/gui-editor/sharedUiComponents/propertyChangedEvent";
2924
+ import { TextBlock } from "@babylonjs/gui/2D/controls/textBlock";
2925
+ import { LockObject } from "@babylonjs/gui-editor/sharedUiComponents/tabs/propertyGrids/lockObject";
2926
+ interface ITextBlockPropertyGridComponentProps {
2927
+ textBlock: TextBlock;
2928
+ lockObject: LockObject;
2929
+ onPropertyChangedObservable?: Observable<PropertyChangedEvent>;
2930
+ }
2931
+ export class TextBlockPropertyGridComponent extends React.Component<ITextBlockPropertyGridComponentProps> {
2932
+ constructor(props: ITextBlockPropertyGridComponentProps);
2933
+ render(): JSX.Element;
2934
+ }
2935
+ }
1511
2936
  declare module "@babylonjs/gui-editor" {
1512
2937
  export * from "@babylonjs/gui-editor/legacy/legacy";
1513
2938
  }