A #GtkAllocation-struct of a widget represents region which has been allocated to the widget by its parent. It is a subregion of its parents allocation. See [GtkWidget’s geometry management section][geometry-management] for more information.
Accelerator flags used with gtk.accel_group.AccelGroup.connect.
Controls how a widget deals with extra space in a single (x or y) dimension.
Types of user actions that may be blocked by gtk.application.Application.inhibit.
Used to specify the placement of scroll arrows in scrolling menus.
Used to indicate the direction in which an arrow should point.
An enum for determining the page role inside the #GtkAssistant. It's used to handle buttons sensitivity and visibility.
Denotes the expansion properties that a widget will have when it (or its parent) is resized.
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.
Describes how the border of a UI element should be rendered.
Error codes that identify various errors that can occur while using #GtkBuilder.
Used to dictate the style that a #GtkButtonBox uses to layout the buttons it contains.
The role specifies the desired appearance of a #GtkModelButton.
Prebuilt sets of buttons for the dialog. If none of these choices are appropriate, simply use gtk.types.ButtonsType.None then call gtk.dialog.Dialog.addButtons.
These options can be used to influence the display and behaviour of a #GtkCalendar.
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.
Identifies how the user can interact with a particular cell.
Tells how a cell is to be rendered.
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.
Error codes for GTK_CSS_PROVIDER_ERROR.
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, but may contain extensions.
See also: #GtkEntry::delete-from-cursor.
The #GtkDestDefaults enumeration specifies the various types of action that will be taken on behalf of the user for a drag destination site.
Flags used to influence dialog construction.
Focus movement types.
Gives an indication why a drag operation failed. The value can by obtained by connecting to the #GtkWidget::drag-failed signal.
Specifies the side of the entry at which an icon is placed.
Describes the behavior of a #GtkEventControllerScroll.
Describes the state of a #GdkEventSequence in a #GtkGesture.
Used to specify the style of the expanders drawn by a #GtkTreeView.
Describes whether a #GtkFileChooser is being used to open existing files or to save to a possibly new file.
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.
These identify the various errors that can occur while calling #GtkFileChooser functions.
These flags indicate what parts of a #GtkFileFilterInfo struct are filled or need to be filled.
This enumeration specifies the granularity of font selection that is desired in a font chooser.
Style for input method preedit. See also #GtkSettings:gtk-im-preedit-style
Style for input method status. See also #GtkSettings:gtk-im-status-style
Used to specify options for gtk.icon_theme.IconTheme.lookupIcon
Built-in stock icon sizes.
Error codes for GtkIconTheme operations.
An enum for determining where a dropped item goes.
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.Image.getStorageType returns #GTK_IMAGE_PIXBUF, then you can call gtk.image.Image.getPixbuf but not gtk.image.Image.getStock. For empty images, you can request any storage type (call any of the "get" functions), but they will all return null values.
Describes hints that might be taken into account by input methods or applications. Note that input methods may already tailor their behaviour according to the #GtkInputPurpose of the entry.
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.
Describes how a rendered element connects to adjacent elements.
Used for justifying the text inside a #GtkLabel widget. (See also #GtkAlignment).
Describes how #GtkLevelBar contents should be rendered. Note that this enumeration could be extended with additional modes in the future.
The type of license for an application.
An enumeration representing directional movements within a menu.
The type of message being displayed in the dialog.
Used to determine the layout of pages on a sheet when printing multiple pages per sheet.
Represents the orientation of widgets and other objects which can be switched between horizontal and vertical orientation on the fly, like #GtkToolbar or #GtkGesturePan.
Determines how widgets should be packed inside menubars and menuitems contained in menubars.
Represents the packing location #GtkBox children. (See: #GtkVBox, #GtkHBox, and #GtkButtonBox).
The type of a pad action.
See also gtk.print_job.PrintJob.setPageSet.
Describes the panning direction of a #GtkGesturePan
Priorities for path lookups. See also gtk.binding_set.BindingSet.addPath.
Widget path types. See also gtk.binding_set.BindingSet.addPath.
These flags serve two purposes. First, the application can call gtk.places_sidebar.PlacesSidebar.setOpenFlags using these flags as a bitmask. This tells the sidebar that the application is able to open folders selected from the sidebar in various ways, for example, in new tabs or in new windows in addition to the normal mode.
Determines how the size should be computed to achieve the one of the visibility mode for the scrollbars.
Describes constraints to positioning of popovers. More values may be added to this enumeration in the future.
Describes which edge of a widget a certain feature is positioned at, e.g. the tabs of a #GtkNotebook, the handle of a #GtkHandleBox or the label of a #GtkScale.
Error codes that identify various errors that can occur while using the GTK+ printing support.
The @action parameter to gtk.print_operation.PrintOperation.run determines what action the print operation should perform.
A value of this type is returned by gtk.print_operation.PrintOperation.run.
See also gtk.print_job.PrintJob.setPages
The status gives a rough indication of the completion of a running print operation.
Describes the stage at which events are fed into a #GtkEventController.
Deprecated
The #GtkRcTokenType enumeration represents the tokens in the RC file. It is exposed so that theme engines can reuse these tokens when parsing the theme-engine specific portions of a RC file.
These identify the various errors that can occur while calling #GtkRecentChooser functions.
These flags indicate what parts of a #GtkRecentFilterInfo struct are filled or need to be filled.
Error codes for #GtkRecentManager operations
Used to specify the sorting method to be applyed to the recently used resource list.
Describes a region within a widget.
Indicated the relief to be drawn around a #GtkButton.
Predefined values for use as response ids in gtk.dialog.Dialog.addButton. All predefined values are negative; GTK+ leaves values of 0 or greater for application-defined response ids.
These enumeration values describe the possible transitions when the child of a #GtkRevealer widget is shown or hidden.
Scrolling types.
Defines the policy to be used in a scrollable widget when updating the scrolled window adjustments in a given orientation.
Used to control what selections users are allowed to make.
Determines how GTK+ handles the sensitivity of stepper arrows at the end of range widgets.
Used to change the appearance of an outline typically provided by a #GtkFrame.
GtkShortcutType specifies the kind of shortcut that is being described. More values may be added to this enumeration over time.
The mode of the size group determines the directions in which the size group affects the requested sizes of its component widgets.
Specifies a preference for height-for-width or width-for-height geometry management.
Determines the direction of a sort.
The spin button update policy determines whether the spin button displays values even if they are outside the bounds of its adjustment. See gtk.spin_button.SpinButton.setUpdatePolicy.
The values of the GtkSpinType enumeration are used to specify the change to make in gtk.spin_button.SpinButton.spin.
These enumeration values describe the possible transitions between pages in a #GtkStack widget.
Describes a widget state. Widget states are used to match the widget against CSS pseudo-classes. Note that GTK extends the regular CSS classes and sometimes uses different names.
This type indicates the current state of a widget; the state determines how the widget is drawn. The #GtkStateType enumeration is also used to identify different colors in a #GtkStyle for drawing, so states can be used for subparts of a widget as well as entire widgets.
Flags that modify the behavior of gtk.style_context.StyleContext.toString_. New values may be added to this enumeration.
The #GtkTargetFlags enumeration is used to specify constraints on a #GtkTargetEntry.
These values are used as “info” for the targets contained in the lists returned by gtk.text_buffer.TextBuffer.getCopyTargetList and gtk.text_buffer.TextBuffer.getPasteTargetList.
Reading directions for text.
Granularity types that extend the text selection. Use the #GtkTextView::extend-selection signal to customize the selection.
Flags affecting how a search is done.
Used to reference the layers of #GtkTextView for the purpose of customized drawing with the ::draw_layer vfunc.
Used to reference the parts of #GtkTextView.
Flags used to specify the supported drag targets.
Whether spacers are vertical lines or just blank.
Used to customize the appearance of a #GtkToolbar. Note that setting the toolbar style overrides the user’s preferences for the default toolbar style. Note that if the button has only a label set and GTK_TOOLBAR_ICONS is used, the label will be visible, and vice versa.
These flags indicate various properties of a #GtkTreeModel.
The sizing method the column uses to determine its width. Please note that @GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and can make columns appear choppy.
An enum for determining where a dropped row goes.
Used to indicate which grid lines to draw in a tree view.
These enumeration values are used by gtk.uimanager.UIManager.addUi to determine what UI element to create.
Kinds of widget-specific help. Used by the ::show-help signal.
Window placement can be influenced using this enumeration. Note that using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea. It won’t necessarily work well with all window managers or on all windowing systems.
A #GtkWindow can be one of these types. Most things you’d consider a “window” should have type #GTK_WINDOW_TOPLEVEL; windows with this type are managed by the window manager and have a frame by default (call gtk.window.Window.setDecorated to toggle the frame). Windows with type #GTK_WINDOW_POPUP are ignored by the window manager; window manager keybindings won’t work on them, the window manager won’t decorate the window with a frame, many GTK+ features that rely on the window manager will not work (e.g. resize grips and maximization/minimization). #GTK_WINDOW_POPUP is used to implement widgets such as #GtkMenu or tooltips that you normally don’t think of as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL. In particular, do not use #GTK_WINDOW_POPUP just to turn off the window borders; use gtk.window.Window.setDecorated for that.
Describes a type of line wrapping.
The GtkAboutDialog offers a simple way to display information about a program like its logo, name, copyright, website and license. It is also possible to give credits to the authors, documenters, translators and artists who have worked on the program. An about dialog is typically opened when the user selects the About option from the Help menu. All parts of the dialog are optional.
A #GtkAccelGroup represents a group of keyboard accelerators, typically attached to a toplevel #GtkWindow (with gtk.window.Window.addAccelGroup). Usually you won’t need to create a #GtkAccelGroup directly; instead, when using #GtkUIManager, GTK+ automatically sets up the accelerators for your menus in the ui manager’s #GtkAccelGroup.
The #GtkAccelLabel widget is a subclass of #GtkLabel that also displays an accelerator key on the right of the label text, e.g. “Ctrl+S”. It is commonly used in menus to show the keyboard short-cuts for commands.
Accelerator maps are used to define runtime configurable accelerators. Functions for manipulating them are are usually used by higher level convenience mechanisms like #GtkUIManager and are thus considered “low-level”. You’ll want to use them if you’re manually creating menus that should have user-configurable accelerators.
The #GtkAccessible class is the base class for accessible implementations for #GtkWidget subclasses. It is a thin wrapper around #AtkObject, which adds facilities for associating a widget with its accessible object.
> In GTK+ 3.10, GtkAction has been deprecated. Use #GAction > instead, and associate actions with #GtkActionable widgets. Use > #GMenuModel for creating menus with gtk.menu.Menu.newFromModel.
GtkActionBar is designed to present contextual actions. It is expected to be displayed below the content and expand horizontally to fill the area.
#GtkActionEntry structs are used with gtk.action_group.ActionGroup.addActions to construct actions.
Actions are organised into groups. An action group is essentially a map from names to #GtkAction objects.
This interface provides a convenient way of associating widgets with actions on a #GtkApplicationWindow or #GtkApplication.
The interface vtable for #GtkActionable.
Activatable widgets can be connected to a #GtkAction and reflects the state of its action. A #GtkActivatable can also provide feedback through its action, as they are responsible for activating their related actions.
> This method can be called with a null action at times.
The #GtkAdjustment object represents a value which has an associated lower and upper bound, together with step and page increments, and a page size. It is used within several GTK+ widgets, including #GtkSpinButton, #GtkViewport, and #GtkRange (which is a base class for #GtkScrollbar and #GtkScale).
The #GtkAlignment widget controls the alignment and size of its child widget. It has four settings: xscale, yscale, xalign, and yalign.
#GtkAppChooser is an interface that can be implemented by widgets which allow the user to choose an application (typically for the purpose of opening a file). The main objects that implement this interface are #GtkAppChooserWidget, #GtkAppChooserDialog and #GtkAppChooserButton.
The #GtkAppChooserButton is a widget that lets the user select an application. It implements the #GtkAppChooser interface.
#GtkAppChooserDialog shows a #GtkAppChooserWidget inside a #GtkDialog.
#GtkAppChooserWidget is a widget for selecting applications. It is the main building block for #GtkAppChooserDialog. Most applications only need to use the latter; but you can use this widget as part of a larger widget if you have special needs.
#GtkApplication is a class that handles many important aspects of a GTK+ application in a convenient fashion, without enforcing a one-size-fits-all application model.
#GtkApplicationWindow is a #GtkWindow subclass that offers some extra functionality for better integration with #GtkApplication features. Notably, it can handle both the application menu as well as the menubar. See gtk.application.Application.setAppMenu and gtk.application.Application.setMenubar.
GtkArrow should be used to draw simple arrows that need to point in one of the four cardinal directions (up, down, left, or right). The style of the arrow can be one of shadow in, shadow out, etched in, or etched out. Note that these directions and style types may be amended in versions of GTK+ to come.
The #GtkAspectFrame is useful when you want pack a widget so that it can resize but always retains the same aspect ratio. For instance, one might be drawing a small preview of a larger image. #GtkAspectFrame derives from #GtkFrame, so it can draw a label and a frame around the child. The frame will be “shrink-wrapped” to the size of the child.
A #GtkAssistant is a widget used to represent a generally complex operation splitted in several steps, guiding the user through its pages and controlling the page flow to collect the necessary data.
The #GtkBin widget is a container with just one child. It is not very useful itself, but it is useful for deriving subclasses, since it provides common code needed for handling a single child widget.
A #GtkBindingArg holds the data associated with an argument for a key binding signal emission as stored in #GtkBindingSignal.
Each key binding element of a binding sets binding list is represented by a GtkBindingEntry.
A binding set maintains a list of activatable key bindings. A single binding set can match multiple types of widgets. Similar to style contexts, can be matched by any information contained in a widgets #GtkWidgetPath. When a binding within a set is matched upon activation, an action signal is emitted on the target widget to carry out the actual activation.
A GtkBindingSignal stores the necessary information to activate a widget in response to a key press via a signal emission.
A struct that specifies a border around a rectangular area that can be of different width on each side.
The GtkBox widget arranges child widgets into a single row or column, depending upon the value of its #GtkOrientable:orientation property. Within the other dimension, all children are allocated the same size. Of course, the #GtkWidget:halign and #GtkWidget:valign properties can be used on the children to influence their allocation.
GtkBuildable allows objects to extend and customize their deserialization from [GtkBuilder UI descriptions][BUILDER-UI]. The interface includes methods for setting names and properties of objects, parsing custom tags and constructing child objects.
The #GtkBuildableIface interface contains method that are necessary to allow #GtkBuilder to construct an object from a #GtkBuilder UI definition.
A GtkBuilder is an auxiliary object that reads textual descriptions of a user interface and instantiates the described objects. To create a GtkBuilder from a user interface description, call gtk.builder.Builder.newFromFile, gtk.builder.Builder.newFromResource or gtk.builder.Builder.newFromString.
The #GtkButton widget is generally used to trigger a callback function that is called when the button is pressed. The various signals and how to use them are outlined below.
#GtkCalendar is a widget that displays a Gregorian calendar, one month at a time. It can be created with gtk.calendar.Calendar.new_.
The #GtkCellArea is an abstract class for #GtkCellLayout widgets (also referred to as "layouting widgets") to interface with an arbitrary number of #GtkCellRenderers and interact with the user for a given #GtkTreeModel row.
The #GtkCellAreaBox renders cell renderers into a row or a column depending on its #GtkOrientation.
The #GtkCellAreaContext object is created by a given #GtkCellArea implementation via its #GtkCellAreaClass.create_context() virtual method and is used to store cell sizes and alignments for a series of #GtkTreeModel rows that are requested and rendered in the same context.
The #GtkCellEditable interface must be implemented for widgets to be usable to edit the contents of a #GtkTreeView cell. It provides a way to specify how temporary widgets should be configured for editing, get the new value, etc.
#GtkCellLayout is an interface to be implemented by all objects which want to provide a #GtkTreeViewColumn like API for packing cells, setting attributes and data funcs.
The #GtkCellRenderer is a base class of a set of objects used for rendering a cell to a #cairo_t. These objects are used primarily by the #GtkTreeView widget, though they aren’t tied to them in any specific way. It is worth noting that #GtkCellRenderer is not a #GtkWidget and cannot be treated as such.
#GtkCellRendererAccel displays a keyboard accelerator (i.e. a key combination like Control + a). If the cell renderer is editable, the accelerator can be changed by simply typing the new combination.
#GtkCellRendererCombo renders text in a cell like #GtkCellRendererText from which it is derived. But while #GtkCellRendererText offers a simple entry to edit the text, #GtkCellRendererCombo offers a #GtkComboBox widget to edit the text. The values to display in the combo box are taken from the tree model specified in the #GtkCellRendererCombo:model property.
A #GtkCellRendererPixbuf can be used to render an image in a cell. It allows to render either a given #GdkPixbuf (set via the #GtkCellRendererPixbuf:pixbuf property) or a named icon (set via the #GtkCellRendererPixbuf:icon-name property).
#GtkCellRendererProgress renders a numeric value as a progress par in a cell. Additionally, it can display a text on top of the progress bar.
#GtkCellRendererSpin renders text in a cell like #GtkCellRendererText from which it is derived. But while #GtkCellRendererText offers a simple entry to edit the text, #GtkCellRendererSpin offers a #GtkSpinButton widget. Of course, that means that the text has to be parseable as a floating point number.
GtkCellRendererSpinner renders a spinning animation in a cell, very similar to #GtkSpinner. It can often be used as an alternative to a #GtkCellRendererProgress for displaying indefinite activity, instead of actual progress.
A #GtkCellRendererText renders a given text in its cell, using the font, color and style information provided by its properties. The text will be ellipsized if it is too long and the #GtkCellRendererText:ellipsize property allows it.
#GtkCellRendererToggle renders a toggle button in a cell. The button is drawn as a radio or a checkbutton, depending on the #GtkCellRendererToggle:radio property. When activated, it emits the #GtkCellRendererToggle::toggled signal.
A #GtkCellView displays a single row of a #GtkTreeModel using a #GtkCellArea and #GtkCellAreaContext. A #GtkCellAreaContext can be provided to the #GtkCellView at construction time in order to keep the cellview in context of a group of cell views, this ensures that the renderers displayed will be properly aligned with eachother (like the aligned cells in the menus of #GtkComboBox).
A #GtkCheckButton places a discrete #GtkToggleButton next to a widget, (usually a #GtkLabel). See the section on #GtkToggleButton widgets for more information about toggle/check buttons.
A #GtkCheckMenuItem is a menu item that maintains the state of a boolean value in addition to a #GtkMenuItem usual role in activating application code.
The #GtkClipboard object represents a clipboard of data shared between different processes or between different widgets in the same process. Each clipboard is identified by a name encoded as a #GdkAtom. (Conversion to and from strings can be done with gdk.atom.Atom.intern and gdk.atom.Atom.name.) The default clipboard corresponds to the “CLIPBOARD” atom; another commonly used clipboard is the “PRIMARY” clipboard, which, in X, traditionally contains the currently selected text.
The #GtkColorButton is a button which displays the currently selected color and allows to open a color selection dialog to change the color. It is suitable widget for selecting a color in a preference dialog.
#GtkColorChooser is an interface that is implemented by widgets for choosing colors. Depending on the situation, colors may be allowed to have alpha (translucency).
The #GtkColorChooserDialog widget is a dialog for choosing a color. It implements the #GtkColorChooser interface.
The #GtkColorChooserWidget widget lets the user select a color. By default, the chooser presents a predefined palette of colors, plus a small number of settable custom colors. It is also possible to select a different color with the single-color editor. To enter the single-color editing mode, use the context menu of any color of the palette, or use the '+' button to add a new custom color.
A GtkComboBox is a widget that allows the user to choose from a list of valid choices. The GtkComboBox displays the selected choice. When activated, the GtkComboBox displays a popup which allows the user to make a new choice. The style in which the selected value is displayed, and the style of the popup is determined by the current theme. It may be similar to a Windows-style combo box.
A GtkComboBoxText is a simple variant of #GtkComboBox that hides the model-view complexity for simple text-only use cases.
A GTK+ user interface is constructed by nesting widgets inside widgets. Container widgets are the inner nodes in the resulting tree of widgets: they contain other widgets. So, for example, you might have a #GtkWindow containing a #GtkFrame containing a #GtkLabel. If you wanted an image instead of a textual label inside the frame, you might replace the #GtkLabel widget with a #GtkImage widget.
Base class for containers.
GtkCssProvider is an object implementing the #GtkStyleProvider interface. It is able to parse [CSS-like][css-overview] input in order to style widgets.
Defines a part of a CSS document. Because sections are nested into one another, you can use gtk.css_section.CssSection.getParent to get the containing region.
Dialog boxes are a convenient way to prompt the user for a small amount of input, e.g. to display a message, ask a question, or anything else that does not require extensive effort on the user’s part.
The #GtkDrawingArea widget is used for creating custom user interface elements. It’s essentially a blank widget; you can draw on it. After creating a drawing area, the application may want to connect to:
The #GtkEditable interface is an interface which should be implemented by text editing widgets, such as #GtkEntry and #GtkSpinButton. It contains functions for generically manipulating an editable widget, a large number of action signals used for key bindings, and several signals that an application can connect to to modify the behavior of a widget.
The #GtkEntry widget is a single line text entry widget. A fairly large set of key bindings are supported by default. If the entered text is longer than the allocation of the widget, the widget will scroll so that the cursor position is visible.
The #GtkEntryBuffer class contains the actual text displayed in a #GtkEntry widget.
Class structure for #GtkEntry. All virtual functions have a default implementation. Derived classes may set the virtual function pointers for the signal handlers to null, but must keep @get_text_area_size and @get_frame_size non-null; either use the default implementation, or provide a custom one.
#GtkEntryCompletion is an auxiliary object to be used in conjunction with #GtkEntry to provide the completion functionality. It implements the #GtkCellLayout interface, to allow the user to add extra cells to the #GtkTreeView with completion matches.
The #GtkEventBox widget is a subclass of #GtkBin which also has its own window. It is useful since it allows you to catch events for widgets which do not have their own window.
#GtkEventController is a base, low-level implementation for event controllers. Those react to a series of #GdkEvents, and possibly trigger actions as a consequence of those.
#GtkEventControllerKey is an event controller meant for situations where you need access to key events.
#GtkEventControllerMotion is an event controller meant for situations where you need to track the position of the pointer.
#GtkEventControllerScroll is an event controller meant to handle scroll events from mice and touchpads. It is capable of handling both discrete and continuous scroll events, abstracting them both on the #GtkEventControllerScroll::scroll signal (deltas in the discrete case are multiples of 1).
A #GtkExpander allows the user to hide or show its child by clicking on an expander triangle similar to the triangles used in a #GtkTreeView.
#GtkFileChooser is an interface that can be implemented by file selection widgets. In GTK+, the main objects that implement this interface are #GtkFileChooserWidget, #GtkFileChooserDialog, and #GtkFileChooserButton. You do not need to write an object that implements the #GtkFileChooser interface unless you are trying to adapt an existing file selector to expose a standard programming interface.
The #GtkFileChooserButton is a widget that lets the user select a file. It implements the #GtkFileChooser interface. Visually, it is a file name with a button to bring up a #GtkFileChooserDialog. The user can then use that dialog to change the file associated with that button. This widget does not support setting the #GtkFileChooser:select-multiple property to true.
#GtkFileChooserDialog is a dialog box suitable for use with “File/Open” or “File/Save as” commands. This widget works by putting a #GtkFileChooserWidget inside a #GtkDialog. It exposes the #GtkFileChooser interface, so you can use all of the #GtkFileChooser functions on the file chooser dialog as well as those for #GtkDialog.
#GtkFileChooserNative is an abstraction of a dialog box suitable for use with “File/Open” or “File/Save as” commands. By default, this just uses a #GtkFileChooserDialog to implement the actual dialog. However, on certain platforms, such as Windows and macOS, the native platform file chooser is used instead. When the application is running in a sandboxed environment without direct filesystem access (such as Flatpak), #GtkFileChooserNative may call the proper APIs (portals) to let the user choose a file and make it available to the application.
#GtkFileChooserWidget is a widget for choosing files. It exposes the #GtkFileChooser interface, and you should use the methods of this interface to interact with the widget.
A GtkFileFilter can be used to restrict the files being shown in a #GtkFileChooser. Files can be filtered based on their name (with gtk.file_filter.FileFilter.addPattern), on their mime type (with gtk.file_filter.FileFilter.addMimeType), or by a custom filter function (with gtk.file_filter.FileFilter.addCustom).
A #GtkFileFilterInfo-struct is used to pass information about the tested file to gtk.file_filter.FileFilter.filter.
The #GtkFixed widget is a container which can place child widgets at fixed positions and with fixed sizes, given in pixels. #GtkFixed performs no automatic layout management.
A GtkFlowBox positions child widgets in sequence according to its orientation.
The #GtkFontButton is a button which displays the currently selected font an allows to open a font chooser dialog to change the font. It is suitable widget for selecting a font in a preference dialog.
#GtkFontChooser is an interface that can be implemented by widgets displaying the list of fonts. In GTK+, the main objects that implement this interface are #GtkFontChooserWidget, #GtkFontChooserDialog and #GtkFontButton. The GtkFontChooser interface has been introducted in GTK+ 3.2.
The #GtkFontChooserDialog widget is a dialog for selecting a font. It implements the #GtkFontChooser interface.
The #GtkFontChooserWidget widget lists the available fonts, styles and sizes, allowing the user to select a font. It is used in the #GtkFontChooserDialog widget to provide a dialog box for selecting fonts.
The frame widget is a bin that surrounds its child with a decorative frame and an optional label. If present, the label is drawn in a gap in the top side of the frame. The position of the label can be controlled with gtk.frame.Frame.setLabelAlign.
#GtkGLArea is a widget that allows drawing with OpenGL.
The gtk.glarea_class.GLAreaClass structure contains only private data.
#GtkGesture is the base object for gesture recognition, although this object is quite generalized to serve as a base for multi-touch gestures, it is suitable to implement single-touch and pointer-based gestures (using the special null #GdkEventSequence value for these).
#GtkGestureDrag is a #GtkGesture implementation that recognizes drag operations. The drag operation itself can be tracked throught the #GtkGestureDrag::drag-begin, #GtkGestureDrag::drag-update and #GtkGestureDrag::drag-end signals, or the relevant coordinates be extracted through gtk.gesture_drag.GestureDrag.getOffset and gtk.gesture_drag.GestureDrag.getStartPoint.
#GtkGestureLongPress is a #GtkGesture implementation able to recognize long presses, triggering the #GtkGestureLongPress::pressed after the timeout is exceeded.
#GtkGestureMultiPress is a #GtkGesture implementation able to recognize multiple clicks on a nearby zone, which can be listened for through the #GtkGestureMultiPress::pressed signal. Whenever time or distance between clicks exceed the GTK+ defaults, #GtkGestureMultiPress::stopped is emitted, and the click counter is reset.
#GtkGesturePan is a #GtkGesture implementation able to recognize pan gestures, those are drags that are locked to happen along one axis. The axis that a #GtkGesturePan handles is defined at construct time, and can be changed through gtk.gesture_pan.GesturePan.setOrientation.
#GtkGestureRotate is a #GtkGesture implementation able to recognize 2-finger rotations, whenever the angle between both handled sequences changes, the #GtkGestureRotate::angle-changed signal is emitted.
#GtkGestureSingle is a subclass of #GtkGesture, optimized (although not restricted) for dealing with mouse and single-touch gestures. Under interaction, these gestures stick to the first interacting sequence, which is accessible through gtk.gesture_single.GestureSingle.getCurrentSequence while the gesture is being interacted with.
#GtkGestureStylus is a #GtkGesture implementation specific to stylus input. The provided signals just provide the basic information
#GtkGestureSwipe is a #GtkGesture implementation able to recognize swipes, after a press/move/.../move/release sequence happens, the #GtkGestureSwipe::swipe signal will be emitted, providing the velocity and directionality of the sequence at the time it was lifted.
#GtkGestureZoom is a #GtkGesture implementation able to recognize pinch/zoom gestures, whenever the distance between both tracked sequences changes, the #GtkGestureZoom::scale-changed signal is emitted to report the scale factor.
GtkGradient is a boxed type that represents a gradient. It is the result of parsing a [gradient expression][gtkcssprovider-gradients]. To obtain the gradient represented by a GtkGradient, it has to be resolved with gtk.gradient.Gradient.resolve, which replaces all symbolic color references by the colors they refer to (in a given context) and constructs a #cairo_pattern_t value.
GtkGrid is a container which arranges its child widgets in rows and columns, with arbitrary positions and horizontal/vertical spans.
#GtkHBox is a container that organizes child widgets into a single row.
The HPaned widget is a container widget with two children arranged horizontally. The division between the two panes is adjustable by the user by dragging a handle. See #GtkPaned for details.
#GtkHSV is the “color wheel” part of a complete color selector widget. It allows to select a color by determining its HSV components in an intuitive way. Moving the selection around the outer ring changes the hue, and moving the selection point inside the inner triangle changes value and saturation.
The #GtkHScale widget is used to allow the user to select a value using a horizontal slider. To create one, use gtk.hscale.HScale.newWithRange.
The #GtkHScrollbar widget is a widget arranged horizontally creating a scrollbar. See #GtkScrollbar for details on scrollbars. #GtkAdjustment pointers may be added to handle the adjustment of the scrollbar or it may be left null in which case one will be created for you. See #GtkScrollbar for a description of what the fields in an adjustment represent for a scrollbar.
The #GtkHSeparator widget is a horizontal separator, used to group the widgets within a window. It displays a horizontal line with a shadow to make it appear sunken into the interface.
The #GtkHandleBox widget allows a portion of a window to be "torn off". It is a bin widget which displays its child and a handle that the user can drag to tear off a separate window (the “float window”) containing the child widget. A thin “ghost” is drawn in the original location of the handlebox. By dragging the separate window back to its original location, it can be reattached.
GtkHeaderBar is similar to a horizontal #GtkBox. It allows children to be placed at the start or the end. In addition, it allows a title and subtitle to be displayed. The title will be centered with respect to the width of the box, even if the children at either side take up different amounts of space. The height of the titlebar will be set to provide sufficient space for the subtitle, even if none is currently set. If a subtitle is not needed, the space reservation can be turned off with gtk.header_bar.HeaderBar.setHasSubtitle.
#GtkIMContext defines the interface for GTK+ input methods. An input method is used by GTK+ text input widgets like #GtkEntry to map from key events to Unicode character strings.
Bookkeeping information about a loadable input method.
GtkIMContextSimple is a simple input method context supporting table-based input methods. It has a built-in table of compose sequences that is derived from the X11 Compose files.
An icon factory manages a collection of #GtkIconSet; a #GtkIconSet manages a set of variants of a particular icon (i.e. a #GtkIconSet contains variants for different sizes and widget states). Icons in an icon factory are named by a stock ID, which is a simple string identifying the icon. Each #GtkStyle has a list of #GtkIconFactory derived from the current theme; those icon factories are consulted first when searching for an icon. If the theme doesn’t set a particular icon, GTK+ looks for the icon in a list of default icon factories, maintained by gtk.icon_factory.IconFactory.addDefault and gtk.icon_factory.IconFactory.removeDefault. Applications with icons should add a default icon factory with their icons, which will allow themes to override the icons for the application.
Contains information found when looking up an icon in an icon theme.
#GtkIconTheme provides a facility for looking up icons by name and size. The main reason for using a name rather than simply providing a filename is to allow different icons to be used depending on what “icon theme” is selected by the user. The operation of icon themes on Linux and Unix follows the Icon Theme Specification There is a fallback icon theme, named hicolor, where applications should install their icons, but additional icon themes can be installed as operating system vendors and users choose.
#GtkIconView provides an alternative view on a #GtkTreeModel. It displays the model as a grid of icons with labels. Like #GtkTreeView, it allows to select one or multiple items (depending on the selection mode, see gtk.icon_view.IconView.setSelectionMode). In addition to selection with the arrow keys, #GtkIconView supports rubberband selection, which is controlled by dragging the pointer.
The #GtkImage widget displays an image. Various kinds of object can be displayed as an image; most typically, you would load a #GdkPixbuf ("pixel buffer") from a file, and then display that. There’s a convenience function to do this, gtk.image.Image.newFromFile, used as follows:
A GtkImageMenuItem is a menu item which has an icon next to the text label.
#GtkInfoBar is a widget that can be used to show messages to the user without showing a dialog. It is often temporarily shown at the top or bottom of a document. In contrast to #GtkDialog, which has a action area at the bottom, #GtkInfoBar has an action area at the side.
The #GtkInvisible widget is used internally in GTK+, and is probably not very useful for application developers.
The #GtkLabel widget displays a small amount of text. As the name implies, most labels are used to label another widget such as a #GtkButton, a #GtkMenuItem, or a #GtkComboBox.
#GtkLayout is similar to #GtkDrawingArea in that it’s a “blank slate” and doesn’t do anything except paint a blank background by default. It’s different in that it supports scrolling natively due to implementing #GtkScrollable, and can contain child widgets since it’s a #GtkContainer.
The #GtkLevelBar is a bar widget that can be used as a level indicator. Typical use cases are displaying the strength of a password, or showing the charge level of a battery.
A GtkLinkButton is a #GtkButton with a hyperlink, similar to the one used by web browsers, which triggers an action when clicked. It is useful to show quick links to resources.
The #GtkLinkButtonClass contains only private data.
A GtkListBox is a vertical container that contains GtkListBoxRow children. These rows can be dynamically sorted and filtered, and headers can be added dynamically depending on the row content. It also allows keyboard and mouse navigation and selection like a typical list.
The #GtkListStore object is a list model for use with a #GtkTreeView widget. It implements the #GtkTreeModel interface, and consequentialy, can use all of the methods available there. It also implements the #GtkTreeSortable interface so it can be sorted by the view. Finally, it also implements the tree [drag and drop][gtk3-GtkTreeView-drag-and-drop] interfaces.
GtkLockButton is a widget that can be used in control panels or preference dialogs to allow users to obtain and revoke authorizations needed to operate the controls. The required authorization is represented by a #GPermission object. Concrete implementations of #GPermission may use PolicyKit or some other authorization framework. To obtain a PolicyKit-based #GPermission, use polkit_permission_new().
A #GtkMenu is a #GtkMenuShell that implements a drop down menu consisting of a list of #GtkMenuItem objects which can be navigated and activated by the user to perform application functions.
The #GtkMenuBar is a subclass of #GtkMenuShell which contains one or more #GtkMenuItems. The result is a standard menu bar which can hold many menu items.
The #GtkMenuButton widget is used to display a popup when clicked on. This popup can be provided either as a #GtkMenu, a #GtkPopover or an abstract #GMenuModel.
The #GtkMenuItem widget and the derived widgets are the only valid children for menus. Their function is to correctly handle highlighting, alignment, events and submenus.
A #GtkMenuShell is the abstract base class used to derive the #GtkMenu and #GtkMenuBar subclasses.
A #GtkMenuToolButton is a #GtkToolItem that contains a button and a small additional button with an arrow. When clicked, the arrow button pops up a dropdown menu.
#GtkMessageDialog presents a dialog with some message text. It’s simply a convenience widget; you could construct the equivalent of #GtkMessageDialog from #GtkDialog without too much effort, but #GtkMessageDialog saves typing.
The #GtkMisc widget is an abstract widget which is not useful itself, but is used to derive subclasses which have alignment and padding attributes.
GtkModelButton is a button class that can use a #GAction as its model. In contrast to #GtkToggleButton or #GtkRadioButton, which can also be backed by a #GAction via the #GtkActionable:action-name property, GtkModelButton will adapt its appearance according to the kind of action it is backed by, and appear either as a plain, check or radio button.
This should not be accessed directly. Use the accessor functions below.
Native dialogs are platform dialogs that don't use #GtkDialog or #GtkWindow. They are used in order to integrate better with a platform, by looking the same as other native applications and supporting platform specific features.
The #GtkNotebook widget is a #GtkContainer whose children are pages that can be switched between using tab labels along one edge.
GtkNumerableIcon is a subclass of #GEmblemedIcon that can show a number or short string as an emblem. The number can be overlayed on top of another emblem, if desired.
GtkOffscreenWindow is strictly intended to be used for obtaining snapshots of widgets that are not part of a normal widget hierarchy. Since #GtkOffscreenWindow is a toplevel widget you cannot obtain snapshots of a full window with it since you cannot pack a toplevel widget in another toplevel.
The #GtkOrientable interface is implemented by all widgets that can be oriented horizontally or vertically. Historically, such widgets have been realized as subclasses of a common base class (e.g #GtkBox/#GtkHBox/#GtkVBox or #GtkScale/#GtkHScale/#GtkVScale). #GtkOrientable is more flexible in that it allows the orientation to be changed at runtime, allowing the widgets to “flip”.
GtkOverlay is a container which contains a single main child, on top of which it can place “overlay” widgets. The position of each overlay widget is determined by its #GtkWidget:halign and #GtkWidget:valign properties. E.g. a widget with both alignments set to gtk.types.Align.Start will be placed at the top left corner of the GtkOverlay container, whereas an overlay with halign set to gtk.types.Align.Center and valign set to gtk.types.Align.End will be placed a the bottom edge of the GtkOverlay, horizontally centered. The position can be adjusted by setting the margin properties of the child to non-zero values.
Struct defining a pad action entry.
#GtkPadController is an event controller for the pads found in drawing tablets (The collection of buttons and tactile sensors often found around the stylus-sensitive area).
A GtkPageSetup object stores the page size, orientation and margins. The idea is that you can get one of these from the page setup dialog and then pass it to the #GtkPrintOperation when printing. The benefit of splitting this out of the #GtkPrintSettings is that these affect the actual layout of the page, and thus need to be set long before user prints.
#GtkPaned has two panes, arranged either horizontally or vertically. The division between the two panes is adjustable by the user by dragging a handle.
GtkPaperSize handles paper sizes. It uses the standard called PWG 5101.1-2002 PWG: Standard for Media Standardized Names
to name the paper sizes (and to get the data for the page sizes). In addition to standard paper sizes, GtkPaperSize allows to construct custom paper sizes with arbitrary dimensions.
#GtkPlacesSidebar is a widget that displays a list of frequently-used places in the file system: the user’s home directory, the user’s bookmarks, and volumes and drives. This widget is used as a sidebar in #GtkFileChooser and may be used by file managers and similar programs.
Together with #GtkSocket, #GtkPlug provides the ability to embed widgets from one process into another process in a fashion that is transparent to the user. One process creates a #GtkSocket widget and passes the ID of that widget’s window to the other process, which then creates a #GtkPlug with that window ID. Any widgets contained in the #GtkPlug then will appear inside the first application’s window.
GtkPopover is a bubble-like context window, primarily meant to provide context-dependent information or options. Popovers are attached to a widget, passed at construction time on gtk.popover.Popover.new_, or updated afterwards through gtk.popover.Popover.setRelativeTo, by default they will point to the whole widget area, although this behavior can be changed through gtk.popover.Popover.setPointingTo.
GtkPopoverMenu is a subclass of #GtkPopover that treats its children like menus and allows switching between them. It is meant to be used primarily together with #GtkModelButton, but any widget can be used, such as #GtkSpinButton or #GtkScale. In this respect, GtkPopoverMenu is more flexible than popovers that are created from a #GMenuModel with gtk.popover.Popover.newFromModel.
A GtkPrintContext encapsulates context information that is required when drawing pages for printing, such as the cairo context and important parameters like page size and resolution. It also lets you easily create #PangoLayout and #PangoContext objects that match the font metrics of the cairo surface.
GtkPrintOperation is the high-level, portable printing API. It looks a bit different than other GTK+ dialogs such as the #GtkFileChooser, since some platforms don’t expose enough infrastructure to implement a good print dialog. On such platforms, GtkPrintOperation uses the native print dialog. On platforms which do not provide a native print dialog, GTK+ uses its own, see #GtkPrintUnixDialog.
A GtkPrintSettings object represents the settings of a print dialog in a system-independent way. The main use for this object is that once you’ve printed you can get a settings object that represents the settings the user chose, and the next time you print you can pass that object in so that the user doesn’t have to re-set all his settings.
The #GtkProgressBar is typically used to display the progress of a long running operation. It provides a visual clue that processing is underway. The GtkProgressBar can be used in two different modes: percentage mode and activity mode.
A #GtkRadioAction is similar to #GtkRadioMenuItem. A number of radio actions can be linked together so that only one may be active at any one time.
#GtkRadioActionEntry structs are used with gtk.action_group.ActionGroup.addRadioActions to construct groups of radio actions.
A single radio button performs the same basic function as a #GtkCheckButton, as its position in the object hierarchy reflects. It is only when multiple radio buttons are grouped together that they become a different user interface component in their own right.
A radio menu item is a check menu item that belongs to a group. At each instant exactly one of the radio menu items from a group is selected.
A #GtkRadioToolButton is a #GtkToolItem that contains a radio button, that is, a button that is part of a group of toggle buttons where only one button can be active at a time.
#GtkRange is the common base class for widgets which visualize an adjustment, e.g #GtkScale or #GtkScrollbar.
Deprecated
The #GtkRcStyle-struct is used to represent a set of information about the appearance of a widget. This can later be composited together with other #GtkRcStyle-struct<!-- -->s to form a #GtkStyle.
A #GtkRecentAction represents a list of recently used files, which can be shown by widgets such as #GtkRecentChooserDialog or #GtkRecentChooserMenu.
#GtkRecentChooser is an interface that can be implemented by widgets displaying the list of recently used files. In GTK+, the main objects that implement this interface are #GtkRecentChooserWidget, #GtkRecentChooserDialog and #GtkRecentChooserMenu.
#GtkRecentChooserDialog is a dialog box suitable for displaying the recently used documents. This widgets works by putting a #GtkRecentChooserWidget inside a #GtkDialog. It exposes the #GtkRecentChooserIface interface, so you can use all the #GtkRecentChooser functions on the recent chooser dialog as well as those for #GtkDialog.
#GtkRecentChooserMenu is a widget suitable for displaying recently used files inside a menu. It can be used to set a sub-menu of a #GtkMenuItem using gtk.menu_item.MenuItem.setSubmenu, or as the menu of a #GtkMenuToolButton.
#GtkRecentChooserWidget is a widget suitable for selecting recently used files. It is the main building block of a #GtkRecentChooserDialog. Most applications will only need to use the latter; you can use #GtkRecentChooserWidget as part of a larger window if you have special needs.
Meta-data to be passed to gtk.recent_manager.RecentManager.addFull when registering a recently used resource.
A #GtkRecentFilter can be used to restrict the files being shown in a #GtkRecentChooser. Files can be filtered based on their name (with gtk.recent_filter.RecentFilter.addPattern), on their mime type (with gtk.file_filter.FileFilter.addMimeType), on the application that has registered them (with gtk.recent_filter.RecentFilter.addApplication), or by a custom filter function (with gtk.recent_filter.RecentFilter.addCustom).
A GtkRecentFilterInfo struct is used to pass information about the tested file to gtk.recent_filter.RecentFilter.filter.
#GtkRecentInfo-struct contains private data only, and should be accessed using the provided API.
#GtkRecentManager provides a facility for adding, removing and looking up recently used files. Each recently used file is identified by its URI, and has meta-data associated to it, like the names and command lines of the applications that have registered it, the number of time each application has registered the same file, the mime type of the file and whether the file should be displayed only by the applications that have registered it.
#GtkRecentManagerClass contains only private data.
Represents a request of a screen object in a given orientation. These are primarily used in container implementations when allocating a natural size for children calling. See gtk.global.distributeNaturalAllocation.
A #GtkRequisition-struct represents the desired size of a widget. See [GtkWidget’s geometry management section][geometry-management] for more information.
The GtkRevealer widget is a container which animates the transition of its child from invisible to visible.
A GtkScale is a slider control used to select a numeric value. To use it, you’ll probably want to investigate the methods on its base class, #GtkRange, in addition to the methods for GtkScale itself. To set the value of a scale, you would normally use gtk.range.Range.setValue. To detect changes to the value, you would normally use the #GtkRange::value-changed signal.
#GtkScaleButton provides a button which pops up a scale widget. This kind of widget is commonly used for volume controls in multimedia applications, and GTK+ provides a #GtkVolumeButton subclass that is tailored for this use case.
#GtkScrollable is an interface that is implemented by widgets with native scrolling ability.
The #GtkScrollbar widget is a horizontal or vertical scrollbar, depending on the value of the #GtkOrientable:orientation property.
GtkScrolledWindow is a container that accepts a single child widget and makes that child scrollable using either internally added scrollbars or externally associated adjustments.
#GtkSearchBar is a container made to have a search entry (possibly with additional connex widgets, such as drop-down menus, or buttons) built-in. The search bar would appear when a search is started through typing on the keyboard, or the application’s search mode is toggled on.
#GtkSearchEntry is a subclass of #GtkEntry that has been tailored for use as a search entry.
GtkSeparator is a horizontal or vertical separator widget, depending on the value of the #GtkOrientable:orientation property, used to group the widgets within a window. It displays a line with a shadow to make it appear sunken into the interface.
The #GtkSeparatorMenuItem is a separator used to group items within a menu. It displays a horizontal line with a shadow to make it appear sunken into the interface.
A #GtkSeparatorToolItem is a #GtkToolItem that separates groups of other #GtkToolItems. Depending on the theme, a #GtkSeparatorToolItem will often look like a vertical line on horizontally docked toolbars.
GtkSettings provide a mechanism to share global settings between applications.
#GtkShortcutLabel is a widget that represents a single keyboard shortcut or gesture in the user interface.
A GtkShortcutsGroup represents a group of related keyboard shortcuts or gestures. The group has a title. It may optionally be associated with a view of the application, which can be used to show only relevant shortcuts depending on the application context.
A GtkShortcutsSection collects all the keyboard shortcuts and gestures for a major application mode. If your application needs multiple sections, you should give each section a unique #GtkShortcutsSection:section-name and a #GtkShortcutsSection:title that can be shown in the section selector of the GtkShortcutsWindow.
A GtkShortcutsShortcut represents a single keyboard shortcut or gesture with a short text. This widget is only meant to be used with #GtkShortcutsWindow.
A GtkShortcutsWindow shows brief information about the keyboard shortcuts and gestures of an application. The shortcuts can be grouped, and you can have multiple sections in this window, corresponding to the major modes of your application.
#GtkSizeGroup provides a mechanism for grouping a number of widgets together so they all request the same amount of space. This is typically useful when you want a column of widgets to have the same size, but you can’t use a #GtkGrid widget.
Together with #GtkPlug, #GtkSocket provides the ability to embed widgets from one process into another process in a fashion that is transparent to the user. One process creates a #GtkSocket widget and passes that widget’s window ID to the other process, which then creates a #GtkPlug with that window ID. Any widgets contained in the #GtkPlug then will appear inside the first application’s window.
A #GtkSpinButton is an ideal way to allow the user to set the value of some attribute. Rather than having to directly type a number into a #GtkEntry, GtkSpinButton allows the user to click on one of two arrows to increment or decrement the displayed value. A value can still be typed in, with the bonus that it can be checked to ensure it is in a given range.
A GtkSpinner widget displays an icon-size spinning animation. It is often used as an alternative to a #GtkProgressBar for displaying indefinite activity, instead of actual progress.
The GtkStack widget is a container which only shows one of its children at a time. In contrast to GtkNotebook, GtkStack does not provide a means for users to change the visible child. Instead, the #GtkStackSwitcher widget can be used with GtkStack to provide this functionality.
A GtkStackSidebar enables you to quickly and easily provide a consistent "sidebar" object for your user interface.
The GtkStackSwitcher widget acts as a controller for a #GtkStack; it shows a row of buttons to switch between the various pages of the associated stack widget.
The “system tray” or notification area is normally used for transient icons that indicate some special state. For example, a system tray icon might appear to tell the user that they have new mail, or have an incoming instant message, or something along those lines. The basic idea is that creating an icon in the notification area is less annoying than popping up a dialog.
A #GtkStatusbar is usually placed along the bottom of an application's main #GtkWindow. It may provide a regular commentary of the application's status (as is usually the case in a web browser, for example), or may be used to simply output a message when the status changes, (when an upload is complete in an FTP client, for example).
A #GtkStyle object encapsulates the information that provides the look and feel for a widget.
#GtkStyleContext is an object that stores styling information affecting a widget defined by #GtkWidgetPath.
GtkStyleProperties provides the storage for style information that is used by #GtkStyleContext and other #GtkStyleProvider implementations.
GtkStyleProvider is an interface used to provide style information to a #GtkStyleContext. See gtk.style_context.StyleContext.addProvider and gtk.style_context.StyleContext.addProviderForScreen.
#GtkSwitch is a widget that has two states: on or off. The user can control which state should be active by clicking the empty area, or by dragging the handle.
GtkSymbolicColor is a boxed type that represents a symbolic color. It is the result of parsing a [color expression][gtkcssprovider-symbolic-colors]. To obtain the color represented by a GtkSymbolicColor, it has to be resolved with gtk.symbolic_color.SymbolicColor.resolve, which replaces all symbolic color references by the colors they refer to (in a given context) and evaluates mix, shade and other expressions, resulting in a #GdkRGBA value.
The #GtkTable functions allow the programmer to arrange widgets in rows and columns, making it easy to align many widgets next to each other, horizontally and vertically.
A #GtkTargetEntry represents a single type of data than can be supplied for by a widget for a selection or for supplied or received during drag-and-drop.
A #GtkTargetList-struct is a reference counted list of #GtkTargetPair and should be treated as opaque.
A #GtkTargetPair is used to represent the same information as a table of #GtkTargetEntry, but in an efficient form.
A #GtkTearoffMenuItem is a special #GtkMenuItem which is used to tear off and reattach its menu.
Using #GtkTextAttributes directly should rarely be necessary. It’s primarily useful with gtk.text_iter.TextIter.getAttributes. As with most GTK+ structs, the fields in this struct should only be read, never modified directly.
You may wish to begin by reading the text widget conceptual overview
which gives an overview of all the objects and data types related to the text widget and how they work together.
A #GtkTextChildAnchor is a spot in the buffer where child widgets can be “anchored” (inserted inline, as if they were characters). The anchor can have multiple widgets anchored, to allow for multiple views.
You may wish to begin by reading the text widget conceptual overview
which gives an overview of all the objects and data types related to the text widget and how they work together.
You may wish to begin by reading the text widget conceptual overview
which gives an overview of all the objects and data types related to the text widget and how they work together.
You may wish to begin by reading the text widget conceptual overview
which gives an overview of all the objects and data types related to the text widget and how they work together.
You may wish to begin by reading the text widget conceptual overview
which gives an overview of all the objects and data types related to the text widget and how they work together.
You may wish to begin by reading the text widget conceptual overview
which gives an overview of all the objects and data types related to the text widget and how they work together.
#GtkThemingEngine was the object used for rendering themed content in GTK+ widgets. It used to allow overriding GTK+'s default implementation of rendering functions by allowing engines to be loaded as modules.
Base class for theming engines.
A #GtkToggleAction corresponds roughly to a #GtkCheckMenuItem. It has an “active” state specifying whether the action has been checked or not.
#GtkToggleActionEntry structs are used with gtk.action_group.ActionGroup.addToggleActions to construct toggle actions.
A #GtkToggleButton is a #GtkButton which will remain “pressed-in” when clicked. Clicking again will cause the toggle button to return to its normal state.
A #GtkToggleToolButton is a #GtkToolItem that contains a toggle button.
#GtkToolButtons are #GtkToolItems containing buttons.
#GtkToolItems are widgets that can appear on a toolbar. To create a toolbar item that contain something else than a button, use gtk.tool_item.ToolItem.new_. Use gtk.container.Container.add to add a child widget to the tool item.
A #GtkToolItemGroup is used together with #GtkToolPalette to add #GtkToolItems to a palette like container with different categories and drag and drop support.
A #GtkToolPalette allows you to add #GtkToolItems to a palette-like container with different categories and drag and drop support.
The #GtkToolShell interface allows container widgets to provide additional information when embedding #GtkToolItem widgets.
Virtual function table for the #GtkToolShell interface.
A toolbar is created with a call to gtk.toolbar.Toolbar.new_.
Basic tooltips can be realized simply by using gtk.widget.Widget.setTooltipText or gtk.widget.Widget.setTooltipMarkup without any explicit tooltip object.
The #GtkTreeIter is the primary structure for accessing a #GtkTreeModel. Models are expected to put a unique integer in the @stamp member, and put model-specific data in the three @user_data members.
The #GtkTreeModel interface defines a generic tree interface for use by the #GtkTreeView widget. It is an abstract interface, and is designed to be usable with any appropriate data structure. The programmer just has to implement this interface on their own data type for it to be viewable by a #GtkTreeView widget.
A #GtkTreeModelFilter is a tree model which wraps another tree model, and can do the following things:
The #GtkTreeModelSort is a model which implements the #GtkTreeSortable interface. It does not hold any data itself, but rather is created with a child model and proxies its data. It has identical column types to this child model, and the changes in the child are propagated. The primary purpose of this model is to provide a way to sort a different model without modifying it. Note that the sort function used by #GtkTreeModelSort is not guaranteed to be stable.
A GtkTreeRowReference tracks model changes so that it always refers to the same row (a #GtkTreePath refers to a position, not a fixed row). Create a new GtkTreeRowReference with gtk.tree_row_reference.TreeRowReference.new_.
The #GtkTreeSelection object is a helper object to manage the selection for a #GtkTreeView widget. The #GtkTreeSelection object is automatically created when a new #GtkTreeView widget is created, and cannot exist independently of this widget. The primary reason the #GtkTreeSelection objects exists is for cleanliness of code and API. That is, there is no conceptual reason all these functions could not be methods on the #GtkTreeView widget instead of a separate function.
#GtkTreeSortable is an interface to be implemented by tree models which support sorting. The #GtkTreeView uses the methods provided by this interface to sort the model.
The #GtkTreeStore object is a list model for use with a #GtkTreeView widget. It implements the #GtkTreeModel interface, and consequentially, can use all of the methods available there. It also implements the #GtkTreeSortable interface so it can be sorted by the view. Finally, it also implements the tree [drag and drop][gtk3-GtkTreeView-drag-and-drop] interfaces.
Widget that displays any object that implements the #GtkTreeModel interface.
The GtkTreeViewColumn object represents a visible column in a #GtkTreeView widget. It allows to set properties of the column header, and functions as a holding pen for the cell renderers which determine how the data in the column is displayed.
A #GtkUIManager constructs a user interface (menus and toolbars) from one or more UI definitions, which reference actions from one or more action groups.
A #GtkVBox is a container that organizes child widgets into a single column.
The VPaned widget is a container widget with two children arranged vertically. The division between the two panes is adjustable by the user by dragging a handle. See #GtkPaned for details.
The #GtkVScale widget is used to allow the user to select a value using a vertical slider. To create one, use gtk.hscale.HScale.newWithRange.
The #GtkVScrollbar widget is a widget arranged vertically creating a scrollbar. See #GtkScrollbar for details on scrollbars. #GtkAdjustment pointers may be added to handle the adjustment of the scrollbar or it may be left null in which case one will be created for you. See #GtkScrollbar for a description of what the fields in an adjustment represent for a scrollbar.
The #GtkVSeparator widget is a vertical separator, used to group the widgets within a window. It displays a vertical line with a shadow to make it appear sunken into the interface.
The #GtkViewport widget acts as an adaptor class, implementing scrollability for child widgets that lack their own scrolling capabilities. Use GtkViewport to scroll child widgets such as #GtkGrid, #GtkBox, and so on.
#GtkVolumeButton is a subclass of #GtkScaleButton that has been tailored for use as a volume control widget with suitable icons, tooltips and accessible labels.
GtkWidget is the base class all widgets in GTK+ derive from. It manages the widget lifecycle, states and style.
GtkWidgetPath is a boxed type that represents a widget hierarchy from the topmost widget, typically a toplevel, to any child. This widget path abstraction is used in #GtkStyleContext on behalf of the real widget in order to query style information.
A GtkWindow is a toplevel window which can contain other widgets. Windows normally have decorations that are under the control of the windowing system and allow the user to manipulate the window (resize it, move it, close it,...).
A #GtkWindowGroup restricts the effect of grabs to windows in the same group, thereby making window groups almost behave like separate applications.
Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-Gtk-MountOperationHandler.top_of_page">org.Gtk.MountOperationHandler</link>.
Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-Gtk-MountOperationHandler.top_of_page">org.Gtk.MountOperationHandler</link>.
The #_GtkMountOperationHandlerProxy structure contains only private data and should only be accessed using the provided API.
Class structure for #_GtkMountOperationHandlerProxy.
The #_GtkMountOperationHandlerSkeleton structure contains only private data and should only be accessed using the provided API.
Class structure for #_GtkMountOperationHandlerSkeleton.
C types for gtk3 library