babylon.gui.d.ts 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735
  1. declare module BABYLON.GUI {
  2. interface IFocusableControl {
  3. onFocus(): void;
  4. onBlur(): void;
  5. processKeyboard(evt: KeyboardEvent): void;
  6. }
  7. class AdvancedDynamicTexture extends DynamicTexture {
  8. private _isDirty;
  9. private _renderObserver;
  10. private _resizeObserver;
  11. private _preKeyboardObserver;
  12. private _pointerMoveObserver;
  13. private _pointerObserver;
  14. private _canvasPointerOutObserver;
  15. private _background;
  16. _rootContainer: Container;
  17. _lastPickedControl: Control;
  18. _lastControlOver: Nullable<Control>;
  19. _lastControlDown: Nullable<Control>;
  20. _capturingControl: Nullable<Control>;
  21. _shouldBlockPointer: boolean;
  22. _layerToDispose: Nullable<Layer>;
  23. _linkedControls: Control[];
  24. private _isFullscreen;
  25. private _fullscreenViewport;
  26. private _idealWidth;
  27. private _idealHeight;
  28. private _renderAtIdealSize;
  29. private _focusedControl;
  30. private _blockNextFocusCheck;
  31. private _renderScale;
  32. renderScale: number;
  33. background: string;
  34. idealWidth: number;
  35. idealHeight: number;
  36. renderAtIdealSize: boolean;
  37. readonly layer: Nullable<Layer>;
  38. readonly rootContainer: Container;
  39. focusedControl: Nullable<IFocusableControl>;
  40. isForeground: boolean;
  41. constructor(name: string, width: number | undefined, height: number | undefined, scene: Nullable<Scene>, generateMipMaps?: boolean, samplingMode?: number);
  42. executeOnAllControls(func: (control: Control) => void, container?: Container): void;
  43. markAsDirty(): void;
  44. addControl(control: Control): AdvancedDynamicTexture;
  45. removeControl(control: Control): AdvancedDynamicTexture;
  46. dispose(): void;
  47. private _onResize();
  48. _getGlobalViewport(scene: Scene): Viewport;
  49. private _checkUpdate(camera);
  50. private _render();
  51. private _doPicking(x, y, type, buttonIndex);
  52. attach(): void;
  53. attachToMesh(mesh: AbstractMesh, supportPointerMove?: boolean): void;
  54. moveFocusToControl(control: IFocusableControl): void;
  55. private _manageFocus();
  56. private _attachToOnPointerOut(scene);
  57. static CreateForMesh(mesh: AbstractMesh, width?: number, height?: number, supportPointerMove?: boolean): AdvancedDynamicTexture;
  58. static CreateFullscreenUI(name: string, foreground?: boolean, scene?: Nullable<Scene>, sampling?: number): AdvancedDynamicTexture;
  59. }
  60. }
  61. declare module BABYLON.GUI {
  62. class Measure {
  63. left: number;
  64. top: number;
  65. width: number;
  66. height: number;
  67. constructor(left: number, top: number, width: number, height: number);
  68. copyFrom(other: Measure): void;
  69. isEqualsTo(other: Measure): boolean;
  70. static Empty(): Measure;
  71. }
  72. }
  73. declare module BABYLON.GUI {
  74. class Vector2WithInfo extends Vector2 {
  75. buttonIndex: number;
  76. constructor(source: Vector2, buttonIndex?: number);
  77. }
  78. class Matrix2D {
  79. m: Float32Array;
  80. constructor(m00: number, m01: number, m10: number, m11: number, m20: number, m21: number);
  81. fromValues(m00: number, m01: number, m10: number, m11: number, m20: number, m21: number): Matrix2D;
  82. determinant(): number;
  83. invertToRef(result: Matrix2D): Matrix2D;
  84. multiplyToRef(other: Matrix2D, result: Matrix2D): Matrix2D;
  85. transformCoordinates(x: number, y: number, result: Vector2): Matrix2D;
  86. static Identity(): Matrix2D;
  87. static TranslationToRef(x: number, y: number, result: Matrix2D): void;
  88. static ScalingToRef(x: number, y: number, result: Matrix2D): void;
  89. static RotationToRef(angle: number, result: Matrix2D): void;
  90. private static _TempPreTranslationMatrix;
  91. private static _TempPostTranslationMatrix;
  92. private static _TempRotationMatrix;
  93. private static _TempScalingMatrix;
  94. private static _TempCompose0;
  95. private static _TempCompose1;
  96. private static _TempCompose2;
  97. static ComposeToRef(tx: number, ty: number, angle: number, scaleX: number, scaleY: number, parentMatrix: Nullable<Matrix2D>, result: Matrix2D): void;
  98. }
  99. }
  100. declare module BABYLON.GUI {
  101. class ValueAndUnit {
  102. unit: number;
  103. negativeValueAllowed: boolean;
  104. private _value;
  105. ignoreAdaptiveScaling: boolean;
  106. constructor(value: number, unit?: number, negativeValueAllowed?: boolean);
  107. readonly isPercentage: boolean;
  108. readonly isPixel: boolean;
  109. readonly internalValue: number;
  110. getValueInPixel(host: AdvancedDynamicTexture, refValue: number): number;
  111. getValue(host: AdvancedDynamicTexture): number;
  112. toString(host: AdvancedDynamicTexture): string;
  113. fromString(source: string | number): boolean;
  114. private static _Regex;
  115. private static _UNITMODE_PERCENTAGE;
  116. private static _UNITMODE_PIXEL;
  117. static readonly UNITMODE_PERCENTAGE: number;
  118. static readonly UNITMODE_PIXEL: number;
  119. }
  120. }
  121. declare module BABYLON.GUI {
  122. class Control {
  123. name: string | undefined;
  124. private _alpha;
  125. private _alphaSet;
  126. private _zIndex;
  127. _root: Nullable<Container>;
  128. _host: AdvancedDynamicTexture;
  129. parent: Nullable<Container>;
  130. _currentMeasure: Measure;
  131. private _fontFamily;
  132. private _fontStyle;
  133. private _fontSize;
  134. private _font;
  135. _width: ValueAndUnit;
  136. _height: ValueAndUnit;
  137. protected _fontOffset: {
  138. ascent: number;
  139. height: number;
  140. descent: number;
  141. };
  142. private _color;
  143. protected _horizontalAlignment: number;
  144. protected _verticalAlignment: number;
  145. private _isDirty;
  146. protected _cachedParentMeasure: Measure;
  147. private _paddingLeft;
  148. private _paddingRight;
  149. private _paddingTop;
  150. private _paddingBottom;
  151. _left: ValueAndUnit;
  152. _top: ValueAndUnit;
  153. private _scaleX;
  154. private _scaleY;
  155. private _rotation;
  156. private _transformCenterX;
  157. private _transformCenterY;
  158. private _transformMatrix;
  159. protected _invertTransformMatrix: Matrix2D;
  160. protected _transformedPosition: Vector2;
  161. private _isMatrixDirty;
  162. private _cachedOffsetX;
  163. private _cachedOffsetY;
  164. private _isVisible;
  165. _linkedMesh: Nullable<AbstractMesh>;
  166. private _fontSet;
  167. private _dummyVector2;
  168. private _downCount;
  169. private _enterCount;
  170. private _doNotRender;
  171. isHitTestVisible: boolean;
  172. isPointerBlocker: boolean;
  173. isFocusInvisible: boolean;
  174. shadowOffsetX: number;
  175. shadowOffsetY: number;
  176. shadowBlur: number;
  177. shadowColor: string;
  178. protected _linkOffsetX: ValueAndUnit;
  179. protected _linkOffsetY: ValueAndUnit;
  180. readonly typeName: string;
  181. /**
  182. * An event triggered when the pointer move over the control.
  183. * @type {BABYLON.Observable}
  184. */
  185. onPointerMoveObservable: Observable<Vector2>;
  186. /**
  187. * An event triggered when the pointer move out of the control.
  188. * @type {BABYLON.Observable}
  189. */
  190. onPointerOutObservable: Observable<Control>;
  191. /**
  192. * An event triggered when the pointer taps the control
  193. * @type {BABYLON.Observable}
  194. */
  195. onPointerDownObservable: Observable<Vector2WithInfo>;
  196. /**
  197. * An event triggered when pointer up
  198. * @type {BABYLON.Observable}
  199. */
  200. onPointerUpObservable: Observable<Vector2WithInfo>;
  201. /**
  202. * An event triggered when pointer enters the control
  203. * @type {BABYLON.Observable}
  204. */
  205. onPointerEnterObservable: Observable<Control>;
  206. /**
  207. * An event triggered when the control is marked as dirty
  208. * @type {BABYLON.Observable}
  209. */
  210. onDirtyObservable: Observable<Control>;
  211. /**
  212. * An event triggered after the control is drawn
  213. * @type {BABYLON.Observable}
  214. */
  215. onAfterDrawObservable: Observable<Control>;
  216. alpha: number;
  217. scaleX: number;
  218. scaleY: number;
  219. rotation: number;
  220. transformCenterY: number;
  221. transformCenterX: number;
  222. horizontalAlignment: number;
  223. verticalAlignment: number;
  224. width: string | number;
  225. readonly widthInPixels: number;
  226. height: string | number;
  227. readonly heightInPixels: number;
  228. fontFamily: string;
  229. fontStyle: string;
  230. readonly fontSizeInPixels: number;
  231. fontSize: string | number;
  232. color: string;
  233. zIndex: number;
  234. notRenderable: boolean;
  235. isVisible: boolean;
  236. readonly isDirty: boolean;
  237. paddingLeft: string | number;
  238. readonly paddingLeftInPixels: number;
  239. paddingRight: string | number;
  240. readonly paddingRightInPixels: number;
  241. paddingTop: string | number;
  242. readonly paddingTopInPixels: number;
  243. paddingBottom: string | number;
  244. readonly paddingBottomInPixels: number;
  245. left: string | number;
  246. readonly leftInPixels: number;
  247. top: string | number;
  248. readonly topInPixels: number;
  249. linkOffsetX: string | number;
  250. readonly linkOffsetXInPixels: number;
  251. linkOffsetY: string | number;
  252. readonly linkOffsetYInPixels: number;
  253. readonly centerX: number;
  254. readonly centerY: number;
  255. constructor(name?: string | undefined);
  256. protected _getTypeName(): string;
  257. getLocalCoordinates(globalCoordinates: Vector2): Vector2;
  258. getLocalCoordinatesToRef(globalCoordinates: Vector2, result: Vector2): Control;
  259. getParentLocalCoordinates(globalCoordinates: Vector2): Vector2;
  260. moveToVector3(position: Vector3, scene: Scene): void;
  261. linkWithMesh(mesh: Nullable<AbstractMesh>): void;
  262. _moveToProjectedPosition(projectedPosition: Vector3): void;
  263. _markMatrixAsDirty(): void;
  264. _markAsDirty(): void;
  265. _markAllAsDirty(): void;
  266. _link(root: Nullable<Container>, host: AdvancedDynamicTexture): void;
  267. protected _transform(context: CanvasRenderingContext2D): void;
  268. protected _applyStates(context: CanvasRenderingContext2D): void;
  269. protected _processMeasures(parentMeasure: Measure, context: CanvasRenderingContext2D): boolean;
  270. protected _clip(context: CanvasRenderingContext2D): void;
  271. _measure(): void;
  272. protected _computeAlignment(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  273. protected _preMeasure(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  274. protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  275. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  276. contains(x: number, y: number): boolean;
  277. _processPicking(x: number, y: number, type: number, buttonIndex: number): boolean;
  278. _onPointerMove(target: Control, coordinates: Vector2): void;
  279. _onPointerEnter(target: Control): boolean;
  280. _onPointerOut(target: Control): void;
  281. _onPointerDown(target: Control, coordinates: Vector2, buttonIndex: number): boolean;
  282. _onPointerUp(target: Control, coordinates: Vector2, buttonIndex: number): void;
  283. forcePointerUp(): void;
  284. _processObservables(type: number, x: number, y: number, buttonIndex: number): boolean;
  285. private _prepareFont();
  286. dispose(): void;
  287. private static _HORIZONTAL_ALIGNMENT_LEFT;
  288. private static _HORIZONTAL_ALIGNMENT_RIGHT;
  289. private static _HORIZONTAL_ALIGNMENT_CENTER;
  290. private static _VERTICAL_ALIGNMENT_TOP;
  291. private static _VERTICAL_ALIGNMENT_BOTTOM;
  292. private static _VERTICAL_ALIGNMENT_CENTER;
  293. static readonly HORIZONTAL_ALIGNMENT_LEFT: number;
  294. static readonly HORIZONTAL_ALIGNMENT_RIGHT: number;
  295. static readonly HORIZONTAL_ALIGNMENT_CENTER: number;
  296. static readonly VERTICAL_ALIGNMENT_TOP: number;
  297. static readonly VERTICAL_ALIGNMENT_BOTTOM: number;
  298. static readonly VERTICAL_ALIGNMENT_CENTER: number;
  299. private static _FontHeightSizes;
  300. static _GetFontOffset(font: string): {
  301. ascent: number;
  302. height: number;
  303. descent: number;
  304. };
  305. static AddHeader(control: Control, text: string, size: string | number, options: {
  306. isHorizontal: boolean;
  307. controlFirst: boolean;
  308. }): StackPanel;
  309. protected static drawEllipse(x: number, y: number, width: number, height: number, context: CanvasRenderingContext2D): void;
  310. }
  311. }
  312. declare module BABYLON.GUI {
  313. class Container extends Control {
  314. name: string | undefined;
  315. protected _children: Control[];
  316. protected _measureForChildren: Measure;
  317. protected _background: string;
  318. background: string;
  319. readonly children: Control[];
  320. constructor(name?: string | undefined);
  321. protected _getTypeName(): string;
  322. getChildByName(name: string): Nullable<Control>;
  323. getChildByType(name: string, type: string): Nullable<Control>;
  324. containsControl(control: Control): boolean;
  325. addControl(control: Control): Container;
  326. removeControl(control: Control): Container;
  327. _reOrderControl(control: Control): void;
  328. _markMatrixAsDirty(): void;
  329. _markAllAsDirty(): void;
  330. protected _localDraw(context: CanvasRenderingContext2D): void;
  331. _link(root: Nullable<Container>, host: AdvancedDynamicTexture): void;
  332. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  333. _processPicking(x: number, y: number, type: number, buttonIndex: number): boolean;
  334. protected _clipForChildren(context: CanvasRenderingContext2D): void;
  335. protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  336. dispose(): void;
  337. }
  338. }
  339. declare module BABYLON.GUI {
  340. class StackPanel extends Container {
  341. name: string | undefined;
  342. private _isVertical;
  343. private _manualWidth;
  344. private _manualHeight;
  345. private _doNotTrackManualChanges;
  346. private _tempMeasureStore;
  347. isVertical: boolean;
  348. width: string | number;
  349. height: string | number;
  350. constructor(name?: string | undefined);
  351. protected _getTypeName(): string;
  352. protected _preMeasure(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  353. }
  354. }
  355. declare module BABYLON.GUI {
  356. class Rectangle extends Container {
  357. name: string | undefined;
  358. private _thickness;
  359. private _cornerRadius;
  360. thickness: number;
  361. cornerRadius: number;
  362. constructor(name?: string | undefined);
  363. protected _getTypeName(): string;
  364. protected _localDraw(context: CanvasRenderingContext2D): void;
  365. protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  366. private _drawRoundedRect(context, offset?);
  367. protected _clipForChildren(context: CanvasRenderingContext2D): void;
  368. }
  369. }
  370. declare module BABYLON.GUI {
  371. class Ellipse extends Container {
  372. name: string | undefined;
  373. private _thickness;
  374. thickness: number;
  375. constructor(name?: string | undefined);
  376. protected _getTypeName(): string;
  377. protected _localDraw(context: CanvasRenderingContext2D): void;
  378. protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  379. protected _clipForChildren(context: CanvasRenderingContext2D): void;
  380. }
  381. }
  382. declare module BABYLON.GUI {
  383. class Line extends Control {
  384. name: string | undefined;
  385. private _lineWidth;
  386. private _x1;
  387. private _y1;
  388. private _x2;
  389. private _y2;
  390. private _dash;
  391. private _connectedControl;
  392. private _connectedControlDirtyObserver;
  393. dash: Array<number>;
  394. connectedControl: Control;
  395. x1: string | number;
  396. y1: string | number;
  397. x2: string | number;
  398. y2: string | number;
  399. lineWidth: number;
  400. horizontalAlignment: number;
  401. verticalAlignment: number;
  402. private readonly _effectiveX2;
  403. private readonly _effectiveY2;
  404. constructor(name?: string | undefined);
  405. protected _getTypeName(): string;
  406. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  407. _measure(): void;
  408. protected _computeAlignment(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  409. _moveToProjectedPosition(projectedPosition: Vector3): void;
  410. }
  411. }
  412. declare module BABYLON.GUI {
  413. class Slider extends Control {
  414. name: string | undefined;
  415. private _thumbWidth;
  416. private _minimum;
  417. private _maximum;
  418. private _value;
  419. private _background;
  420. private _borderColor;
  421. private _barOffset;
  422. private _isThumbCircle;
  423. onValueChangedObservable: Observable<number>;
  424. borderColor: string;
  425. background: string;
  426. barOffset: string | number;
  427. readonly barOffsetInPixels: number;
  428. thumbWidth: string | number;
  429. readonly thumbWidthInPixels: number;
  430. minimum: number;
  431. maximum: number;
  432. value: number;
  433. isThumbCircle: boolean;
  434. constructor(name?: string | undefined);
  435. protected _getTypeName(): string;
  436. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  437. private _pointerIsDown;
  438. private _updateValueFromPointer(x, y);
  439. _onPointerDown(target: Control, coordinates: Vector2, buttonIndex: number): boolean;
  440. _onPointerMove(target: Control, coordinates: Vector2): void;
  441. _onPointerUp(target: Control, coordinates: Vector2, buttonIndex: number): void;
  442. }
  443. }
  444. declare module BABYLON.GUI {
  445. class Checkbox extends Control {
  446. name: string | undefined;
  447. private _isChecked;
  448. private _background;
  449. private _checkSizeRatio;
  450. private _thickness;
  451. thickness: number;
  452. onIsCheckedChangedObservable: Observable<boolean>;
  453. checkSizeRatio: number;
  454. background: string;
  455. isChecked: boolean;
  456. constructor(name?: string | undefined);
  457. protected _getTypeName(): string;
  458. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  459. _onPointerDown(target: Control, coordinates: Vector2, buttonIndex: number): boolean;
  460. }
  461. }
  462. declare module BABYLON.GUI {
  463. class RadioButton extends Control {
  464. name: string | undefined;
  465. private _isChecked;
  466. private _background;
  467. private _checkSizeRatio;
  468. private _thickness;
  469. thickness: number;
  470. group: string;
  471. onIsCheckedChangedObservable: Observable<boolean>;
  472. checkSizeRatio: number;
  473. background: string;
  474. isChecked: boolean;
  475. constructor(name?: string | undefined);
  476. protected _getTypeName(): string;
  477. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  478. _onPointerDown(target: Control, coordinates: Vector2, buttonIndex: number): boolean;
  479. }
  480. }
  481. declare module BABYLON.GUI {
  482. class TextBlock extends Control {
  483. name: string | undefined;
  484. private _text;
  485. private _textWrapping;
  486. private _textHorizontalAlignment;
  487. private _textVerticalAlignment;
  488. private _lines;
  489. private _resizeToFit;
  490. private _lineSpacing;
  491. /**
  492. * An event triggered after the text is changed
  493. * @type {BABYLON.Observable}
  494. */
  495. onTextChangedObservable: Observable<TextBlock>;
  496. resizeToFit: boolean;
  497. textWrapping: boolean;
  498. text: string;
  499. textHorizontalAlignment: number;
  500. textVerticalAlignment: number;
  501. lineSpacing: string | number;
  502. constructor(name?: string | undefined, text?: string);
  503. protected _getTypeName(): string;
  504. private _drawText(text, textWidth, y, context);
  505. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  506. protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  507. protected _parseLine(line: string | undefined, context: CanvasRenderingContext2D): object;
  508. protected _parseLineWithTextWrapping(line: string | undefined, context: CanvasRenderingContext2D): object;
  509. protected _renderLines(context: CanvasRenderingContext2D): void;
  510. dispose(): void;
  511. }
  512. }
  513. declare var DOMImage: new (width?: number | undefined, height?: number | undefined) => HTMLImageElement;
  514. declare module BABYLON.GUI {
  515. class Image extends Control {
  516. name: string | undefined;
  517. private _domImage;
  518. private _imageWidth;
  519. private _imageHeight;
  520. private _loaded;
  521. private _stretch;
  522. private _source;
  523. private _autoScale;
  524. private _sourceLeft;
  525. private _sourceTop;
  526. private _sourceWidth;
  527. private _sourceHeight;
  528. private _cellWidth;
  529. private _cellHeight;
  530. private _cellId;
  531. sourceLeft: number;
  532. sourceTop: number;
  533. sourceWidth: number;
  534. sourceHeight: number;
  535. autoScale: boolean;
  536. stretch: number;
  537. domImage: HTMLImageElement;
  538. private _onImageLoaded();
  539. source: Nullable<string>;
  540. cellWidth: number;
  541. cellHeight: number;
  542. cellId: number;
  543. constructor(name?: string | undefined, url?: Nullable<string>);
  544. protected _getTypeName(): string;
  545. synchronizeSizeWithContent(): void;
  546. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  547. private static _STRETCH_NONE;
  548. private static _STRETCH_FILL;
  549. private static _STRETCH_UNIFORM;
  550. private static _STRETCH_EXTEND;
  551. static readonly STRETCH_NONE: number;
  552. static readonly STRETCH_FILL: number;
  553. static readonly STRETCH_UNIFORM: number;
  554. static readonly STRETCH_EXTEND: number;
  555. }
  556. }
  557. declare module BABYLON.GUI {
  558. class Button extends Rectangle {
  559. name: string | undefined;
  560. pointerEnterAnimation: () => void;
  561. pointerOutAnimation: () => void;
  562. pointerDownAnimation: () => void;
  563. pointerUpAnimation: () => void;
  564. constructor(name?: string | undefined);
  565. protected _getTypeName(): string;
  566. _processPicking(x: number, y: number, type: number, buttonIndex: number): boolean;
  567. _onPointerEnter(target: Control): boolean;
  568. _onPointerOut(target: Control): void;
  569. _onPointerDown(target: Control, coordinates: Vector2, buttonIndex: number): boolean;
  570. _onPointerUp(target: Control, coordinates: Vector2, buttonIndex: number): void;
  571. static CreateImageButton(name: string, text: string, imageUrl: string): Button;
  572. static CreateImageOnlyButton(name: string, imageUrl: string): Button;
  573. static CreateSimpleButton(name: string, text: string): Button;
  574. static CreateImageWithCenterTextButton(name: string, text: string, imageUrl: string): Button;
  575. }
  576. }
  577. declare module BABYLON.GUI {
  578. class ColorPicker extends Control {
  579. name: string | undefined;
  580. private _colorWheelCanvas;
  581. private _value;
  582. private _tmpColor;
  583. private _pointerStartedOnSquare;
  584. private _pointerStartedOnWheel;
  585. private _squareLeft;
  586. private _squareTop;
  587. private _squareSize;
  588. private _h;
  589. private _s;
  590. private _v;
  591. onValueChangedObservable: Observable<Color3>;
  592. value: Color3;
  593. width: string | number;
  594. height: string | number;
  595. size: string | number;
  596. constructor(name?: string | undefined);
  597. protected _getTypeName(): string;
  598. private _updateSquareProps();
  599. private _drawGradientSquare(hueValue, left, top, width, height, context);
  600. private _drawCircle(centerX, centerY, radius, context);
  601. private _createColorWheelCanvas(radius, thickness);
  602. private _RGBtoHSV(color, result);
  603. private _HSVtoRGB(hue, saturation, value, result);
  604. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  605. private _pointerIsDown;
  606. private _updateValueFromPointer(x, y);
  607. private _isPointOnSquare(coordinates);
  608. private _isPointOnWheel(coordinates);
  609. _onPointerDown(target: Control, coordinates: Vector2, buttonIndex: number): boolean;
  610. _onPointerMove(target: Control, coordinates: Vector2): void;
  611. _onPointerUp(target: Control, coordinates: Vector2, buttonIndex: number): void;
  612. }
  613. }
  614. declare module BABYLON.GUI {
  615. class InputText extends Control implements IFocusableControl {
  616. name: string | undefined;
  617. private _text;
  618. private _placeholderText;
  619. private _background;
  620. private _focusedBackground;
  621. private _placeholderColor;
  622. private _thickness;
  623. private _margin;
  624. private _autoStretchWidth;
  625. private _maxWidth;
  626. private _isFocused;
  627. private _blinkTimeout;
  628. private _blinkIsEven;
  629. private _cursorOffset;
  630. private _scrollLeft;
  631. private _textWidth;
  632. private _clickedCoordinate;
  633. promptMessage: string;
  634. onTextChangedObservable: Observable<InputText>;
  635. onFocusObservable: Observable<InputText>;
  636. onBlurObservable: Observable<InputText>;
  637. maxWidth: string | number;
  638. readonly maxWidthInPixels: number;
  639. margin: string;
  640. readonly marginInPixels: number;
  641. autoStretchWidth: boolean;
  642. thickness: number;
  643. focusedBackground: string;
  644. background: string;
  645. placeholderColor: string;
  646. placeholderText: string;
  647. text: string;
  648. width: string | number;
  649. constructor(name?: string | undefined, text?: string);
  650. onBlur(): void;
  651. onFocus(): void;
  652. protected _getTypeName(): string;
  653. processKey(keyCode: number, key?: string): void;
  654. processKeyboard(evt: KeyboardEvent): void;
  655. _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
  656. _onPointerDown(target: Control, coordinates: Vector2, buttonIndex: number): boolean;
  657. _onPointerUp(target: Control, coordinates: Vector2, buttonIndex: number): void;
  658. dispose(): void;
  659. }
  660. }
  661. declare module BABYLON.GUI {
  662. class KeyPropertySet {
  663. width?: string;
  664. height?: string;
  665. paddingLeft?: string;
  666. paddingRight?: string;
  667. paddingTop?: string;
  668. paddingBottom?: string;
  669. color?: string;
  670. background?: string;
  671. }
  672. class VirtualKeyboard extends StackPanel {
  673. onKeyPressObservable: Observable<string>;
  674. defaultButtonWidth: string;
  675. defaultButtonHeight: string;
  676. defaultButtonPaddingLeft: string;
  677. defaultButtonPaddingRight: string;
  678. defaultButtonPaddingTop: string;
  679. defaultButtonPaddingBottom: string;
  680. defaultButtonColor: string;
  681. defaultButtonBackground: string;
  682. shiftButtonColor: string;
  683. selectedShiftThickness: number;
  684. shiftState: number;
  685. protected _getTypeName(): string;
  686. private _createKey(key, propertySet);
  687. addKeysRow(keys: Array<string>, propertySets?: Array<KeyPropertySet>): void;
  688. applyShiftState(shiftState: number): void;
  689. private _connectedInputText;
  690. private _onFocusObserver;
  691. private _onBlurObserver;
  692. private _onKeyPressObserver;
  693. readonly connectedInputText: Nullable<InputText>;
  694. connect(input: InputText): void;
  695. disconnect(): void;
  696. static CreateDefaultLayout(): VirtualKeyboard;
  697. }
  698. }