@galacean/effects-plugin-gui 2.10.0-alpha.5

package/LICENSE

@@ -0,0 +1,22 @@
+MIT LICENSE
+
+Copyright (c) 2019-present Ant Group Co., Ltd. https://www.antgroup.com/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# @galacean/effects-plugin-gui
+
+Concrete GUI behavior for Galacean Effects. The core package owns only the
+`Control`, `Container`, GUI roots and input bridge
+protocols; automatic layout algorithms and future widgets/themes belong here.
+
+The package currently exports:
+
+- `BoxContainer`, `HBoxContainer`, `VBoxContainer`
+- `GridContainer`
+- `MarginContainer`
+- `CenterContainer`
+- `AspectRatioContainer`
+
+Importing the package does not register a plugin and has no logging side
+effects. Create controls with the same `Engine` used by the owning GUI tree.
+
+```ts
+import type { Engine } from '@galacean/effects';
+import { Control, SizeFlags } from '@galacean/effects';
+import { HBoxContainer } from '@galacean/effects-plugin-gui';
+
+function createRow (engine: Engine): HBoxContainer {
+  const row = new HBoxContainer(engine);
+  const child = new Control(engine);
+
+  row.setThemeConstantOverride('separation', 12);
+  child.setSizeFlags(SizeFlags.ExpandFill, SizeFlags.Fill);
+  row.addChild(child);
+
+  return row;
+}
+```

package/dist/components/gui-window-component.d.ts

@@ -0,0 +1,15 @@
+import { Component } from '@galacean/effects';
+import type { Engine } from '@galacean/effects';
+import { WindowRootControl } from '../core/roots';
+/** Engine-level owner for the GUI window root and its runtime subscriptions. */
+export declare class GUIWindowComponent extends Component {
+    readonly windowRoot: WindowRootControl;
+    private disposed;
+    private readonly updateWindowRoot;
+    private readonly renderWindowRoot;
+    private readonly resizeWindowRoot;
+    private readonly pushInput;
+    private readonly onCanvasBlur;
+    constructor(engine: Engine);
+    dispose(): void;
+}

package/dist/components/index.d.ts

@@ -0,0 +1,3 @@
+export { GUIWindowComponent } from './gui-window-component';
+export * from './ui-canvas';
+export * from './ui-control';

package/dist/components/ui-canvas.d.ts

@@ -0,0 +1,28 @@
+import { Component } from '@galacean/effects';
+import type { Engine } from '@galacean/effects';
+import { CanvasRootControl } from '../core/roots';
+export declare enum CanvasRenderMode {
+    ScreenSpace = 0,
+    CameraSpace = 1,
+    WorldSpace = 2,
+    WorldSpaceFaceCamera = 3
+}
+/** Canvas-layer boundary attached to a VFXItem. Input state remains owned by the window root. */
+export declare class UICanvas extends Component {
+    readonly rootControl: CanvasRootControl;
+    renderMode: CanvasRenderMode;
+    receivesEvents: boolean;
+    private _order;
+    private registered;
+    constructor(engine: Engine);
+    get order(): number;
+    set order(value: number);
+    get isVisible(): boolean;
+    onEnable(): void;
+    onDisable(): void;
+    onDestroy(): void;
+    dispose(): void;
+    private register;
+    private unregister;
+    private destroyCanvas;
+}

package/dist/components/ui-control.d.ts

@@ -0,0 +1,40 @@
+import { Component } from '@galacean/effects';
+import type { Engine, spec } from '@galacean/effects';
+import type { Control } from '../core/control';
+/**
+ * Scene-tree bridge for a GUI Control. The VFXItem tree owns lifecycle and
+ * serialization while the Control tree owns layout, drawing and input.
+ */
+export declare class UIControl extends Component {
+    static fallbackParentGetDelegate?: (control: UIControl) => Control | null;
+    private controlNode;
+    private linkedItemTransform;
+    private linkedControl;
+    private syncingLocation;
+    private readonly itemTransformChanged;
+    private readonly controlLocationChanged;
+    constructor(engine: Engine);
+    get control(): Control | null;
+    set control(value: Control | null);
+    get hasControl(): boolean;
+    onAwake(): void;
+    onEnable(): void;
+    onDisable(): void;
+    onParentChanged(): void;
+    onOrderInParentChanged(): void;
+    onDestroy(): void;
+    dispose(): void;
+    /** Unlinks the GUI object without disposing or modifying it. */
+    unlinkControl(): void;
+    private attachControl;
+    private disposeControl;
+    private syncControl;
+    private syncControlOrder;
+    private resolveParent;
+    private bindLocationSync;
+    private unbindLocationSync;
+    private syncItemLocationToControl;
+    private syncControlLocationToItem;
+    private copyItemLocationToControl;
+    fromData(data: spec.ComponentData): void;
+}

