1268 lines
52 KiB
TypeScript
1268 lines
52 KiB
TypeScript
/// <reference path="./gobject-2.0.d.ts" />
|
|
/// <reference path="./glib-2.0.d.ts" />
|
|
|
|
/**
|
|
* Type Definitions for Gjs (https://gjs.guide/)
|
|
*
|
|
* These type definitions are automatically generated, do not edit them by hand.
|
|
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
|
|
*
|
|
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
|
|
*/
|
|
|
|
declare module 'gi://Dbusmenu?version=0.4' {
|
|
// Module dependencies
|
|
import type GObject from 'gi://GObject?version=2.0';
|
|
import type GLib from 'gi://GLib?version=2.0';
|
|
|
|
export namespace Dbusmenu {
|
|
/**
|
|
* Dbusmenu-0.4
|
|
*/
|
|
|
|
/**
|
|
* Tracks how the menus should be presented to the user.
|
|
*/
|
|
|
|
/**
|
|
* Tracks how the menus should be presented to the user.
|
|
*/
|
|
export namespace Status {
|
|
export const $gtype: GObject.GType<Status>;
|
|
}
|
|
|
|
enum Status {
|
|
/**
|
|
* Everything is normal
|
|
*/
|
|
NORMAL,
|
|
/**
|
|
* The menus should be shown at a higher priority
|
|
*/
|
|
NOTICE,
|
|
}
|
|
/**
|
|
* The direction of text that the strings that this server
|
|
* will be sending strings as.
|
|
*/
|
|
|
|
/**
|
|
* The direction of text that the strings that this server
|
|
* will be sending strings as.
|
|
*/
|
|
export namespace TextDirection {
|
|
export const $gtype: GObject.GType<TextDirection>;
|
|
}
|
|
|
|
enum TextDirection {
|
|
/**
|
|
* Unspecified text direction
|
|
*/
|
|
NONE,
|
|
/**
|
|
* Left-to-right text direction
|
|
*/
|
|
LTR,
|
|
/**
|
|
* Right-to-left text direction
|
|
*/
|
|
RTL,
|
|
}
|
|
/**
|
|
* String to access property #DbusmenuClient:dbus-name
|
|
*/
|
|
const CLIENT_PROP_DBUS_NAME: string;
|
|
/**
|
|
* String to access property #DbusmenuClient:dbus-object
|
|
*/
|
|
const CLIENT_PROP_DBUS_OBJECT: string;
|
|
/**
|
|
* String to access property #DbusmenuClient:group-events
|
|
*/
|
|
const CLIENT_PROP_GROUP_EVENTS: string;
|
|
/**
|
|
* String to access property #DbusmenuClient:status
|
|
*/
|
|
const CLIENT_PROP_STATUS: string;
|
|
/**
|
|
* String to access property #DbusmenuClient:text-direction
|
|
*/
|
|
const CLIENT_PROP_TEXT_DIRECTION: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuClient::event-result
|
|
*/
|
|
const CLIENT_SIGNAL_EVENT_RESULT: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuClient::icon-theme-dirs-changed
|
|
*/
|
|
const CLIENT_SIGNAL_ICON_THEME_DIRS_CHANGED: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuClient::item-activate
|
|
*/
|
|
const CLIENT_SIGNAL_ITEM_ACTIVATE: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuClient::layout-updated
|
|
*/
|
|
const CLIENT_SIGNAL_LAYOUT_UPDATED: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuClient::new-menuitem
|
|
*/
|
|
const CLIENT_SIGNAL_NEW_MENUITEM: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuClient::root-changed
|
|
*/
|
|
const CLIENT_SIGNAL_ROOT_CHANGED: string;
|
|
/**
|
|
* Used to set the 'type' property on a menu item to create
|
|
* a standard menu item.
|
|
*/
|
|
const CLIENT_TYPES_DEFAULT: string;
|
|
/**
|
|
* Used to set the 'type' property on a menu item to create
|
|
* an image menu item. Deprecated as standard menu items now
|
|
* support images as well.
|
|
*/
|
|
const CLIENT_TYPES_IMAGE: string;
|
|
/**
|
|
* Used to set the 'type' property on a menu item to create
|
|
* a separator menu item.
|
|
*/
|
|
const CLIENT_TYPES_SEPARATOR: string;
|
|
/**
|
|
* Used in #DBUSMENU_MENUITEM_PROP_CHILD_DISPLAY to have the
|
|
* subitems displayed as a submenu.
|
|
*/
|
|
const MENUITEM_CHILD_DISPLAY_SUBMENU: string;
|
|
/**
|
|
* Used in #DBUSMENU_MENUITEM_PROP_DISPOSITION to have a menu
|
|
* item displayed in a way that conveys it's giving an alert
|
|
* to the user.
|
|
*/
|
|
const MENUITEM_DISPOSITION_ALERT: string;
|
|
/**
|
|
* Used in #DBUSMENU_MENUITEM_PROP_DISPOSITION to have a menu
|
|
* item displayed in a way that conveys it's giving additional
|
|
* information to the user.
|
|
*/
|
|
const MENUITEM_DISPOSITION_INFORMATIVE: string;
|
|
/**
|
|
* Used in #DBUSMENU_MENUITEM_PROP_DISPOSITION to have a menu
|
|
* item displayed in the normal manner. Default value.
|
|
*/
|
|
const MENUITEM_DISPOSITION_NORMAL: string;
|
|
/**
|
|
* Used in #DBUSMENU_MENUITEM_PROP_DISPOSITION to have a menu
|
|
* item displayed in a way that conveys it's giving a warning
|
|
* to the user.
|
|
*/
|
|
const MENUITEM_DISPOSITION_WARNING: string;
|
|
/**
|
|
* String for the event identifier when a menu item is clicked
|
|
* on by the user.
|
|
*/
|
|
const MENUITEM_EVENT_ACTIVATED: string;
|
|
/**
|
|
* String for the event identifier when a menu is closed and
|
|
* displayed to the user. Only valid for items that contain
|
|
* submenus.
|
|
*/
|
|
const MENUITEM_EVENT_CLOSED: string;
|
|
/**
|
|
* String for the event identifier when a menu is opened and
|
|
* displayed to the user. Only valid for items that contain
|
|
* submenus.
|
|
*/
|
|
const MENUITEM_EVENT_OPENED: string;
|
|
/**
|
|
* Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_STATE so that the menu's
|
|
* toggle item is undecided.
|
|
*/
|
|
const MENUITEM_ICON_NAME_BLANK: string;
|
|
/**
|
|
* #DbusmenuMenuitem property used to provide a textual description of any
|
|
* information that the icon may convey. The contents of this property are
|
|
* passed through to assistive technologies such as the Orca screen reader.
|
|
* The contents of this property will not be visible in the menu item. If
|
|
* this property is set, Orca will use this property instead of the label
|
|
* property.
|
|
*/
|
|
const MENUITEM_PROP_ACCESSIBLE_DESC: string;
|
|
/**
|
|
* #DbusmenuMenuitem property that tells how the children of this menuitem
|
|
* should be displayed. Most likely this will be unset or of the value
|
|
* #DBUSMENU_MENUITEM_CHILD_DISPLAY_SUBMENU. Type: #G_VARIANT_TYPE_STRING
|
|
*/
|
|
const MENUITEM_PROP_CHILD_DISPLAY: string;
|
|
/**
|
|
* #DbusmenuMenuitem property to tell what type of information that the
|
|
* menu item is displaying to the user. Type: #G_VARIANT_TYPE_STRING
|
|
*/
|
|
const MENUITEM_PROP_DISPOSITION: string;
|
|
/**
|
|
* #DbusmenuMenuitem property used to represent whether the menuitem
|
|
* is clickable or not. Type: #G_VARIANT_TYPE_BOOLEAN.
|
|
*/
|
|
const MENUITEM_PROP_ENABLED: string;
|
|
/**
|
|
* #DbusmenuMenuitem property that is the raw data of a custom icon
|
|
* used in the application. Type: #G_VARIANT_TYPE_VARIANT
|
|
*
|
|
* It is recommended that this is not set directly but instead the
|
|
* libdbusmenu-gtk library is used with the function dbusmenu_menuitem_property_set_image()
|
|
*/
|
|
const MENUITEM_PROP_ICON_DATA: string;
|
|
/**
|
|
* #DbusmenuMenuitem property that is the name of the icon under the
|
|
* Freedesktop.org icon naming spec. Type: #G_VARIANT_TYPE_STRING
|
|
*/
|
|
const MENUITEM_PROP_ICON_NAME: string;
|
|
/**
|
|
* #DbusmenuMenuitem property used for the text on the menu item.
|
|
*/
|
|
const MENUITEM_PROP_LABEL: string;
|
|
/**
|
|
* #DbusmenuMenuitem property that is the entries that represent a shortcut
|
|
* to activate the menuitem. It is an array of arrays of strings.
|
|
*
|
|
* It is recommended that this is not set directly but instead the
|
|
* libdbusmenu-gtk library is used with the function dbusmenu_menuitem_property_set_shortcut()
|
|
*/
|
|
const MENUITEM_PROP_SHORTCUT: string;
|
|
/**
|
|
* #DbusmenuMenuitem property that says what state a toggle entry should
|
|
* be shown as the menu. Should be either #DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED
|
|
* #DBUSMENU_MENUITEM_TOGGLE_STATE_CHECKED or #DBUSMENU_MENUITEM_TOGGLE_STATUE_UNKNOWN.
|
|
*/
|
|
const MENUITEM_PROP_TOGGLE_STATE: string;
|
|
/**
|
|
* #DbusmenuMenuitem property that says what type of toggle entry should
|
|
* be shown in the menu. Should be either #DBUSMENU_MENUITEM_TOGGLE_CHECK
|
|
* or #DBUSMENU_MENUITEM_TOGGLE_RADIO. Type: #G_VARIANT_TYPE_STRING
|
|
*/
|
|
const MENUITEM_PROP_TOGGLE_TYPE: string;
|
|
/**
|
|
* #DbusmenuMenuitem property used to represent what type of menuitem
|
|
* this object represents. Type: #G_VARIANT_TYPE_STRING.
|
|
*/
|
|
const MENUITEM_PROP_TYPE: string;
|
|
/**
|
|
* #DbusmenuMenuitem property used to represent whether the menuitem
|
|
* should be shown or not. Type: #G_VARIANT_TYPE_BOOLEAN.
|
|
*/
|
|
const MENUITEM_PROP_VISIBLE: string;
|
|
/**
|
|
* Used in #DBUSMENU_MENUITEM_PROP_SHORTCUT to represent the
|
|
* alternate key.
|
|
*/
|
|
const MENUITEM_SHORTCUT_ALT: string;
|
|
/**
|
|
* Used in #DBUSMENU_MENUITEM_PROP_SHORTCUT to represent the
|
|
* control key.
|
|
*/
|
|
const MENUITEM_SHORTCUT_CONTROL: string;
|
|
/**
|
|
* Used in #DBUSMENU_MENUITEM_PROP_SHORTCUT to represent the
|
|
* shift key.
|
|
*/
|
|
const MENUITEM_SHORTCUT_SHIFT: string;
|
|
/**
|
|
* Used in #DBUSMENU_MENUITEM_PROP_SHORTCUT to represent the
|
|
* super key.
|
|
*/
|
|
const MENUITEM_SHORTCUT_SUPER: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::about-to-show
|
|
*/
|
|
const MENUITEM_SIGNAL_ABOUT_TO_SHOW: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::child-added
|
|
*/
|
|
const MENUITEM_SIGNAL_CHILD_ADDED: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::child-moved
|
|
*/
|
|
const MENUITEM_SIGNAL_CHILD_MOVED: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::child-removed
|
|
*/
|
|
const MENUITEM_SIGNAL_CHILD_REMOVED: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::event
|
|
*/
|
|
const MENUITEM_SIGNAL_EVENT: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::item-activated
|
|
*/
|
|
const MENUITEM_SIGNAL_ITEM_ACTIVATED: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::property-changed
|
|
*/
|
|
const MENUITEM_SIGNAL_PROPERTY_CHANGED: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::realized
|
|
*/
|
|
const MENUITEM_SIGNAL_REALIZED: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::show-to-user
|
|
*/
|
|
const MENUITEM_SIGNAL_SHOW_TO_USER: string;
|
|
/**
|
|
* Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE to be a standard
|
|
* check mark item.
|
|
*/
|
|
const MENUITEM_TOGGLE_CHECK: string;
|
|
/**
|
|
* Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE to be a standard
|
|
* radio item.
|
|
*/
|
|
const MENUITEM_TOGGLE_RADIO: string;
|
|
/**
|
|
* Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_STATE so that the menu's
|
|
* toggle item is filled.
|
|
*/
|
|
const MENUITEM_TOGGLE_STATE_CHECKED: number;
|
|
/**
|
|
* Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_STATE so that the menu's
|
|
* toggle item is empty.
|
|
*/
|
|
const MENUITEM_TOGGLE_STATE_UNCHECKED: number;
|
|
/**
|
|
* Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_STATE so that the menu's
|
|
* toggle item is undecided.
|
|
*/
|
|
const MENUITEM_TOGGLE_STATE_UNKNOWN: number;
|
|
/**
|
|
* String to access property #DbusmenuServer:dbus-object
|
|
*/
|
|
const SERVER_PROP_DBUS_OBJECT: string;
|
|
/**
|
|
* String to access property #DbusmenuServer:root-node
|
|
*/
|
|
const SERVER_PROP_ROOT_NODE: string;
|
|
/**
|
|
* String to access property #DbusmenuServer:status
|
|
*/
|
|
const SERVER_PROP_STATUS: string;
|
|
/**
|
|
* String to access property #DbusmenuServer:text-direction
|
|
*/
|
|
const SERVER_PROP_TEXT_DIRECTION: string;
|
|
/**
|
|
* String to access property #DbusmenuServer:version
|
|
*/
|
|
const SERVER_PROP_VERSION: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::item-property-updated
|
|
*/
|
|
const SERVER_SIGNAL_ID_PROP_UPDATE: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::item-updated
|
|
*/
|
|
const SERVER_SIGNAL_ID_UPDATE: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::item-activation-requested
|
|
*/
|
|
const SERVER_SIGNAL_ITEM_ACTIVATION: string;
|
|
/**
|
|
* String to attach to signal #DbusmenuServer::layout-updated
|
|
*/
|
|
const SERVER_SIGNAL_LAYOUT_UPDATED: string;
|
|
interface ClientTypeHandler {
|
|
(newitem: Menuitem, parent: Menuitem, client: Client): boolean;
|
|
}
|
|
interface menuitem_about_to_show_cb {
|
|
(mi: Menuitem): void;
|
|
}
|
|
interface menuitem_buildvariant_slot_t {
|
|
(mi: Menuitem, properties?: string | null): GLib.Variant;
|
|
}
|
|
namespace Client {
|
|
// Signal callback interfaces
|
|
|
|
interface EventResult {
|
|
(object: GObject.Object, p0: string, p1: GLib.Variant, p2: number, p3?: any | null): void;
|
|
}
|
|
|
|
interface IconThemeDirsChanged {
|
|
(arg1?: any | null): void;
|
|
}
|
|
|
|
interface ItemActivate {
|
|
(arg1: GObject.Object, arg2: number): void;
|
|
}
|
|
|
|
interface LayoutUpdated {
|
|
(): void;
|
|
}
|
|
|
|
interface NewMenuitem {
|
|
(arg1: GObject.Object): void;
|
|
}
|
|
|
|
interface RootChanged {
|
|
(arg1: GObject.Object): void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
dbus_name: string;
|
|
dbusName: string;
|
|
dbus_object: string;
|
|
dbusObject: string;
|
|
group_events: boolean;
|
|
groupEvents: boolean;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The client for a #DbusmenuServer creating a shared
|
|
* object set of #DbusmenuMenuitem objects.
|
|
*/
|
|
class Client extends GObject.Object {
|
|
static $gtype: GObject.GType<Client>;
|
|
|
|
// Properties
|
|
|
|
get dbus_name(): string;
|
|
get dbusName(): string;
|
|
get dbus_object(): string;
|
|
get dbusObject(): string;
|
|
get group_events(): boolean;
|
|
set group_events(val: boolean);
|
|
get groupEvents(): boolean;
|
|
set groupEvents(val: boolean);
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Client.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](name: string, object: string): Client;
|
|
|
|
// Signals
|
|
|
|
connect(id: string, callback: (...args: any[]) => any): number;
|
|
connect_after(id: string, callback: (...args: any[]) => any): number;
|
|
emit(id: string, ...args: any[]): void;
|
|
connect(
|
|
signal: 'event-result',
|
|
callback: (
|
|
_source: this,
|
|
object: GObject.Object,
|
|
p0: string,
|
|
p1: GLib.Variant,
|
|
p2: number,
|
|
p3: any | null,
|
|
) => void,
|
|
): number;
|
|
connect_after(
|
|
signal: 'event-result',
|
|
callback: (
|
|
_source: this,
|
|
object: GObject.Object,
|
|
p0: string,
|
|
p1: GLib.Variant,
|
|
p2: number,
|
|
p3: any | null,
|
|
) => void,
|
|
): number;
|
|
emit(
|
|
signal: 'event-result',
|
|
object: GObject.Object,
|
|
p0: string,
|
|
p1: GLib.Variant,
|
|
p2: number,
|
|
p3?: any | null,
|
|
): void;
|
|
connect(signal: 'icon-theme-dirs-changed', callback: (_source: this, arg1: any | null) => void): number;
|
|
connect_after(
|
|
signal: 'icon-theme-dirs-changed',
|
|
callback: (_source: this, arg1: any | null) => void,
|
|
): number;
|
|
emit(signal: 'icon-theme-dirs-changed', arg1?: any | null): void;
|
|
connect(
|
|
signal: 'item-activate',
|
|
callback: (_source: this, arg1: GObject.Object, arg2: number) => void,
|
|
): number;
|
|
connect_after(
|
|
signal: 'item-activate',
|
|
callback: (_source: this, arg1: GObject.Object, arg2: number) => void,
|
|
): number;
|
|
emit(signal: 'item-activate', arg1: GObject.Object, arg2: number): void;
|
|
connect(signal: 'layout-updated', callback: (_source: this) => void): number;
|
|
connect_after(signal: 'layout-updated', callback: (_source: this) => void): number;
|
|
emit(signal: 'layout-updated'): void;
|
|
connect(signal: 'new-menuitem', callback: (_source: this, arg1: GObject.Object) => void): number;
|
|
connect_after(signal: 'new-menuitem', callback: (_source: this, arg1: GObject.Object) => void): number;
|
|
emit(signal: 'new-menuitem', arg1: GObject.Object): void;
|
|
connect(signal: 'root-changed', callback: (_source: this, arg1: GObject.Object) => void): number;
|
|
connect_after(signal: 'root-changed', callback: (_source: this, arg1: GObject.Object) => void): number;
|
|
emit(signal: 'root-changed', arg1: GObject.Object): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* This function connects into the type handling of the #DbusmenuClient.
|
|
* Every new menuitem that comes in immediately gets asked for its
|
|
* properties. When we get those properties we check the 'type'
|
|
* property and look to see if it matches a handler that is known
|
|
* by the client. If so, the `newfunc` function is executed on that
|
|
* #DbusmenuMenuitem. If not, then the DbusmenuClient::new-menuitem
|
|
* signal is sent.
|
|
*
|
|
* In the future the known types will be sent to the server so that it
|
|
* can make choices about the menu item types availble.
|
|
* @param type A text string that will be matched with the 'type' property on incoming menu items
|
|
* @param newfunc The function that will be executed with those new items when they come in.
|
|
* @returns If registering the new type was successful.
|
|
*/
|
|
add_type_handler(type: string, newfunc: ClientTypeHandler): boolean;
|
|
/**
|
|
* This function connects into the type handling of the #DbusmenuClient.
|
|
* Every new menuitem that comes in immediately gets asked for its
|
|
* properties. When we get those properties we check the 'type'
|
|
* property and look to see if it matches a handler that is known
|
|
* by the client. If so, the `newfunc` function is executed on that
|
|
* #DbusmenuMenuitem. If not, then the DbusmenuClient::new-menuitem
|
|
* signal is sent.
|
|
*
|
|
* In the future the known types will be sent to the server so that it
|
|
* can make choices about the menu item types availble.
|
|
* @param type A text string that will be matched with the 'type' property on incoming menu items
|
|
* @param newfunc The function that will be executed with those new items when they come in.
|
|
* @returns If registering the new type was successful.
|
|
*/
|
|
add_type_handler_full(type: string, newfunc: ClientTypeHandler): boolean;
|
|
/**
|
|
* Gets the stored and exported icon paths from the client.
|
|
* @returns A NULL-terminated list of icon paths with memory managed by the client. Duplicate if you want to keep them.
|
|
*/
|
|
get_icon_paths(): string[];
|
|
/**
|
|
* Grabs the root node for the specified client `client`. This
|
|
* function may block. It will block if there is currently a
|
|
* call to update the layout, it will block on that layout
|
|
* updated and then return the newly updated layout. Chances
|
|
* are that this update is in the queue for the mainloop as
|
|
* it would have been requested some time ago, but in theory
|
|
* it could block longer.
|
|
* @returns A #DbusmenuMenuitem representing the root of menu on the server. If there is no server or there is an error receiving its layout it'll return #NULL.
|
|
*/
|
|
get_root(): Menuitem;
|
|
/**
|
|
* Gets the recommended current status that the server
|
|
* is exporting for the menus. In situtations where the
|
|
* value is #DBUSMENU_STATUS_NOTICE it is recommended that
|
|
* the client show the menus to the user an a more noticible
|
|
* way.
|
|
*
|
|
* Return value: Status being exported.
|
|
*/
|
|
get_status(): Status;
|
|
/**
|
|
* Gets the text direction that the server is exporting. If
|
|
* the server is not exporting a direction then the value
|
|
* #DBUSMENU_TEXT_DIRECTION_NONE will be returned.
|
|
*
|
|
* Return value: Text direction being exported.
|
|
*/
|
|
get_text_direction(): TextDirection;
|
|
}
|
|
|
|
namespace Menuitem {
|
|
// Signal callback interfaces
|
|
|
|
interface AboutToShow {
|
|
(): boolean;
|
|
}
|
|
|
|
interface ChildAdded {
|
|
(arg1: GObject.Object, arg2: number): void;
|
|
}
|
|
|
|
interface ChildMoved {
|
|
(arg1: GObject.Object, arg2: number, arg3: number): void;
|
|
}
|
|
|
|
interface ChildRemoved {
|
|
(arg1: GObject.Object): void;
|
|
}
|
|
|
|
interface Event {
|
|
(arg1: string, arg2: GLib.Variant, arg3: number): boolean;
|
|
}
|
|
|
|
interface ItemActivated {
|
|
(arg1: number): void;
|
|
}
|
|
|
|
interface PropertyChanged {
|
|
(arg1: string, arg2: GLib.Variant): void;
|
|
}
|
|
|
|
interface Realized {
|
|
(): void;
|
|
}
|
|
|
|
interface ShowToUser {
|
|
(arg1: number): void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
id: number;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is the #GObject based object that represents a menu
|
|
* item. It gets created the same on both the client and
|
|
* the server side and libdbusmenu-glib does the work of making
|
|
* this object model appear on both sides of DBus. Simple
|
|
* really, though through updates and people coming on and off
|
|
* the bus it can lead to lots of fun complex scenarios.
|
|
*/
|
|
class Menuitem extends GObject.Object {
|
|
static $gtype: GObject.GType<Menuitem>;
|
|
|
|
// Properties
|
|
|
|
get id(): number;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Menuitem.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): Menuitem;
|
|
|
|
static new_with_id(id: number): Menuitem;
|
|
|
|
// Signals
|
|
|
|
connect(id: string, callback: (...args: any[]) => any): number;
|
|
connect_after(id: string, callback: (...args: any[]) => any): number;
|
|
emit(id: string, ...args: any[]): void;
|
|
connect(signal: 'about-to-show', callback: (_source: this) => boolean): number;
|
|
connect_after(signal: 'about-to-show', callback: (_source: this) => boolean): number;
|
|
emit(signal: 'about-to-show'): void;
|
|
connect(
|
|
signal: 'child-added',
|
|
callback: (_source: this, arg1: GObject.Object, arg2: number) => void,
|
|
): number;
|
|
connect_after(
|
|
signal: 'child-added',
|
|
callback: (_source: this, arg1: GObject.Object, arg2: number) => void,
|
|
): number;
|
|
emit(signal: 'child-added', arg1: GObject.Object, arg2: number): void;
|
|
connect(
|
|
signal: 'child-moved',
|
|
callback: (_source: this, arg1: GObject.Object, arg2: number, arg3: number) => void,
|
|
): number;
|
|
connect_after(
|
|
signal: 'child-moved',
|
|
callback: (_source: this, arg1: GObject.Object, arg2: number, arg3: number) => void,
|
|
): number;
|
|
emit(signal: 'child-moved', arg1: GObject.Object, arg2: number, arg3: number): void;
|
|
connect(signal: 'child-removed', callback: (_source: this, arg1: GObject.Object) => void): number;
|
|
connect_after(signal: 'child-removed', callback: (_source: this, arg1: GObject.Object) => void): number;
|
|
emit(signal: 'child-removed', arg1: GObject.Object): void;
|
|
connect(
|
|
signal: 'event',
|
|
callback: (_source: this, arg1: string, arg2: GLib.Variant, arg3: number) => boolean,
|
|
): number;
|
|
connect_after(
|
|
signal: 'event',
|
|
callback: (_source: this, arg1: string, arg2: GLib.Variant, arg3: number) => boolean,
|
|
): number;
|
|
emit(signal: 'event', arg1: string, arg2: GLib.Variant, arg3: number): void;
|
|
connect(signal: 'item-activated', callback: (_source: this, arg1: number) => void): number;
|
|
connect_after(signal: 'item-activated', callback: (_source: this, arg1: number) => void): number;
|
|
emit(signal: 'item-activated', arg1: number): void;
|
|
connect(
|
|
signal: 'property-changed',
|
|
callback: (_source: this, arg1: string, arg2: GLib.Variant) => void,
|
|
): number;
|
|
connect_after(
|
|
signal: 'property-changed',
|
|
callback: (_source: this, arg1: string, arg2: GLib.Variant) => void,
|
|
): number;
|
|
emit(signal: 'property-changed', arg1: string, arg2: GLib.Variant): void;
|
|
connect(signal: 'realized', callback: (_source: this) => void): number;
|
|
connect_after(signal: 'realized', callback: (_source: this) => void): number;
|
|
emit(signal: 'realized'): void;
|
|
connect(signal: 'show-to-user', callback: (_source: this, arg1: number) => void): number;
|
|
connect_after(signal: 'show-to-user', callback: (_source: this, arg1: number) => void): number;
|
|
emit(signal: 'show-to-user', arg1: number): void;
|
|
|
|
// Virtual methods
|
|
|
|
vfunc_child_added(position: number): void;
|
|
vfunc_child_moved(newpos: number, oldpos: number): void;
|
|
vfunc_child_removed(): void;
|
|
/**
|
|
* This function is called to create an event. It is likely
|
|
* to be overrided by subclasses. The default menu item
|
|
* will respond to the activate signal and do:
|
|
*
|
|
* Emits the #DbusmenuMenuitem::item-activate signal on this
|
|
* menu item. Called by server objects when they get the
|
|
* appropriate DBus signals from the client.
|
|
*
|
|
* If you subclass this function you should really think
|
|
* about calling the parent function unless you have a good
|
|
* reason not to.
|
|
* @param name The name of the signal
|
|
* @param variant A value that could be set for the event
|
|
* @param timestamp The timestamp of when the event happened
|
|
*/
|
|
vfunc_handle_event(name: string, variant: GLib.Variant, timestamp: number): void;
|
|
vfunc_show_to_user(timestamp: number, cb_data?: any | null): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Puts `child` in the list of children for `mi` at the location
|
|
* specified in `position`. If there is not enough entires available
|
|
* then `child` will be placed at the end of the list.
|
|
* @param child The #DbusmenuMenuitem to make a child of @mi.
|
|
* @param position Where in @mi object's list of chidren @child should be placed.
|
|
* @returns Whether @child was added successfully.
|
|
*/
|
|
child_add_position(child: Menuitem, position: number): boolean;
|
|
/**
|
|
* This function adds `child` to the list of children on `mi` at
|
|
* the end of that list.
|
|
* @param child The #DbusmenMenuitem that will be a child
|
|
* @returns Whether the child has been added successfully.
|
|
*/
|
|
child_append(child: Menuitem): boolean;
|
|
/**
|
|
* This function removes `child` from the children list of `mi`. It does
|
|
* not call #g_object_unref on `child`.
|
|
* @param child The child #DbusmenuMenuitem that you want to no longer be a child of @mi.
|
|
* @returns If we were able to delete @child.
|
|
*/
|
|
child_delete(child: Menuitem): boolean;
|
|
/**
|
|
* Search the children of `mi` to find one with the ID of `id`.
|
|
* If it doesn't exist then we return #NULL.
|
|
* @param id The ID of the child that we're looking for.
|
|
* @returns The menu item with the ID @id or #NULL if it can't be found.
|
|
*/
|
|
child_find(id: number): Menuitem;
|
|
/**
|
|
* This function adds `child` to the list of children on `mi` at
|
|
* the beginning of that list.
|
|
* @param child The #DbusmenMenuitem that will be a child
|
|
* @returns Whether the child has been added successfully.
|
|
*/
|
|
child_prepend(child: Menuitem): boolean;
|
|
/**
|
|
* This function moves a child on the list of children. It is
|
|
* for a child that is already in the list, but simply needs a
|
|
* new location.
|
|
* @param child The #DbusmenuMenuitem that is a child needing to be moved
|
|
* @param position The position in the list to place it in
|
|
* @returns Whether the move was successful.
|
|
*/
|
|
child_reorder(child: Menuitem, position: number): boolean;
|
|
/**
|
|
* This function searchs the whole tree of children that
|
|
* are attached to `mi`. This could be quite a few nodes, all
|
|
* the way down the tree. It is a depth first search.
|
|
* @param id ID of the #DbusmenuMenuitem to search for
|
|
* @returns The #DbusmenuMenuitem with the ID of @id or #NULL if there isn't such a menu item in the tree represented by @mi.
|
|
*/
|
|
find_id(id: number): Menuitem;
|
|
/**
|
|
* This calls the function `func` on this menu item and all
|
|
* of the children of this item. And their children. And
|
|
* their children. And... you get the point. It will get
|
|
* called on the whole tree.
|
|
* @param func Function to call on every node in the tree
|
|
* @param data User data to pass to the function
|
|
*/
|
|
foreach(func?: any | null, data?: any | null): void;
|
|
/**
|
|
* Returns simply the list of children that this menu item
|
|
* has. The list is valid until another child related function
|
|
* is called, where it might be changed.
|
|
* @returns A #GList of pointers to #DbusmenuMenuitem objects.
|
|
*/
|
|
get_children(): Menuitem[];
|
|
/**
|
|
* Gets the unique ID for `mi`.
|
|
* @returns The ID of the @mi.
|
|
*/
|
|
get_id(): number;
|
|
/**
|
|
* This function looks up the parent of `mi`
|
|
* @returns The parent of this menu item
|
|
*/
|
|
get_parent(): Menuitem;
|
|
/**
|
|
* This function returns the position of the menu item `mi`
|
|
* in the children of `parent`. It will return zero if the
|
|
* menu item can't be found.
|
|
* @param parent The #DbusmenuMenuitem who's children contain @mi
|
|
* @returns The position of @mi in the children of @parent.
|
|
*/
|
|
get_position(parent: Menuitem): number;
|
|
/**
|
|
* This function is very similar to #dbusmenu_menuitem_get_position
|
|
* except that it only counts in the children that have been realized.
|
|
* @param parent The #DbusmenuMenuitem who's children contain @mi
|
|
* @returns The position of @mi in the realized children of @parent.
|
|
*/
|
|
get_position_realized(parent: Menuitem): number;
|
|
/**
|
|
* This function returns the internal value of whether this is a
|
|
* root node or not.
|
|
* @returns #TRUE if this is a root node
|
|
*/
|
|
get_root(): boolean;
|
|
/**
|
|
* This function is called to create an event. It is likely
|
|
* to be overrided by subclasses. The default menu item
|
|
* will respond to the activate signal and do:
|
|
*
|
|
* Emits the #DbusmenuMenuitem::item-activate signal on this
|
|
* menu item. Called by server objects when they get the
|
|
* appropriate DBus signals from the client.
|
|
*
|
|
* If you subclass this function you should really think
|
|
* about calling the parent function unless you have a good
|
|
* reason not to.
|
|
* @param name The name of the signal
|
|
* @param variant A value that could be set for the event
|
|
* @param timestamp The timestamp of when the event happened
|
|
*/
|
|
handle_event(name: string, variant: GLib.Variant, timestamp: number): void;
|
|
/**
|
|
* This function takes the properties of a #DbusmenuMenuitem
|
|
* and puts them into a #GHashTable that is referenced by the
|
|
* key of a string and has the value of a string. The hash
|
|
* table may not have any entries if there aren't any or there
|
|
* is an error in processing. It is the caller's responsibility
|
|
* to destroy the created #GHashTable.
|
|
* @returns A brand new #GHashTable that contains all of theroperties that are on this #DbusmenuMenuitem @mi.
|
|
*/
|
|
properties_copy(): GLib.HashTable<any, any>;
|
|
/**
|
|
* This functiong gets a list of the names of all the properties
|
|
* that are set on this menu item. This data on the list is owned
|
|
* by the menuitem but the list is not and should be freed using
|
|
* g_list_free() when the calling function is done with it.
|
|
* @returns A list of strings or NULL if there are none.
|
|
*/
|
|
properties_list(): string[];
|
|
/**
|
|
* Checkes to see if a particular property exists on `mi` and
|
|
* returns #TRUE if so.
|
|
* @param property The property to look for.
|
|
* @returns A boolean checking to see if the property is available
|
|
*/
|
|
property_exist(property: string): boolean;
|
|
/**
|
|
* Look up a property on `mi` and return the value of it if
|
|
* it exits. #NULL will be returned if the property doesn't
|
|
* exist.
|
|
* @param property The property to grab.
|
|
* @returns A string with the value of the property that shouldn't be free'd. Or #NULL if the property is not set or is not a string.
|
|
*/
|
|
property_get(property: string): string;
|
|
/**
|
|
* Look up a property on `mi` and return the value of it if
|
|
* it exits. Returns #FALSE if the property doesn't exist.
|
|
* @param property The property to grab.
|
|
* @returns The value of the property or #FALSE.
|
|
*/
|
|
property_get_bool(property: string): boolean;
|
|
/**
|
|
* Look up a property on `mi` and return the value of it if
|
|
* it exits. #NULL will be returned if the property doesn't
|
|
* exist.
|
|
* @param property The property to grab.
|
|
* @returns A byte array with the value of the property that shouldn't be free'd. Or #NULL if the property is not set or is not a byte array.
|
|
*/
|
|
property_get_byte_array(property: string): Uint8Array;
|
|
/**
|
|
* Look up a property on `mi` and return the value of it if
|
|
* it exits. Returns zero if the property doesn't exist.
|
|
* @param property The property to grab.
|
|
* @returns The value of the property or zero.
|
|
*/
|
|
property_get_int(property: string): number;
|
|
/**
|
|
* Look up a property on `mi` and return the value of it if
|
|
* it exits. #NULL will be returned if the property doesn't
|
|
* exist.
|
|
* @param property The property to grab.
|
|
* @returns A GVariant for the property.
|
|
*/
|
|
property_get_variant(property: string): GLib.Variant;
|
|
/**
|
|
* Removes a property from the menuitem.
|
|
* @param property The property to look for.
|
|
*/
|
|
property_remove(property: string): void;
|
|
/**
|
|
* Takes the pair of `property` and `value` and places them as a
|
|
* property on `mi`. If a property already exists by that name,
|
|
* then the value is set to the new value. If not, the property
|
|
* is added. If the value is changed or the property was previously
|
|
* unset then the signal #DbusmenuMenuitem::prop-changed will be
|
|
* emitted by this function.
|
|
* @param property Name of the property to set.
|
|
* @param value The value of the property.
|
|
* @returns A boolean representing if the property value was set.
|
|
*/
|
|
property_set(property: string, value: string): boolean;
|
|
/**
|
|
* Takes a boolean `value` and sets it on `property` as a
|
|
* property on `mi`. If a property already exists by that name,
|
|
* then the value is set to the new value. If not, the property
|
|
* is added. If the value is changed or the property was previously
|
|
* unset then the signal #DbusmenuMenuitem::prop-changed will be
|
|
* emitted by this function.
|
|
* @param property Name of the property to set.
|
|
* @param value The value of the property.
|
|
* @returns A boolean representing if the property value was set.
|
|
*/
|
|
property_set_bool(property: string, value: boolean): boolean;
|
|
/**
|
|
* Takes a byte array `value` and sets it on `property` as a
|
|
* property on `mi`. If a property already exists by that name,
|
|
* then the value is set to the new value. If not, the property
|
|
* is added. If the value is changed or the property was previously
|
|
* unset then the signal #DbusmenuMenuitem::prop-changed will be
|
|
* emitted by this function.
|
|
* @param property Name of the property to set.
|
|
* @param value The byte array.
|
|
* @param nelements The number of elements in the byte array.
|
|
* @returns A boolean representing if the property value was set.
|
|
*/
|
|
property_set_byte_array(property: string, value: number, nelements: number): boolean;
|
|
/**
|
|
* Takes a boolean `value` and sets it on `property` as a
|
|
* property on `mi`. If a property already exists by that name,
|
|
* then the value is set to the new value. If not, the property
|
|
* is added. If the value is changed or the property was previously
|
|
* unset then the signal #DbusmenuMenuitem::prop-changed will be
|
|
* emitted by this function.
|
|
* @param property Name of the property to set.
|
|
* @param value The value of the property.
|
|
* @returns A boolean representing if the property value was set.
|
|
*/
|
|
property_set_int(property: string, value: number): boolean;
|
|
/**
|
|
* Takes the pair of `property` and `value` and places them as a
|
|
* property on `mi`. If a property already exists by that name,
|
|
* then the value is set to the new value. If not, the property
|
|
* is added. If the value is changed or the property was previously
|
|
* unset then the signal #DbusmenuMenuitem::prop-changed will be
|
|
* emitted by this function.
|
|
* @param property Name of the property to set.
|
|
* @param value The value of the property.
|
|
* @returns A boolean representing if the property value was set.
|
|
*/
|
|
property_set_variant(property: string, value: GLib.Variant): boolean;
|
|
/**
|
|
* This function is used to send the even that the submenu
|
|
* of this item is about to be shown. Callers to this event
|
|
* should delay showing the menu until their callback is
|
|
* called if possible.
|
|
* @param cb Callback to call when the call has returned.
|
|
* @param cb_data Data to pass to the callback.
|
|
*/
|
|
send_about_to_show(cb?: any | null, cb_data?: any | null): void;
|
|
/**
|
|
* Sets the parent of `mi` to `parent`. If `mi` already
|
|
* has a parent, then this call will fail. The parent will
|
|
* be set automatically when using the usual methods to add a
|
|
* child menuitem, so this function should not normally be
|
|
* called directly
|
|
* @param parent The new parent #DbusmenuMenuitem
|
|
* @returns Whether the parent was set successfully
|
|
*/
|
|
set_parent(parent: Menuitem): boolean;
|
|
/**
|
|
* This function sets the internal value of whether this is a
|
|
* root node or not.
|
|
* @param root Whether @mi is a root node or not
|
|
*/
|
|
set_root(root: boolean): void;
|
|
/**
|
|
* Signals that this menu item should be shown to the user. If this is
|
|
* server side the server will then take it and send it over the
|
|
* bus.
|
|
* @param timestamp The time that the user requested it to be shown
|
|
*/
|
|
show_to_user(timestamp: number): void;
|
|
/**
|
|
* While the name sounds devious that's exactly what this function
|
|
* does. It takes the list of children from the `mi` and clears the
|
|
* internal list. The calling function is now in charge of the ref's
|
|
* on the children it has taken. A lot of responsibility involved
|
|
* in taking children.
|
|
* @returns A #GList of pointers to #DbusmenuMenuitem objects.
|
|
*/
|
|
take_children(): Menuitem[];
|
|
/**
|
|
* Unparents the menu item `mi`. If `mi` doesn't have a
|
|
* parent, then this call will fail. The menuitem will
|
|
* be unparented automatically when using the usual methods
|
|
* to delete a child menuitem, so this function should not
|
|
* normally be called directly
|
|
* @returns Whether the menu item was unparented successfully
|
|
*/
|
|
unparent(): boolean;
|
|
}
|
|
|
|
namespace MenuitemProxy {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Menuitem.ConstructorProps {
|
|
menu_item: Menuitem;
|
|
menuItem: Menuitem;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Public instance data for a #DbusmenuMenuitemProxy.
|
|
*/
|
|
class MenuitemProxy extends Menuitem {
|
|
static $gtype: GObject.GType<MenuitemProxy>;
|
|
|
|
// Properties
|
|
|
|
get menu_item(): Menuitem;
|
|
get menuItem(): Menuitem;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<MenuitemProxy.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](mi: Menuitem): MenuitemProxy;
|
|
// Conflicted with Dbusmenu.Menuitem.new
|
|
|
|
static ['new'](...args: never[]): any;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Accesses the private variable of which #DbusmenuMenuitem
|
|
* we are doing the proxying for.
|
|
* @returns A #DbusmenuMenuitem object or a #NULL if we don't have one or there is an error.
|
|
*/
|
|
get_wrapped(): Menuitem;
|
|
}
|
|
|
|
namespace Server {
|
|
// Signal callback interfaces
|
|
|
|
interface ItemActivationRequested {
|
|
(arg1: number, arg2: number): void;
|
|
}
|
|
|
|
interface ItemPropertyUpdated {
|
|
(object: number, p0: string, p1: GLib.Variant): void;
|
|
}
|
|
|
|
interface ItemUpdated {
|
|
(object: number): void;
|
|
}
|
|
|
|
interface LayoutUpdated {
|
|
(arg1: number, arg2: number): void;
|
|
}
|
|
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
dbus_object: string;
|
|
dbusObject: string;
|
|
root_node: Menuitem;
|
|
rootNode: Menuitem;
|
|
version: number;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A server which represents a sharing of a set of
|
|
* #DbusmenuMenuitems across DBus to a #DbusmenuClient.
|
|
*/
|
|
class Server extends GObject.Object {
|
|
static $gtype: GObject.GType<Server>;
|
|
|
|
// Properties
|
|
|
|
get dbus_object(): string;
|
|
get dbusObject(): string;
|
|
get root_node(): Menuitem;
|
|
set root_node(val: Menuitem);
|
|
get rootNode(): Menuitem;
|
|
set rootNode(val: Menuitem);
|
|
get version(): number;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Server.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](object: string): Server;
|
|
|
|
// Signals
|
|
|
|
connect(id: string, callback: (...args: any[]) => any): number;
|
|
connect_after(id: string, callback: (...args: any[]) => any): number;
|
|
emit(id: string, ...args: any[]): void;
|
|
connect(
|
|
signal: 'item-activation-requested',
|
|
callback: (_source: this, arg1: number, arg2: number) => void,
|
|
): number;
|
|
connect_after(
|
|
signal: 'item-activation-requested',
|
|
callback: (_source: this, arg1: number, arg2: number) => void,
|
|
): number;
|
|
emit(signal: 'item-activation-requested', arg1: number, arg2: number): void;
|
|
connect(
|
|
signal: 'item-property-updated',
|
|
callback: (_source: this, object: number, p0: string, p1: GLib.Variant) => void,
|
|
): number;
|
|
connect_after(
|
|
signal: 'item-property-updated',
|
|
callback: (_source: this, object: number, p0: string, p1: GLib.Variant) => void,
|
|
): number;
|
|
emit(signal: 'item-property-updated', object: number, p0: string, p1: GLib.Variant): void;
|
|
connect(signal: 'item-updated', callback: (_source: this, object: number) => void): number;
|
|
connect_after(signal: 'item-updated', callback: (_source: this, object: number) => void): number;
|
|
emit(signal: 'item-updated', object: number): void;
|
|
connect(signal: 'layout-updated', callback: (_source: this, arg1: number, arg2: number) => void): number;
|
|
connect_after(
|
|
signal: 'layout-updated',
|
|
callback: (_source: this, arg1: number, arg2: number) => void,
|
|
): number;
|
|
emit(signal: 'layout-updated', arg1: number, arg2: number): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Gets the stored and exported icon paths from the server.
|
|
* @returns A NULL-terminated list of icon paths with memory managed by the server. Duplicate if you want to keep them.
|
|
*/
|
|
get_icon_paths(): string[];
|
|
/**
|
|
* Gets the current statust hat the server is sending out over
|
|
* DBus.
|
|
*
|
|
* Return value: The current status the server is sending
|
|
*/
|
|
get_status(): Status;
|
|
/**
|
|
* Returns the value of the text direction that is being exported
|
|
* over DBus for this server. It should relate to the direction
|
|
* of the labels and other text fields that are being exported by
|
|
* this server.
|
|
*
|
|
* Return value: Text direction exported for this server.
|
|
*/
|
|
get_text_direction(): TextDirection;
|
|
/**
|
|
* Sets the icon paths for the server. This will replace previously
|
|
* set icon theme paths.
|
|
* @param icon_paths
|
|
*/
|
|
set_icon_paths(icon_paths: string[]): void;
|
|
/**
|
|
* This function contains all of the #GValue wrapping
|
|
* required to set the property #DbusmenuServer:root-node
|
|
* on the server `self`.
|
|
* @param root The new root #DbusmenuMenuitem tree
|
|
*/
|
|
set_root(root: Menuitem): void;
|
|
/**
|
|
* Changes the status of the server.
|
|
* @param status Status value to set on the server
|
|
*/
|
|
set_status(status: Status | null): void;
|
|
/**
|
|
* Sets the text direction that should be exported over DBus for
|
|
* this server. If the value is set to #DBUSMENU_TEXT_DIRECTION_NONE
|
|
* the default detection will be used for setting the value and
|
|
* exported over DBus.
|
|
* @param dir Direction of the text
|
|
*/
|
|
set_text_direction(dir: TextDirection | null): void;
|
|
}
|
|
|
|
type ClientClass = typeof Client;
|
|
abstract class ClientPrivate {
|
|
static $gtype: GObject.GType<ClientPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type MenuitemClass = typeof Menuitem;
|
|
/**
|
|
* These are the little secrets that we don't want getting
|
|
* out of data that we have. They can still be gotten using
|
|
* accessor functions, but are protected appropriately.
|
|
*/
|
|
abstract class MenuitemPrivate {
|
|
static $gtype: GObject.GType<MenuitemPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type MenuitemProxyClass = typeof MenuitemProxy;
|
|
abstract class MenuitemProxyPrivate {
|
|
static $gtype: GObject.GType<MenuitemProxyPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type ServerClass = typeof Server;
|
|
abstract class ServerPrivate {
|
|
static $gtype: GObject.GType<ServerPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
/**
|
|
* Name of the imported GIR library
|
|
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
|
|
*/
|
|
const __name__: string;
|
|
/**
|
|
* Version of the imported GIR library
|
|
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
|
|
*/
|
|
const __version__: string;
|
|
}
|
|
|
|
export default Dbusmenu;
|
|
}
|
|
|
|
declare module 'gi://Dbusmenu' {
|
|
import Dbusmenu04 from 'gi://Dbusmenu?version=0.4';
|
|
export default Dbusmenu04;
|
|
}
|
|
// END
|