Widget

Object Hierarchy:

Description:

[ CCode ( type_id = "gtk_widget_get_type ()" ) ]
public abstract class Widget : InitiallyUnowned, Accessible, Buildable, ConstraintTarget

The base class for all widgets.

It manages the widget lifecycle, layout, states and style.

### Height-for-width Geometry Management

GTK uses a height-for-width (and width-for-height) geometry management system. Height-for-width means that a widget can change how much vertical space it needs, depending on the amount of horizontal space that it is given (and similar for width-for-height). The most common example is a label that reflows to fill up the available width, wraps to fewer lines, and therefore needs less height.

Height-for-width geometry management is implemented in GTK by way of two virtual methods:

[vfunc@Gtk.Widget.get_request_mode]
[vfunc@Gtk.Widget.measure]

There are some important things to keep in mind when implementing height-for-width and when using it in widget implementations.

If you implement a direct `GtkWidget` subclass that supports height-for-width or width-for-height geometry management for itself or its child widgets, the [vfunc@Gtk.Widget.get_request_mode] virtual function must be implemented as well and return the widget's preferred request mode. The default implementation of this virtual function returns gtk_size_request_constant_size, which means that the widget will only ever get -1 passed as the for_size value to its [vfunc@Gtk.Widget.measure] implementation.

The geometry management system will query a widget hierarchy in only one orientation at a time. When widgets are initially queried for their minimum sizes it is generally done in two initial passes in the [enum@Gtk.SizeRequestMode] chosen by the toplevel.

For example, when queried in the normal gtk_size_request_height_for_width mode:

First, the default minimum and natural width for each widget in the interface will be computed using [method@Gtk.Widget.measure] with an orientation of gtk_orientation_horizontal and a for_size of -1. Because the preferred widths for each widget depend on the preferred widths of their children, this information propagates up the hierarchy, and finally a minimum and natural width is determined for the entire toplevel. Next, the toplevel will use the minimum width to query for the minimum height contextual to that width using [method@Gtk.Widget.measure] with an orientation of gtk_orientation_vertical and a for_size of the just computed width. This will also be a highly recursive operation. The minimum height for the minimum width is normally used to set the minimum size constraint on the toplevel.

After the toplevel window has initially requested its size in both dimensions it can go on to allocate itself a reasonable size (or a size previously specified with [method@Gtk.Window.set_default_size]). During the recursive allocation process it’s important to note that request cycles will be recursively executed while widgets allocate their children. Each widget, once allocated a size, will go on to first share the space in one orientation among its children and then request each child's height for its target allocated width or its width for allocated height, depending. In this way a widget will typically be requested its size a number of times before actually being allocated a size. The size a widget is finally allocated can of course differ from the size it has requested. For this reason, `GtkWidget` caches a small number of results to avoid re-querying for the same sizes in one allocation cycle.

If a widget does move content around to intelligently use up the allocated size then it must support the request in both `GtkSizeRequestMode`s even if the widget in question only trades sizes in a single orientation.

For instance, a [class@Gtk.Label] that does height-for-width word wrapping will not expect to have [vfunc@Gtk.Widget.measure] with an orientation of gtk_orientation_vertical called because that call is specific to a width-for-height request. In this case the label must return the height required for its own minimum possible width. By following this rule any widget that handles height-for-width or width-for-height requests will always be allocated at least enough space to fit its own content.

Here are some examples of how a gtk_size_request_height_for_width widget generally deals with width-for-height requests:

```c static void foo_widget_measure (GtkWidget *widget, GtkOrientation orientation, int for_size, int *minimum_size, int *natural_size, int *minimum_baseline, int *natural_baseline) { if (orientation == GTK_ORIENTATION_HORIZONTAL) { // Calculate minimum and natural width } else // VERTICAL { if (i_am_in_height_for_width_mode) { int min_width, dummy;

// First, get the minimum width of our widget GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_HORIZONTAL, -1, & min_width, &dummy, &dummy, &dummy);

// Now use the minimum width to retrieve the minimum and natural height to display // that width. GTK_WIDGET_GET_CLASS (widget)->measure ( widget, GTK_ORIENTATION_VERTICAL, min_width, minimum_size, natural_size, &dummy, &dummy); } else { // ... some widgets do both. } } } ```