package/dist/controls/base-button.d.ts

@@ -0,0 +1,85 @@
+import { MouseButtonMask } from '@galacean/effects';
+import type { Engine, EventEmitterListener, InputEventKey, InputEventMouseButton, InputEventMouseMotion, InputEventScreenDrag, InputEventScreenTouch } from '@galacean/effects';
+import { Control } from '../core/control';
+import type { ControlEvent, RootControl } from '../core/control';
+import { FocusMode, MouseFilter } from '../core/enums';
+import { ButtonActionMode, ButtonDrawMode } from './enums';
+import type { BaseButtonData } from '../data';
+export type BaseButtonEvent = ControlEvent & {
+    buttonDown: [];
+    buttonUp: [];
+    pressed: [];
+    toggled: [pressed: boolean];
+};
+export type ButtonGroupEvent = {
+    pressed: [button: BaseButton];
+};
+export declare class ButtonGroup {
+    private readonly buttons;
+    private readonly eventEmitter;
+    allowUnpress: boolean;
+    on<E extends keyof ButtonGroupEvent>(eventName: E, listener: EventEmitterListener<ButtonGroupEvent[E]>): void;
+    off<E extends keyof ButtonGroupEvent>(eventName: E, listener: EventEmitterListener<ButtonGroupEvent[E]>): void;
+    getPressedButton(): BaseButton | null;
+    getButtons(): BaseButton[];
+    select(button: BaseButton, signal: boolean, emitPressed?: boolean): boolean;
+}
+export declare class BaseButton extends Control {
+    static readonly themeType: string;
+    private readonly buttonEventEmitter;
+    private _disabled;
+    private _toggleMode;
+    private _buttonPressed;
+    private _buttonMask;
+    private _buttonGroup;
+    private hovered;
+    private pressing;
+    private pressInside;
+    private mousePressing;
+    private keyboardPressing;
+    private touchIndex;
+    private readonly controlStateChanged;
+    actionMode: ButtonActionMode;
+    keepPressedOutside: boolean;
+    constructor(engine: Engine);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get toggleMode(): boolean;
+    set toggleMode(value: boolean);
+    get buttonPressed(): boolean;
+    set buttonPressed(value: boolean);
+    get buttonMask(): MouseButtonMask;
+    set buttonMask(value: MouseButtonMask);
+    get buttonGroup(): ButtonGroup | null;
+    set buttonGroup(value: ButtonGroup | null);
+    on<E extends keyof BaseButtonEvent>(eventName: E, listener: EventEmitterListener<BaseButtonEvent[E]>): void;
+    off<E extends keyof BaseButtonEvent>(eventName: E, listener: EventEmitterListener<BaseButtonEvent[E]>): void;
+    setPressedNoSignal(value: boolean): void;
+    isHovered(): boolean;
+    isPressing(): boolean;
+    getDrawMode(): ButtonDrawMode;
+    getEffectiveMouseFilter(): MouseFilter;
+    getFocusModeWithOverride(): FocusMode;
+    onMouseEnter(): void;
+    onMouseMove(event: InputEventMouseMotion): void;
+    onMouseLeave(): void;
+    onMouseDown(event: InputEventMouseButton): void;
+    onMouseUp(event: InputEventMouseButton): void;
+    onTouchDown(event: InputEventScreenTouch): void;
+    onTouchMove(event: InputEventScreenDrag): void;
+    onTouchUp(event: InputEventScreenTouch): void;
+    onKeyDown(event: InputEventKey): void;
+    onKeyUp(event: InputEventKey): void;
+    onLostFocus(): void;
+    onScrollBegin(): void;
+    onDestroy(): void;
+    setPressedFromGroup(value: boolean, signal: boolean): void;
+    protected onRootChanged(previousRoot: RootControl | null, nextRoot: RootControl | null): void;
+    private setPressed;
+    private setPressedDirect;
+    private beginPress;
+    private finishPress;
+    private cancelPress;
+    private activate;
+    fromData(data: BaseButtonData): void;
+}

