@girs/gtk-3.0
Version:
GJS TypeScript type definitions for Gtk-3.0, generated from library version 3.24.50
1,921 lines (1,798 loc) • 17 MB
TypeScript
/**
* 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, ...
*/
import '@girs/gjs';
// Module dependencies
import type xlib from '@girs/xlib-2.0';
import type Gdk from '@girs/gdk-3.0';
import type cairo from 'cairo';
import type GObject from '@girs/gobject-2.0';
import type GLib from '@girs/glib-2.0';
import type Pango from '@girs/pango-1.0';
import type HarfBuzz from '@girs/harfbuzz-0.0';
import type freetype2 from '@girs/freetype2-2.0';
import type Gio from '@girs/gio-2.0';
import type GModule from '@girs/gmodule-2.0';
import type GdkPixbuf from '@girs/gdkpixbuf-2.0';
import type Atk from '@girs/atk-1.0';
export namespace Gtk {
/**
* Gtk-3.0
*/
/**
* Controls how a widget deals with extra space in a single (x or y)
* dimension.
*
* Alignment only matters if the widget receives a “too large” allocation,
* for example if you packed the widget with the #GtkWidget:expand
* flag inside a #GtkBox, then the widget might get extra space. If
* you have for example a 16x16 icon inside a 32x32 space, the icon
* could be scaled and stretched, it could be centered, or it could be
* positioned to one side of the space.
*
* Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
* are interpreted relative to text direction.
*
* GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and
* it is only supported for vertical alignment. When its not supported by
* a child or a container it is treated as `GTK_ALIGN_FILL`.
*/
/**
* Controls how a widget deals with extra space in a single (x or y)
* dimension.
*
* Alignment only matters if the widget receives a “too large” allocation,
* for example if you packed the widget with the #GtkWidget:expand
* flag inside a #GtkBox, then the widget might get extra space. If
* you have for example a 16x16 icon inside a 32x32 space, the icon
* could be scaled and stretched, it could be centered, or it could be
* positioned to one side of the space.
*
* Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
* are interpreted relative to text direction.
*
* GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and
* it is only supported for vertical alignment. When its not supported by
* a child or a container it is treated as `GTK_ALIGN_FILL`.
*/
export namespace Align {
export const $gtype: GObject.GType<Align>;
}
enum Align {
/**
* stretch to fill all space if possible, center if
* no meaningful way to stretch
*/
FILL,
/**
* snap to left or top side, leaving space on right
* or bottom
*/
START,
/**
* snap to right or bottom side, leaving space on left
* or top
*/
END,
/**
* center natural width of widget inside the
* allocation
*/
CENTER,
/**
* align the widget according to the baseline. Since 3.10.
*/
BASELINE,
}
/**
* Used to specify the placement of scroll arrows in scrolling menus.
*/
/**
* Used to specify the placement of scroll arrows in scrolling menus.
*/
export namespace ArrowPlacement {
export const $gtype: GObject.GType<ArrowPlacement>;
}
enum ArrowPlacement {
/**
* Place one arrow on each end of the menu.
*/
BOTH,
/**
* Place both arrows at the top of the menu.
*/
START,
/**
* Place both arrows at the bottom of the menu.
*/
END,
}
/**
* Used to indicate the direction in which an arrow should point.
*/
/**
* Used to indicate the direction in which an arrow should point.
*/
export namespace ArrowType {
export const $gtype: GObject.GType<ArrowType>;
}
enum ArrowType {
/**
* Represents an upward pointing arrow.
*/
UP,
/**
* Represents a downward pointing arrow.
*/
DOWN,
/**
* Represents a left pointing arrow.
*/
LEFT,
/**
* Represents a right pointing arrow.
*/
RIGHT,
/**
* No arrow. Since 2.10.
*/
NONE,
}
/**
* An enum for determining the page role inside the #GtkAssistant. It's
* used to handle buttons sensitivity and visibility.
*
* Note that an assistant needs to end its page flow with a page of type
* %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
* %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
*
* The Cancel button will only be shown if the page isn’t “committed”.
* See gtk_assistant_commit() for details.
*/
/**
* An enum for determining the page role inside the #GtkAssistant. It's
* used to handle buttons sensitivity and visibility.
*
* Note that an assistant needs to end its page flow with a page of type
* %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
* %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
*
* The Cancel button will only be shown if the page isn’t “committed”.
* See gtk_assistant_commit() for details.
*/
export namespace AssistantPageType {
export const $gtype: GObject.GType<AssistantPageType>;
}
enum AssistantPageType {
/**
* The page has regular contents. Both the
* Back and forward buttons will be shown.
*/
CONTENT,
/**
* The page contains an introduction to the
* assistant task. Only the Forward button will be shown if there is a
* next page.
*/
INTRO,
/**
* The page lets the user confirm or deny the
* changes. The Back and Apply buttons will be shown.
*/
CONFIRM,
/**
* The page informs the user of the changes
* done. Only the Close button will be shown.
*/
SUMMARY,
/**
* Used for tasks that take a long time to
* complete, blocks the assistant until the page is marked as complete.
* Only the back button will be shown.
*/
PROGRESS,
/**
* Used for when other page types are not
* appropriate. No buttons will be shown, and the application must
* add its own buttons through gtk_assistant_add_action_widget().
*/
CUSTOM,
}
/**
* Whenever a container has some form of natural row it may align
* children in that row along a common typographical baseline. If
* the amount of verical space in the row is taller than the total
* requested height of the baseline-aligned children then it can use a
* #GtkBaselinePosition to select where to put the baseline inside the
* extra availible space.
*/
/**
* Whenever a container has some form of natural row it may align
* children in that row along a common typographical baseline. If
* the amount of verical space in the row is taller than the total
* requested height of the baseline-aligned children then it can use a
* #GtkBaselinePosition to select where to put the baseline inside the
* extra availible space.
*/
export namespace BaselinePosition {
export const $gtype: GObject.GType<BaselinePosition>;
}
enum BaselinePosition {
/**
* Align the baseline at the top
*/
TOP,
/**
* Center the baseline
*/
CENTER,
/**
* Align the baseline at the bottom
*/
BOTTOM,
}
/**
* Describes how the border of a UI element should be rendered.
*/
/**
* Describes how the border of a UI element should be rendered.
*/
export namespace BorderStyle {
export const $gtype: GObject.GType<BorderStyle>;
}
enum BorderStyle {
/**
* No visible border
*/
NONE,
/**
* A single line segment
*/
SOLID,
/**
* Looks as if the content is sunken into the canvas
*/
INSET,
/**
* Looks as if the content is coming out of the canvas
*/
OUTSET,
/**
* Same as `GTK_BORDER_STYLE_NONE`
*/
HIDDEN,
/**
* A series of round dots
*/
DOTTED,
/**
* A series of square-ended dashes
*/
DASHED,
/**
* Two parallel lines with some space between them
*/
DOUBLE,
/**
* Looks as if it were carved in the canvas
*/
GROOVE,
/**
* Looks as if it were coming out of the canvas
*/
RIDGE,
}
/**
* Error codes that identify various errors that can occur while using
* #GtkBuilder.
*/
class BuilderError extends GLib.Error {
static $gtype: GObject.GType<BuilderError>;
// Static fields
/**
* A type-func attribute didn’t name
* a function that returns a #GType.
*/
static INVALID_TYPE_FUNCTION: number;
/**
* The input contained a tag that #GtkBuilder
* can’t handle.
*/
static UNHANDLED_TAG: number;
/**
* An attribute that is required by
* #GtkBuilder was missing.
*/
static MISSING_ATTRIBUTE: number;
/**
* #GtkBuilder found an attribute that
* it doesn’t understand.
*/
static INVALID_ATTRIBUTE: number;
/**
* #GtkBuilder found a tag that
* it doesn’t understand.
*/
static INVALID_TAG: number;
/**
* A required property value was
* missing.
*/
static MISSING_PROPERTY_VALUE: number;
/**
* #GtkBuilder couldn’t parse
* some attribute value.
*/
static INVALID_VALUE: number;
/**
* The input file requires a newer version
* of GTK+.
*/
static VERSION_MISMATCH: number;
/**
* An object id occurred twice.
*/
static DUPLICATE_ID: number;
/**
* A specified object type is of the same type or
* derived from the type of the composite class being extended with builder XML.
*/
static OBJECT_TYPE_REFUSED: number;
/**
* The wrong type was specified in a composite class’s template XML
*/
static TEMPLATE_MISMATCH: number;
/**
* The specified property is unknown for the object class.
*/
static INVALID_PROPERTY: number;
/**
* The specified signal is unknown for the object class.
*/
static INVALID_SIGNAL: number;
/**
* An object id is unknown
*/
static INVALID_ID: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
/**
* Used to dictate the style that a #GtkButtonBox uses to layout the buttons it
* contains.
*/
/**
* Used to dictate the style that a #GtkButtonBox uses to layout the buttons it
* contains.
*/
export namespace ButtonBoxStyle {
export const $gtype: GObject.GType<ButtonBoxStyle>;
}
enum ButtonBoxStyle {
/**
* Buttons are evenly spread across the box.
*/
SPREAD,
/**
* Buttons are placed at the edges of the box.
*/
EDGE,
/**
* Buttons are grouped towards the start of the box,
* (on the left for a HBox, or the top for a VBox).
*/
START,
/**
* Buttons are grouped towards the end of the box,
* (on the right for a HBox, or the bottom for a VBox).
*/
END,
/**
* Buttons are centered in the box. Since 2.12.
*/
CENTER,
/**
* Buttons expand to fill the box. This entails giving
* buttons a "linked" appearance, making button sizes homogeneous, and
* setting spacing to 0 (same as calling gtk_box_set_homogeneous() and
* gtk_box_set_spacing() manually). Since 3.12.
*/
EXPAND,
}
/**
* The role specifies the desired appearance of a #GtkModelButton.
*/
/**
* The role specifies the desired appearance of a #GtkModelButton.
*/
export namespace ButtonRole {
export const $gtype: GObject.GType<ButtonRole>;
}
enum ButtonRole {
/**
* A plain button
*/
NORMAL,
/**
* A check button
*/
CHECK,
/**
* A radio button
*/
RADIO,
}
/**
* Prebuilt sets of buttons for the dialog. If
* none of these choices are appropriate, simply use %GTK_BUTTONS_NONE
* then call gtk_dialog_add_buttons().
*
* > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
* > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
* > [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/).
*/
/**
* Prebuilt sets of buttons for the dialog. If
* none of these choices are appropriate, simply use %GTK_BUTTONS_NONE
* then call gtk_dialog_add_buttons().
*
* > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
* > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
* > [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/).
*/
export namespace ButtonsType {
export const $gtype: GObject.GType<ButtonsType>;
}
enum ButtonsType {
/**
* no buttons at all
*/
NONE,
/**
* an OK button
*/
OK,
/**
* a Close button
*/
CLOSE,
/**
* a Cancel button
*/
CANCEL,
/**
* Yes and No buttons
*/
YES_NO,
/**
* OK and Cancel buttons
*/
OK_CANCEL,
}
/**
* Determines if the edited accelerators are GTK+ accelerators. If
* they are, consumed modifiers are suppressed, only accelerators
* accepted by GTK+ are allowed, and the accelerators are rendered
* in the same way as they are in menus.
*/
/**
* Determines if the edited accelerators are GTK+ accelerators. If
* they are, consumed modifiers are suppressed, only accelerators
* accepted by GTK+ are allowed, and the accelerators are rendered
* in the same way as they are in menus.
*/
export namespace CellRendererAccelMode {
export const $gtype: GObject.GType<CellRendererAccelMode>;
}
enum CellRendererAccelMode {
/**
* GTK+ accelerators mode
*/
GTK,
/**
* Other accelerator mode
*/
OTHER,
}
/**
* Identifies how the user can interact with a particular cell.
*/
/**
* Identifies how the user can interact with a particular cell.
*/
export namespace CellRendererMode {
export const $gtype: GObject.GType<CellRendererMode>;
}
enum CellRendererMode {
/**
* The cell is just for display
* and cannot be interacted with. Note that this doesn’t mean that eg. the
* row being drawn can’t be selected -- just that a particular element of
* it cannot be individually modified.
*/
INERT,
/**
* The cell can be clicked.
*/
ACTIVATABLE,
/**
* The cell can be edited or otherwise modified.
*/
EDITABLE,
}
/**
* Specifies which corner a child widget should be placed in when packed into
* a #GtkScrolledWindow. This is effectively the opposite of where the scroll
* bars are placed.
*/
/**
* Specifies which corner a child widget should be placed in when packed into
* a #GtkScrolledWindow. This is effectively the opposite of where the scroll
* bars are placed.
*/
export namespace CornerType {
export const $gtype: GObject.GType<CornerType>;
}
enum CornerType {
/**
* Place the scrollbars on the right and bottom of the
* widget (default behaviour).
*/
TOP_LEFT,
/**
* Place the scrollbars on the top and right of the
* widget.
*/
BOTTOM_LEFT,
/**
* Place the scrollbars on the left and bottom of the
* widget.
*/
TOP_RIGHT,
/**
* Place the scrollbars on the top and left of the
* widget.
*/
BOTTOM_RIGHT,
}
/**
* Error codes for %GTK_CSS_PROVIDER_ERROR.
*/
class CssProviderError extends GLib.Error {
static $gtype: GObject.GType<CssProviderError>;
// Static fields
/**
* Failed.
*/
static FAILED: number;
/**
* Syntax error.
*/
static SYNTAX: number;
/**
* Import error.
*/
static IMPORT: number;
/**
* Name error.
*/
static NAME: number;
/**
* Deprecation error.
*/
static DEPRECATED: number;
/**
* Unknown value.
*/
static UNKNOWN_VALUE: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
/**
* The different types of sections indicate parts of a CSS document as
* parsed by GTK’s CSS parser. They are oriented towards the
* [CSS Grammar](http://www.w3.org/TR/CSS21/grammar.html),
* but may contain extensions.
*
* More types might be added in the future as the parser incorporates
* more features.
*/
/**
* The different types of sections indicate parts of a CSS document as
* parsed by GTK’s CSS parser. They are oriented towards the
* [CSS Grammar](http://www.w3.org/TR/CSS21/grammar.html),
* but may contain extensions.
*
* More types might be added in the future as the parser incorporates
* more features.
*/
export namespace CssSectionType {
export const $gtype: GObject.GType<CssSectionType>;
}
enum CssSectionType {
/**
* The section describes a complete document.
* This section time is the only one where gtk_css_section_get_parent()
* might return %NULL.
*/
DOCUMENT,
/**
* The section defines an import rule.
*/
IMPORT,
/**
* The section defines a color. This
* is a GTK extension to CSS.
*/
COLOR_DEFINITION,
/**
* The section defines a binding set. This
* is a GTK extension to CSS.
*/
BINDING_SET,
/**
* The section defines a CSS ruleset.
*/
RULESET,
/**
* The section defines a CSS selector.
*/
SELECTOR,
/**
* The section defines the declaration of
* a CSS variable.
*/
DECLARATION,
/**
* The section defines the value of a CSS declaration.
*/
VALUE,
/**
* The section defines keyframes. See [CSS
* Animations](http://dev.w3.org/csswg/css3-animations/#keyframes) for details. Since 3.6
*/
KEYFRAMES,
}
/**
* See also: #GtkEntry::delete-from-cursor.
*/
/**
* See also: #GtkEntry::delete-from-cursor.
*/
export namespace DeleteType {
export const $gtype: GObject.GType<DeleteType>;
}
enum DeleteType {
/**
* Delete characters.
*/
CHARS,
/**
* Delete only the portion of the word to the
* left/right of cursor if we’re in the middle of a word.
*/
WORD_ENDS,
/**
* Delete words.
*/
WORDS,
/**
* Delete display-lines. Display-lines
* refers to the visible lines, with respect to to the current line
* breaks. As opposed to paragraphs, which are defined by line
* breaks in the input.
*/
DISPLAY_LINES,
/**
* Delete only the portion of the
* display-line to the left/right of cursor.
*/
DISPLAY_LINE_ENDS,
/**
* Delete to the end of the
* paragraph. Like C-k in Emacs (or its reverse).
*/
PARAGRAPH_ENDS,
/**
* Delete entire line. Like C-k in pico.
*/
PARAGRAPHS,
/**
* Delete only whitespace. Like M-\ in Emacs.
*/
WHITESPACE,
}
/**
* Focus movement types.
*/
/**
* Focus movement types.
*/
export namespace DirectionType {
export const $gtype: GObject.GType<DirectionType>;
}
enum DirectionType {
/**
* Move forward.
*/
TAB_FORWARD,
/**
* Move backward.
*/
TAB_BACKWARD,
/**
* Move up.
*/
UP,
/**
* Move down.
*/
DOWN,
/**
* Move left.
*/
LEFT,
/**
* Move right.
*/
RIGHT,
}
/**
* Gives an indication why a drag operation failed.
* The value can by obtained by connecting to the
* #GtkWidget::drag-failed signal.
*/
/**
* Gives an indication why a drag operation failed.
* The value can by obtained by connecting to the
* #GtkWidget::drag-failed signal.
*/
export namespace DragResult {
export const $gtype: GObject.GType<DragResult>;
}
enum DragResult {
/**
* The drag operation was successful.
*/
SUCCESS,
/**
* No suitable drag target.
*/
NO_TARGET,
/**
* The user cancelled the drag operation.
*/
USER_CANCELLED,
/**
* The drag operation timed out.
*/
TIMEOUT_EXPIRED,
/**
* The pointer or keyboard grab used
* for the drag operation was broken.
*/
GRAB_BROKEN,
/**
* The drag operation failed due to some
* unspecified error.
*/
ERROR,
}
/**
* Specifies the side of the entry at which an icon is placed.
*/
/**
* Specifies the side of the entry at which an icon is placed.
*/
export namespace EntryIconPosition {
export const $gtype: GObject.GType<EntryIconPosition>;
}
enum EntryIconPosition {
/**
* At the beginning of the entry (depending on the text direction).
*/
PRIMARY,
/**
* At the end of the entry (depending on the text direction).
*/
SECONDARY,
}
/**
* Describes the state of a #GdkEventSequence in a #GtkGesture.
*/
/**
* Describes the state of a #GdkEventSequence in a #GtkGesture.
*/
export namespace EventSequenceState {
export const $gtype: GObject.GType<EventSequenceState>;
}
enum EventSequenceState {
/**
* The sequence is handled, but not grabbed.
*/
NONE,
/**
* The sequence is handled and grabbed.
*/
CLAIMED,
/**
* The sequence is denied.
*/
DENIED,
}
/**
* Used to specify the style of the expanders drawn by a #GtkTreeView.
*/
/**
* Used to specify the style of the expanders drawn by a #GtkTreeView.
*/
export namespace ExpanderStyle {
export const $gtype: GObject.GType<ExpanderStyle>;
}
enum ExpanderStyle {
/**
* The style used for a collapsed subtree.
*/
COLLAPSED,
/**
* Intermediate style used during animation.
*/
SEMI_COLLAPSED,
/**
* Intermediate style used during animation.
*/
SEMI_EXPANDED,
/**
* The style used for an expanded subtree.
*/
EXPANDED,
}
/**
* Describes whether a #GtkFileChooser is being used to open existing files
* or to save to a possibly new file.
*/
/**
* Describes whether a #GtkFileChooser is being used to open existing files
* or to save to a possibly new file.
*/
export namespace FileChooserAction {
export const $gtype: GObject.GType<FileChooserAction>;
}
enum FileChooserAction {
/**
* Indicates open mode. The file chooser
* will only let the user pick an existing file.
*/
OPEN,
/**
* Indicates save mode. The file chooser
* will let the user pick an existing file, or type in a new
* filename.
*/
SAVE,
/**
* Indicates an Open mode for
* selecting folders. The file chooser will let the user pick an
* existing folder.
*/
SELECT_FOLDER,
/**
* Indicates a mode for creating a
* new folder. The file chooser will let the user name an existing or
* new folder.
*/
CREATE_FOLDER,
}
/**
* Used as a return value of handlers for the
* #GtkFileChooser::confirm-overwrite signal of a #GtkFileChooser. This
* value determines whether the file chooser will present the stock
* confirmation dialog, accept the user’s choice of a filename, or
* let the user choose another filename.
*/
/**
* Used as a return value of handlers for the
* #GtkFileChooser::confirm-overwrite signal of a #GtkFileChooser. This
* value determines whether the file chooser will present the stock
* confirmation dialog, accept the user’s choice of a filename, or
* let the user choose another filename.
*/
export namespace FileChooserConfirmation {
export const $gtype: GObject.GType<FileChooserConfirmation>;
}
enum FileChooserConfirmation {
/**
* The file chooser will present
* its stock dialog to confirm about overwriting an existing file.
*/
CONFIRM,
/**
* The file chooser will
* terminate and accept the user’s choice of a file name.
*/
ACCEPT_FILENAME,
/**
* The file chooser will
* continue running, so as to let the user select another file name.
*/
SELECT_AGAIN,
}
/**
* These identify the various errors that can occur while calling
* #GtkFileChooser functions.
*/
class FileChooserError extends GLib.Error {
static $gtype: GObject.GType<FileChooserError>;
// Static fields
/**
* Indicates that a file does not exist.
*/
static NONEXISTENT: number;
/**
* Indicates a malformed filename.
*/
static BAD_FILENAME: number;
/**
* Indicates a duplicate path (e.g. when
* adding a bookmark).
*/
static ALREADY_EXISTS: number;
/**
* Indicates an incomplete hostname (e.g. "http://foo" without a slash after that).
*/
static INCOMPLETE_HOSTNAME: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
/**
* Registers an error quark for #GtkFileChooser if necessary.
*/
static quark(): GLib.Quark;
}
/**
* Style for input method preedit. See also
* #GtkSettings:gtk-im-preedit-style
*/
/**
* Style for input method preedit. See also
* #GtkSettings:gtk-im-preedit-style
*/
export namespace IMPreeditStyle {
export const $gtype: GObject.GType<IMPreeditStyle>;
}
enum IMPreeditStyle {
/**
* Deprecated
*/
NOTHING,
/**
* Deprecated
*/
CALLBACK,
/**
* Deprecated
*/
NONE,
}
/**
* Style for input method status. See also
* #GtkSettings:gtk-im-status-style
*/
/**
* Style for input method status. See also
* #GtkSettings:gtk-im-status-style
*/
export namespace IMStatusStyle {
export const $gtype: GObject.GType<IMStatusStyle>;
}
enum IMStatusStyle {
/**
* Deprecated
*/
NOTHING,
/**
* Deprecated
*/
CALLBACK,
/**
* Deprecated
*/
NONE,
}
/**
* Built-in stock icon sizes.
*/
/**
* Built-in stock icon sizes.
*/
export namespace IconSize {
export const $gtype: GObject.GType<IconSize>;
}
enum IconSize {
/**
* Invalid size.
*/
INVALID,
/**
* Size appropriate for menus (16px).
*/
MENU,
/**
* Size appropriate for small toolbars (16px).
*/
SMALL_TOOLBAR,
/**
* Size appropriate for large toolbars (24px)
*/
LARGE_TOOLBAR,
/**
* Size appropriate for buttons (16px)
*/
BUTTON,
/**
* Size appropriate for drag and drop (32px)
*/
DND,
/**
* Size appropriate for dialogs (48px)
*/
DIALOG,
}
/**
* Error codes for GtkIconTheme operations.
*/
class IconThemeError extends GLib.Error {
static $gtype: GObject.GType<IconThemeError>;
// Static fields
/**
* The icon specified does not exist in the theme
*/
static NOT_FOUND: number;
/**
* An unspecified error occurred.
*/
static FAILED: number;
// Constructors
constructor(options: { message: string; code: number });
_init(...args: any[]): void;
// Static methods
static quark(): GLib.Quark;
}
/**
* An enum for determining where a dropped item goes.
*/
/**
* An enum for determining where a dropped item goes.
*/
export namespace IconViewDropPosition {
export const $gtype: GObject.GType<IconViewDropPosition>;
}
enum IconViewDropPosition {
/**
* no drop possible
*/
NO_DROP,
/**
* dropped item replaces the item
*/
DROP_INTO,
/**
* droppped item is inserted to the left
*/
DROP_LEFT,
/**
* dropped item is inserted to the right
*/
DROP_RIGHT,
/**
* dropped item is inserted above
*/
DROP_ABOVE,
/**
* dropped item is inserted below
*/
DROP_BELOW,
}
/**
* Describes the image data representation used by a #GtkImage. If you
* want to get the image from the widget, you can only get the
* currently-stored representation. e.g. if the
* gtk_image_get_storage_type() returns #GTK_IMAGE_PIXBUF, then you can
* call gtk_image_get_pixbuf() but not gtk_image_get_stock(). For empty
* images, you can request any storage type (call any of the "get"
* functions), but they will all return %NULL values.
*/
/**
* Describes the image data representation used by a #GtkImage. If you
* want to get the image from the widget, you can only get the
* currently-stored representation. e.g. if the
* gtk_image_get_storage_type() returns #GTK_IMAGE_PIXBUF, then you can
* call gtk_image_get_pixbuf() but not gtk_image_get_stock(). For empty
* images, you can request any storage type (call any of the "get"
* functions), but they will all return %NULL values.
*/
export namespace ImageType {
export const $gtype: GObject.GType<ImageType>;
}
enum ImageType {
/**
* there is no image displayed by the widget
*/
EMPTY,
/**
* the widget contains a #GdkPixbuf
*/
PIXBUF,
/**
* the widget contains a [stock item name][gtkstock]
*/
STOCK,
/**
* the widget contains a #GtkIconSet
*/
ICON_SET,
/**
* the widget contains a #GdkPixbufAnimation
*/
ANIMATION,
/**
* the widget contains a named icon.
* This image type was added in GTK+ 2.6
*/
ICON_NAME,
/**
* the widget contains a #GIcon.
* This image type was added in GTK+ 2.14
*/
GICON,
/**
* the widget contains a #cairo_surface_t.
* This image type was added in GTK+ 3.10
*/
SURFACE,
}
/**
* Describes primary purpose of the input widget. This information is
* useful for on-screen keyboards and similar input methods to decide
* which keys should be presented to the user.
*
* Note that the purpose is not meant to impose a totally strict rule
* about allowed characters, and does not replace input validation.
* It is fine for an on-screen keyboard to let the user override the
* character set restriction that is expressed by the purpose. The
* application is expected to validate the entry contents, even if
* it specified a purpose.
*
* The difference between `GTK_INPUT_PURPOSE_DIGITS` and
* `GTK_INPUT_PURPOSE_NUMBER` is that the former accepts only digits
* while the latter also some punctuation (like commas or points, plus,
* minus) and “e” or “E” as in 3.14E+000.
*
* This enumeration may be extended in the future; input methods should
* interpret unknown values as “free form”.
*/
/**
* Describes primary purpose of the input widget. This information is
* useful for on-screen keyboards and similar input methods to decide
* which keys should be presented to the user.
*
* Note that the purpose is not meant to impose a totally strict rule
* about allowed characters, and does not replace input validation.
* It is fine for an on-screen keyboard to let the user override the
* character set restriction that is expressed by the purpose. The
* application is expected to validate the entry contents, even if
* it specified a purpose.
*
* The difference between `GTK_INPUT_PURPOSE_DIGITS` and
* `GTK_INPUT_PURPOSE_NUMBER` is that the former accepts only digits
* while the latter also some punctuation (like commas or points, plus,
* minus) and “e” or “E” as in 3.14E+000.
*
* This enumeration may be extended in the future; input methods should
* interpret unknown values as “free form”.
*/
export namespace InputPurpose {
export const $gtype: GObject.GType<InputPurpose>;
}
enum InputPurpose {
/**
* Allow any character
*/
FREE_FORM,
/**
* Allow only alphabetic characters
*/
ALPHA,
/**
* Allow only digits
*/
DIGITS,
/**
* Edited field expects numbers
*/
NUMBER,
/**
* Edited field expects phone number
*/
PHONE,
/**
* Edited field expects URL
*/
URL,
/**
* Edited field expects email address
*/
EMAIL,
/**
* Edited field expects the name of a person
*/
NAME,
/**
* Like `GTK_INPUT_PURPOSE_FREE_FORM,` but characters are hidden
*/
PASSWORD,
/**
* Like `GTK_INPUT_PURPOSE_DIGITS,` but characters are hidden
*/
PIN,
/**
* Allow any character, in addition to control codes
*/
TERMINAL,
}
/**
* Used for justifying the text inside a #GtkLabel widget. (See also
* #GtkAlignment).
*/
/**
* Used for justifying the text inside a #GtkLabel widget. (See also
* #GtkAlignment).
*/
export namespace Justification {
export const $gtype: GObject.GType<Justification>;
}
enum Justification {
/**
* The text is placed at the left edge of the label.
*/
LEFT,
/**
* The text is placed at the right edge of the label.
*/
RIGHT,
/**
* The text is placed in the center of the label.
*/
CENTER,
/**
* The text is placed is distributed across the label.
*/
FILL,
}
/**
* Describes how #GtkLevelBar contents should be rendered.
* Note that this enumeration could be extended with additional modes
* in the future.
*/
/**
* Describes how #GtkLevelBar contents should be rendered.
* Note that this enumeration could be extended with additional modes
* in the future.
*/
export namespace LevelBarMode {
export const $gtype: GObject.GType<LevelBarMode>;
}
enum LevelBarMode {
/**
* the bar has a continuous mode
*/
CONTINUOUS,
/**
* the bar has a discrete mode
*/
DISCRETE,
}
/**
* The type of license for an application.
*
* This enumeration can be expanded at later date.
*/
/**
* The type of license for an application.
*
* This enumeration can be expanded at later date.
*/
export namespace License {
export const $gtype: GObject.GType<License>;
}
enum License {
/**
* No license specified
*/
UNKNOWN,
/**
* A license text is going to be specified by the
* developer
*/
CUSTOM,
/**
* The GNU General Public License, version 2.0 or later
*/
GPL_2_0,
/**
* The GNU General Public License, version 3.0 or later
*/
GPL_3_0,
/**
* The GNU Lesser General Public License, version 2.1 or later
*/
LGPL_2_1,
/**
* The GNU Lesser General Public License, version 3.0 or later
*/
LGPL_3_0,
/**
* The BSD standard license
*/
BSD,
/**
* The MIT/X11 standard license
*/
MIT_X11,
/**
* The Artistic License, version 2.0
*/
ARTISTIC,
/**
* The GNU General Public License, version 2.0 only. Since 3.12.
*/
GPL_2_0_ONLY,
/**
* The GNU General Public License, version 3.0 only. Since 3.12.
*/
GPL_3_0_ONLY,
/**
* The GNU Lesser General Public License, version 2.1 only. Since 3.12.
*/
LGPL_2_1_ONLY,
/**
* The GNU Lesser General Public License, version 3.0 only. Since 3.12.
*/
LGPL_3_0_ONLY,
/**
* The GNU Affero General Public License, version 3.0 or later. Since: 3.22.
*/
AGPL_3_0,
/**
* The GNU Affero General Public License, version 3.0 only. Since: 3.22.27.
*/
AGPL_3_0_ONLY,
/**
* The 3-clause BSD licence. Since: 3.24.20.
*/
BSD_3,
/**
* The Apache License, version 2.0. Since: 3.24.20.
*/
APACHE_2_0,
/**
* The Mozilla Public License, version 2.0. Since: 3.24.20.
*/
MPL_2_0,
}
/**
* An enumeration representing directional movements within a menu.
*/
/**
* An enumeration representing directional movements within a menu.
*/
export namespace MenuDirectionType {
export const $gtype: GObject.GType<MenuDirectionType>;
}
enum MenuDirectionType {
/**
* To the parent menu shell
*/
PARENT,
/**
* To the submenu, if any, associated with the item
*/
CHILD,
/**
* To the next menu item
*/
NEXT,
/**
* To the previous menu item
*/
PREV,
}
/**
* The type of message being displayed in the dialog.
*/
/**
* The type of message being displayed in the dialog.
*/
export namespace MessageType {
export const $gtype: GObject.GType<MessageType>;
}
enum MessageType {
/**
* Informational message
*/
INFO,
/**
* Non-fatal warning message
*/
WARNING,
/**
* Question requiring a choice
*/
QUESTION,
/**
* Fatal error message
*/
ERROR,
/**
* None of the above
*/
OTHER,
}
export namespace MovementStep {
export const $gtype: GObject.GType<MovementStep>;
}
enum MovementStep {
/**
* Move forward or back by graphemes
*/
LOGICAL_POSITIONS,
/**
* Move left or right by graphemes
*/
VISUAL_POSITIONS,
/**
* Move forward or back by words
*/
WORDS,
/**
* Move up or down lines (wrapped lines)
*/
DISPLAY_LINES,
/**
* Move to either end of a line
*/
DISPLAY_LINE_ENDS,
/**
* Move up or down paragraphs (newline-ended lines)
*/
PARAGRAPHS,
/**
* Move to either end of a paragraph
*/
PARAGRAPH_ENDS,
/**
* Move by pages
*/
PAGES,
/**
* Move to ends of the buffer
*/
BUFFER_ENDS,
/**
* Move horizontally by pages
*/
HORIZONTAL_PAGES,
}
export namespace NotebookTab {
export const $gtype: GObject.GType<NotebookTab>;
}
enum NotebookTab {
FIRST,
LAST,
}
/**
* Used to determine the layout of pages on a sheet when printing
* multiple pages per sheet.
*/
/**
* Used to determine the layout of pages on a sheet when printing
* multiple pages per sheet.
*/
export namespace NumberUpLayout {
export const $gtype: GObject.GType<NumberUpLayout>;
}
enum NumberUpLayout {
/**
* 
*/
LRTB,
/**
* 
*/
LRBT,
/**
* 
*/
RLTB,
/**
* 
*/
RLBT,
/**
* 
*/
TBLR,
/**
* 
*/
TBRL,
/**
* 
*/
BTLR,
/**
* 
*/
BTRL,
}
/**
* Represents the orientation of widgets and other objects which can be switched
* between horizontal and vertical orientation on the fly, like #GtkToolbar or
* #GtkGesturePan.
*/
/**
* Represents the orientation of widgets and other objects which can be switched
* between horizontal and vertical orientation on the fly, like #GtkToolbar or
* #GtkGesturePan.
*/
export namespace Orientation {
export const $gtype: GObject.GType<Orientation>;
}
enum Orientation {
/**
* The element is in horizontal orientation.
*/
HORIZONTAL,
/**
* The element is in vertical orientation.
*/
VERTICAL,
}
/**
* Determines how widgets should be packed inside menubars
* and menuitems contained in menubars.
*/
/**
* Determines how widgets should be packed inside menubars
* and menuitems contained in menubars.
*/
export namespace PackDirection {
export const $gtype: GObject.GType<PackDirection>;
}
enum PackDirection {
/**
* Widgets are packed left-to-right
*/
LTR,
/**
* Widgets are packed right-to-left
*/
RTL,
/**
* Widgets are packed top-to-bottom
*/
TTB,
/**
* Widgets are packed bottom-to-top
*/
BTT,
}
/**
* Represents the packing location #GtkBox children. (See: #GtkVBox,
* #GtkHBox, and #GtkButtonBox).
*/
/**
* Represents the packing location #GtkBox children. (See: #GtkVBox,
* #GtkHBox, and #GtkButtonBox).
*/
export namespace PackType {
export const $gtype: GObject.GType<PackType>;
}
enum PackType {
/**
* The child is packed into the start of the box
*/
START,
/**
* The child is packed into the end of the box
*/
END,
}
/**
* The type of a pad action.
*/
/**
* The type of a pad action.
*/
export namespace PadActionType {
export const $gtype: GObject.GType<PadActionType>;
}
enum PadActionType {
/**
* Action is triggered by a pad button
*/
BUTTON,
/**
* Action is triggered by a pad ring
*/
RING,
/**
* Action is triggered by a pad strip
*/
STRIP,
}
/**
* See also gtk_print_settings_set_orientation().
*/
/**
* See also gtk_print_settings_set_orientation().
*/
export namespace PageOrientation {
export const $gtype: GObject.GType<PageOrientation>;
}
enum PageOrientation {
/**
* Portrait mode.
*/
PORTRAIT,
/**
* Landscape mode.
*/
LANDSCAPE,
/**
* Reverse portrait mode.
*/
REVERSE_PORTRAIT,
/**
* Reverse landscape mode.
*/
REVERSE_LANDSCAPE,
}
/**
* See also gtk_print_job_set_page_set().
*/
/**
* See also gtk_print_job_set_page_set().
*/
export namespace PageSet {
export const $gtype: GObject.GType<PageSet>;
}
enum PageSet {
/**
* All pages.
*/
ALL,
/**
* Even pages.
*/
EVEN,
/**
* Odd pages.
*/
ODD,
}
/**
* Describes the panning direction of a #GtkGesturePan
*/
/**
* Describes the panning direction of a #GtkGesturePan
*/
export namespace PanDirection {
export const $gtype: GObject.GType<PanDirection>;
}
enum PanDirection {
/**
* panned towards the left
*/
LEFT,
/**
* panned towards the right
*/
RIGHT,
/**
* panned upwards
*/
UP,
/**
* panned downwards
*/
DOWN,
}
/**
* Priorities for path lookups.
* See also gtk_binding_set_add_path().
*/
/**
* Priorities for path lookups.
* See also gtk_binding_set_add_path().
*/
export namespace PathPriorityType {
export const $gtype: GObject.GType<PathPriorityType>;
}
enum PathPriorityType {
/**
* Deprecated
*/
LOWEST,
/**
* Deprecated
*/
GTK,
/**
* Deprecated
*/
APPLICATION,
/**
* Deprecated
*/
THEME,
/**
* Deprecated
*/
RC,
/**
* Deprecated
*/
HIGHEST,
}
/**
* Widget path types.
* See also gtk_binding_set_add_path().
*/
/**
* Widget path types.
* See also gtk_binding_set_add_path().
*/
export namespace PathType {
export const $gtype: GObject.GType<PathType>;
}
enum PathType {
/**
* Deprecated
*/
WIDGET,
/**
* Deprecated
*/
WIDGET_CLASS,
/**
* Deprecated
*/
CLASS,
}
/**
* Determines how the size should be computed to achieve the one of the
* visibility mode for the scrollbars.
*/
/**
* Determines how the size should be computed to achieve the one of the
* visibility mode for the scrollbars.
*/
export namespace PolicyType {
export const $gtype: GObject.GType<PolicyType>;
}
enum PolicyType {
/**
* The scrollbar is always visible. The view size is