Often a widget needs to get its own request during size request or allocation. For example, when computing height it may need to also compute width. Or when deciding how to use an allocation, the widget may need to know its natural size. In these cases, the widget should be careful to call its virtual methods directly, like in the code example above.

It will not work to use the wrapper function [method@Gtk.Widget.measure] inside your own [vfunc@Gtk.Widget.size_allocate] implementation. These return a request adjusted by [class@Gtk.SizeGroup], the widget's align and expand flags, as well as its CSS style.

If a widget used the wrappers inside its virtual method implementations, then the adjustments (such as widget margins) would be applied twice. GTK therefore does not allow this and will warn if you try to do it.

Of course if you are getting the size request for another widget, such as a child widget, you must use [method@Gtk.Widget.measure]; otherwise, you would not properly consider widget margins, [class@Gtk.SizeGroup], and so forth.

GTK also supports baseline vertical alignment of widgets. This means that widgets are positioned such that the typographical baseline of widgets in the same row are aligned. This happens if a widget supports baselines, has a vertical alignment using baselines, and is inside a widget that supports baselines and has a natural “row” that it aligns to the baseline, or a baseline assigned to it by the grandparent.

Baseline alignment support for a widget is also done by the [vfunc@Gtk.Widget.measure] virtual function. It allows you to report both a minimum and natural size.

If a widget ends up baseline aligned it will be allocated all the space in the parent as if it was gtk_align_fill , but the selected baseline can be found via [method@Gtk.Widget.get_baseline]. If the baseline has a value other than -1 you need to align the widget such that the baseline appears at the position.

### GtkWidget as GtkBuildable

The `GtkWidget` implementation of the `GtkBuildable` interface supports various custom elements to specify additional aspects of widgets that are not directly expressed as properties.

If the widget uses a [class@Gtk.LayoutManager], `GtkWidget` supports a custom `<layout>` element, used to define layout properties:

```xml <object class="GtkGrid" id="my_grid"> <child> <object class="GtkLabel" id="label1"> <property name="label"> Description</property> <layout> <property name="column">0</property> <property name="row">0</property> <property name="row-span">1</property> <property name="column-span">1</property> </layout> </object> </child> <child> <object class="GtkEntry" id="description_entry"> <layout> <property name="column">1< /property> <property name="row">0</property> <property name="row-span">1</property> <property name="column-span">1</property> </layout> </object> </child> </object> ```

`GtkWidget` allows style information such as style classes to be associated with widgets, using the custom `<style>` element:

```xml <object class="GtkButton" id="button1"> <style> <class name="my-special-button-class"/> <class name="dark-button"/> </style> </object> ```

`GtkWidget` allows defining accessibility information, such as properties, relations, and states, using the custom `<accessibility>` element:

```xml <object class="GtkButton" id="button1"> <accessibility> <property name="label">Download</property> < relation name="labelled-by">label1</relation> </accessibility> </object> ```

### Building composite widgets from template XML

`GtkWidget `exposes some facilities to automate the procedure of creating composite widgets using "templates".

To create composite widgets with `GtkBuilder` XML, one must associate the interface description with the widget class at class initialization time using [method@Gtk.WidgetClass.set_template].

The interface description semantics expected in composite template descriptions is slightly different from regular [class@Gtk.Builder] XML.

Unlike regular interface descriptions, [method@Gtk.WidgetClass.set_template] will expect a `<template>` tag as a direct child of the toplevel `<interface>` tag. The `<template>` tag must specify the “class” attribute which must be the type name of the widget. Optionally, the “parent” attribute may be specified to specify the direct parent type of the widget type; this is ignored by `GtkBuilder` but can be used by UI design tools to introspect what kind of properties and internal children exist for a given type when the actual type does not exist.