package/dist/controls/button.d.ts

@@ -0,0 +1,44 @@
+import { math } from '@galacean/effects';
+import type { Engine, Texture } from '@galacean/effects';
+import type { ButtonData } from '../data';
+import { BaseButton } from './base-button';
+import { ButtonDrawMode, HorizontalAlignment, VerticalAlignment } from './enums';
+export type ContentInsets = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export declare class Button extends BaseButton {
+    static readonly themeType: string;
+    private _text;
+    private _icon;
+    flat: boolean;
+    clipText: boolean;
+    expandIcon: boolean;
+    textAlignment: HorizontalAlignment;
+    iconAlignment: HorizontalAlignment;
+    iconVerticalAlignment: VerticalAlignment;
+    constructor(engine: Engine, text?: string);
+    get text(): string;
+    set text(value: string);
+    get icon(): Texture | null;
+    set icon(value: Texture | null);
+    getMinimumSize(): math.Vector2;
+    getDesiredSize(): math.Vector2;
+    draw(): void;
+    protected getContentInsets(): ContentInsets;
+    protected getNormalContentInsets(): ContentInsets;
+    protected drawDecoration(mode: ButtonDrawMode): void;
+    private measureButton;
+    private getStyleBoxName;
+    private drawContent;
+    private getFontColor;
+    private getIconTint;
+    protected getBaseContentInsets(): ContentInsets;
+    private getIconSize;
+    private getAlignedX;
+    private getAlignedY;
+    private ellipsizeText;
+    fromData(data: ButtonData): void;
+}

package/dist/controls/check-button.d.ts

@@ -0,0 +1,10 @@
+import type { Engine } from '@galacean/effects';
+import { Button } from './button';
+import type { ContentInsets } from './button';
+export declare class CheckButton extends Button {
+    static readonly themeType: string;
+    constructor(engine: Engine, text?: string);
+    protected getContentInsets(): ContentInsets;
+    protected drawDecoration(): void;
+    private getSwitchSize;
+}

package/dist/controls/checkbox.d.ts

@@ -0,0 +1,12 @@
+import type { Engine } from '@galacean/effects';
+import { Button } from './button';
+import type { ContentInsets } from './button';
+export declare class Checkbox extends Button {
+    static readonly themeType: string;
+    constructor(engine: Engine, text?: string);
+    protected getContentInsets(): ContentInsets;
+    protected drawDecoration(): void;
+    private fillRoundedMark;
+    private fillCheckMark;
+    private getMarkSize;
+}

package/dist/controls/color-picker.d.ts

@@ -0,0 +1,59 @@
+import { math } from '@galacean/effects';
+import type { Engine, EventEmitterListener } from '@galacean/effects';
+import type { ColorPickerButtonData, ColorPickerData } from '../data';
+import type { ControlEvent } from '../core/control';
+import { VBoxContainer } from '../layout/box-container';
+import { PopupPanel } from './popup';
+import { Button } from './button';
+import type { ContentInsets } from './button';
+import type { ButtonDrawMode } from './enums';
+import type { BaseButtonEvent } from './base-button';
+export type ColorPickerEvent = ControlEvent & {
+    colorChanged: [color: math.Color];
+};
+export type ColorPickerButtonEvent = BaseButtonEvent & {
+    colorChanged: [color: math.Color];
+};
+export declare class ColorPicker extends VBoxContainer {
+    static readonly themeType: string;
+    private readonly colorEventEmitter;
+    private readonly plane;
+    private readonly hueBar;
+    private readonly alphaSlider;
+    private readonly channelFields;
+    private readonly hexField;
+    private readonly currentColor;
+    private syncing;
+    private _editAlpha;
+    constructor(engine: Engine);
+    get color(): math.Color;
+    set color(value: math.Color);
+    get editAlpha(): boolean;
+    set editAlpha(value: boolean);
+    on<E extends keyof ColorPickerEvent>(eventName: E, listener: EventEmitterListener<ColorPickerEvent[E]>): void;
+    off<E extends keyof ColorPickerEvent>(eventName: E, listener: EventEmitterListener<ColorPickerEvent[E]>): void;
+    setColor(value: math.Color, signal?: boolean): void;
+    private syncEditors;
+    private submitChannel;
+    private submitHex;
+    fromData(data: ColorPickerData): void;
+}
+export declare class ColorPickerButton extends Button {
+    static readonly themeType: string;
+    readonly picker: ColorPicker;
+    readonly popupPanel: PopupPanel;
+    private readonly colorEventEmitter;
+    private readonly openPicker;
+    constructor(engine: Engine);
+    get color(): math.Color;
+    set color(value: math.Color);
+    get editAlpha(): boolean;
+    set editAlpha(value: boolean);
+    on<E extends keyof ColorPickerButtonEvent>(eventName: E, listener: EventEmitterListener<ColorPickerButtonEvent[E]>): void;
+    off<E extends keyof ColorPickerButtonEvent>(eventName: E, listener: EventEmitterListener<ColorPickerButtonEvent[E]>): void;
+    showPicker(): void;
+    protected getContentInsets(): ContentInsets;
+    protected drawDecoration(_mode: ButtonDrawMode): void;
+    onDestroy(): void;
+    fromData(data: ColorPickerButtonData): void;
+}

