| AboutDialog | The AboutDialog 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.
|
| AboutDialogBuilder | |
| AboutDialogClass | |
| AccelFlags | Accelerator flags used with AccelGroup::connect.
|
| AccelGroup | A AccelGroup represents a group of keyboard accelerators,
typically attached to a toplevel Window (with
GtkWindowExt::add_accel_group). Usually you won’t need to create a
AccelGroup directly; instead, when using UIManager, GTK+
automatically sets up the accelerators for your menus in the ui
manager’s AccelGroup.
|
| AccelGroupClass | |
| AccelLabel | The AccelLabel widget is a subclass of Label 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.
|
| AccelLabelBuilder | |
| AccelLabelClass | |
| ActionBar | ActionBar is designed to present contextual actions. It is
expected to be displayed below the content and expand horizontally
to fill the area.
|
| ActionBarBuilder | |
| ActionBarClass | |
| Actionable | This interface provides a convenient way of associating widgets with
actions on a ApplicationWindow or Application.
|
| Adjustment | The Adjustment 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 SpinButton, Viewport,
and Range (which is a base class for Scrollbar and Scale).
|
| AdjustmentBuilder | |
| AdjustmentClass | |
| Allocation | Defines the position and size of a rectangle. It is identical to
cairo::RectangleInt.
|
| AppChooser | AppChooser 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
AppChooserWidget, AppChooserDialog and AppChooserButton.
|
| AppChooserButton | The AppChooserButton is a widget that lets the user select
an application. It implements the AppChooser interface.
|
| AppChooserButtonBuilder | |
| AppChooserButtonClass | |
| AppChooserDialog | AppChooserDialog shows a AppChooserWidget inside a Dialog.
|
| AppChooserDialogBuilder | |
| AppChooserDialogClass | |
| AppChooserWidget | AppChooserWidget is a widget for selecting applications.
It is the main building block for AppChooserDialog. 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.
|
| AppChooserWidgetBuilder | |
| AppChooserWidgetClass | |
| Application | Application 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.
|
| ApplicationBuilder | |
| ApplicationClass | |
| ApplicationInhibitFlags | Types of user actions that may be blocked by GtkApplicationExt::inhibit.
|
| ApplicationWindow | ApplicationWindow is a Window subclass that offers some
extra functionality for better integration with Application
features. Notably, it can handle both the application menu as well
as the menubar. See GtkApplicationExt::set_app_menu and
GtkApplicationExt::set_menubar.
|
| ApplicationWindowBuilder | |
| ApplicationWindowClass | |
| AspectFrame | The AspectFrame 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. AspectFrame
derives from Frame, so it can draw a label and
a frame around the child. The frame will be
“shrink-wrapped” to the size of the child.
|
| AspectFrameBuilder | |
| AspectFrameClass | |
| Assistant | A Assistant 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.
|
| AssistantBuilder | |
| AssistantClass | |
| Bin | The Bin 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.
|
| BinClass | |
| Border | A struct that specifies a border around a rectangular area
that can be of different width on each side.
|
| Box | The Box widget arranges child widgets into a single row or column,
depending upon the value of its Orientable:orientation property. Within
the other dimension, all children are allocated the same size. Of course,
the Widget:halign and Widget:valign properties can be used on
the children to influence their allocation.
|
| BoxBuilder | |
| BoxClass | |
| Buildable | Buildable allows objects to extend and customize their deserialization
from [Builder UI descriptions][BUILDER-UI].
The interface includes methods for setting names and properties of objects,
parsing custom tags and constructing child objects.
|
| Builder | A Builder is an auxiliary object that reads textual descriptions
of a user interface and instantiates the described objects. To create
a Builder from a user interface description, call
Builder::new_from_file, Builder::new_from_resource or
Builder::new_from_string.
|
| BuilderClass | |
| Button | The Button 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.
|
| ButtonBox | Implements
|
| ButtonBoxBuilder | |
| ButtonBoxClass | |
| ButtonBuilder | |
| ButtonClass | |
| Calendar | Calendar is a widget that displays a Gregorian calendar, one month
at a time. It can be created with Calendar::new.
|
| CalendarBuilder | |
| CalendarClass | |
| CalendarDisplayOptions | These options can be used to influence the display and behaviour of a Calendar.
|
| CellArea | The CellArea is an abstract class for CellLayout widgets
(also referred to as "layouting widgets") to interface with an
arbitrary number of GtkCellRenderers and interact with the user
for a given TreeModel row.
|
| CellAreaBox | The CellAreaBox renders cell renderers into a row or a column
depending on its Orientation.
|
| CellAreaBoxBuilder | |
| CellAreaBoxClass | |
| CellAreaClass | |
| CellAreaContext | The CellAreaContext object is created by a given CellArea
implementation via its CellAreaClass.create_context() virtual
method and is used to store cell sizes and alignments for a series of
TreeModel rows that are requested and rendered in the same context.
|
| CellAreaContextClass | |
| CellEditable | The CellEditable interface must be implemented for widgets to be usable
to edit the contents of a TreeView cell. It provides a way to specify how
temporary widgets should be configured for editing, get the new value, etc.
|
| CellLayout | CellLayout is an interface to be implemented by all objects which
want to provide a TreeViewColumn like API for packing cells,
setting attributes and data funcs.
|
| CellRenderer | The CellRenderer is a base class of a set of objects used for
rendering a cell to a cairo::Context. These objects are used primarily by
the TreeView widget, though they aren’t tied to them in any
specific way. It is worth noting that CellRenderer is not a
Widget and cannot be treated as such.
|
| CellRendererAccel | CellRendererAccel 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.
|
| CellRendererAccelBuilder | |
| CellRendererAccelClass | |
| CellRendererClass | |
| CellRendererCombo | CellRendererCombo renders text in a cell like CellRendererText from
which it is derived. But while CellRendererText offers a simple entry to
edit the text, CellRendererCombo offers a ComboBox
widget to edit the text. The values to display in the combo box are taken from
the tree model specified in the CellRendererCombo:model property.
|
| CellRendererComboBuilder | |
| CellRendererComboClass | |
| CellRendererPixbuf | A CellRendererPixbuf can be used to render an image in a cell. It allows
to render either a given gdk_pixbuf::Pixbuf (set via the
CellRendererPixbuf:pixbuf property) or a named icon (set via the
CellRendererPixbuf:icon-name property).
|
| CellRendererPixbufBuilder | |
| CellRendererPixbufClass | |
| CellRendererProgress | CellRendererProgress renders a numeric value as a progress par in a cell.
Additionally, it can display a text on top of the progress bar.
|
| CellRendererProgressBuilder | |
| CellRendererProgressClass | |
| CellRendererSpin | CellRendererSpin renders text in a cell like CellRendererText from
which it is derived. But while CellRendererText offers a simple entry to
edit the text, CellRendererSpin offers a SpinButton widget. Of course,
that means that the text has to be parseable as a floating point number.
|
| CellRendererSpinBuilder | |
| CellRendererSpinClass | |
| CellRendererSpinner | CellRendererSpinner renders a spinning animation in a cell, very
similar to Spinner. It can often be used as an alternative
to a CellRendererProgress for displaying indefinite activity,
instead of actual progress.
|
| CellRendererSpinnerBuilder | |
| CellRendererSpinnerClass | |
| CellRendererState | Tells how a cell is to be rendered.
|
| CellRendererText | A CellRendererText 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 CellRendererText:ellipsize property allows it.
|
| CellRendererTextBuilder | |
| CellRendererTextClass | |
| CellRendererToggle | CellRendererToggle renders a toggle button in a cell. The
button is drawn as a radio or a checkbutton, depending on the
CellRendererToggle:radio property.
When activated, it emits the CellRendererToggle::toggled signal.
|
| CellRendererToggleBuilder | |
| CellRendererToggleClass | |
| CellView | A CellView displays a single row of a TreeModel using a CellArea
and CellAreaContext. A CellAreaContext can be provided to the
CellView 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 ComboBox).
|
| CellViewBuilder | |
| CellViewClass | |
| CheckButton | A CheckButton places a discrete ToggleButton next to a widget,
(usually a Label). See the section on ToggleButton widgets for
more information about toggle/check buttons.
|
| CheckButtonBuilder | |
| CheckButtonClass | |
| CheckMenuItem | A CheckMenuItem is a menu item that maintains the state of a boolean
value in addition to a MenuItem usual role in activating application
code.
|
| CheckMenuItemBuilder | |
| CheckMenuItemClass | |
| Clipboard | The Clipboard 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
gdk::Atom. (Conversion to and from strings can be done with
gdk::Atom::intern and gdk::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.
|
| ClipboardClass | |
| ColorButton | The ColorButton 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.
|
| ColorButtonBuilder | |
| ColorButtonClass | |
| ColorChooser | ColorChooser is an interface that is implemented by widgets
for choosing colors. Depending on the situation, colors may be
allowed to have alpha (translucency).
|
| ColorChooserDialog | The ColorChooserDialog widget is a dialog for choosing
a color. It implements the ColorChooser interface.
|
| ColorChooserDialogBuilder | |
| ColorChooserDialogClass | |
| ColorChooserWidget | The ColorChooserWidget 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.
|
| ColorChooserWidgetBuilder | |
| ColorChooserWidgetClass | |
| ComboBox | A ComboBox is a widget that allows the user to choose from a list of
valid choices. The ComboBox displays the selected choice. When
activated, the ComboBox 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.
|
| ComboBoxBuilder | |
| ComboBoxClass | |
| ComboBoxText | A ComboBoxText is a simple variant of ComboBox that hides
the model-view complexity for simple text-only use cases.
|
| ComboBoxTextBuilder | |
| ComboBoxTextClass | |
| Container | 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 Window
containing a Frame containing a Label. If you wanted an image instead
of a textual label inside the frame, you might replace the Label widget
with a Image widget.
|
| ContainerClass | |
| CssProvider | CssProvider is an object implementing the StyleProvider interface.
It is able to parse [CSS-like][css-overview] input in order to style widgets.
|
| CssProviderClass | |
| CssSection | Defines a part of a CSS document. Because sections are nested into
one another, you can use CssSection::get_parent to get the
containing region.
|
| DestDefaults | The DestDefaults enumeration specifies the various
types of action that will be taken on behalf
of the user for a drag destination site.
|
| Dialog | 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.
|
| DialogBuilder | |
| DialogClass | |
| DialogFlags | Flags used to influence dialog construction.
|
| DrawingArea | The DrawingArea 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:
|
| DrawingAreaBuilder | |
| DrawingAreaClass | |
| Editable | The Editable interface is an interface which should be implemented by
text editing widgets, such as Entry and SpinButton. 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.
|
| Entry | The Entry 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.
|
| EntryBuffer | The EntryBuffer class contains the actual text displayed in a
Entry widget.
|
| EntryBuilder | |
| EntryClass | |
| EntryCompletion | EntryCompletion is an auxiliary object to be used in conjunction with
Entry to provide the completion functionality. It implements the
CellLayout interface, to allow the user to add extra cells to the
TreeView with completion matches.
|
| EntryCompletionBuilder | |
| EntryCompletionClass | |
| EventBox | The EventBox widget is a subclass of Bin 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.
|
| EventBoxBuilder | |
| EventBoxClass | |
| EventController | EventController 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.
|
| EventControllerClass | |
| EventControllerKey | EventControllerKey is an event controller meant for situations
where you need access to key events.
|
| EventControllerKeyClass | |
| EventControllerMotion | EventControllerMotion is an event controller meant for situations
where you need to track the position of the pointer.
|
| EventControllerMotionClass | |
| EventControllerScroll | EventControllerScroll 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 EventControllerScroll::scroll signal (deltas in the
discrete case are multiples of 1).
|
| EventControllerScrollClass | |
| EventControllerScrollFlags | Describes the behavior of a EventControllerScroll.
|
| Expander | A Expander allows the user to hide or show its child by clicking
on an expander triangle similar to the triangles used in a TreeView.
|
| ExpanderBuilder | |
| ExpanderClass | |
| FileChooser | FileChooser is an interface that can be implemented by file
selection widgets. In GTK+, the main objects that implement this
interface are FileChooserWidget, FileChooserDialog, and
FileChooserButton. You do not need to write an object that
implements the FileChooser interface unless you are trying to
adapt an existing file selector to expose a standard programming
interface.
|
| FileChooserButton | The FileChooserButton is a widget that lets the user select a
file. It implements the FileChooser interface. Visually, it is a
file name with a button to bring up a FileChooserDialog.
The user can then use that dialog to change the file associated with
that button. This widget does not support setting the
FileChooser:select-multiple property to true.
|
| FileChooserButtonBuilder | |
| FileChooserButtonClass | |
| FileChooserDialog | FileChooserDialog is a dialog box suitable for use with
“File/Open” or “File/Save as” commands. This widget works by
putting a FileChooserWidget inside a Dialog. It exposes
the FileChooser interface, so you can use all of the
FileChooser functions on the file chooser dialog as well as
those for Dialog.
|
| FileChooserDialogBuilder | |
| FileChooserDialogClass | |
| FileChooserNative | FileChooserNative is an abstraction of a dialog box suitable
for use with “File/Open” or “File/Save as” commands. By default, this
just uses a FileChooserDialog 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),
FileChooserNative may call the proper APIs (portals) to let the user
choose a file and make it available to the application.
|
| FileChooserNativeBuilder | |
| FileChooserNativeClass | |
| FileChooserWidget | FileChooserWidget is a widget for choosing files.
It exposes the FileChooser interface, and you should
use the methods of this interface to interact with the
widget.
|
| FileChooserWidgetBuilder | |
| FileChooserWidgetClass | |
| FileFilter | A FileFilter can be used to restrict the files being shown in a
FileChooser. Files can be filtered based on their name (with
FileFilter::add_pattern), on their mime type (with
FileFilter::add_mime_type), or by a custom filter function
(with FileFilter::add_custom).
|
| FileFilterClass | |
| FileFilterFlags | These flags indicate what parts of a FileFilterInfo struct
are filled or need to be filled.
|
| Fixed | The Fixed widget is a container which can place child widgets
at fixed positions and with fixed sizes, given in pixels. Fixed
performs no automatic layout management.
|
| FixedBuilder | |
| FixedClass | |
| FlowBox | A FlowBox positions child widgets in sequence according to its
orientation.
|
| FlowBoxBuilder | |
| FlowBoxChild | Implements
|
| FlowBoxChildBuilder | |
| FlowBoxChildClass | |
| FlowBoxClass | |
| FontButton | The FontButton 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.
|
| FontButtonBuilder | |
| FontButtonClass | |
| FontChooser | FontChooser is an interface that can be implemented by widgets
displaying the list of fonts. In GTK+, the main objects
that implement this interface are FontChooserWidget,
FontChooserDialog and FontButton. The FontChooser interface
has been introducted in GTK+ 3.2.
|
| FontChooserDialog | The FontChooserDialog widget is a dialog for selecting a font.
It implements the FontChooser interface.
|
| FontChooserDialogBuilder | |
| FontChooserDialogClass | |
| FontChooserLevel | This enumeration specifies the granularity of font selection
that is desired in a font chooser.
|
| FontChooserWidget | The FontChooserWidget widget lists the available fonts,
styles and sizes, allowing the user to select a font. It is
used in the FontChooserDialog widget to provide a
dialog box for selecting fonts.
|
| FontChooserWidgetBuilder | |
| FontChooserWidgetClass | |
| Frame | 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 FrameExt::set_label_align.
|
| FrameBuilder | |
| FrameClass | |
| GLArea | GLArea is a widget that allows drawing with OpenGL.
|
| GLAreaBuilder | |
| GLAreaClass | |
| Gesture | Gesture 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 None gdk::EventSequence value for these).
|
| GestureClass | |
| GestureDrag | GestureDrag is a Gesture implementation that recognizes drag
operations. The drag operation itself can be tracked throught the
GestureDrag::drag-begin, GestureDrag::drag-update and
GestureDrag::drag-end signals, or the relevant coordinates be
extracted through GestureDragExt::get_offset and
GestureDragExt::get_start_point.
|
| GestureDragBuilder | |
| GestureDragClass | |
| GestureLongPress | GestureLongPress is a Gesture implementation able to recognize
long presses, triggering the GestureLongPress::pressed after the
timeout is exceeded.
|
| GestureLongPressBuilder | |
| GestureLongPressClass | |
| GestureMultiPress | GestureMultiPress is a Gesture implementation able to recognize
multiple clicks on a nearby zone, which can be listened for through the
GestureMultiPress::pressed signal. Whenever time or distance between
clicks exceed the GTK+ defaults, GestureMultiPress::stopped is emitted,
and the click counter is reset.
|
| GestureMultiPressBuilder | |
| GestureMultiPressClass | |
| GesturePan | GesturePan is a Gesture implementation able to recognize
pan gestures, those are drags that are locked to happen along one
axis. The axis that a GesturePan handles is defined at
construct time, and can be changed through
GesturePan::set_orientation.
|
| GesturePanBuilder | |
| GesturePanClass | |
| GestureRotate | GestureRotate is a Gesture implementation able to recognize
2-finger rotations, whenever the angle between both handled sequences
changes, the GestureRotate::angle-changed signal is emitted.
|
| GestureRotateBuilder | |
| GestureRotateClass | |
| GestureSingle | GestureSingle is a subclass of Gesture, 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 GestureSingleExt::get_current_sequence while the
gesture is being interacted with.
|
| GestureSingleClass | |
| GestureStylus | GestureStylus is a Gesture implementation specific to stylus
input. The provided signals just provide the basic information
|
| GestureStylusClass | |
| GestureSwipe | GestureSwipe is a Gesture implementation able to recognize
swipes, after a press/move/.../move/release sequence happens, the
GestureSwipe::swipe signal will be emitted, providing the velocity
and directionality of the sequence at the time it was lifted.
|
| GestureSwipeBuilder | |
| GestureSwipeClass | |
| GestureZoom | GestureZoom is a Gesture implementation able to recognize
pinch/zoom gestures, whenever the distance between both tracked
sequences changes, the GestureZoom::scale-changed signal is
emitted to report the scale factor.
|
| GestureZoomBuilder | |
| GestureZoomClass | |
| Grid | Grid is a container which arranges its child widgets in
rows and columns, with arbitrary positions and horizontal/vertical spans.
|
| GridBuilder | |
| GridClass | |
| HeaderBar | HeaderBar is similar to a horizontal Box. 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 HeaderBarExt::set_has_subtitle.
|
| HeaderBarBuilder | |
| HeaderBarClass | |
| IMContext | IMContext defines the interface for GTK+ input methods. An input method
is used by GTK+ text input widgets like Entry to map from key events to
Unicode character strings.
|
| IMContextClass | |
| IMContextSimple | IMContextSimple 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.
|
| IMContextSimpleBuilder | |
| IMContextSimpleClass | |
| IMMulticontext | Implements
|
| IMMulticontextBuilder | |
| IMMulticontextClass | |
| IconInfo | Contains information found when looking up an icon in
an icon theme.
|
| IconInfoClass | |
| IconLookupFlags | Used to specify options for IconThemeExt::lookup_icon
|
| IconTheme | IconTheme 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.
|
| IconThemeClass | |
| IconView | IconView provides an alternative view on a TreeModel.
It displays the model as a grid of icons with labels. Like
TreeView, it allows to select one or multiple items
(depending on the selection mode, see IconViewExt::set_selection_mode).
In addition to selection with the arrow keys, IconView supports
rubberband selection, which is controlled by dragging the pointer.
|
| IconViewBuilder | |
| IconViewClass | |
| Image | The Image widget displays an image. Various kinds of object
can be displayed as an image; most typically, you would load a
gdk_pixbuf::Pixbuf ("pixel buffer") from a file, and then display that.
There’s a convenience function to do this, Image::new_from_file,
used as follows:
|
| ImageBuilder | |
| ImageClass | |
| InfoBar | InfoBar 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 Dialog, which
has a action area at the bottom, InfoBar has an action area
at the side.
|
| InfoBarBuilder | |
| InfoBarClass | |
| Inhibit | Whether to propagate the signal to the default handler.
|
| InputHints | 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 InputPurpose of the entry.
|
| Invisible | The Invisible widget is used internally in GTK+, and is probably not
very useful for application developers.
|
| InvisibleBuilder | |
| InvisibleClass | |
| JunctionSides | Describes how a rendered element connects to adjacent elements.
|
| Label | The Label widget displays a small amount of text. As the name
implies, most labels are used to label another widget such as a
Button, a MenuItem, or a ComboBox.
|
| LabelBuilder | |
| LabelClass | |
| Layout | Layout is similar to DrawingArea 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
Scrollable, and can contain child widgets since it’s a Container.
|
| LayoutBuilder | |
| LayoutClass | |
| LevelBar | The LevelBar 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.
|
| LevelBarBuilder | |
| LevelBarClass | |
| LinkButton | A LinkButton is a Button 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.
|
| LinkButtonBuilder | |
| LinkButtonClass | |
| ListBox | A ListBox is a vertical container that contains ListBoxRow
children. These rows can by 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.
|
| ListBoxBuilder | |
| ListBoxClass | |
| ListBoxRow | Implements
|
| ListBoxRowBuilder | |
| ListBoxRowClass | |
| ListStore | The ListStore object is a list model for use with a TreeView
widget. It implements the TreeModel interface, and consequentialy,
can use all of the methods available there. It also implements the
TreeSortable interface so it can be sorted by the view.
Finally, it also implements the tree
[drag and drop][gtk3-TreeView-drag-and-drop]
interfaces.
|
| ListStoreClass | |
| LockButton | LockButton 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 gio::Permission object. Concrete implementations of gio::Permission may use
PolicyKit or some other authorization framework. To obtain a PolicyKit-based
gio::Permission, use polkit_permission_new.
|
| LockButtonBuilder | |
| LockButtonClass | |
| Menu | A Menu is a MenuShell that implements a drop down menu
consisting of a list of MenuItem objects which can be navigated
and activated by the user to perform application functions.
|
| MenuBar | The MenuBar is a subclass of MenuShell which contains one or
more GtkMenuItems. The result is a standard menu bar which can hold
many menu items.
|
| MenuBarBuilder | |
| MenuBarClass | |
| MenuBuilder | |
| MenuButton | The MenuButton widget is used to display a popup when clicked on.
This popup can be provided either as a Menu, a Popover or an
abstract gio::MenuModel.
|
| MenuButtonBuilder | |
| MenuButtonClass | |
| MenuClass | |
| MenuItem | The MenuItem widget and the derived widgets are the only valid
children for menus. Their function is to correctly handle highlighting,
alignment, events and submenus.
|
| MenuItemBuilder | |
| MenuItemClass | |
| MenuShell | A MenuShell is the abstract base class used to derive the
Menu and MenuBar subclasses.
|
| MenuShellClass | |
| MenuToolButton | A MenuToolButton is a ToolItem that contains a button and
a small additional button with an arrow. When clicked, the arrow
button pops up a dropdown menu.
|
| MenuToolButtonBuilder | |
| MenuToolButtonClass | |
| MessageDialog | MessageDialog presents a dialog with some message text. It’s simply a
convenience widget; you could construct the equivalent of MessageDialog
from Dialog without too much effort, but MessageDialog saves typing.
|
| MessageDialogBuilder | |
| MessageDialogClass | |
| Misc | The Misc widget is an abstract widget which is not useful itself, but
is used to derive subclasses which have alignment and padding attributes.
|
| MiscClass | |
| ModelButton | ModelButton is a button class that can use a gio::Action as its model.
In contrast to ToggleButton or RadioButton, which can also
be backed by a gio::Action via the Actionable:action-name property,
ModelButton will adapt its appearance according to the kind of
action it is backed by, and appear either as a plain, check or
radio button.
|
| ModelButtonBuilder | |
| ModelButtonClass | |
| MountOperation | This should not be accessed directly. Use the accessor functions below.
|
| MountOperationBuilder | |
| MountOperationClass | |
| NativeDialog | Native dialogs are platform dialogs that don't use Dialog or
Window. They are used in order to integrate better with a
platform, by looking the same as other native applications and
supporting platform specific features.
|
| NativeDialogClass | |
| Notebook | The Notebook widget is a Container whose children are pages that
can be switched between using tab labels along one edge.
|
| NotebookBuilder | |
| NotebookClass | |
| OffscreenWindow | OffscreenWindow is strictly intended to be used for obtaining
snapshots of widgets that are not part of a normal widget hierarchy.
Since OffscreenWindow is a toplevel widget you cannot obtain
snapshots of a full window with it since you cannot pack a toplevel
widget in another toplevel.
|
| OffscreenWindowBuilder | |
| OffscreenWindowClass | |
| Orientable | The Orientable 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 Box/HBox/VBox
or Scale/HScale/VScale). Orientable is more flexible in that
it allows the orientation to be changed at runtime, allowing the widgets
to “flip”.
|
| Overlay | Overlay 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 Widget:halign and Widget:valign
properties. E.g. a widget with both alignments set to Align::Start
will be placed at the top left corner of the Overlay container,
whereas an overlay with halign set to Align::Center and valign set
to Align::End will be placed a the bottom edge of the Overlay,
horizontally centered. The position can be adjusted by setting the margin
properties of the child to non-zero values.
|
| OverlayBuilder | |
| OverlayClass | |
| PadActionEntry | |
| PadController | PadController 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).
|
| PadControllerBuilder | |
| PadControllerClass | |
| PageRange | |
| PageSetup | A PageSetup 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 PrintOperation when printing.
The benefit of splitting this out of the PrintSettings is that
these affect the actual layout of the page, and thus need to be set
long before user prints.
|
| PageSetupClass | |
| Paned | Paned has two panes, arranged either
horizontally or vertically. The division between
the two panes is adjustable by the user by dragging
a handle.
|
| PanedBuilder | |
| PanedClass | |
| PaperSize | PaperSize 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, PaperSize allows to
construct custom paper sizes with arbitrary dimensions.
|
| PlacesOpenFlags | These flags serve two purposes. First, the application can call PlacesSidebar::set_open_flags
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.
|
| PlacesSidebar | PlacesSidebar 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 FileChooser and may be used by file managers
and similar programs.
|
| PlacesSidebarBuilder | |
| PlacesSidebarClass | |
| Plug | Together with Socket, Plug 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 Socket widget
and passes the ID of that widget’s window to the other process,
which then creates a Plug with that window ID. Any widgets
contained in the Plug then will appear inside the first
application’s window.
|
| PlugBuilder | |
| PlugClass | |
| Popover | Popover 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 Popover::new,
or updated afterwards through PopoverExt::set_relative_to, by
default they will point to the whole widget area, although this
behavior can be changed through PopoverExt::set_pointing_to.
|
| PopoverBuilder | |
| PopoverClass | |
| PopoverMenu | PopoverMenu is a subclass of Popover that treats its
children like menus and allows switching between them. It is
meant to be used primarily together with ModelButton, but
any widget can be used, such as SpinButton or Scale.
In this respect, PopoverMenu is more flexible than popovers
that are created from a gio::MenuModel with Popover::new_from_model.
|
| PopoverMenuBuilder | |
| PopoverMenuClass | |
| PrintContext | A PrintContext 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 pango::Layout and pango::Context objects that match the font metrics
of the cairo surface.
|
| PrintContextClass | |
| PrintOperation | PrintOperation is the high-level, portable printing API.
It looks a bit different than other GTK+ dialogs such as the
FileChooser, since some platforms don’t expose enough
infrastructure to implement a good print dialog. On such
platforms, PrintOperation uses the native print dialog.
On platforms which do not provide a native print dialog, GTK+
uses its own, see GtkPrintUnixDialog.
|
| PrintOperationBuilder | |
| PrintOperationClass | |
| PrintOperationPreview | Implements
|
| PrintSettings | A PrintSettings 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.
|
| PrintSettingsClass | |
| ProgressBar | The ProgressBar is typically used to display the progress of a long
running operation. It provides a visual clue that processing is underway.
The ProgressBar can be used in two different modes: percentage mode
and activity mode.
|
| ProgressBarBuilder | |
| ProgressBarClass | |
| RadioButton | A single radio button performs the same basic function as a CheckButton,
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.
|
| RadioButtonBuilder | |
| RadioButtonClass | |
| RadioMenuItem | 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.
|
| RadioMenuItemBuilder | |
| RadioMenuItemClass | |
| RadioToolButton | A RadioToolButton is a ToolItem 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.
|
| RadioToolButtonBuilder | |
| RadioToolButtonClass | |
| Range | Range is the common base class for widgets which visualize an
adjustment, e.g Scale or Scrollbar.
|
| RangeClass | |
| RecentChooser | RecentChooser 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 RecentChooserWidget,
RecentChooserDialog and RecentChooserMenu.
|
| RecentChooserDialog | RecentChooserDialog is a dialog box suitable for displaying the recently
used documents. This widgets works by putting a RecentChooserWidget inside
a Dialog. It exposes the RecentChooserIface interface, so you can use
all the RecentChooser functions on the recent chooser dialog as well as
those for Dialog.
|
| RecentChooserDialogBuilder | |
| RecentChooserDialogClass | |
| RecentChooserMenu | RecentChooserMenu is a widget suitable for displaying recently used files
inside a menu. It can be used to set a sub-menu of a MenuItem using
GtkMenuItemExt::set_submenu, or as the menu of a MenuToolButton.
|
| RecentChooserMenuBuilder | |
| RecentChooserMenuClass | |
| RecentChooserWidget | RecentChooserWidget is a widget suitable for selecting recently used
files. It is the main building block of a RecentChooserDialog. Most
applications will only need to use the latter; you can use
RecentChooserWidget as part of a larger window if you have special needs.
|
| RecentChooserWidgetBuilder | |
| RecentChooserWidgetClass | |
| RecentData | |
| RecentFilter | A RecentFilter can be used to restrict the files being shown
in a RecentChooser. Files can be filtered based on their name
(with RecentFilter::add_pattern), on their mime type (with
FileFilter::add_mime_type), on the application that has
registered them (with RecentFilter::add_application), or by
a custom filter function (with RecentFilter::add_custom).
|
| RecentFilterClass | |
| RecentFilterFlags | These flags indicate what parts of a RecentFilterInfo struct
are filled or need to be filled.
|
| RecentInfo | RecentInfo-struct contains private data only, and should
be accessed using the provided API.
|
| RecentManager | RecentManager 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.
|
| RecentManagerBuilder | |
| RecentManagerClass | |
| Rectangle | Defines the position and size of a rectangle. It is identical to
cairo::RectangleInt.
|
| RegionFlags | Describes a region within a widget.
|
| Requisition | A Requisition-struct represents the desired size of a widget. See
[Widget’s geometry management section][geometry-management] for
more information.
|
| Revealer | The Revealer widget is a container which animates
the transition of its child from invisible to visible.
|
| RevealerBuilder | |
| RevealerClass | |
| Scale | A Scale 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, Range, in addition to the methods for Scale itself.
To set the value of a scale, you would normally use RangeExt::set_value.
To detect changes to the value, you would normally use the
Range::value-changed signal.
|
| ScaleBuilder | |
| ScaleButton | ScaleButton 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 VolumeButton subclass that
is tailored for this use case.
|
| ScaleButtonBuilder | |
| ScaleButtonClass | |
| ScaleClass | |
| Scrollable | Scrollable is an interface that is implemented by widgets with native
scrolling ability.
|
| Scrollbar | The Scrollbar widget is a horizontal or vertical scrollbar,
depending on the value of the Orientable:orientation property.
|
| ScrollbarBuilder | |
| ScrollbarClass | |
| ScrolledWindow | ScrolledWindow is a container that accepts a single child widget, makes
that child scrollable using either internally added scrollbars or externally
associated adjustments, and optionally draws a frame around the child.
|
| ScrolledWindowBuilder | |
| ScrolledWindowClass | |
| SearchBar | SearchBar 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.
|
| SearchBarBuilder | |
| SearchBarClass | |
| SearchEntry | SearchEntry is a subclass of Entry that has been
tailored for use as a search entry.
|
| SearchEntryBuilder | |
| SearchEntryClass | |
| SelectionData | |
| Separator | Separator is a horizontal or vertical separator widget, depending on the
value of the Orientable: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.
|
| SeparatorBuilder | |
| SeparatorClass | |
| SeparatorMenuItem | The SeparatorMenuItem 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.
|
| SeparatorMenuItemBuilder | |
| SeparatorMenuItemClass | |
| SeparatorToolItem | A SeparatorToolItem is a ToolItem that separates groups of other
GtkToolItems. Depending on the theme, a SeparatorToolItem will
often look like a vertical line on horizontally docked toolbars.
|
| SeparatorToolItemBuilder | |
| SeparatorToolItemClass | |
| Settings | Settings provide a mechanism to share global settings between
applications.
|
| SettingsClass | |
| ShortcutLabel | ShortcutLabel is a widget that represents a single keyboard shortcut or gesture
in the user interface.
|
| ShortcutLabelBuilder | |
| ShortcutLabelClass | |
| ShortcutsGroup | A ShortcutsGroup 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.
|
| ShortcutsGroupBuilder | |
| ShortcutsGroupClass | |
| ShortcutsSection | A ShortcutsSection 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 ShortcutsSection:section-name and
a ShortcutsSection:title that can be shown in the section selector of
the ShortcutsWindow.
|
| ShortcutsSectionBuilder | |
| ShortcutsSectionClass | |
| ShortcutsShortcut | A ShortcutsShortcut represents a single keyboard shortcut or gesture
with a short text. This widget is only meant to be used with ShortcutsWindow.
|
| ShortcutsShortcutBuilder | |
| ShortcutsShortcutClass | |
| ShortcutsWindow | A ShortcutsWindow 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.
|
| ShortcutsWindowBuilder | |
| ShortcutsWindowClass | |
| SizeGroup | SizeGroup 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 Grid widget.
|
| SizeGroupBuilder | |
| SizeGroupClass | |
| Socket | Together with Plug, Socket 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 Socket widget
and passes that widget’s window ID to the other process, which then
creates a Plug with that window ID. Any widgets contained in the
Plug then will appear inside the first application’s window.
|
| SocketBuilder | |
| SocketClass | |
| SpinButton | A SpinButton 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
Entry, SpinButton 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.
|
| SpinButtonBuilder | |
| SpinButtonClass | |
| Spinner | A Spinner widget displays an icon-size spinning animation.
It is often used as an alternative to a ProgressBar for
displaying indefinite activity, instead of actual progress.
|
| SpinnerBuilder | |
| SpinnerClass | |
| Stack | The Stack widget is a container which only shows
one of its children at a time. In contrast to Notebook,
Stack does not provide a means for users to change the
visible child. Instead, the StackSwitcher widget can be
used with Stack to provide this functionality.
|
| StackBuilder | |
| StackClass | |
| StackSidebar | A StackSidebar enables you to quickly and easily provide a
consistent "sidebar" object for your user interface.
|
| StackSidebarBuilder | |
| StackSidebarClass | |
| StackSwitcher | The StackSwitcher widget acts as a controller for a
Stack; it shows a row of buttons to switch between
the various pages of the associated stack widget.
|
| StackSwitcherBuilder | |
| StackSwitcherClass | |
| StateFlags | 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.
|
| Statusbar | A Statusbar is usually placed along the bottom of an application's
main Window. 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).
|
| StatusbarBuilder | |
| StatusbarClass | |
| StyleContext | StyleContext is an object that stores styling information affecting
a widget defined by WidgetPath.
|
| StyleContextBuilder | |
| StyleContextClass | |
| StyleContextPrintFlags | Flags that modify the behavior of StyleContextExt::to_string.
New values may be added to this enumeration.
|
| StyleProperties | [Deprecated since 3.16] StyleProperties provides the storage for style information
that is used by StyleContext and other StyleProvider
implementations.
|
| StylePropertiesClass | |
| StyleProvider | StyleProvider is an interface used to provide style information to a StyleContext.
See StyleContextExt::add_provider and StyleContext::add_provider_for_screen.
|
| Switch | Switch 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.
|
| SwitchBuilder | |
| SwitchClass | |
| TargetEntry | A TargetEntry 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.
|
| TargetFlags | The TargetFlags enumeration is used to specify
constraints on a TargetEntry.
|
| TargetList | A TargetList-struct is a reference counted list
of TargetPair and should be treated as
opaque.
|
| TextAttributes | Using TextAttributes directly should rarely be necessary.
It’s primarily useful with TextIter::get_attributes.
As with most GTK+ structs, the fields in this struct should only
be read, never modified directly.
|
| TextBuffer | 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.
|
| TextBufferBuilder | |
| TextBufferClass | |
| TextChildAnchor | A TextChildAnchor 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.
|
| TextChildAnchorClass | |
| TextIter | 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.
|
| TextMark | You may wish to begin by reading the
[text widget conceptual overview][TextWidget]
which gives an overview of all the objects and data
types related to the text widget and how they work together.
|
| TextMarkBuilder | |
| TextMarkClass | |
| TextSearchFlags | Flags affecting how a search is done.
|
| TextTag | You may wish to begin by reading the
[text widget conceptual overview][TextWidget]
which gives an overview of all the objects and
data types related to the text widget and how they work together.
|
| TextTagBuilder | |
| TextTagClass | |
| TextTagTable | You may wish to begin by reading the
[text widget conceptual overview][TextWidget]
which gives an overview of all the objects and
data types related to the text widget and how they work together.
|
| TextTagTableClass | |
| TextView | You may wish to begin by reading the
[text widget conceptual overview][TextWidget]
which gives an overview of all the objects and data
types related to the text widget and how they work together.
|
| TextViewBuilder | |
| TextViewClass | |
| TickCallbackId | |
| ToggleButton | A ToggleButton is a Button which will remain “pressed-in” when
clicked. Clicking again will cause the toggle button to return to its
normal state.
|
| ToggleButtonBuilder | |
| ToggleButtonClass | |
| ToggleToolButton | A ToggleToolButton is a ToolItem that contains a toggle
button.
|
| ToggleToolButtonBuilder | |
| ToggleToolButtonClass | |
| ToolButton | GtkToolButtons are GtkToolItems containing buttons.
|
| ToolButtonBuilder | |
| ToolButtonClass | |
| ToolItem | GtkToolItems are widgets that can appear on a toolbar. To
create a toolbar item that contain something else than a button, use
ToolItem::new. Use ContainerExt::add to add a child
widget to the tool item.
|
| ToolItemBuilder | |
| ToolItemClass | |
| ToolItemGroup | A ToolItemGroup is used together with ToolPalette to add
GtkToolItems to a palette like container with different
categories and drag and drop support.
|
| ToolItemGroupBuilder | |
| ToolItemGroupClass | |
| ToolPalette | A ToolPalette allows you to add GtkToolItems to a palette-like
container with different categories and drag and drop support.
|
| ToolPaletteBuilder | |
| ToolPaletteClass | |
| ToolPaletteDragTargets | Flags used to specify the supported drag targets.
|
| ToolShell | The ToolShell interface allows container widgets to provide additional
information when embedding ToolItem widgets.
|
| Toolbar | A toolbar is created with a call to Toolbar::new.
|
| ToolbarBuilder | |
| ToolbarClass | |
| Tooltip | Basic tooltips can be realized simply by using WidgetExt::set_tooltip_text
or WidgetExt::set_tooltip_markup without any explicit tooltip object.
|
| TooltipClass | |
| TreeDragDest | Implements
|
| TreeDragSource | Implements
|
| TreeIter | The TreeIter is the primary structure
for accessing a TreeModel. Models are expected to put a unique
integer in the stamp member, and put
model-specific data in the three user_data
members.
|
| TreeModel | The TreeModel interface defines a generic tree interface for
use by the TreeView 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 TreeView widget.
|
| TreeModelFilter | A TreeModelFilter is a tree model which wraps another tree model,
and can do the following things:
|
| TreeModelFilterClass | |
| TreeModelFlags | These flags indicate various properties of a TreeModel.
|
| TreeModelSort | The TreeModelSort is a model which implements the TreeSortable
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
TreeModelSort is not guaranteed to be stable.
|
| TreeModelSortClass | |
| TreePath | |
| TreeRowReference | A TreeRowReference tracks model changes so that it always refers to the
same row (a TreePath refers to a position, not a fixed row). Create a
new TreeRowReference with TreeRowReference::new.
|
| TreeSelection | The TreeSelection object is a helper object to manage the selection
for a TreeView widget. The TreeSelection object is
automatically created when a new TreeView widget is created, and
cannot exist independently of this widget. The primary reason the
TreeSelection 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 TreeView widget instead of a separate function.
|
| TreeSelectionClass | |
| TreeSortable | TreeSortable is an interface to be implemented by tree models which
support sorting. The TreeView uses the methods provided by this interface
to sort the model.
|
| TreeStore | The TreeStore object is a list model for use with a TreeView
widget. It implements the TreeModel interface, and consequentially,
can use all of the methods available there. It also implements the
TreeSortable interface so it can be sorted by the view. Finally,
it also implements the tree
[drag and drop][gtk3-TreeView-drag-and-drop]
interfaces.
|
| TreeStoreClass | |
| TreeView | Widget that displays any object that implements the TreeModel interface.
|
| TreeViewBuilder | |
| TreeViewClass | |
| TreeViewColumn | The TreeViewColumn object represents a visible column in a TreeView 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.
|
| TreeViewColumnBuilder | |
| TreeViewColumnClass | |
| Viewport | The Viewport widget acts as an adaptor class, implementing
scrollability for child widgets that lack their own scrolling
capabilities. Use Viewport to scroll child widgets such as
Grid, Box, and so on.
|
| ViewportBuilder | |
| ViewportClass | |
| VolumeButton | VolumeButton is a subclass of ScaleButton that has
been tailored for use as a volume control widget with suitable
icons, tooltips and accessible labels.
|
| VolumeButtonBuilder | |
| VolumeButtonClass | |
| Widget | Widget is the base class all widgets in GTK+ derive from. It manages the
widget lifecycle, states and style.
|
| WidgetClass | |
| WidgetPath | WidgetPath 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 StyleContext on behalf of the real
widget in order to query style information.
|
| Window | A Window 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,...).
|
| WindowBuilder | |
| WindowClass | |
| WindowGroup | A WindowGroup restricts the effect of grabs to windows
in the same group, thereby making window groups almost behave
like separate applications.
|
| WindowGroupClass | |
| Align | Controls how a widget deals with extra space in a single (x or y)
dimension.
|
| ArrowType | Used to indicate the direction in which an arrow should point.
|
| AssistantPageType | An enum for determining the page role inside the Assistant. It's
used to handle buttons sensitivity and visibility.
|
| BaselinePosition | 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
BaselinePosition to select where to put the baseline inside the
extra availible space.
|
| BorderStyle | Describes how the border of a UI element should be rendered.
|
| BuilderError | Error codes that identify various errors that can occur while using
Builder.
|
| ButtonBoxStyle | Used to dictate the style that a ButtonBox uses to layout the buttons it
contains.
|
| ButtonRole | The role specifies the desired appearance of a ModelButton.
|
| ButtonsType | Prebuilt sets of buttons for the dialog. If
none of these choices are appropriate, simply use ButtonsType::None
then call DialogExt::add_buttons.
|
| CellRendererAccelMode | 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.
|
| CellRendererMode | Identifies how the user can interact with a particular cell.
|
| CornerType | Specifies which corner a child widget should be placed in when packed into
a ScrolledWindow. This is effectively the opposite of where the scroll
bars are placed.
|
| CssProviderError | Error codes for GTK_CSS_PROVIDER_ERROR.
|
| CssSectionType | 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.
|
| DeleteType | See also: Entry::delete-from-cursor.
|
| DirectionType | Focus movement types.
|
| DragResult | Gives an indication why a drag operation failed.
The value can by obtained by connecting to the
Widget::drag-failed signal.
|
| EntryIconPosition | Specifies the side of the entry at which an icon is placed.
|
| EventSequenceState | Describes the state of a gdk::EventSequence in a Gesture.
|
| FileChooserAction | Describes whether a FileChooser is being used to open existing files
or to save to a possibly new file.
|
| FileChooserConfirmation | Used as a return value of handlers for the
FileChooser::confirm-overwrite signal of a FileChooser. 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.
|
| FileChooserError | These identify the various errors that can occur while calling
FileChooser functions.
|
| IMPreeditStyle | Deprecated |
| IMStatusStyle | Deprecated |
| IconSize | Built-in stock icon sizes.
|
| IconThemeError | Error codes for IconTheme operations.
|
| IconViewDropPosition | An enum for determining where a dropped item goes.
|
| ImageType | Describes the image data representation used by a Image. If you
want to get the image from the widget, you can only get the
currently-stored representation. e.g. if the
ImageExt::get_storage_type returns ImageType::Pixbuf, then you can
call ImageExt::get_pixbuf but not Image::get_stock. For empty
images, you can request any storage type (call any of the "get"
functions), but they will all return None values.
|
| InputPurpose | 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.
|
| Justification | Used for justifying the text inside a Label widget. (See also
Alignment).
|
| LevelBarMode | Describes how LevelBar contents should be rendered.
Note that this enumeration could be extended with additional modes
in the future.
|
| License | The type of license for an application.
|
| MenuDirectionType | An enumeration representing directional movements within a menu.
|
| MessageType | The type of message being displayed in the dialog.
|
| MovementStep | |
| NotebookTab | |
| NumberUpLayout | Used to determine the layout of pages on a sheet when printing
multiple pages per sheet.
|
| Orientation | Represents the orientation of widgets and other objects which can be switched
between horizontal and vertical orientation on the fly, like Toolbar or
GesturePan.
|
| PackDirection | Determines how widgets should be packed inside menubars
and menuitems contained in menubars.
|
| PackType | Represents the packing location Box children. (See: VBox,
HBox, and ButtonBox).
|
| PadActionType | The type of a pad action.
|
| PageOrientation | See also PrintSettings::set_orientation.
|
| PageSet | See also gtk_print_job_set_page_set.
|
| PanDirection | Describes the panning direction of a GesturePan
|
| PolicyType | Determines how the size should be computed to achieve the one of the
visibility mode for the scrollbars.
|
| PopoverConstraint | Describes constraints to positioning of popovers. More values
may be added to this enumeration in the future.
|
| PositionType | Describes which edge of a widget a certain feature is positioned at, e.g. the
tabs of a Notebook, the handle of a HandleBox or the label of a
Scale.
|
| PrintDuplex | See also PrintSettings::set_duplex.
|
| PrintError | Error codes that identify various errors that can occur while
using the GTK+ printing support.
|
| PrintOperationAction | The action parameter to PrintOperationExt::run
determines what action the print operation should perform.
|
| PrintOperationResult | A value of this type is returned by PrintOperationExt::run.
|
| PrintPages | See also gtk_print_job_set_pages
|
| PrintQuality | See also PrintSettings::set_quality.
|
| PrintStatus | The status gives a rough indication of the completion of a running
print operation.
|
| PropagationPhase | Describes the stage at which events are fed into a EventController.
|
| RecentChooserError | These identify the various errors that can occur while calling
RecentChooser functions.
|
| RecentManagerError | Error codes for RecentManager operations
|
| RecentSortType | Used to specify the sorting method to be applyed to the recently
used resource list.
|
| ReliefStyle | Indicated the relief to be drawn around a Button.
|
| ResizeMode | |
| ResponseType | Predefined values for use as response ids in DialogExt::add_button.
All predefined values are negative; GTK+ leaves values of 0 or greater for
application-defined response ids.
|
| RevealerTransitionType | These enumeration values describe the possible transitions
when the child of a Revealer widget is shown or hidden.
|
| ScrollStep | |
| ScrollType | Scrolling types.
|
| ScrollablePolicy | Defines the policy to be used in a scrollable widget when updating
the scrolled window adjustments in a given orientation.
|
| SelectionMode | Used to control what selections users are allowed to make.
|
| SensitivityType | Determines how GTK+ handles the sensitivity of stepper arrows
at the end of range widgets.
|
| ShadowType | Used to change the appearance of an outline typically provided by a Frame.
|
| ShortcutType | ShortcutType specifies the kind of shortcut that is being described.
More values may be added to this enumeration over time.
|
| SizeGroupMode | The mode of the size group determines the directions in which the size
group affects the requested sizes of its component widgets.
|
| SizeRequestMode | Specifies a preference for height-for-width or
width-for-height geometry management.
|
| SortColumn | |
| SortType | Determines the direction of a sort.
|
| SpinButtonUpdatePolicy | The spin button update policy determines whether the spin button displays
values even if they are outside the bounds of its adjustment.
See SpinButtonExt::set_update_policy.
|
| SpinType | The values of the SpinType enumeration are used to specify the
change to make in SpinButtonExt::spin.
|
| StackTransitionType | These enumeration values describe the possible transitions
between pages in a Stack widget.
|
| StateType | Deprecated |
| TextDirection | Reading directions for text.
|
| TextExtendSelection | Granularity types that extend the text selection. Use the
TextView::extend-selection signal to customize the selection.
|
| TextViewLayer | Used to reference the layers of TextView for the purpose of customized
drawing with the ::draw_layer vfunc.
|
| TextWindowType | Used to reference the parts of TextView.
|
| ToolbarStyle | Used to customize the appearance of a Toolbar. 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.
|
| TreeViewColumnSizing | The sizing method the column uses to determine its width. Please note
that TreeViewColumnSizing::Autosize are inefficient for large views, and
can make columns appear choppy.
|
| TreeViewDropPosition | An enum for determining where a dropped row goes.
|
| TreeViewGridLines | Used to indicate which grid lines to draw in a tree view.
|
| Unit | See also PrintSettings::set_paper_width.
|
| WidgetHelpType | Kinds of widget-specific help. Used by the ::show-help signal.
|
| WindowPosition | Window placement can be influenced using this enumeration. Note that
using WindowPosition::CenterAlways is almost always a bad idea.
It won’t necessarily work well with all window managers or on all windowing systems.
|
| WindowType | A Window can be one of these types. Most things you’d consider a
“window” should have type WindowType::Toplevel; windows with this type
are managed by the window manager and have a frame by default (call
GtkWindowExt::set_decorated to toggle the frame). Windows with type
WindowType::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). WindowType::Popup is used to implement
widgets such as Menu or tooltips that you normally don’t think of
as windows per se. Nearly all windows should be WindowType::Toplevel.
In particular, do not use WindowType::Popup just to turn off
the window borders; use GtkWindowExt::set_decorated for that.
|
| WrapMode | Describes a type of line wrapping.
|