@girs/amtk-5
Advanced tools
Comparing version 5.0.0-3.3.0 to 5.0.0-4.0.0-beta.1
| declare module 'gi://Amtk?version=5' { | ||
| import Amtk5 from '@girs/amtk-5'; | ||
| export default Amtk5; | ||
| import Amtk from '@girs/amtk-5'; | ||
| export default Amtk; | ||
| } | ||
| declare module 'gi://Amtk' { | ||
| import Amtk5 from '@girs/amtk-5'; | ||
| import Amtk5 from 'gi://Amtk?version=5'; | ||
| export default Amtk5; | ||
@@ -10,0 +10,0 @@ } |
1738
amtk-5.d.ts
@@ -1,2 +0,1 @@ | ||
| /* | ||
@@ -10,3 +9,3 @@ * Type Definitions for Gjs (https://gjs.guide/) | ||
| import './amtk-5-ambient.d.ts'; | ||
| import './amtk-5-import.d.ts'; | ||
| /** | ||
@@ -31,502 +30,454 @@ * Amtk-5 | ||
| export namespace Amtk { | ||
| /** | ||
| * #AmtkFactoryFlags permits to control how a factory function creates the | ||
| * object, to ignore some steps. | ||
| * @bitfield | ||
| */ | ||
| enum FactoryFlags { | ||
| /** | ||
| * No flags. | ||
| * A wrapper function for g_action_map_add_action_entries() that checks | ||
| * duplicates. | ||
| * | ||
| * This function first checks - for each entry - that the `action_map` doesn't | ||
| * already contain a #GAction with the same name. A warning is printed if an old | ||
| * action will be dropped. In any case, it then calls | ||
| * g_action_map_add_action_entries() with the same arguments as passed to this | ||
| * function. | ||
| * | ||
| * This function also checks if there are duplicates in the `entries` array | ||
| * itself. | ||
| * @param action_map a #GActionMap. | ||
| * @param entries a pointer to the first item in an array of #GActionEntry structs. | ||
| * @param user_data the user data for signal connections. | ||
| */ | ||
| FLAGS_NONE, | ||
| function action_map_add_action_entries_check_dups( | ||
| action_map: Gio.ActionMap, | ||
| entries: Gio.ActionEntry[], | ||
| user_data?: any | null, | ||
| ): void; | ||
| /** | ||
| * Do not associate the created object with the | ||
| * #GAction. For example if the object to create is a #GtkActionable, do not | ||
| * call gtk_actionable_set_detailed_action_name(). | ||
| * Free the resources allocated by Amtk. For example it unrefs the singleton | ||
| * objects. | ||
| * | ||
| * It is not mandatory to call this function, it's just to be friendlier to | ||
| * memory debugging tools. This function is meant to be called at the end of | ||
| * main(). It can be called several times. | ||
| */ | ||
| IGNORE_GACTION, | ||
| function finalize(): void; | ||
| /** | ||
| * Do not set an icon. | ||
| * Like g_menu_append_item() but with (transfer full) for the `item` parameter. | ||
| * @param menu a #GMenu. | ||
| * @param item a #GMenuItem to append. | ||
| */ | ||
| IGNORE_ICON, | ||
| function gmenu_append_item(menu: Gio.Menu, item: Gio.MenuItem): void; | ||
| /** | ||
| * Do not set a label/short description. | ||
| * Like g_menu_append_section() but with (transfer full) and a different type | ||
| * for the `section` parameter, and calls g_menu_freeze() on `section`. | ||
| * @param menu a #GMenu. | ||
| * @param label the section label, or %NULL. | ||
| * @param section a #GMenu with the items of the section. | ||
| */ | ||
| IGNORE_LABEL, | ||
| function gmenu_append_section(menu: Gio.Menu, label: string | null, section: Gio.Menu): void; | ||
| /** | ||
| * Do not set a tooltip/long description. | ||
| * Initializes the Amtk library (e.g. for the internationalization). | ||
| * | ||
| * This function can be called several times, but is meant to be called at the | ||
| * beginning of main(), before any other Amtk function call. | ||
| */ | ||
| IGNORE_TOOLTIP, | ||
| function init(): void; | ||
| function menu_item_get_long_description(menu_item: Gtk.MenuItem): string | null; | ||
| /** | ||
| * Ignore completely the accelerators. | ||
| * Sets an icon to a #GtkMenuItem. | ||
| * | ||
| * If the child widget of `item` is already a #GtkBox, all #GtkImage widgets | ||
| * inside that box are first destroyed. A #GtkImage for `icon_name` is then | ||
| * inserted to the box. | ||
| * | ||
| * If the child widget of `item` is not a #GtkBox (it's usually the | ||
| * #GtkAccelLabel), it is replaced by a new #GtkBox and the initial child widget | ||
| * is inserted to the #GtkBox, alongside the icon. | ||
| * | ||
| * As a consequence, if you want to call functions on the #GtkAccelLabel, it's | ||
| * easier to do it before calling this function. | ||
| * @param item a #GtkMenuItem. | ||
| * @param icon_name an icon name. | ||
| */ | ||
| IGNORE_ACCELS, | ||
| function menu_item_set_icon_name(item: Gtk.MenuItem, icon_name: string): void; | ||
| /** | ||
| * Ignore the accelerators for | ||
| * documentation purposes only. For example do not add/configure a | ||
| * #GtkAccelLabel. | ||
| * Sets the long description of `menu_item`. A possible use-case is to display it | ||
| * in a #GtkStatusbar, or as a tooltip. | ||
| * @param menu_item a #GtkMenuItem. | ||
| * @param long_description the long description, or %NULL to unset it. | ||
| */ | ||
| IGNORE_ACCELS_FOR_DOC, | ||
| function menu_item_set_long_description(menu_item: Gtk.MenuItem, long_description?: string | null): void; | ||
| function shortcuts_group_new(title: string): Gtk.Container; | ||
| function shortcuts_section_new(title: string): Gtk.Container; | ||
| /** | ||
| * Do not call | ||
| * gtk_application_set_accels_for_action(). | ||
| * Creates a new #GtkShortcutsWindow. The #GtkWindow:modal property is set to | ||
| * %TRUE. | ||
| * | ||
| * It is on purpose that the return type is #GtkShortcutsWindow, not #GtkWidget | ||
| * or something else, so in C when you declare the variable as | ||
| * #GtkShortcutsWindow it's easier to find it later (searching "GtkShortcuts" | ||
| * will return something in your codebase). | ||
| * @param parent the #GtkWindow:transient-for. | ||
| * @returns a new #GtkShortcutsWindow. | ||
| */ | ||
| IGNORE_ACCELS_FOR_APP, | ||
| } | ||
| /** | ||
| * A wrapper function for g_action_map_add_action_entries() that checks | ||
| * duplicates. | ||
| * | ||
| * This function first checks - for each entry - that the `action_map` doesn't | ||
| * already contain a #GAction with the same name. A warning is printed if an old | ||
| * action will be dropped. In any case, it then calls | ||
| * g_action_map_add_action_entries() with the same arguments as passed to this | ||
| * function. | ||
| * | ||
| * This function also checks if there are duplicates in the `entries` array | ||
| * itself. | ||
| * @param action_map a #GActionMap. | ||
| * @param entries a pointer to the first item in an array of #GActionEntry structs. | ||
| * @param user_data the user data for signal connections. | ||
| */ | ||
| function action_map_add_action_entries_check_dups(action_map: Gio.ActionMap, entries: Gio.ActionEntry[], user_data: any | null): void | ||
| /** | ||
| * Free the resources allocated by Amtk. For example it unrefs the singleton | ||
| * objects. | ||
| * | ||
| * It is not mandatory to call this function, it's just to be friendlier to | ||
| * memory debugging tools. This function is meant to be called at the end of | ||
| * main(). It can be called several times. | ||
| */ | ||
| function finalize(): void | ||
| /** | ||
| * Like g_menu_append_item() but with (transfer full) for the `item` parameter. | ||
| * @param menu a #GMenu. | ||
| * @param item a #GMenuItem to append. | ||
| */ | ||
| function gmenu_append_item(menu: Gio.Menu, item: Gio.MenuItem): void | ||
| /** | ||
| * Like g_menu_append_section() but with (transfer full) and a different type | ||
| * for the `section` parameter, and calls g_menu_freeze() on `section`. | ||
| * @param menu a #GMenu. | ||
| * @param label the section label, or %NULL. | ||
| * @param section a #GMenu with the items of the section. | ||
| */ | ||
| function gmenu_append_section(menu: Gio.Menu, label: string | null, section: Gio.Menu): void | ||
| /** | ||
| * Initializes the Amtk library (e.g. for the internationalization). | ||
| * | ||
| * This function can be called several times, but is meant to be called at the | ||
| * beginning of main(), before any other Amtk function call. | ||
| */ | ||
| function init(): void | ||
| function menu_item_get_long_description(menu_item: Gtk.MenuItem): string | null | ||
| /** | ||
| * Sets an icon to a #GtkMenuItem. | ||
| * | ||
| * If the child widget of `item` is already a #GtkBox, all #GtkImage widgets | ||
| * inside that box are first destroyed. A #GtkImage for `icon_name` is then | ||
| * inserted to the box. | ||
| * | ||
| * If the child widget of `item` is not a #GtkBox (it's usually the | ||
| * #GtkAccelLabel), it is replaced by a new #GtkBox and the initial child widget | ||
| * is inserted to the #GtkBox, alongside the icon. | ||
| * | ||
| * As a consequence, if you want to call functions on the #GtkAccelLabel, it's | ||
| * easier to do it before calling this function. | ||
| * @param item a #GtkMenuItem. | ||
| * @param icon_name an icon name. | ||
| */ | ||
| function menu_item_set_icon_name(item: Gtk.MenuItem, icon_name: string): void | ||
| /** | ||
| * Sets the long description of `menu_item`. A possible use-case is to display it | ||
| * in a #GtkStatusbar, or as a tooltip. | ||
| * @param menu_item a #GtkMenuItem. | ||
| * @param long_description the long description, or %NULL to unset it. | ||
| */ | ||
| function menu_item_set_long_description(menu_item: Gtk.MenuItem, long_description: string | null): void | ||
| function shortcuts_group_new(title: string): Gtk.Container | ||
| function shortcuts_section_new(title: string): Gtk.Container | ||
| /** | ||
| * Creates a new #GtkShortcutsWindow. The #GtkWindow:modal property is set to | ||
| * %TRUE. | ||
| * | ||
| * It is on purpose that the return type is #GtkShortcutsWindow, not #GtkWidget | ||
| * or something else, so in C when you declare the variable as | ||
| * #GtkShortcutsWindow it's easier to find it later (searching "GtkShortcuts" | ||
| * will return something in your codebase). | ||
| * @param parent the #GtkWindow:transient-for. | ||
| * @returns a new #GtkShortcutsWindow. | ||
| */ | ||
| function shortcuts_window_new(parent: Gtk.Window): Gtk.ShortcutsWindow | ||
| /** | ||
| * Utility function to be able to port an application gradually to #GAction, | ||
| * when #GtkUIManager and #GtkAction are still used. Porting to #GAction should | ||
| * be the first step. | ||
| * | ||
| * For `detailed_g_action_name_without_prefix,` see the | ||
| * g_action_parse_detailed_name() function. The `"app."` or `"win."` prefix (or | ||
| * any other #GActionMap prefix) must not be included in | ||
| * `detailed_g_action_name_without_prefix`. For example a valid | ||
| * `detailed_g_action_name_without_prefix` is `"open"` or | ||
| * `"insert-command::foobar"`. | ||
| * | ||
| * The same #GAction can be bound to several #GtkAction's (with different | ||
| * parameter values for the #GAction), but the reverse is not true, one | ||
| * #GtkAction cannot be bound to several #GAction's. | ||
| * | ||
| * This function: | ||
| * - Calls g_action_activate() when the #GtkAction #GtkAction::activate signal | ||
| * is emitted. | ||
| * - Binds the #GAction #GAction:enabled property to the #GtkAction | ||
| * #GtkAction:sensitive property. The binding is done with the | ||
| * %G_BINDING_BIDIRECTIONAL and %G_BINDING_SYNC_CREATE flags, the source is | ||
| * the #GAction and the target is the #GtkAction. | ||
| * | ||
| * When using this function, you should set the callback to %NULL in the | ||
| * corresponding #GtkActionEntry. | ||
| * @param g_action_map a #GActionMap. | ||
| * @param detailed_g_action_name_without_prefix a detailed #GAction name without the #GActionMap prefix; the #GAction must be present in `g_action_map`. | ||
| * @param gtk_action_group a #GtkActionGroup. | ||
| * @param gtk_action_name a #GtkAction name present in `gtk_action_group`. | ||
| */ | ||
| function utils_bind_g_action_to_gtk_action(g_action_map: Gio.ActionMap, detailed_g_action_name_without_prefix: string, gtk_action_group: Gtk.ActionGroup, gtk_action_name: string): void | ||
| /** | ||
| * Utility function to be able to port an application gradually to #GAction and | ||
| * #AmtkActionInfo, when #GtkUIManager is still used. This function goes one | ||
| * step further compared to amtk_utils_bind_g_action_to_gtk_action(). With | ||
| * amtk_utils_bind_g_action_to_gtk_action(), only the #GAction must exist. With | ||
| * amtk_utils_create_gtk_action(), both the #GAction and #AmtkActionInfo must | ||
| * exist (so typically you need to convert the #GtkActionEntry's into | ||
| * #AmtkActionInfoEntry's). | ||
| * | ||
| * This function creates a #GtkAction from a #GAction plus its corresponding | ||
| * #AmtkActionInfo. | ||
| * | ||
| * The #GtkAction is created with the information provided by the | ||
| * #AmtkActionInfo (retrieved with amtk_action_info_central_store_lookup() with | ||
| * `detailed_g_action_name_with_prefix` as argument). Only the first accelerator | ||
| * is taken into account. | ||
| * | ||
| * Once the #GtkAction is created, it is added to the `gtk_action_group,` and | ||
| * amtk_utils_bind_g_action_to_gtk_action() is called. | ||
| * @param g_action_map a #GActionMap. | ||
| * @param detailed_g_action_name_with_prefix a detailed #GAction name with the #GActionMap prefix; the #GAction must be present in `g_action_map`. | ||
| * @param gtk_action_group a #GtkActionGroup. | ||
| * @param gtk_action_name the name of the #GtkAction to create and add to `gtk_action_group`. | ||
| */ | ||
| function utils_create_gtk_action(g_action_map: Gio.ActionMap, detailed_g_action_name_with_prefix: string, gtk_action_group: Gtk.ActionGroup, gtk_action_name: string): void | ||
| /** | ||
| * This function wraps `menubar` into a container, to allow the menubar to shrink | ||
| * below its minimum width. | ||
| * | ||
| * A possible use-case: have two applications side-by-side on a single screen. | ||
| * @param menubar a #GtkMenuBar. | ||
| * @returns a new widget that contains @menubar. | ||
| */ | ||
| function utils_get_shrinkable_menubar(menubar: Gtk.MenuBar): Gtk.Widget | ||
| /** | ||
| * Gets the URI of `item`. `item` must be a child of `menu`. `menu` must be a | ||
| * #GtkRecentChooserMenu. | ||
| * | ||
| * This function has been written because the value returned by | ||
| * gtk_recent_chooser_get_current_uri() is not updated when #GtkMenuItem's of a | ||
| * #GtkRecentChooserMenu are selected/deselected. | ||
| * @param menu a #GtkRecentChooserMenu. | ||
| * @param item a #GtkMenuItem. | ||
| * @returns the URI of @item. Free with g_free() when no longer needed. | ||
| */ | ||
| function utils_recent_chooser_menu_get_item_uri(menu: Gtk.RecentChooserMenu, item: Gtk.MenuItem): string | null | ||
| /** | ||
| * Removes the mnemonics from `str`. Single underscores are removed, and two | ||
| * consecutive underscores are replaced by one underscore (see the documentation | ||
| * of gtk_label_new_with_mnemonic()). | ||
| * @param str a string. | ||
| * @returns the new string with the mnemonics removed. Free with g_free() when no longer needed. | ||
| */ | ||
| function utils_remove_mnemonic(str: string): string | null | ||
| module ActionInfoCentralStore { | ||
| function shortcuts_window_new(parent: Gtk.Window): Gtk.ShortcutsWindow; | ||
| /** | ||
| * Utility function to be able to port an application gradually to #GAction, | ||
| * when #GtkUIManager and #GtkAction are still used. Porting to #GAction should | ||
| * be the first step. | ||
| * | ||
| * For `detailed_g_action_name_without_prefix,` see the | ||
| * g_action_parse_detailed_name() function. The `"app."` or `"win."` prefix (or | ||
| * any other #GActionMap prefix) must not be included in | ||
| * `detailed_g_action_name_without_prefix`. For example a valid | ||
| * `detailed_g_action_name_without_prefix` is `"open"` or | ||
| * `"insert-command::foobar"`. | ||
| * | ||
| * The same #GAction can be bound to several #GtkAction's (with different | ||
| * parameter values for the #GAction), but the reverse is not true, one | ||
| * #GtkAction cannot be bound to several #GAction's. | ||
| * | ||
| * This function: | ||
| * - Calls g_action_activate() when the #GtkAction #GtkAction::activate signal | ||
| * is emitted. | ||
| * - Binds the #GAction #GAction:enabled property to the #GtkAction | ||
| * #GtkAction:sensitive property. The binding is done with the | ||
| * %G_BINDING_BIDIRECTIONAL and %G_BINDING_SYNC_CREATE flags, the source is | ||
| * the #GAction and the target is the #GtkAction. | ||
| * | ||
| * When using this function, you should set the callback to %NULL in the | ||
| * corresponding #GtkActionEntry. | ||
| * @param g_action_map a #GActionMap. | ||
| * @param detailed_g_action_name_without_prefix a detailed #GAction name without the #GActionMap prefix; the #GAction must be present in @g_action_map. | ||
| * @param gtk_action_group a #GtkActionGroup. | ||
| * @param gtk_action_name a #GtkAction name present in @gtk_action_group. | ||
| */ | ||
| function utils_bind_g_action_to_gtk_action( | ||
| g_action_map: Gio.ActionMap, | ||
| detailed_g_action_name_without_prefix: string, | ||
| gtk_action_group: Gtk.ActionGroup, | ||
| gtk_action_name: string, | ||
| ): void; | ||
| /** | ||
| * Utility function to be able to port an application gradually to #GAction and | ||
| * #AmtkActionInfo, when #GtkUIManager is still used. This function goes one | ||
| * step further compared to amtk_utils_bind_g_action_to_gtk_action(). With | ||
| * amtk_utils_bind_g_action_to_gtk_action(), only the #GAction must exist. With | ||
| * amtk_utils_create_gtk_action(), both the #GAction and #AmtkActionInfo must | ||
| * exist (so typically you need to convert the #GtkActionEntry's into | ||
| * #AmtkActionInfoEntry's). | ||
| * | ||
| * This function creates a #GtkAction from a #GAction plus its corresponding | ||
| * #AmtkActionInfo. | ||
| * | ||
| * The #GtkAction is created with the information provided by the | ||
| * #AmtkActionInfo (retrieved with amtk_action_info_central_store_lookup() with | ||
| * `detailed_g_action_name_with_prefix` as argument). Only the first accelerator | ||
| * is taken into account. | ||
| * | ||
| * Once the #GtkAction is created, it is added to the `gtk_action_group,` and | ||
| * amtk_utils_bind_g_action_to_gtk_action() is called. | ||
| * @param g_action_map a #GActionMap. | ||
| * @param detailed_g_action_name_with_prefix a detailed #GAction name with the #GActionMap prefix; the #GAction must be present in @g_action_map. | ||
| * @param gtk_action_group a #GtkActionGroup. | ||
| * @param gtk_action_name the name of the #GtkAction to create and add to @gtk_action_group. | ||
| */ | ||
| function utils_create_gtk_action( | ||
| g_action_map: Gio.ActionMap, | ||
| detailed_g_action_name_with_prefix: string, | ||
| gtk_action_group: Gtk.ActionGroup, | ||
| gtk_action_name: string, | ||
| ): void; | ||
| /** | ||
| * This function wraps `menubar` into a container, to allow the menubar to shrink | ||
| * below its minimum width. | ||
| * | ||
| * A possible use-case: have two applications side-by-side on a single screen. | ||
| * @param menubar a #GtkMenuBar. | ||
| * @returns a new widget that contains @menubar. | ||
| */ | ||
| function utils_get_shrinkable_menubar(menubar: Gtk.MenuBar): Gtk.Widget; | ||
| /** | ||
| * Gets the URI of `item`. `item` must be a child of `menu`. `menu` must be a | ||
| * #GtkRecentChooserMenu. | ||
| * | ||
| * This function has been written because the value returned by | ||
| * gtk_recent_chooser_get_current_uri() is not updated when #GtkMenuItem's of a | ||
| * #GtkRecentChooserMenu are selected/deselected. | ||
| * @param menu a #GtkRecentChooserMenu. | ||
| * @param item a #GtkMenuItem. | ||
| * @returns the URI of @item. Free with g_free() when no longer needed. | ||
| */ | ||
| function utils_recent_chooser_menu_get_item_uri(menu: Gtk.RecentChooserMenu, item: Gtk.MenuItem): string; | ||
| /** | ||
| * Removes the mnemonics from `str`. Single underscores are removed, and two | ||
| * consecutive underscores are replaced by one underscore (see the documentation | ||
| * of gtk_label_new_with_mnemonic()). | ||
| * @param str a string. | ||
| * @returns the new string with the mnemonics removed. Free with g_free() when no longer needed. | ||
| */ | ||
| function utils_remove_mnemonic(str: string): string; | ||
| /** | ||
| * #AmtkFactoryFlags permits to control how a factory function creates the | ||
| * object, to ignore some steps. | ||
| */ | ||
| enum FactoryFlags { | ||
| /** | ||
| * No flags. | ||
| */ | ||
| FLAGS_NONE, | ||
| /** | ||
| * Do not associate the created object with the | ||
| * #GAction. For example if the object to create is a #GtkActionable, do not | ||
| * call gtk_actionable_set_detailed_action_name(). | ||
| */ | ||
| IGNORE_GACTION, | ||
| /** | ||
| * Do not set an icon. | ||
| */ | ||
| IGNORE_ICON, | ||
| /** | ||
| * Do not set a label/short description. | ||
| */ | ||
| IGNORE_LABEL, | ||
| /** | ||
| * Do not set a tooltip/long description. | ||
| */ | ||
| IGNORE_TOOLTIP, | ||
| /** | ||
| * Ignore completely the accelerators. | ||
| */ | ||
| IGNORE_ACCELS, | ||
| /** | ||
| * Ignore the accelerators for | ||
| * documentation purposes only. For example do not add/configure a | ||
| * #GtkAccelLabel. | ||
| */ | ||
| IGNORE_ACCELS_FOR_DOC, | ||
| /** | ||
| * Do not call | ||
| * gtk_application_set_accels_for_action(). | ||
| */ | ||
| IGNORE_ACCELS_FOR_APP, | ||
| } | ||
| module ActionInfoCentralStore { | ||
| // Constructor properties interface | ||
| // Constructor properties interface | ||
| interface ConstructorProperties extends GObject.Object.ConstructorProperties { | ||
| interface ConstructorProps extends GObject.Object.ConstructorProps {} | ||
| } | ||
| } | ||
| class ActionInfoCentralStore extends GObject.Object { | ||
| static $gtype: GObject.GType<ActionInfoCentralStore>; | ||
| interface ActionInfoCentralStore { | ||
| // Constructors of Amtk.ActionInfoCentralStore | ||
| // Own fields of Amtk-5.Amtk.ActionInfoCentralStore | ||
| constructor(properties?: Partial<ActionInfoCentralStore.ConstructorProps>, ...args: any[]); | ||
| parent: GObject.Object | ||
| priv: ActionInfoCentralStorePrivate | ||
| _init(...args: any[]): void; | ||
| // Owm methods of Amtk-5.Amtk.ActionInfoCentralStore | ||
| // Own static methods of Amtk.ActionInfoCentralStore | ||
| lookup(action_name: string): ActionInfo | ||
| static get_singleton(): ActionInfoCentralStore; | ||
| // Class property signals of Amtk-5.Amtk.ActionInfoCentralStore | ||
| // Own methods of Amtk.ActionInfoCentralStore | ||
| connect(sigName: string, callback: (...args: any[]) => void): number | ||
| connect_after(sigName: string, callback: (...args: any[]) => void): number | ||
| emit(sigName: string, ...args: any[]): void | ||
| disconnect(id: number): void | ||
| } | ||
| lookup(action_name: string): ActionInfo; | ||
| } | ||
| class ActionInfoCentralStore extends GObject.Object { | ||
| module ActionInfoStore { | ||
| // Constructor properties interface | ||
| // Own properties of Amtk-5.Amtk.ActionInfoCentralStore | ||
| static name: string | ||
| static $gtype: GObject.GType<ActionInfoCentralStore> | ||
| // Constructors of Amtk-5.Amtk.ActionInfoCentralStore | ||
| constructor(config?: ActionInfoCentralStore.ConstructorProperties) | ||
| _init(config?: ActionInfoCentralStore.ConstructorProperties): void | ||
| static get_singleton(): ActionInfoCentralStore | ||
| } | ||
| module ActionInfoStore { | ||
| // Constructor properties interface | ||
| interface ConstructorProperties extends GObject.Object.ConstructorProperties { | ||
| interface ConstructorProps extends GObject.Object.ConstructorProps {} | ||
| } | ||
| } | ||
| class ActionInfoStore extends GObject.Object { | ||
| static $gtype: GObject.GType<ActionInfoStore>; | ||
| interface ActionInfoStore { | ||
| // Constructors of Amtk.ActionInfoStore | ||
| // Own fields of Amtk-5.Amtk.ActionInfoStore | ||
| constructor(properties?: Partial<ActionInfoStore.ConstructorProps>, ...args: any[]); | ||
| parent: GObject.Object | ||
| priv: ActionInfoStorePrivate | ||
| _init(...args: any[]): void; | ||
| // Owm methods of Amtk-5.Amtk.ActionInfoStore | ||
| static ['new'](): ActionInfoStore; | ||
| /** | ||
| * Inserts `info` into `store` and into the #AmtkActionInfoCentralStore. Both the | ||
| * `store` and central store must <emphasis>not</emphasis> already contain an | ||
| * #AmtkActionInfo with the same action name. The stores take their own | ||
| * reference on `info`. | ||
| * @param info an #AmtkActionInfo. | ||
| */ | ||
| add(info: ActionInfo): void | ||
| /** | ||
| * Calls amtk_action_info_store_add() for each entry. | ||
| * | ||
| * If `translation_domain` is not %NULL, g_dgettext() is used to translate the | ||
| * `label` and `tooltip` of each entry before setting them to the #AmtkActionInfo. | ||
| * | ||
| * An API similar to g_action_map_add_action_entries(). | ||
| * @param entries a pointer to the first item in an array of #AmtkActionInfoEntry structs. | ||
| * @param translation_domain a gettext domain, or %NULL. | ||
| */ | ||
| add_entries(entries: ActionInfoEntry[], translation_domain: string | null): void | ||
| /** | ||
| * Checks for each #AmtkActionInfo of `store` that it has been used (see | ||
| * amtk_action_info_has_been_used()). If an #AmtkActionInfo has not been used, a | ||
| * warning is printed and might indicate dead code. | ||
| * | ||
| * You probably want to call this function on the application store after | ||
| * creating the menu and toolbar. But it can also be useful for a store provided | ||
| * by a library, to easily see which actions are not used by the application. | ||
| */ | ||
| check_all_used(): void | ||
| lookup(action_name: string): ActionInfo | ||
| /** | ||
| * Calls gtk_application_set_accels_for_action() for all #AmtkActionInfo's part | ||
| * of `store` with the accelerators returned by amtk_action_info_get_accels(). | ||
| * This function does *not* call amtk_action_info_mark_as_used(), because if it | ||
| * did it would not be possible to detect dead code in `store` with | ||
| * amtk_action_info_store_check_all_used(). | ||
| * | ||
| * This function is not recommended if `store` is provided by a library, because | ||
| * a future version of the library may add accelerators that are not wanted in | ||
| * the application. So for a library store, you should let #AmtkFactory call | ||
| * gtk_application_set_accels_for_action(). | ||
| * | ||
| * This function can be convenient for an application store, in combination with | ||
| * %AMTK_FACTORY_IGNORE_ACCELS_FOR_APP (and/or having a %NULL #GtkApplication in | ||
| * #AmtkFactory). It has the advantage that | ||
| * gtk_application_set_accels_for_action() is called only once per action, not | ||
| * each time that a #GtkApplicationWindow is created. | ||
| * | ||
| * This function can also be useful if – for some actions – the objects are not | ||
| * created directly with #AmtkFactory on application startup, but are created | ||
| * later, on demand. For example to create a #GtkShortcutsWindow with | ||
| * #AmtkFactory, containing information about actions that are not added to any | ||
| * menu or toolbar. | ||
| * @param application a #GtkApplication. | ||
| */ | ||
| set_all_accels_to_app(application: Gtk.Application): void | ||
| // Own methods of Amtk.ActionInfoStore | ||
| // Class property signals of Amtk-5.Amtk.ActionInfoStore | ||
| /** | ||
| * Inserts `info` into `store` and into the #AmtkActionInfoCentralStore. Both the | ||
| * `store` and central store must <emphasis>not</emphasis> already contain an | ||
| * #AmtkActionInfo with the same action name. The stores take their own | ||
| * reference on `info`. | ||
| * @param info an #AmtkActionInfo. | ||
| */ | ||
| add(info: ActionInfo): void; | ||
| /** | ||
| * Calls amtk_action_info_store_add() for each entry. | ||
| * | ||
| * If `translation_domain` is not %NULL, g_dgettext() is used to translate the | ||
| * `label` and `tooltip` of each entry before setting them to the #AmtkActionInfo. | ||
| * | ||
| * An API similar to g_action_map_add_action_entries(). | ||
| * @param entries a pointer to the first item in an array of #AmtkActionInfoEntry structs. | ||
| * @param translation_domain a gettext domain, or %NULL. | ||
| */ | ||
| add_entries(entries: ActionInfoEntry[], translation_domain?: string | null): void; | ||
| /** | ||
| * Checks for each #AmtkActionInfo of `store` that it has been used (see | ||
| * amtk_action_info_has_been_used()). If an #AmtkActionInfo has not been used, a | ||
| * warning is printed and might indicate dead code. | ||
| * | ||
| * You probably want to call this function on the application store after | ||
| * creating the menu and toolbar. But it can also be useful for a store provided | ||
| * by a library, to easily see which actions are not used by the application. | ||
| */ | ||
| check_all_used(): void; | ||
| lookup(action_name: string): ActionInfo; | ||
| /** | ||
| * Calls gtk_application_set_accels_for_action() for all #AmtkActionInfo's part | ||
| * of `store` with the accelerators returned by amtk_action_info_get_accels(). | ||
| * This function does *not* call amtk_action_info_mark_as_used(), because if it | ||
| * did it would not be possible to detect dead code in `store` with | ||
| * amtk_action_info_store_check_all_used(). | ||
| * | ||
| * This function is not recommended if `store` is provided by a library, because | ||
| * a future version of the library may add accelerators that are not wanted in | ||
| * the application. So for a library store, you should let #AmtkFactory call | ||
| * gtk_application_set_accels_for_action(). | ||
| * | ||
| * This function can be convenient for an application store, in combination with | ||
| * %AMTK_FACTORY_IGNORE_ACCELS_FOR_APP (and/or having a %NULL #GtkApplication in | ||
| * #AmtkFactory). It has the advantage that | ||
| * gtk_application_set_accels_for_action() is called only once per action, not | ||
| * each time that a #GtkApplicationWindow is created. | ||
| * | ||
| * This function can also be useful if – for some actions – the objects are not | ||
| * created directly with #AmtkFactory on application startup, but are created | ||
| * later, on demand. For example to create a #GtkShortcutsWindow with | ||
| * #AmtkFactory, containing information about actions that are not added to any | ||
| * menu or toolbar. | ||
| * @param application a #GtkApplication. | ||
| */ | ||
| set_all_accels_to_app(application: Gtk.Application): void; | ||
| } | ||
| connect(sigName: string, callback: (...args: any[]) => void): number | ||
| connect_after(sigName: string, callback: (...args: any[]) => void): number | ||
| emit(sigName: string, ...args: any[]): void | ||
| disconnect(id: number): void | ||
| } | ||
| module ApplicationWindow { | ||
| // Constructor properties interface | ||
| class ActionInfoStore extends GObject.Object { | ||
| interface ConstructorProps extends GObject.Object.ConstructorProps { | ||
| application_window: Gtk.ApplicationWindow; | ||
| applicationWindow: Gtk.ApplicationWindow; | ||
| statusbar: Gtk.Statusbar; | ||
| } | ||
| } | ||
| // Own properties of Amtk-5.Amtk.ActionInfoStore | ||
| class ApplicationWindow extends GObject.Object { | ||
| static $gtype: GObject.GType<ApplicationWindow>; | ||
| static name: string | ||
| static $gtype: GObject.GType<ActionInfoStore> | ||
| // Own properties of Amtk.ApplicationWindow | ||
| // Constructors of Amtk-5.Amtk.ActionInfoStore | ||
| constructor(config?: ActionInfoStore.ConstructorProperties) | ||
| constructor() | ||
| static new(): ActionInfoStore | ||
| _init(config?: ActionInfoStore.ConstructorProperties): void | ||
| } | ||
| module ApplicationWindow { | ||
| // Constructor properties interface | ||
| interface ConstructorProperties extends GObject.Object.ConstructorProperties { | ||
| // Own constructor properties of Amtk-5.Amtk.ApplicationWindow | ||
| /** | ||
| * The #GtkApplicationWindow. | ||
| */ | ||
| applicationWindow?: Gtk.ApplicationWindow | null | ||
| get application_window(): Gtk.ApplicationWindow; | ||
| /** | ||
| * The #GtkApplicationWindow. | ||
| */ | ||
| get applicationWindow(): Gtk.ApplicationWindow; | ||
| /** | ||
| * The #GtkStatusbar. %NULL by default. | ||
| */ | ||
| statusbar?: Gtk.Statusbar | null | ||
| } | ||
| get statusbar(): Gtk.Statusbar; | ||
| set statusbar(val: Gtk.Statusbar); | ||
| } | ||
| // Constructors of Amtk.ApplicationWindow | ||
| interface ApplicationWindow { | ||
| constructor(properties?: Partial<ApplicationWindow.ConstructorProps>, ...args: any[]); | ||
| // Own properties of Amtk-5.Amtk.ApplicationWindow | ||
| _init(...args: any[]): void; | ||
| /** | ||
| * The #GtkApplicationWindow. | ||
| */ | ||
| readonly applicationWindow: Gtk.ApplicationWindow | ||
| /** | ||
| * The #GtkStatusbar. %NULL by default. | ||
| */ | ||
| statusbar: Gtk.Statusbar | ||
| // Own static methods of Amtk.ApplicationWindow | ||
| // Own fields of Amtk-5.Amtk.ApplicationWindow | ||
| /** | ||
| * Creates the base of a simple and generic #GtkRecentChooserMenu. | ||
| * | ||
| * The #GtkRecentChooser is configured to show files only recently used with the | ||
| * current application, as returned by g_get_application_name(). If recent files | ||
| * are added to the default #GtkRecentManager with | ||
| * gtk_recent_manager_add_item(), the files will normally show up in the | ||
| * #GtkRecentChooserMenu. | ||
| */ | ||
| static create_open_recent_menu_base(): Gtk.RecentChooserMenu; | ||
| /** | ||
| * Returns the #AmtkApplicationWindow of `gtk_window`. The returned object is | ||
| * guaranteed to be the same for the lifetime of `gtk_window`. | ||
| * @param gtk_window a #GtkApplicationWindow. | ||
| */ | ||
| static get_from_gtk_application_window(gtk_window: Gtk.ApplicationWindow): ApplicationWindow; | ||
| parent: GObject.Object | ||
| priv: ApplicationWindowPrivate | ||
| // Own methods of Amtk.ApplicationWindow | ||
| // Owm methods of Amtk-5.Amtk.ApplicationWindow | ||
| /** | ||
| * Connects to the #AmtkMenuShell::menu-item-selected and | ||
| * #AmtkMenuShell::menu-item-deselected signals of `menu_shell` to push/pop the | ||
| * long description of #GtkMenuItem's to the #AmtkApplicationWindow:statusbar. | ||
| * | ||
| * The long description is retrieved with amtk_menu_item_get_long_description(). | ||
| * So amtk_menu_item_set_long_description() must have been called, which is the | ||
| * case if the #GtkMenuItem has been created with #AmtkFactory. | ||
| * @param menu_shell a #GtkMenuShell. | ||
| */ | ||
| connect_menu_to_statusbar(menu_shell: Gtk.MenuShell): void; | ||
| /** | ||
| * An alternative to gtk_recent_chooser_set_show_tips(). Shows the full path in | ||
| * the #AmtkApplicationWindow:statusbar when a #GtkMenuItem of `menu` is | ||
| * selected. | ||
| * | ||
| * The full path is retrieved with | ||
| * amtk_utils_recent_chooser_menu_get_item_uri(). | ||
| * @param menu a #GtkRecentChooserMenu. | ||
| */ | ||
| connect_recent_chooser_menu_to_statusbar(menu: Gtk.RecentChooserMenu): void; | ||
| /** | ||
| * This function creates a #GtkRecentChooserMenu with | ||
| * amtk_application_window_create_open_recent_menu_base(), and setup these | ||
| * additional things: | ||
| * | ||
| * - The #GtkRecentChooserMenu is connected to the statusbar with | ||
| * amtk_application_window_connect_recent_chooser_menu_to_statusbar(). | ||
| * | ||
| * - When the #GtkRecentChooser::item-activated signal is emitted, | ||
| * g_application_open() is called (with an empty hint), so the #GApplication | ||
| * must have the %G_APPLICATION_HANDLES_OPEN flag set. | ||
| * @returns a new #GtkRecentChooserMenu. | ||
| */ | ||
| create_open_recent_menu(): Gtk.Widget; | ||
| /** | ||
| * Creates a #GtkMenuItem with a simple and generic #GtkRecentChooserMenu as | ||
| * submenu. The #GtkRecentChooserMenu is created with | ||
| * amtk_application_window_create_open_recent_menu(). | ||
| * @returns a new #GtkMenuItem. | ||
| */ | ||
| create_open_recent_menu_item(): Gtk.Widget; | ||
| get_application_window(): Gtk.ApplicationWindow; | ||
| get_statusbar(): Gtk.Statusbar | null; | ||
| /** | ||
| * Sets the #AmtkApplicationWindow:statusbar property. | ||
| * @param statusbar a #GtkStatusbar, or %NULL. | ||
| */ | ||
| set_statusbar(statusbar?: Gtk.Statusbar | null): void; | ||
| } | ||
| /** | ||
| * Connects to the #AmtkMenuShell::menu-item-selected and | ||
| * #AmtkMenuShell::menu-item-deselected signals of `menu_shell` to push/pop the | ||
| * long description of #GtkMenuItem's to the #AmtkApplicationWindow:statusbar. | ||
| * | ||
| * The long description is retrieved with amtk_menu_item_get_long_description(). | ||
| * So amtk_menu_item_set_long_description() must have been called, which is the | ||
| * case if the #GtkMenuItem has been created with #AmtkFactory. | ||
| * @param menu_shell a #GtkMenuShell. | ||
| */ | ||
| connect_menu_to_statusbar(menu_shell: Gtk.MenuShell): void | ||
| /** | ||
| * An alternative to gtk_recent_chooser_set_show_tips(). Shows the full path in | ||
| * the #AmtkApplicationWindow:statusbar when a #GtkMenuItem of `menu` is | ||
| * selected. | ||
| * | ||
| * The full path is retrieved with | ||
| * amtk_utils_recent_chooser_menu_get_item_uri(). | ||
| * @param menu a #GtkRecentChooserMenu. | ||
| */ | ||
| connect_recent_chooser_menu_to_statusbar(menu: Gtk.RecentChooserMenu): void | ||
| /** | ||
| * This function creates a #GtkRecentChooserMenu with | ||
| * amtk_application_window_create_open_recent_menu_base(), and setup these | ||
| * additional things: | ||
| * | ||
| * - The #GtkRecentChooserMenu is connected to the statusbar with | ||
| * amtk_application_window_connect_recent_chooser_menu_to_statusbar(). | ||
| * | ||
| * - When the #GtkRecentChooser::item-activated signal is emitted, | ||
| * g_application_open() is called (with an empty hint), so the #GApplication | ||
| * must have the %G_APPLICATION_HANDLES_OPEN flag set. | ||
| * @returns a new #GtkRecentChooserMenu. | ||
| */ | ||
| create_open_recent_menu(): Gtk.Widget | ||
| /** | ||
| * Creates a #GtkMenuItem with a simple and generic #GtkRecentChooserMenu as | ||
| * submenu. The #GtkRecentChooserMenu is created with | ||
| * amtk_application_window_create_open_recent_menu(). | ||
| * @returns a new #GtkMenuItem. | ||
| */ | ||
| create_open_recent_menu_item(): Gtk.Widget | ||
| get_application_window(): Gtk.ApplicationWindow | ||
| get_statusbar(): Gtk.Statusbar | null | ||
| /** | ||
| * Sets the #AmtkApplicationWindow:statusbar property. | ||
| * @param statusbar a #GtkStatusbar, or %NULL. | ||
| */ | ||
| set_statusbar(statusbar: Gtk.Statusbar | null): void | ||
| module Factory { | ||
| // Constructor properties interface | ||
| // Class property signals of Amtk-5.Amtk.ApplicationWindow | ||
| interface ConstructorProps extends GObject.Object.ConstructorProps { | ||
| application: Gtk.Application; | ||
| default_flags: FactoryFlags; | ||
| defaultFlags: FactoryFlags; | ||
| } | ||
| } | ||
| connect(sigName: "notify::application-window", callback: (($obj: ApplicationWindow, pspec: GObject.ParamSpec) => void)): number | ||
| connect_after(sigName: "notify::application-window", callback: (($obj: ApplicationWindow, pspec: GObject.ParamSpec) => void)): number | ||
| emit(sigName: "notify::application-window", ...args: any[]): void | ||
| connect(sigName: "notify::statusbar", callback: (($obj: ApplicationWindow, pspec: GObject.ParamSpec) => void)): number | ||
| connect_after(sigName: "notify::statusbar", callback: (($obj: ApplicationWindow, pspec: GObject.ParamSpec) => void)): number | ||
| emit(sigName: "notify::statusbar", ...args: any[]): void | ||
| connect(sigName: string, callback: (...args: any[]) => void): number | ||
| connect_after(sigName: string, callback: (...args: any[]) => void): number | ||
| emit(sigName: string, ...args: any[]): void | ||
| disconnect(id: number): void | ||
| } | ||
| class Factory extends GObject.Object { | ||
| static $gtype: GObject.GType<Factory>; | ||
| class ApplicationWindow extends GObject.Object { | ||
| // Own properties of Amtk.Factory | ||
| // Own properties of Amtk-5.Amtk.ApplicationWindow | ||
| static name: string | ||
| static $gtype: GObject.GType<ApplicationWindow> | ||
| // Constructors of Amtk-5.Amtk.ApplicationWindow | ||
| constructor(config?: ApplicationWindow.ConstructorProperties) | ||
| _init(config?: ApplicationWindow.ConstructorProperties): void | ||
| /** | ||
| * Creates the base of a simple and generic #GtkRecentChooserMenu. | ||
| * | ||
| * The #GtkRecentChooser is configured to show files only recently used with the | ||
| * current application, as returned by g_get_application_name(). If recent files | ||
| * are added to the default #GtkRecentManager with | ||
| * gtk_recent_manager_add_item(), the files will normally show up in the | ||
| * #GtkRecentChooserMenu. | ||
| * @returns a new #GtkRecentChooserMenu. | ||
| */ | ||
| static create_open_recent_menu_base(): Gtk.RecentChooserMenu | ||
| /** | ||
| * Returns the #AmtkApplicationWindow of `gtk_window`. The returned object is | ||
| * guaranteed to be the same for the lifetime of `gtk_window`. | ||
| * @param gtk_window a #GtkApplicationWindow. | ||
| * @returns the #AmtkApplicationWindow of @gtk_window. | ||
| */ | ||
| static get_from_gtk_application_window(gtk_window: Gtk.ApplicationWindow): ApplicationWindow | ||
| } | ||
| module Factory { | ||
| // Constructor properties interface | ||
| interface ConstructorProperties extends GObject.Object.ConstructorProperties { | ||
| // Own constructor properties of Amtk-5.Amtk.Factory | ||
| /** | ||
@@ -536,616 +487,427 @@ * The associated #GtkApplication (it is optional, it can be %NULL). | ||
| */ | ||
| application?: Gtk.Application | null | ||
| get application(): Gtk.Application; | ||
| /** | ||
| * The default #AmtkFactoryFlags. | ||
| */ | ||
| defaultFlags?: FactoryFlags | null | ||
| } | ||
| get default_flags(): FactoryFlags; | ||
| set default_flags(val: FactoryFlags); | ||
| /** | ||
| * The default #AmtkFactoryFlags. | ||
| */ | ||
| get defaultFlags(): FactoryFlags; | ||
| set defaultFlags(val: FactoryFlags); | ||
| } | ||
| // Constructors of Amtk.Factory | ||
| interface Factory { | ||
| constructor(properties?: Partial<Factory.ConstructorProps>, ...args: any[]); | ||
| // Own properties of Amtk-5.Amtk.Factory | ||
| _init(...args: any[]): void; | ||
| /** | ||
| * The associated #GtkApplication (it is optional, it can be %NULL). | ||
| * #AmtkFactory has a weak reference to the #GtkApplication. | ||
| */ | ||
| readonly application: Gtk.Application | ||
| /** | ||
| * The default #AmtkFactoryFlags. | ||
| */ | ||
| defaultFlags: FactoryFlags | ||
| static ['new'](application?: Gtk.Application | null): Factory; | ||
| // Own fields of Amtk-5.Amtk.Factory | ||
| static new_with_default_application(): Factory; | ||
| parent: GObject.Object | ||
| priv: FactoryPrivate | ||
| // Own methods of Amtk.Factory | ||
| // Owm methods of Amtk-5.Amtk.Factory | ||
| /** | ||
| * Creates a new #GtkCheckMenuItem for `action_name` with the | ||
| * #AmtkFactory:default-flags. | ||
| * | ||
| * See the documentation of amtk_factory_create_check_menu_item_full() for more | ||
| * information. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkCheckMenuItem for @action_name. | ||
| */ | ||
| create_check_menu_item(action_name: string): Gtk.Widget; | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * Note that since it is a #GtkCheckMenuItem the icon is not set, even if it | ||
| * would be possible with amtk_menu_item_set_icon_name(). | ||
| * | ||
| * If the action controls a boolean property, think about using | ||
| * #GPropertyAction. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkCheckMenuItem for @action_name. | ||
| */ | ||
| create_check_menu_item_full(action_name: string, flags: FactoryFlags): Gtk.Widget; | ||
| /** | ||
| * Calls amtk_factory_create_gmenu_item_full() with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param action_name an action name. | ||
| * @returns a new #GMenuItem for @action_name. | ||
| */ | ||
| create_gmenu_item(action_name: string): Gio.MenuItem; | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * Creates a new #GMenuItem for `action_name`. It ignores the tooltip, i.e. the | ||
| * return value of amtk_action_info_get_tooltip(). | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GMenuItem for @action_name. | ||
| */ | ||
| create_gmenu_item_full(action_name: string, flags: FactoryFlags): Gio.MenuItem; | ||
| /** | ||
| * Creates a new #GtkMenuItem for `action_name` with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkMenuItem for @action_name. | ||
| */ | ||
| create_menu_item(action_name: string): Gtk.Widget; | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkMenuItem for @action_name. | ||
| */ | ||
| create_menu_item_full(action_name: string, flags: FactoryFlags): Gtk.Widget; | ||
| /** | ||
| * Creates a new #GtkMenuToolButton for `action_name` with the | ||
| * #AmtkFactory:default-flags. | ||
| * | ||
| * See the documentation of amtk_factory_create_menu_tool_button_full() for more | ||
| * information. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkMenuToolButton for @action_name. | ||
| */ | ||
| create_menu_tool_button(action_name: string): Gtk.MenuToolButton; | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * After calling this function, you need to use the #GtkMenuToolButton API to | ||
| * set the menu and also possibly set a tooltip to the arrow. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkMenuToolButton for @action_name. | ||
| */ | ||
| create_menu_tool_button_full(action_name: string, flags: FactoryFlags): Gtk.MenuToolButton; | ||
| /** | ||
| * Calls amtk_factory_create_shortcut_full() with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkShortcutsShortcut for @action_name. | ||
| */ | ||
| create_shortcut(action_name: string): Gtk.Widget; | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * This function creates a new #GtkShortcutsShortcut for `action_name`. | ||
| * | ||
| * For the #GtkShortcutsShortcut:title, the tooltip has the priorioty, with the | ||
| * label as fallback if the tooltip is %NULL (the mnemonic is removed from the | ||
| * label with amtk_utils_remove_mnemonic()). This can be controlled with the | ||
| * %AMTK_FACTORY_IGNORE_TOOLTIP and %AMTK_FACTORY_IGNORE_LABEL flags. | ||
| * | ||
| * The #GtkShortcutsShortcut:accelerator property is set with only the *first* | ||
| * accel returned by amtk_action_info_get_accels(). This step can be ignored | ||
| * with %AMTK_FACTORY_IGNORE_ACCELS or %AMTK_FACTORY_IGNORE_ACCELS_FOR_DOC. | ||
| * | ||
| * The #GtkShortcutsShortcut:action-name property is set to `action_name` if the | ||
| * %AMTK_FACTORY_IGNORE_GACTION flag isn't set. Note that with | ||
| * #GtkShortcutsShortcut:action-name all accelerators are displayed (if set to | ||
| * the #GtkApplication). | ||
| * | ||
| * So depending on whether you want to show only the first accelerator or all | ||
| * accelerators, you need to set `flags` appropriately. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkShortcutsShortcut for @action_name. | ||
| */ | ||
| create_shortcut_full(action_name: string, flags: FactoryFlags): Gtk.Widget; | ||
| /** | ||
| * Calls amtk_factory_create_simple_menu_full() with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param entries a pointer to the first item in an array of #AmtkActionInfoEntry structs. | ||
| * @returns a new simple #GtkMenu for @entries. | ||
| */ | ||
| create_simple_menu(entries: ActionInfoEntry[]): Gtk.Widget; | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * This function: | ||
| * - Creates a #GtkMenu; | ||
| * - For each #AmtkActionInfoEntry action name from `entries,` creates a | ||
| * #GtkMenuItem with amtk_factory_create_menu_item_full() with the same `flags` | ||
| * as passed in to this function, and appends it to the #GtkMenu, in the same | ||
| * order as provided by the `entries` array. | ||
| * | ||
| * So this function is useful only if the #GtkMenu contains only simple | ||
| * #GtkMenuItem's, not #GtkCheckMenuItem's nor #GtkRadioMenuItem's. | ||
| * @param entries a pointer to the first item in an array of #AmtkActionInfoEntry structs. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new simple #GtkMenu for @entries. | ||
| */ | ||
| create_simple_menu_full(entries: ActionInfoEntry[], flags: FactoryFlags): Gtk.Widget; | ||
| /** | ||
| * Creates a new #GtkToolButton for `action_name` with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkToolButton for @action_name. | ||
| */ | ||
| create_tool_button(action_name: string): Gtk.ToolItem; | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkToolButton for @action_name. | ||
| */ | ||
| create_tool_button_full(action_name: string, flags: FactoryFlags): Gtk.ToolItem; | ||
| get_application(): Gtk.Application | null; | ||
| get_default_flags(): FactoryFlags; | ||
| /** | ||
| * Sets the #AmtkFactory:default-flags property. | ||
| * @param default_flags the new value. | ||
| */ | ||
| set_default_flags(default_flags: FactoryFlags): void; | ||
| } | ||
| /** | ||
| * Creates a new #GtkCheckMenuItem for `action_name` with the | ||
| * #AmtkFactory:default-flags. | ||
| * | ||
| * See the documentation of amtk_factory_create_check_menu_item_full() for more | ||
| * information. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkCheckMenuItem for @action_name. | ||
| */ | ||
| create_check_menu_item(action_name: string): Gtk.Widget | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * Note that since it is a #GtkCheckMenuItem the icon is not set, even if it | ||
| * would be possible with amtk_menu_item_set_icon_name(). | ||
| * | ||
| * If the action controls a boolean property, think about using | ||
| * #GPropertyAction. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkCheckMenuItem for @action_name. | ||
| */ | ||
| create_check_menu_item_full(action_name: string, flags: FactoryFlags): Gtk.Widget | ||
| /** | ||
| * Calls amtk_factory_create_gmenu_item_full() with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param action_name an action name. | ||
| * @returns a new #GMenuItem for @action_name. | ||
| */ | ||
| create_gmenu_item(action_name: string): Gio.MenuItem | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * Creates a new #GMenuItem for `action_name`. It ignores the tooltip, i.e. the | ||
| * return value of amtk_action_info_get_tooltip(). | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GMenuItem for @action_name. | ||
| */ | ||
| create_gmenu_item_full(action_name: string, flags: FactoryFlags): Gio.MenuItem | ||
| /** | ||
| * Creates a new #GtkMenuItem for `action_name` with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkMenuItem for @action_name. | ||
| */ | ||
| create_menu_item(action_name: string): Gtk.Widget | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkMenuItem for @action_name. | ||
| */ | ||
| create_menu_item_full(action_name: string, flags: FactoryFlags): Gtk.Widget | ||
| /** | ||
| * Creates a new #GtkMenuToolButton for `action_name` with the | ||
| * #AmtkFactory:default-flags. | ||
| * | ||
| * See the documentation of amtk_factory_create_menu_tool_button_full() for more | ||
| * information. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkMenuToolButton for @action_name. | ||
| */ | ||
| create_menu_tool_button(action_name: string): Gtk.MenuToolButton | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * After calling this function, you need to use the #GtkMenuToolButton API to | ||
| * set the menu and also possibly set a tooltip to the arrow. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkMenuToolButton for @action_name. | ||
| */ | ||
| create_menu_tool_button_full(action_name: string, flags: FactoryFlags): Gtk.MenuToolButton | ||
| /** | ||
| * Calls amtk_factory_create_shortcut_full() with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkShortcutsShortcut for @action_name. | ||
| */ | ||
| create_shortcut(action_name: string): Gtk.Widget | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * This function creates a new #GtkShortcutsShortcut for `action_name`. | ||
| * | ||
| * For the #GtkShortcutsShortcut:title, the tooltip has the priorioty, with the | ||
| * label as fallback if the tooltip is %NULL (the mnemonic is removed from the | ||
| * label with amtk_utils_remove_mnemonic()). This can be controlled with the | ||
| * %AMTK_FACTORY_IGNORE_TOOLTIP and %AMTK_FACTORY_IGNORE_LABEL flags. | ||
| * | ||
| * The #GtkShortcutsShortcut:accelerator property is set with only the *first* | ||
| * accel returned by amtk_action_info_get_accels(). This step can be ignored | ||
| * with %AMTK_FACTORY_IGNORE_ACCELS or %AMTK_FACTORY_IGNORE_ACCELS_FOR_DOC. | ||
| * | ||
| * The #GtkShortcutsShortcut:action-name property is set to `action_name` if the | ||
| * %AMTK_FACTORY_IGNORE_GACTION flag isn't set. Note that with | ||
| * #GtkShortcutsShortcut:action-name all accelerators are displayed (if set to | ||
| * the #GtkApplication). | ||
| * | ||
| * So depending on whether you want to show only the first accelerator or all | ||
| * accelerators, you need to set `flags` appropriately. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkShortcutsShortcut for @action_name. | ||
| */ | ||
| create_shortcut_full(action_name: string, flags: FactoryFlags): Gtk.Widget | ||
| /** | ||
| * Calls amtk_factory_create_simple_menu_full() with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param entries a pointer to the first item in an array of #AmtkActionInfoEntry structs. | ||
| * @returns a new simple #GtkMenu for @entries. | ||
| */ | ||
| create_simple_menu(entries: ActionInfoEntry[]): Gtk.Widget | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * | ||
| * This function: | ||
| * - Creates a #GtkMenu; | ||
| * - For each #AmtkActionInfoEntry action name from `entries,` creates a | ||
| * #GtkMenuItem with amtk_factory_create_menu_item_full() with the same `flags` | ||
| * as passed in to this function, and appends it to the #GtkMenu, in the same | ||
| * order as provided by the `entries` array. | ||
| * | ||
| * So this function is useful only if the #GtkMenu contains only simple | ||
| * #GtkMenuItem's, not #GtkCheckMenuItem's nor #GtkRadioMenuItem's. | ||
| * @param entries a pointer to the first item in an array of #AmtkActionInfoEntry structs. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new simple #GtkMenu for @entries. | ||
| */ | ||
| create_simple_menu_full(entries: ActionInfoEntry[], flags: FactoryFlags): Gtk.Widget | ||
| /** | ||
| * Creates a new #GtkToolButton for `action_name` with the | ||
| * #AmtkFactory:default-flags. | ||
| * @param action_name an action name. | ||
| * @returns a new #GtkToolButton for @action_name. | ||
| */ | ||
| create_tool_button(action_name: string): Gtk.ToolItem | ||
| /** | ||
| * This function ignores the #AmtkFactory:default-flags property and takes the | ||
| * `flags` argument instead. | ||
| * @param action_name an action name. | ||
| * @param flags #AmtkFactoryFlags. | ||
| * @returns a new #GtkToolButton for @action_name. | ||
| */ | ||
| create_tool_button_full(action_name: string, flags: FactoryFlags): Gtk.ToolItem | ||
| get_application(): Gtk.Application | null | ||
| get_default_flags(): FactoryFlags | ||
| /** | ||
| * Sets the #AmtkFactory:default-flags property. | ||
| * @param default_flags the new value. | ||
| */ | ||
| set_default_flags(default_flags: FactoryFlags): void | ||
| module MenuShell { | ||
| // Signal callback interfaces | ||
| // Class property signals of Amtk-5.Amtk.Factory | ||
| interface MenuItemDeselected { | ||
| (menu_item: Gtk.MenuItem): void; | ||
| } | ||
| connect(sigName: "notify::application", callback: (($obj: Factory, pspec: GObject.ParamSpec) => void)): number | ||
| connect_after(sigName: "notify::application", callback: (($obj: Factory, pspec: GObject.ParamSpec) => void)): number | ||
| emit(sigName: "notify::application", ...args: any[]): void | ||
| connect(sigName: "notify::default-flags", callback: (($obj: Factory, pspec: GObject.ParamSpec) => void)): number | ||
| connect_after(sigName: "notify::default-flags", callback: (($obj: Factory, pspec: GObject.ParamSpec) => void)): number | ||
| emit(sigName: "notify::default-flags", ...args: any[]): void | ||
| connect(sigName: string, callback: (...args: any[]) => void): number | ||
| connect_after(sigName: string, callback: (...args: any[]) => void): number | ||
| emit(sigName: string, ...args: any[]): void | ||
| disconnect(id: number): void | ||
| } | ||
| interface MenuItemSelected { | ||
| (menu_item: Gtk.MenuItem): void; | ||
| } | ||
| class Factory extends GObject.Object { | ||
| // Constructor properties interface | ||
| // Own properties of Amtk-5.Amtk.Factory | ||
| static name: string | ||
| static $gtype: GObject.GType<Factory> | ||
| // Constructors of Amtk-5.Amtk.Factory | ||
| constructor(config?: Factory.ConstructorProperties) | ||
| /** | ||
| * Creates a new #AmtkFactory object. Associating a #GtkApplication is optional, | ||
| * if it is %NULL gtk_application_set_accels_for_action() won't be called. | ||
| * @constructor | ||
| * @param application a #GtkApplication, or %NULL. | ||
| * @returns a new #AmtkFactory. | ||
| */ | ||
| constructor(application: Gtk.Application | null) | ||
| /** | ||
| * Creates a new #AmtkFactory object. Associating a #GtkApplication is optional, | ||
| * if it is %NULL gtk_application_set_accels_for_action() won't be called. | ||
| * @constructor | ||
| * @param application a #GtkApplication, or %NULL. | ||
| * @returns a new #AmtkFactory. | ||
| */ | ||
| static new(application: Gtk.Application | null): Factory | ||
| /** | ||
| * Calls amtk_factory_new() with g_application_get_default() (it must be a | ||
| * #GtkApplication). | ||
| * @constructor | ||
| * @returns a new #AmtkFactory with the default #GtkApplication. | ||
| */ | ||
| static new_with_default_application(): Factory | ||
| _init(config?: Factory.ConstructorProperties): void | ||
| } | ||
| module MenuShell { | ||
| // Signal callback interfaces | ||
| /** | ||
| * Signal callback interface for `menu-item-deselected` | ||
| */ | ||
| interface MenuItemDeselectedSignalCallback { | ||
| ($obj: MenuShell, menu_item: Gtk.MenuItem): void | ||
| interface ConstructorProps extends GObject.Object.ConstructorProps { | ||
| menu_shell: Gtk.MenuShell; | ||
| menuShell: Gtk.MenuShell; | ||
| } | ||
| } | ||
| /** | ||
| * Signal callback interface for `menu-item-selected` | ||
| */ | ||
| interface MenuItemSelectedSignalCallback { | ||
| ($obj: MenuShell, menu_item: Gtk.MenuItem): void | ||
| } | ||
| class MenuShell extends GObject.Object { | ||
| static $gtype: GObject.GType<MenuShell>; | ||
| // Own properties of Amtk.MenuShell | ||
| // Constructor properties interface | ||
| interface ConstructorProperties extends GObject.Object.ConstructorProperties { | ||
| // Own constructor properties of Amtk-5.Amtk.MenuShell | ||
| /** | ||
| * The #GtkMenuShell. | ||
| */ | ||
| menuShell?: Gtk.MenuShell | null | ||
| } | ||
| get menu_shell(): Gtk.MenuShell; | ||
| /** | ||
| * The #GtkMenuShell. | ||
| */ | ||
| get menuShell(): Gtk.MenuShell; | ||
| } | ||
| // Constructors of Amtk.MenuShell | ||
| interface MenuShell { | ||
| constructor(properties?: Partial<MenuShell.ConstructorProps>, ...args: any[]); | ||
| // Own properties of Amtk-5.Amtk.MenuShell | ||
| _init(...args: any[]): void; | ||
| /** | ||
| * The #GtkMenuShell. | ||
| */ | ||
| readonly menuShell: Gtk.MenuShell | ||
| // Own signals of Amtk.MenuShell | ||
| // Own fields of Amtk-5.Amtk.MenuShell | ||
| 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: 'menu-item-deselected', callback: (_source: this, menu_item: Gtk.MenuItem) => void): number; | ||
| connect_after( | ||
| signal: 'menu-item-deselected', | ||
| callback: (_source: this, menu_item: Gtk.MenuItem) => void, | ||
| ): number; | ||
| emit(signal: 'menu-item-deselected', menu_item: Gtk.MenuItem): void; | ||
| connect(signal: 'menu-item-selected', callback: (_source: this, menu_item: Gtk.MenuItem) => void): number; | ||
| connect_after(signal: 'menu-item-selected', callback: (_source: this, menu_item: Gtk.MenuItem) => void): number; | ||
| emit(signal: 'menu-item-selected', menu_item: Gtk.MenuItem): void; | ||
| parent: GObject.Object | ||
| priv: MenuShellPrivate | ||
| // Own static methods of Amtk.MenuShell | ||
| // Owm methods of Amtk-5.Amtk.MenuShell | ||
| /** | ||
| * Returns the #AmtkMenuShell of `gtk_menu_shell`. The returned object is | ||
| * guaranteed to be the same for the lifetime of `gtk_menu_shell`. | ||
| * @param gtk_menu_shell a #GtkMenuShell. | ||
| */ | ||
| static get_from_gtk_menu_shell(gtk_menu_shell: Gtk.MenuShell): MenuShell; | ||
| get_menu_shell(): Gtk.MenuShell | ||
| // Own virtual methods of Amtk.MenuShell | ||
| // Own virtual methods of Amtk-5.Amtk.MenuShell | ||
| vfunc_menu_item_deselected(menu_item: Gtk.MenuItem): void; | ||
| vfunc_menu_item_selected(menu_item: Gtk.MenuItem): void; | ||
| vfunc_menu_item_deselected(menu_item: Gtk.MenuItem): void | ||
| vfunc_menu_item_selected(menu_item: Gtk.MenuItem): void | ||
| // Own methods of Amtk.MenuShell | ||
| // Own signals of Amtk-5.Amtk.MenuShell | ||
| get_menu_shell(): Gtk.MenuShell; | ||
| } | ||
| connect(sigName: "menu-item-deselected", callback: MenuShell.MenuItemDeselectedSignalCallback): number | ||
| connect_after(sigName: "menu-item-deselected", callback: MenuShell.MenuItemDeselectedSignalCallback): number | ||
| emit(sigName: "menu-item-deselected", menu_item: Gtk.MenuItem, ...args: any[]): void | ||
| connect(sigName: "menu-item-selected", callback: MenuShell.MenuItemSelectedSignalCallback): number | ||
| connect_after(sigName: "menu-item-selected", callback: MenuShell.MenuItemSelectedSignalCallback): number | ||
| emit(sigName: "menu-item-selected", menu_item: Gtk.MenuItem, ...args: any[]): void | ||
| class ActionInfo { | ||
| static $gtype: GObject.GType<ActionInfo>; | ||
| // Class property signals of Amtk-5.Amtk.MenuShell | ||
| // Constructors of Amtk.ActionInfo | ||
| connect(sigName: "notify::menu-shell", callback: (($obj: MenuShell, pspec: GObject.ParamSpec) => void)): number | ||
| connect_after(sigName: "notify::menu-shell", callback: (($obj: MenuShell, pspec: GObject.ParamSpec) => void)): number | ||
| emit(sigName: "notify::menu-shell", ...args: any[]): void | ||
| connect(sigName: string, callback: (...args: any[]) => void): number | ||
| connect_after(sigName: string, callback: (...args: any[]) => void): number | ||
| emit(sigName: string, ...args: any[]): void | ||
| disconnect(id: number): void | ||
| } | ||
| constructor(properties?: Partial<{}>); | ||
| _init(...args: any[]): void; | ||
| class MenuShell extends GObject.Object { | ||
| static ['new'](): ActionInfo; | ||
| // Own properties of Amtk-5.Amtk.MenuShell | ||
| static new_from_entry(info_entry: ActionInfoEntry, translation_domain?: string | null): ActionInfo; | ||
| static name: string | ||
| static $gtype: GObject.GType<MenuShell> | ||
| // Own methods of Amtk.ActionInfo | ||
| // Constructors of Amtk-5.Amtk.MenuShell | ||
| copy(): ActionInfo; | ||
| /** | ||
| * Returns the accelerators. This function never returns %NULL, it always | ||
| * returns a %NULL-terminated array, to be suitable for | ||
| * gtk_application_set_accels_for_action(). | ||
| * @returns a %NULL-terminated array of accelerators in the format understood by gtk_accelerator_parse(). | ||
| */ | ||
| get_accels(): string[]; | ||
| get_action_name(): string | null; | ||
| get_icon_name(): string | null; | ||
| /** | ||
| * Gets the label. The label has normally a mnemonic. To remove the mnemonic, | ||
| * there is the amtk_utils_remove_mnemonic() function. | ||
| * @returns the label (i.e. a short description), or %NULL. | ||
| */ | ||
| get_label(): string | null; | ||
| get_tooltip(): string | null; | ||
| /** | ||
| * Returns whether `info` has been used (for example by an #AmtkFactory | ||
| * function). See also amtk_action_info_store_check_all_used(). | ||
| * @returns whether @info has been used. | ||
| */ | ||
| has_been_used(): boolean; | ||
| /** | ||
| * Mark `info` as used. An #AmtkFactory function that uses an #AmtkActionInfo | ||
| * should call this function. See amtk_action_info_store_check_all_used(). | ||
| */ | ||
| mark_as_used(): void; | ||
| /** | ||
| * Increments the reference count of `info` by one. | ||
| * @returns the passed in @info. | ||
| */ | ||
| ref(): ActionInfo; | ||
| /** | ||
| * A function similar to gtk_application_set_accels_for_action(). | ||
| * | ||
| * `accels` must not be %NULL, it must be a %NULL-terminated array, to be | ||
| * consistent with gtk_application_set_accels_for_action(). | ||
| * @param accels a %NULL-terminated array of accelerators in the format understood by gtk_accelerator_parse(). | ||
| */ | ||
| set_accels(accels: string[]): void; | ||
| /** | ||
| * Sets the action name, for example `"win.save"`. Can be a detailed action | ||
| * name, see g_action_parse_detailed_name(). | ||
| * @param action_name the action name. | ||
| */ | ||
| set_action_name(action_name: string): void; | ||
| set_icon_name(icon_name?: string | null): void; | ||
| /** | ||
| * Sets the label with a mnemonic. To know how to encode the mnemonic, see the | ||
| * documentation of gtk_label_new_with_mnemonic(). | ||
| * @param label the label (i.e. a short description), or %NULL. | ||
| */ | ||
| set_label(label?: string | null): void; | ||
| set_tooltip(tooltip?: string | null): void; | ||
| /** | ||
| * Decrements the reference count of `info` by one. If the reference count drops | ||
| * to 0, `info` is freed. | ||
| */ | ||
| unref(): void; | ||
| } | ||
| constructor(config?: MenuShell.ConstructorProperties) | ||
| _init(config?: MenuShell.ConstructorProperties): void | ||
| /** | ||
| * Returns the #AmtkMenuShell of `gtk_menu_shell`. The returned object is | ||
| * guaranteed to be the same for the lifetime of `gtk_menu_shell`. | ||
| * @param gtk_menu_shell a #GtkMenuShell. | ||
| * @returns the #AmtkMenuShell of @gtk_menu_shell. | ||
| */ | ||
| static get_from_gtk_menu_shell(gtk_menu_shell: Gtk.MenuShell): MenuShell | ||
| } | ||
| type ActionInfoCentralStoreClass = typeof ActionInfoCentralStore; | ||
| abstract class ActionInfoCentralStorePrivate { | ||
| static $gtype: GObject.GType<ActionInfoCentralStorePrivate>; | ||
| interface ActionInfo { | ||
| // Constructors of Amtk.ActionInfoCentralStorePrivate | ||
| // Owm methods of Amtk-5.Amtk.ActionInfo | ||
| _init(...args: any[]): void; | ||
| } | ||
| copy(): ActionInfo | ||
| /** | ||
| * Returns the accelerators. This function never returns %NULL, it always | ||
| * returns a %NULL-terminated array, to be suitable for | ||
| * gtk_application_set_accels_for_action(). | ||
| * @returns a %NULL-terminated array of accelerators in the format understood by gtk_accelerator_parse(). | ||
| * This struct defines a set of information for a single action. It is for use | ||
| * with amtk_action_info_store_add_entries(). | ||
| * | ||
| * Like #GActionEntry, it is permissible to use an incomplete initialiser in | ||
| * order to leave some of the later values as %NULL. Additional optional fields | ||
| * may be added in the future. | ||
| */ | ||
| get_accels(): string[] | ||
| get_action_name(): string | null | ||
| get_icon_name(): string | null | ||
| /** | ||
| * Gets the label. The label has normally a mnemonic. To remove the mnemonic, | ||
| * there is the amtk_utils_remove_mnemonic() function. | ||
| * @returns the label (i.e. a short description), or %NULL. | ||
| */ | ||
| get_label(): string | null | ||
| get_tooltip(): string | null | ||
| /** | ||
| * Returns whether `info` has been used (for example by an #AmtkFactory | ||
| * function). See also amtk_action_info_store_check_all_used(). | ||
| * @returns whether @info has been used. | ||
| */ | ||
| has_been_used(): boolean | ||
| /** | ||
| * Mark `info` as used. An #AmtkFactory function that uses an #AmtkActionInfo | ||
| * should call this function. See amtk_action_info_store_check_all_used(). | ||
| */ | ||
| mark_as_used(): void | ||
| /** | ||
| * Increments the reference count of `info` by one. | ||
| * @returns the passed in @info. | ||
| */ | ||
| ref(): ActionInfo | ||
| /** | ||
| * A function similar to gtk_application_set_accels_for_action(). | ||
| * | ||
| * `accels` must not be %NULL, it must be a %NULL-terminated array, to be | ||
| * consistent with gtk_application_set_accels_for_action(). | ||
| * @param accels a %NULL-terminated array of accelerators in the format understood by gtk_accelerator_parse(). | ||
| */ | ||
| set_accels(accels: string[]): void | ||
| /** | ||
| * Sets the action name, for example `"win.save"`. Can be a detailed action | ||
| * name, see g_action_parse_detailed_name(). | ||
| * @param action_name the action name. | ||
| */ | ||
| set_action_name(action_name: string): void | ||
| set_icon_name(icon_name: string | null): void | ||
| /** | ||
| * Sets the label with a mnemonic. To know how to encode the mnemonic, see the | ||
| * documentation of gtk_label_new_with_mnemonic(). | ||
| * @param label the label (i.e. a short description), or %NULL. | ||
| */ | ||
| set_label(label: string | null): void | ||
| set_tooltip(tooltip: string | null): void | ||
| /** | ||
| * Decrements the reference count of `info` by one. If the reference count drops | ||
| * to 0, `info` is freed. | ||
| */ | ||
| unref(): void | ||
| } | ||
| class ActionInfoEntry { | ||
| static $gtype: GObject.GType<ActionInfoEntry>; | ||
| class ActionInfo { | ||
| // Own fields of Amtk.ActionInfoEntry | ||
| // Own properties of Amtk-5.Amtk.ActionInfo | ||
| action_name: string; | ||
| icon_name: string; | ||
| label: string; | ||
| accel: string; | ||
| tooltip: string; | ||
| static name: string | ||
| // Constructors of Amtk.ActionInfoEntry | ||
| // Constructors of Amtk-5.Amtk.ActionInfo | ||
| constructor( | ||
| properties?: Partial<{ | ||
| action_name: string; | ||
| icon_name: string; | ||
| label: string; | ||
| accel: string; | ||
| tooltip: string; | ||
| }>, | ||
| ); | ||
| _init(...args: any[]): void; | ||
| } | ||
| constructor() | ||
| static new(): ActionInfo | ||
| /** | ||
| * Creates a new #AmtkActionInfo from an #AmtkActionInfoEntry. | ||
| * | ||
| * If `translation_domain` is not %NULL, g_dgettext() is used to translate the | ||
| * `label` and `tooltip` before setting them to the #AmtkActionInfo. | ||
| * @constructor | ||
| * @param info_entry an #AmtkActionInfoEntry. | ||
| * @param translation_domain a gettext domain, or %NULL. | ||
| * @returns a new #AmtkActionInfo. | ||
| */ | ||
| static new_from_entry(info_entry: ActionInfoEntry, translation_domain: string | null): ActionInfo | ||
| } | ||
| type ActionInfoStoreClass = typeof ActionInfoStore; | ||
| abstract class ActionInfoStorePrivate { | ||
| static $gtype: GObject.GType<ActionInfoStorePrivate>; | ||
| interface ActionInfoCentralStoreClass { | ||
| // Constructors of Amtk.ActionInfoStorePrivate | ||
| // Own fields of Amtk-5.Amtk.ActionInfoCentralStoreClass | ||
| _init(...args: any[]): void; | ||
| } | ||
| parent_class: GObject.ObjectClass | ||
| padding: any[] | ||
| } | ||
| type ApplicationWindowClass = typeof ApplicationWindow; | ||
| abstract class ApplicationWindowPrivate { | ||
| static $gtype: GObject.GType<ApplicationWindowPrivate>; | ||
| abstract class ActionInfoCentralStoreClass { | ||
| // Constructors of Amtk.ApplicationWindowPrivate | ||
| // Own properties of Amtk-5.Amtk.ActionInfoCentralStoreClass | ||
| _init(...args: any[]): void; | ||
| } | ||
| static name: string | ||
| } | ||
| type FactoryClass = typeof Factory; | ||
| abstract class FactoryPrivate { | ||
| static $gtype: GObject.GType<FactoryPrivate>; | ||
| interface ActionInfoCentralStorePrivate { | ||
| } | ||
| // Constructors of Amtk.FactoryPrivate | ||
| class ActionInfoCentralStorePrivate { | ||
| _init(...args: any[]): void; | ||
| } | ||
| // Own properties of Amtk-5.Amtk.ActionInfoCentralStorePrivate | ||
| type MenuShellClass = typeof MenuShell; | ||
| abstract class MenuShellPrivate { | ||
| static $gtype: GObject.GType<MenuShellPrivate>; | ||
| static name: string | ||
| } | ||
| // Constructors of Amtk.MenuShellPrivate | ||
| interface ActionInfoEntry { | ||
| _init(...args: any[]): void; | ||
| } | ||
| // Own fields of Amtk-5.Amtk.ActionInfoEntry | ||
| /** | ||
| * the action name. Can be a detailed action name, see | ||
| * g_action_parse_detailed_name(). | ||
| * @field | ||
| * Name of the imported GIR library | ||
| * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188 | ||
| */ | ||
| action_name: string | ||
| const __name__: string; | ||
| /** | ||
| * the icon name, or %NULL. | ||
| * @field | ||
| * Version of the imported GIR library | ||
| * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189 | ||
| */ | ||
| icon_name: string | ||
| /** | ||
| * the label (i.e. a short description) with a mnemonic, or %NULL. | ||
| * @field | ||
| */ | ||
| label: string | ||
| /** | ||
| * the accelerator, in the format understood by gtk_accelerator_parse(). | ||
| * Or %NULL. | ||
| * @field | ||
| */ | ||
| accel: string | ||
| /** | ||
| * the tooltip (i.e. a long description), or %NULL. | ||
| * @field | ||
| */ | ||
| tooltip: string | ||
| const __version__: string; | ||
| } | ||
| /** | ||
| * This struct defines a set of information for a single action. It is for use | ||
| * with amtk_action_info_store_add_entries(). | ||
| * | ||
| * Like #GActionEntry, it is permissible to use an incomplete initialiser in | ||
| * order to leave some of the later values as %NULL. Additional optional fields | ||
| * may be added in the future. | ||
| * @record | ||
| */ | ||
| class ActionInfoEntry { | ||
| // Own properties of Amtk-5.Amtk.ActionInfoEntry | ||
| static name: string | ||
| } | ||
| interface ActionInfoStoreClass { | ||
| // Own fields of Amtk-5.Amtk.ActionInfoStoreClass | ||
| parent_class: GObject.ObjectClass | ||
| padding: any[] | ||
| } | ||
| abstract class ActionInfoStoreClass { | ||
| // Own properties of Amtk-5.Amtk.ActionInfoStoreClass | ||
| static name: string | ||
| } | ||
| interface ActionInfoStorePrivate { | ||
| } | ||
| class ActionInfoStorePrivate { | ||
| // Own properties of Amtk-5.Amtk.ActionInfoStorePrivate | ||
| static name: string | ||
| } | ||
| interface ApplicationWindowClass { | ||
| // Own fields of Amtk-5.Amtk.ApplicationWindowClass | ||
| parent_class: GObject.ObjectClass | ||
| padding: any[] | ||
| } | ||
| abstract class ApplicationWindowClass { | ||
| // Own properties of Amtk-5.Amtk.ApplicationWindowClass | ||
| static name: string | ||
| } | ||
| interface ApplicationWindowPrivate { | ||
| } | ||
| class ApplicationWindowPrivate { | ||
| // Own properties of Amtk-5.Amtk.ApplicationWindowPrivate | ||
| static name: string | ||
| } | ||
| interface FactoryClass { | ||
| // Own fields of Amtk-5.Amtk.FactoryClass | ||
| parent_class: GObject.ObjectClass | ||
| padding: any[] | ||
| } | ||
| abstract class FactoryClass { | ||
| // Own properties of Amtk-5.Amtk.FactoryClass | ||
| static name: string | ||
| } | ||
| interface FactoryPrivate { | ||
| } | ||
| class FactoryPrivate { | ||
| // Own properties of Amtk-5.Amtk.FactoryPrivate | ||
| static name: string | ||
| } | ||
| interface MenuShellClass { | ||
| // Own fields of Amtk-5.Amtk.MenuShellClass | ||
| parent_class: GObject.ObjectClass | ||
| menu_item_selected: (amtk_menu_shell: MenuShell, menu_item: Gtk.MenuItem) => void | ||
| menu_item_deselected: (amtk_menu_shell: MenuShell, menu_item: Gtk.MenuItem) => void | ||
| padding: any[] | ||
| } | ||
| abstract class MenuShellClass { | ||
| // Own properties of Amtk-5.Amtk.MenuShellClass | ||
| static name: string | ||
| } | ||
| interface MenuShellPrivate { | ||
| } | ||
| class MenuShellPrivate { | ||
| // Own properties of Amtk-5.Amtk.MenuShellPrivate | ||
| static name: string | ||
| } | ||
| /** | ||
| * 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 Amtk; | ||
| // END | ||
| // END |
| // @ts-expect-error | ||
@@ -8,4 +7,1 @@ import Amtk from 'gi://Amtk?version=5'; | ||
| { | ||
| "name": "@girs/amtk-5", | ||
| "version": "5.0.0-3.3.0", | ||
| "version": "5.0.0-4.0.0-beta.1", | ||
| "description": "GJS TypeScript type definitions for Amtk-5, generated from library version 5.0.0", | ||
@@ -11,2 +11,3 @@ "type": "module", | ||
| "types": "./amtk-5-ambient.d.ts", | ||
| "import": "./amtk-5-ambient.js", | ||
| "default": "./amtk-5-ambient.js" | ||
@@ -16,35 +17,29 @@ }, | ||
| "types": "./amtk-5-import.d.ts", | ||
| "import": "./amtk-5-import.js", | ||
| "default": "./amtk-5-import.js" | ||
| }, | ||
| ".": { | ||
| "import": { | ||
| "types": "./amtk-5.d.ts", | ||
| "default": "./amtk-5.js" | ||
| }, | ||
| "require": { | ||
| "types": "./amtk-5.d.cts", | ||
| "default": "./amtk-5.cjs" | ||
| } | ||
| "types": "./amtk-5.d.ts", | ||
| "import": "./amtk-5.js", | ||
| "default": "./amtk-5.js" | ||
| } | ||
| }, | ||
| "scripts": { | ||
| "test": "yarn test:esm && yarn test:cjs", | ||
| "test:esm": "NODE_OPTIONS=--max_old_space_size=9216 tsc --noEmit amtk-5.d.ts", | ||
| "test:cjs": "NODE_OPTIONS=--max_old_space_size=9216 tsc --noEmit amtk-5.d.cts" | ||
| "test": "NODE_OPTIONS=--max_old_space_size=9216 tsc --noEmit amtk-5.d.ts" | ||
| }, | ||
| "dependencies": { | ||
| "@girs/atk-1.0": "^2.50.1-3.3.0", | ||
| "@girs/cairo-1.0": "^1.0.0-3.3.0", | ||
| "@girs/freetype2-2.0": "^2.0.0-3.3.0", | ||
| "@girs/gdk-3.0": "^3.24.41-3.3.0", | ||
| "@girs/gdkpixbuf-2.0": "^2.0.0-3.3.0", | ||
| "@girs/gio-2.0": "^2.78.0-3.3.0", | ||
| "@girs/gjs": "^3.3.0", | ||
| "@girs/glib-2.0": "^2.78.0-3.3.0", | ||
| "@girs/gmodule-2.0": "^2.0.0-3.3.0", | ||
| "@girs/gobject-2.0": "^2.78.0-3.3.0", | ||
| "@girs/gtk-3.0": "^3.24.41-3.3.0", | ||
| "@girs/harfbuzz-0.0": "^8.2.1-3.3.0", | ||
| "@girs/pango-1.0": "^1.51.0-3.3.0", | ||
| "@girs/xlib-2.0": "^2.0.0-3.3.0" | ||
| "@girs/atk-1.0": "^2.45.1-4.0.0-beta.1", | ||
| "@girs/cairo-1.0": "^1.0.0-4.0.0-beta.1", | ||
| "@girs/freetype2-2.0": "^2.0.0-4.0.0-beta.1", | ||
| "@girs/gdk-3.0": "^3.24.39-4.0.0-beta.1", | ||
| "@girs/gdkpixbuf-2.0": "^2.0.0-4.0.0-beta.1", | ||
| "@girs/gio-2.0": "^2.77.0-4.0.0-beta.1", | ||
| "@girs/gjs": "^4.0.0-beta.1", | ||
| "@girs/glib-2.0": "^2.77.0-4.0.0-beta.1", | ||
| "@girs/gmodule-2.0": "^2.0.0-4.0.0-beta.1", | ||
| "@girs/gobject-2.0": "^2.77.0-4.0.0-beta.1", | ||
| "@girs/gtk-3.0": "^3.24.39-4.0.0-beta.1", | ||
| "@girs/harfbuzz-0.0": "^8.1.1-4.0.0-beta.1", | ||
| "@girs/pango-1.0": "^1.51.0-4.0.0-beta.1", | ||
| "@girs/xlib-2.0": "^2.0.0-4.0.0-beta.1" | ||
| }, | ||
@@ -51,0 +46,0 @@ "devDependencies": { |
@@ -8,3 +8,3 @@ | ||
| GJS TypeScript type definitions for Amtk-5, generated from library version 5.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v3.3.0. | ||
| GJS TypeScript type definitions for Amtk-5, generated from library version 5.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v4.0.0-beta.1. | ||
@@ -11,0 +11,0 @@ |
No alert changes
Worsened metrics
- Total package byte prevSize
- decreased by-50.94%
44074
- Number of package files
- decreased by-16.67%
10
- Lines of code
- decreased by-15.94%
865
Dependency changes
+ Added@girs/atk-1.0@2.45.1-4.0.0-beta.1(transitive)
+ Added@girs/gdk-3.0@3.24.39-4.0.0-beta.1(transitive)
+ Added@girs/gio-2.0@2.77.0-4.0.0-beta.1(transitive)
+ Added@girs/glib-2.0@2.77.0-4.0.0-beta.1(transitive)
+ Added@girs/gobject-2.0@2.77.0-4.0.0-beta.1(transitive)
+ Added@girs/gtk-3.0@3.24.39-4.0.0-beta.1(transitive)
+ Added@girs/harfbuzz-0.0@8.1.1-4.0.0-beta.1(transitive)
- Removed@girs/atk-1.0@2.50.1-3.3.02.52.0-4.0.0-beta.5(transitive)
- Removed@girs/gdk-3.0@3.24.41-4.0.0-beta.5(transitive)
- Removed@girs/gio-2.0@2.78.0-3.3.0(transitive)
- Removed@girs/gjs@3.3.0(transitive)
- Removed@girs/glib-2.0@2.78.0-3.3.0(transitive)
- Removed@girs/gobject-2.0@2.78.0-3.3.0(transitive)
- Removed@girs/gtk-3.0@3.24.41-4.0.0-beta.5(transitive)
- Removed@girs/harfbuzz-0.0@8.2.1-3.3.0(transitive)
- Removed@girs/pango-1.0@1.52.2-4.0.0-beta.5(transitive)
Updated@girs/gjs@^4.0.0-beta.1