package/dist/controls/color-rect.d.ts

@@ -0,0 +1,11 @@
+import { math } from '@galacean/effects';
+import type { Engine } from '@galacean/effects';
+import { Control } from '../core/control';
+import type { ColorRectData } from '../data';
+export declare class ColorRect extends Control {
+    static readonly themeType: string;
+    color: math.Color;
+    constructor(engine: Engine);
+    draw(): void;
+    fromData(data: ColorRectData): void;
+}

package/dist/controls/enums.d.ts

@@ -0,0 +1,68 @@
+export declare enum HorizontalAlignment {
+    Left = 0,
+    Center = 1,
+    Right = 2,
+    Fill = 3
+}
+export declare enum VerticalAlignment {
+    Top = 0,
+    Center = 1,
+    Bottom = 2,
+    Fill = 3
+}
+export declare enum AutowrapMode {
+    Off = 0,
+    Arbitrary = 1,
+    Word = 2,
+    WordSmart = 3
+}
+export declare enum TextOverflow {
+    Visible = 0,
+    Clip = 1,
+    Ellipsis = 2
+}
+export declare enum TextureExpandMode {
+    KeepSize = 0,
+    IgnoreSize = 1,
+    FitWidth = 2,
+    FitWidthProportional = 3,
+    FitHeight = 4,
+    FitHeightProportional = 5
+}
+export declare enum TextureStretchMode {
+    Scale = 0,
+    Tile = 1,
+    Keep = 2,
+    KeepCentered = 3,
+    KeepAspect = 4,
+    KeepAspectCentered = 5,
+    KeepAspectCovered = 6
+}
+export declare enum AxisStretchMode {
+    Stretch = 0,
+    Tile = 1,
+    TileFit = 2
+}
+export declare enum Side {
+    Left = 0,
+    Top = 1,
+    Right = 2,
+    Bottom = 3
+}
+export declare enum ButtonDrawMode {
+    Normal = 0,
+    Pressed = 1,
+    Hover = 2,
+    Disabled = 3,
+    HoverPressed = 4
+}
+export declare enum ButtonActionMode {
+    Press = 0,
+    Release = 1
+}
+export declare enum ProgressFillMode {
+    BeginToEnd = 0,
+    EndToBegin = 1,
+    TopToBottom = 2,
+    BottomToTop = 3
+}

package/dist/controls/index.d.ts

@@ -0,0 +1,19 @@
+export * from './enums';
+export * from './label';
+export * from './texture-rect';
+export * from './nine-patch-rect';
+export * from './color-rect';
+export * from './panel';
+export * from './base-button';
+export * from './button';
+export * from './checkbox';
+export * from './check-button';
+export * from './slider';
+export * from './progress-bar';
+export * from './text-input';
+export * from './line-edit';
+export * from './text-edit';
+export * from './popup';
+export * from './popup-menu';
+export * from './menu-button';
+export * from './color-picker';

package/dist/controls/label.d.ts