The XML which is contained inside the `<template>` tag behaves as if it were added to the `<object>` tag defining the widget itself. You may set properties on a widget by inserting `<property>` tags into the `<template>` tag, and also add `<child>` tags to add children and extend a widget in the normal way you would with `<object>` tags.

Additionally, `<object>` tags can also be added before and after the initial `<template>` tag in the normal way, allowing one to define auxiliary objects which might be referenced by other widgets declared as children of the `<template>` tag.

Since, unlike the `<object>` tag, the `<template>` tag does not contain an “id” attribute, if you need to refer to the instance of the object itself that the template will create, simply refer to the template class name in an applicable element content.

Here is an example of a template definition, which includes an example of this in the `<signal>` tag:

```xml <interface> <template class="FooWidget" parent="GtkBox"> <property name="orientation">horizontal</property> <property name="spacing">4</property> <child> <object class="GtkButton" id="hello_button"> <property name="label" >Hello World</property> <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/> </object > </child> <child> <object class="GtkButton" id="goodbye_button"> <property name="label">Goodbye World< /property> </object> </child> </template> </interface> ```

Typically, you'll place the template fragment into a file that is bundled with your project, using `GResource`. In order to load the template, you need to call [method@Gtk.WidgetClass.set_template_from_resource] from the class initialization of your `GtkWidget` type:

```c static void foo_widget_class_init (FooWidgetClass *klass) { // ...

gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass), "/com/example/ui/foowidget.ui"); } ```

You will also need to call [method@Gtk.Widget.init_template] from the instance initialization function:

```c static void foo_widget_init (FooWidget *self) { gtk_widget_init_template (GTK_WIDGET (self));

// Initialize the rest of the widget... } ```

as well as calling [method@Gtk.Widget.dispose_template] from the dispose function:

```c static void foo_widget_dispose (GObject *gobject) { FooWidget *self = FOO_WIDGET (gobject);

// Dispose objects for which you have a reference...

// Clear the template children for this widget type gtk_widget_dispose_template (GTK_WIDGET (self), FOO_TYPE_WIDGET);

G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject); } ```

You can access widgets defined in the template using the [method@Gtk.Widget.get_template_child] function, but you will typically declare a pointer in the instance private data structure of your type using the same name as the widget in the template definition, and call [ method@Gtk.WidgetClass.bind_template_child_full] (or one of its wrapper macros [func@Gtk.widget_class_bind_template_child] and [ func@Gtk.widget_class_bind_template_child_private]) with that name, e.g.

```c typedef struct { GtkWidget *hello_button; GtkWidget *goodbye_button; } FooWidgetPrivate;

G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)

static void foo_widget_dispose (GObject *gobject) { gtk_widget_dispose_template (GTK_WIDGET (gobject), FOO_TYPE_WIDGET);

G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject); }

static void foo_widget_class_init (FooWidgetClass *klass) { // ... G_OBJECT_CLASS (klass)->dispose = foo_widget_dispose;

gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass), "/com/example/ui/foowidget.ui"); gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), FooWidget, hello_button); gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass), FooWidget, goodbye_button); }

static void foo_widget_init (FooWidget *widget) { gtk_widget_init_template (GTK_WIDGET (widget)); } ```

You can also use [method@Gtk.WidgetClass.bind_template_callback_full] (or is wrapper macro [func@Gtk.widget_class_bind_template_callback]) to connect a signal callback defined in the template with a function visible in the scope of the class, e.g.

```c // the signal handler has the instance and user data swapped // because of the swapped="yes" attribute in the template XML static void hello_button_clicked (FooWidget *self, GtkButton *button) { g_print ("Hello, world!\n"); }

static void foo_widget_class_init (FooWidgetClass *klass) { // ... gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass), "/com/example/ui/foowidget.ui"); gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked); } ```

All known sub-classes:

Required by:

Native
Root

Namespace: Gtk

Package: gtk4

Content:

Properties:

public bool can_focus { get; set; }
Whether the widget or any of its descendents can accept the input focus.
public bool can_target { get; set; }
Whether the widget can receive pointer events.
public string[] css_classes { owned get; set; }
A list of css classes applied to this widget.
public string css_name { get; construct; }
The name of this widget in the CSS tree.
public Cursor cursor { get; set; }
The cursor used by widget.
public bool focus_on_click { get; set; }
Whether the widget should grab focus when it is clicked with the mouse.
public bool focusable { get; set; }
Whether this widget itself will accept the input focus.
public Align halign { get; set; }
How to distribute horizontal space if widget gets extra space.
public bool has_default { get; }
Whether the widget is the default widget.
public bool has_focus { get; }
Whether the widget has the input focus.
public bool has_tooltip { get; set; }
Enables or disables the emission of the [signal@Gtk.
public int height_request { get; set; }
Overrides for height request of the widget.
public bool hexpand { get; set; }
Whether to expand horizontally.
public bool hexpand_set { get; set; }
Whether to use the `hexpand` property.
public LayoutManager layout_manager { get; owned set; }
The [class@Gtk.
public bool limit_events { get; set; }
Makes this widget act like a modal dialog, with respect to event delivery.
public int margin_bottom { get; set; }
Margin on bottom side of widget.
public int margin_end { get; set; }
Margin on end of widget, horizontally.
public int margin_start { get; set; }
Margin on start of widget, horizontally.
public int margin_top { get; set; }
Margin on top side of widget.
public string name { get; set; }
The name of the widget.
public double opacity { get; set; }
The requested opacity of the widget.
public Overflow overflow { get; set; }
How content outside the widget's content area is treated.
public Widget parent { get; }
The parent widget of this widget.
public bool receives_default { get; set; }
Whether the widget will receive the default action when it is focused.
public virtual Root root { get; }
The `GtkRoot` widget of the widget tree containing this widget.
public int scale_factor { get; }
The scale factor of the widget.
public bool sensitive { get; set; }
Whether the widget responds to input.
public string tooltip_markup { get; set; }
Sets the text of tooltip to be the given string, which is marked up with Pango markup.
public string tooltip_text { get; set; }
Sets the text of tooltip to be the given string.
public Align valign { get; set; }
How to distribute vertical space if widget gets extra space.
public bool vexpand { get; set; }
Whether to expand vertically.
public bool vexpand_set { get; set; }
Whether to use the `vexpand` property.
public bool visible { get; set; }
Whether the widget is visible.
public int width_request { get; set; }
Overrides for width request of the widget.

Static methods:

public static TextDirection get_default_direction ()
Obtains the default reading direction.
public static void set_default_direction (TextDirection dir)
Sets the default reading direction for widgets.

Creation methods:

protected Widget ()

Methods:

public void action_set_enabled (string action_name, bool enabled)
Enables or disables an action installed with [method@Gtk.
public bool activate ()
Activates the widget.
public bool activate_action (string name, string? format_string, ...)
Activates an action for the widget.
public bool activate_action_variant (string name, Variant? args)
Activates an action for the widget.
public void activate_default ()
Activates the `default.
public class void add_binding (uint keyval, ModifierType mods, ShortcutFunc callback, string? format_string, ...)
Creates a new shortcut for this that calls the given callback with arguments according to format_string.
public class void add_binding_action (uint keyval, ModifierType mods, string action_name, string? format_string, ...)
Creates a new shortcut for this that activates the given action_name with arguments read according to format_string.
public class void add_binding_signal (uint keyval, ModifierType mods, string @signal, string? format_string, ...)
Creates a new shortcut for this that emits the given action signal with arguments read according to format_string.
public void add_controller (owned EventController controller)
Adds an event controller to the widget.
public void add_css_class (string css_class)
Adds a style class to the widget.
public void add_mnemonic_label (Widget label)
Adds a widget to the list of mnemonic labels for this widget.
public class void add_shortcut (Shortcut shortcut)
Installs a shortcut in this.
public uint add_tick_callback (owned TickCallback callback)
Queues an animation frame update and adds a callback to be called before each frame.
public void allocate (int width, int height, int baseline, owned Transform? transform)
Assigns size, position, (optionally) a baseline and transform to a child widget.
public void allocate_size (Allocation allocation, int baseline)
public class void bind_template_callback_full (string callback_name, Callback callback_symbol)
Associates a name to be used in GtkBuilder XML with a symbol.
public class void bind_template_child_full (string name, bool internal_child, ssize_t struct_offset)
Assigns an object declared in the class template XML to be set to a location on a freshly built instance’s private data, or alternatively accessible via [method@Gtk.
public bool child_focus (DirectionType direction)
Called by widgets as the user moves around the window using keyboard shortcuts.
public bool compute_bounds (Widget target, out Rect out_bounds)
Computes the bounds for this in the coordinate space of target.
public bool compute_expand (Orientation orientation)
Computes whether a parent widget should give this widget extra space when possible.
public virtual void compute_expand_internal (out bool hexpand_p, out bool vexpand_p)
public bool compute_point (Widget target, Point point, out Point out_point)
Translates the given point in this 's coordinates to coordinates in target’s coordinate system.
public bool compute_transform (Widget target, out Matrix out_transform)
Computes a matrix suitable to describe a transformation from this's coordinate system into target's coordinate system.
public virtual bool contains (double x, double y)
Tests if a given point is contained in the widget.
public Context create_pango_context ()
Creates a new `PangoContext` that is configured for the widget.
public Layout create_pango_layout (string? text)
Creates a new `PangoLayout` that is configured for the widget.
public virtual void css_changed (CssStyleChange change)
Vfunc called when the CSS used by widget was changed.
public void dispose_template (Type widget_type)
Clears the template children for the widget.
public void error_bell ()
Notifies the user about an input-related error on the widget.
public virtual bool focus (DirectionType direction)
Vfunc for child_focus
public class AccessibleRole get_accessible_role ()
Retrieves the accessible role used by the given widget class.
public class uint get_activate_signal ()
Retrieves the signal id for the activation signal.
public int get_allocated_baseline ()
Returns the baseline that has currently been allocated to the widget.
public int get_allocated_height ()
Returns the height that has currently been allocated to the widget.
public int get_allocated_width ()
Returns the width that has currently been allocated to the widget.
public void get_allocation (out Allocation allocation)
Retrieves the widget’s allocation.
public unowned Widget? get_ancestor (Type widget_type)
Gets the first ancestor of the widget with type widget_type.
public int get_baseline ()
Returns the baseline that has currently been allocated to the widget.
public bool get_can_focus ()
Determines whether the input focus can enter the widget or any of its children.
public bool get_can_target ()
Queries whether the widget can be the target of pointer events.
public bool get_child_visible ()
Gets the value set with [method@Gtk.
public unowned Clipboard get_clipboard ()
Gets the clipboard object for the widget.
public RGBA get_color ()
Gets the current foreground color for the widget’s style.
public string[] get_css_classes ()
Returns the list of style classes applied to the widget.
public class unowned string get_css_name ()
Gets the name used by this class for matching in CSS code.
public unowned Cursor? get_cursor ()
Gets the cursor set on the widget.
public TextDirection get_direction ()
Gets the reading direction for the widget.
public unowned Display get_display ()
Get the display for the window that the widget belongs to.
public unowned Widget? get_first_child ()
Returns the widget’s first child.
public unowned Widget? get_focus_child ()
Returns the focus child of the widget.
public bool get_focus_on_click ()
Returns whether the widget should grab focus when it is clicked with the mouse.
public bool get_focusable ()
Determines whether the widget can own the input focus.
public unowned FontMap? get_font_map ()
Gets the font map of the widget.
public unowned FontOptions? get_font_options ()
Returns the `cairo_font_options_t` of the widget.
public unowned FrameClock? get_frame_clock ()
Obtains the frame clock for a widget.
public Align get_halign ()
Gets the horizontal alignment of the widget.
public bool get_has_tooltip ()
Returns the current value of the `has-tooltip` property.
public int get_height ()
Returns the content height of the widget.
public bool get_hexpand ()
Gets whether the widget would like any available extra horizontal space.
public bool get_hexpand_set ()
Gets whether the `hexpand` flag has been explicitly set.
public unowned Widget? get_last_child ()
Returns the widget’s last child.
public unowned LayoutManager? get_layout_manager ()
Retrieves the layout manager of the widget.
public class Type get_layout_manager_type ()
Retrieves the type of the [class@Gtk.
public bool get_limit_events ()
Gets the value of the [property@Gtk.
public bool get_mapped ()
Returns whether the widget is mapped.
public int get_margin_bottom ()
Gets the bottom margin of the widget.
public int get_margin_end ()
Gets the end margin of the widget.
public int get_margin_start ()
Gets the start margin of the widget.
public int get_margin_top ()
Gets the top margin of the widget.
public unowned string get_name ()
Retrieves the name of a widget.
public unowned Native? get_native ()
Returns the nearest `GtkNative` ancestor of the widget.
public unowned Widget? get_next_sibling ()
Returns the widget’s next sibling.
public double get_opacity ()
Fetches the requested opacity for the widget.
public Overflow get_overflow ()
Returns the widget’s overflow value.
public unowned Context get_pango_context ()
Gets a `PangoContext` that is configured for the widget.
public unowned Widget? get_parent ()
Returns the parent widget of the widget.
public void get_preferred_size (out Requisition minimum_size, out Requisition natural_size)
Retrieves the minimum and natural size of a widget, taking into account the widget’s preference for height-for-width management.
public unowned Widget? get_prev_sibling ()
Returns the widget’s previous sibling.
public unowned Clipboard get_primary_clipboard ()
Gets the primary clipboard of the widget.
public bool get_realized ()
Determines whether the widget is realized.
public bool get_receives_default ()
Determines whether the widget is always treated as the default widget within its toplevel when it has the focus, even if another widget is the default.
public virtual SizeRequestMode get_request_mode ()
Gets whether the widget prefers a height-for-width layout or a width-for-height layout.
public unowned Root? get_root ()
Returns the `GtkRoot` widget of the widget.
public int get_scale_factor ()
Retrieves the internal scale factor that maps from window coordinates to the actual device pixels.
public bool get_sensitive ()
Returns the widget’s sensitivity.
public unowned Settings get_settings ()
Gets the settings object holding the settings used for the widget.
public int get_size (Orientation orientation)
Returns the content width or height of the widget.
public void get_size_request (out int width, out int height)
Gets the size request that was explicitly set for the widget.
public StateFlags get_state_flags ()
Returns the widget state as a flag set.
public unowned StyleContext get_style_context ()
Returns the style context associated to the widget.
public unowned Object get_template_child (Type widget_type, string name)
Fetches an object build from the template XML for widget_type in the widget.
public unowned string? get_tooltip_markup ()
Gets the contents of the tooltip for the widget.
public unowned string? get_tooltip_text ()
Gets the contents of the tooltip for the widget.
public Align get_valign ()
Gets the vertical alignment of the widget.
public bool get_vexpand ()
Gets whether the widget would like any available extra vertical space.
public bool get_vexpand_set ()
Gets whether the `vexpand` flag has been explicitly set.
public bool get_visible ()
Determines whether the widget is visible.
public int get_width ()
Returns the content width of the widget.
public virtual bool grab_focus ()
Causes this to have the keyboard focus for the window that it belongs to.
public bool has_css_class (string css_class)
Returns whether a style class is currently applied to the widget.
public bool has_visible_focus ()
Determines if the widget should show a visible indication that it has the global input focus.
public bool in_destruction ()
Returns whether the widget is currently being destroyed.
public void init_template ()
Creates and initializes child widgets defined in templates.
public void insert_action_group (string name, ActionGroup? group)
Inserts an action group into the widget's actions.
public void insert_after (Widget parent, Widget? previous_sibling)
Sets the parent widget of the widget.
public void insert_before (Widget parent, Widget? next_sibling)
Sets the parent widget of the widget.
public class void install_action (string action_name, string? parameter_type, WidgetActionActivateFunc activate)
Adds an action for all instances of a widget class.
public class void install_property_action (string action_name, string property_name)
Installs an action called action_name on this and binds its state to the value of the property_name property.
public bool is_ancestor (Widget ancestor)
Determines whether the widget is a descendent of ancestor.
public bool is_drawable ()
Determines whether the widget can be drawn to.
public bool is_focus ()
Determines if the widget is the focus widget within its toplevel.
public bool is_sensitive ()
Returns the widget’s effective sensitivity.
public bool is_visible ()
Determines whether the widget and all its parents are marked as visible.
public List<unowned Widget> list_mnemonic_labels ()
Returns the widgets for which this widget is the target of a mnemonic.
public virtual void measure (Orientation orientation, int for_size, out int minimum, out int natural, out int minimum_baseline, out int natural_baseline)
Measures this in the orientation orientation and for the given for_size.
public ListModel observe_children ()
Returns a list model to track the children of the widget.
public ListModel observe_controllers ()
Returns a list model to track the event controllers of the widget.
public unowned Widget? pick (double x, double y, PickFlags flags)
Finds the descendant of the widget closest to a point.
public class bool query_action (uint index_, out Type owner, out unowned string action_name, out unowned VariantType? parameter_type, out unowned string? property_name)
Returns details about an action that has been installed for this.
public void queue_allocate ()
Flags the widget for a rerun of the [vfunc@Gtk.
public void queue_draw ()
Schedules this widget to be redrawn.
public void queue_resize ()
Flags a widget to have its size renegotiated.
public void remove_controller (EventController controller)
Removes an event controller from the widget.
public void remove_css_class (string css_class)
Removes a style from the widget.
public void remove_mnemonic_label (Widget label)
Removes a widget from the list of mnemonic labels for this widget.
public void remove_tick_callback (uint id)
Removes a tick callback previously registered with [method@Gtk.
public class void set_accessible_role (AccessibleRole accessible_role)
Sets the accessible role used by the given widget class.
public class void set_activate_signal (uint signal_id)
Sets the activation signal for a widget class.
public class void set_activate_signal_from_name (string signal_name)
Sets the activation signal for a widget class.
public void set_can_focus (bool can_focus)
Sets whether the input focus can enter the widget or any of its children.
public void set_can_target (bool can_target)
Sets whether the widget can be the target of pointer events.
public void set_child_visible (bool child_visible)
Sets whether the widget should be mapped along with its parent.
public void set_css_classes (string[] classes)
Replaces the current style classes of the widget with classes.
public class void set_css_name (string name)
Sets the name to be used for CSS matching of widgets.
public void set_cursor (Cursor? cursor)
Sets the cursor to be shown when the pointer hovers over the widget.
public void set_cursor_from_name (string? name)
Sets the cursor to be shown when the pointer hovers over the widget.
public void set_direction (TextDirection dir)
Sets the reading direction on the widget.
public virtual void set_focus_child (Widget? child)
Set the focus child of the widget.
public void set_focus_on_click (bool focus_on_click)
Sets whether the widget should grab focus when it is clicked with the mouse.
public void set_focusable (bool focusable)
Sets whether the widget can own the input focus.
public void set_font_map (FontMap? font_map)
Sets the font map to use for text rendering in the widget.
public void set_font_options (FontOptions? options)
Sets the `cairo_font_options_t` used for text rendering in the widget.
public void set_halign (Align align)
Sets the horizontal alignment of the widget.
public void set_has_tooltip (bool has_tooltip)
Sets the `has-tooltip` property on the widget.
public void set_hexpand (bool expand)
Sets whether the widget would like any available extra horizontal space.
public void set_hexpand_set (bool @set)
Sets whether the hexpand flag will be used.
public void set_layout_manager (owned LayoutManager? layout_manager)
Sets the layout manager to use for measuring and allocating children of the widget.
public class void set_layout_manager_type (Type type)
Sets the type to be used for creating layout managers for widgets of this.
public void set_limit_events (bool limit_events)
Sets whether the widget acts like a modal dialog, with respect to event delivery.
public void set_margin_bottom (int margin)
Sets the bottom margin of the widget.
public void set_margin_end (int margin)
Sets the end margin of the widget.
public void set_margin_start (int margin)
Sets the start margin of the widget.
public void set_margin_top (int margin)
Sets the top margin of the widget.
public void set_name (string name)
Sets a widgets name.
public void set_opacity (double opacity)
Requests the widget to be rendered partially transparent.
public void set_overflow (Overflow overflow)
Sets how the widget treats content that is drawn outside the it's content area.
public void set_parent (Widget parent)
Sets the parent widget of the widget.
public void set_receives_default (bool receives_default)
Sets whether the widget will be treated as the default widget within its toplevel when it has the focus, even if another widget is the default.
public void set_sensitive (bool sensitive)
Sets the sensitivity of the widget.
public void set_size_request (int width, int height)
Sets the minimum size of the widget.
public void set_state_flags (StateFlags flags, bool clear)
Turns on flag values in the current widget state.
public class void set_template (Bytes template_bytes)
This should be called at class initialization time to specify the `GtkBuilder` XML to be used to extend a widget.
public class void set_template_from_resource (string resource_name)
A convenience function that calls [method@Gtk.
public class void set_template_scope (BuilderScope scope)
Overrides the default scope to be used when parsing the class template.
public void set_tooltip_markup (string? markup)
Sets the contents of the tooltip for widget.
public void set_tooltip_text (string? text)
Sets the contents of the tooltip for the widget.
public void set_valign (Align align)
Sets the vertical alignment of the widget.
public void set_vexpand (bool expand)
Sets whether the widget would like any available extra vertical space.
public void set_vexpand_set (bool @set)
Sets whether the vexpand flag will be used.
public void set_visible (bool visible)
Sets the visibility state of this.
public bool should_layout ()
Returns whether the widget should contribute to the measuring and allocation of its parent.
public virtual void size_allocate (int width, int height, int baseline)
Allocates widget with a transformation that translates the origin to the position in allocation.
public virtual void snapshot (Snapshot snapshot)
Vfunc called when a new snapshot of the widget has to be taken.
public void snapshot_child (Widget child, Snapshot snapshot)
Snapshots a child of the widget.
public virtual void system_setting_changed (SystemSetting settings)
Emitted when a system setting was changed.
public bool translate_coordinates (Widget dest_widget, double src_x, double src_y, out double dest_x, out double dest_y)
Translates coordinates relative to this ’s allocation to coordinates relative to dest_widget’s allocations.
public void trigger_tooltip_query ()
Triggers a tooltip query on the display of the widget.
public void unparent ()
Removes this from its parent.
public virtual void unroot ()
Called when the widget is about to be removed from its `GtkRoot` widget.
public void unset_state_flags (StateFlags flags)
Turns off flag values for the current widget state.

Signals:

public signal void destroy ()
Signals that all holders of a reference to the widget should release the reference that they hold.
public virtual signal void direction_changed (TextDirection previous_direction)
Emitted when the text direction of a widget changes.
public virtual signal void hide ()
Emitted when widget is hidden.
public virtual signal bool keynav_failed (DirectionType direction)
Emitted if keyboard navigation fails.
public virtual signal void map ()
Emitted when widget is going to be mapped.
public virtual signal bool mnemonic_activate (bool group_cycling)
Emitted when a widget is activated via a mnemonic.
public virtual signal void move_focus (DirectionType direction)
Emitted when the focus is moved.
public virtual signal bool query_tooltip (int x, int y, bool keyboard_tooltip, Tooltip tooltip)
Emitted when the widget’s tooltip is about to be shown.
public virtual signal void realize ()
Emitted when widget is associated with a `GdkSurface`.
public virtual signal void show ()
Emitted when widget is shown.
public virtual signal void state_flags_changed (StateFlags previous_state_flags)
Emitted when the widget state changes.
public virtual signal void unmap ()
Emitted when widget is going to be unmapped.
public virtual signal void unrealize ()
Emitted when the `GdkSurface` associated with widget is destroyed.

Inherited Members:

All known members inherited from class GLib.Object

All known members inherited from interface Gtk.Accessible

All known members inherited from interface Gtk.Buildable