@@ -0,0 +1,46 @@
+import { math } from '@galacean/effects';
+import type { Engine } from '@galacean/effects';
+import { Control } from '../core/control';
+import type { LabelData } from '../data';
+import { AutowrapMode, HorizontalAlignment, TextOverflow, VerticalAlignment } from './enums';
+export declare class Label extends Control {
+    static readonly themeType: string;
+    private _text;
+    private _horizontalAlignment;
+    private _verticalAlignment;
+    private _autowrapMode;
+    private _textOverflow;
+    private layoutDirty;
+    private layoutWidth;
+    private layout;
+    constructor(engine: Engine, text?: string);
+    get text(): string;
+    set text(value: string);
+    get horizontalAlignment(): HorizontalAlignment;
+    set horizontalAlignment(value: HorizontalAlignment);
+    get verticalAlignment(): VerticalAlignment;
+    set verticalAlignment(value: VerticalAlignment);
+    get autowrapMode(): AutowrapMode;
+    set autowrapMode(value: AutowrapMode);
+    get textOverflow(): TextOverflow;
+    set textOverflow(value: TextOverflow);
+    getMinimumSize(): math.Vector2;
+    getDesiredSize(): math.Vector2;
+    draw(): void;
+    private invalidateTextLayout;
+    protected onThemeChanged(affectsLayout: boolean): void;
+    private measure;
+    private getTextLayout;
+    private createNaturalLayout;
+    private createLayout;
+    private wrapParagraph;
+    private findWordEnd;
+    private getMinimumLineWidth;
+    private getTextStartX;
+    private getTextStartY;
+    private getVerticalGap;
+    private ellipsize;
+    private drawFilledLine;
+    private drawThemedText;
+    fromData(data: LabelData): void;
+}

package/dist/controls/line-edit.d.ts

@@ -0,0 +1,28 @@
+import { math } from '@galacean/effects';
+import type { Engine } from '@galacean/effects';
+import type { LineEditData } from '../data';
+import { HorizontalAlignment } from './enums';
+import { TextInput } from './text-input';
+export declare class LineEdit extends TextInput {
+    static readonly themeType: string;
+    protected readonly multiline = false;
+    alignment: HorizontalAlignment;
+    private scrollOffset;
+    private _secret;
+    private _secretCharacter;
+    constructor(engine: Engine, text?: string);
+    get secret(): boolean;
+    set secret(value: boolean);
+    get secretCharacter(): string;
+    set secretCharacter(value: string);
+    getMinimumSize(): math.Vector2;
+    getDesiredSize(): math.Vector2;
+    draw(): void;
+    protected getDisplayText(): string;
+    protected getCharacterIndex(position: math.Vector2): number;
+    private getVisibleText;
+    private measurePrefix;
+    private updateScrollOffset;
+    private getAlignedTextX;
+    fromData(data: LineEditData): void;
+}

package/dist/controls/menu-button.d.ts

@@ -0,0 +1,39 @@
+import type { Engine, EventEmitterListener } from '@galacean/effects';
+import type { MenuButtonData, OptionButtonData } from '../data';
+import { Button } from './button';
+import type { ContentInsets } from './button';
+import { ButtonDrawMode } from './enums';
+import type { PopupMenuItemId } from './popup-menu';
+import { PopupMenu } from './popup-menu';
+export declare class MenuButton extends Button {
+    static readonly themeType: string;
+    readonly popupMenu: PopupMenu;
+    private readonly openMenu;
+    constructor(engine: Engine, text?: string);
+    showPopup(): void;
+    onDestroy(): void;
+    fromData(data: MenuButtonData): void;
+}
+export type OptionButtonEvent = {
+    itemSelected: [id: PopupMenuItemId];
+};
+export declare class OptionButton extends MenuButton {
+    static readonly themeType: string;
+    private readonly optionEventEmitter;
+    private _selected;
+    private readonly menuSelected;
+    constructor(engine: Engine);
+    protected getContentInsets(): ContentInsets;
+    protected drawDecoration(mode: ButtonDrawMode): void;
+    private getArrowColor;
+    get selected(): number;
+    set selected(value: number);
+    onOption<E extends keyof OptionButtonEvent>(eventName: E, listener: EventEmitterListener<OptionButtonEvent[E]>): void;
+    offOption<E extends keyof OptionButtonEvent>(eventName: E, listener: EventEmitterListener<OptionButtonEvent[E]>): void;
+    addItem(text: string, id?: PopupMenuItemId): void;
+    clear(): void;
+    select(index: number, signal?: boolean): void;
+    selectId(id: PopupMenuItemId, signal?: boolean): void;
+    onDestroy(): void;
+    fromData(data: OptionButtonData): void;
+}

package/dist/controls/nine-patch-rect.d.ts

@@ -0,0 +1,35 @@
+import { math } from '@galacean/effects';
+import type { Engine, EventEmitterListener, Texture } from '@galacean/effects';
+import { Control } from '../core/control';
+import type { ControlEvent, Rect } from '../core/control';
+import { AxisStretchMode, Side } from './enums';
+import type { NinePatchRectData } from '../data';
+export type NinePatchRectEvent = ControlEvent & {
+    textureChanged: [texture: Texture | null];
+};
+export declare class NinePatchRect extends Control {
+    static readonly themeType: string;
+    private readonly ninePatchEventEmitter;
+    private readonly patchMargins;
+    private _texture;
+    private _regionRect;
+    drawCenter: boolean;
+    horizontalAxisStretchMode: AxisStretchMode;
+    verticalAxisStretchMode: AxisStretchMode;
+    tint: math.Color;
+    constructor(engine: Engine, texture?: Texture | null);
+    get texture(): Texture | null;
+    set texture(value: Texture | null);
+    get regionRect(): Rect;
+    set regionRect(value: Rect);
+    on<E extends keyof NinePatchRectEvent>(eventName: E, listener: EventEmitterListener<NinePatchRectEvent[E]>): void;
+    off<E extends keyof NinePatchRectEvent>(eventName: E, listener: EventEmitterListener<NinePatchRectEvent[E]>): void;
+    setRegionRect(x: number, y: number, width: number, height: number): void;
+    setPatchMargin(side: Side, value: number): void;
+    getPatchMargin(side: Side): number;
+    getMinimumSize(): math.Vector2;
+    getDesiredSize(): math.Vector2;
+    draw(): void;
+    private getSourceRect;
+    fromData(data: NinePatchRectData): void;
+}

package/dist/controls/panel.d.ts

@@ -0,0 +1,9 @@
+import type { Engine, math } from '@galacean/effects';
+import { Control } from '../core/control';
+export declare class Panel extends Control {
+    static readonly themeType: string;
+    constructor(engine: Engine);
+    draw(): void;
+    getMinimumSize(): math.Vector2;
+    getDesiredSize(): math.Vector2;
+}

package/dist/controls/popup-menu.d.ts

@@ -0,0 +1,44 @@
+import { math } from '@galacean/effects';
+import type { EventEmitterListener, InputEventKey, InputEventMouseButton, InputEventMouseMotion, Texture } from '@galacean/effects';
+import type { PopupMenuData } from '../data';
+import type { ControlEvent } from '../core/control';
+import { Popup } from './popup';
+export type PopupMenuItemId = number | string;
+export type PopupMenuItem = {
+    id: PopupMenuItemId;
+    text: string;
+    icon?: Texture | null;
+    disabled?: boolean;
+    separator?: boolean;
+    checked?: boolean;
+};
+export type PopupMenuEvent = ControlEvent & {
+    idPressed: [id: PopupMenuItemId];
+};
+export declare class PopupMenu extends Popup {
+    static readonly themeType: string;
+    private readonly menuEventEmitter;
+    private readonly items;
+    private hoveredIndex;
+    on<E extends keyof PopupMenuEvent>(eventName: E, listener: EventEmitterListener<PopupMenuEvent[E]>): void;
+    off<E extends keyof PopupMenuEvent>(eventName: E, listener: EventEmitterListener<PopupMenuEvent[E]>): void;
+    addItem(text: string, id?: PopupMenuItemId, icon?: Texture | null): void;
+    addSeparator(text?: string): void;
+    clear(): void;
+    getItemCount(): number;
+    getItem(index: number): PopupMenuItem | undefined;
+    setItemDisabled(index: number, disabled: boolean): void;
+    setItemChecked(index: number, checked: boolean): void;
+    getMinimumSize(): math.Vector2;
+    getDesiredSize(): math.Vector2;
+    draw(): void;
+    onMouseMove(event: InputEventMouseMotion): void;
+    onMouseLeave(): void;
+    onMouseDown(event: InputEventMouseButton): void;
+    onKeyDown(event: InputEventKey): void;
+    onPopupOpened(): void;
+    private getIndexAt;
+    private activateIndex;
+    private findEnabledIndex;
+    fromData(data: PopupMenuData): void;
+}