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.

`GtkWidget` is the base class all widgets in GTK derive from. 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 `GtkWidget` 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 query_tooltip signal on widget.
public int height_request { get; set; }
Override 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 `GtkLayoutManager` instance to use to compute the preferred size of the widget, and allocate its children.
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; }
Override for width request of the widget.

Static methods:

public static TextDirection get_default_direction ()
Obtains the current 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)
Enable or disable an action installed with install_action.
public bool activate ()
For widgets that can be “activated” (buttons, menu items, etc.
public bool activate_action (string name, string? format_string, ...)
Looks up the action in the action groups associated with this and its ancestors, and activates it.
public bool activate_action_variant (string name, Variant? args)
Looks up the action in the action groups associated with this and its ancestors, and activates it.
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 read 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 controller to this so that it will receive events.
public void add_css_class (string css_class)
Adds a style class to this.
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)
This function is only used by `GtkWidget` subclasses, to assign a size, position and (optionally) baseline to their child widgets.
public void allocate_size (Allocation allocation, int baseline)
public class void bind_template_callback_full (string callback_name, Callback callback_symbol)
Declares a callback_symbol to handle callback_name from the template XML defined for widget_type.
public class void bind_template_child_full (string name, bool internal_child, ssize_t struct_offset)
Automatically assign 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 container 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 relative to 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 the point at (x, y) is contained in this.
public Context create_pango_context ()
Creates a new `PangoContext` with the appropriate font map, font options, font description, and base direction for drawing text for this widget.
public Layout create_pango_layout (string? text)
Creates a new `PangoLayout` with the appropriate font map, font description, and base direction for drawing text for this 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 given widget.
public void error_bell ()
Notifies the user about an input-related error on this 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 `GtkWidget` 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 this.
public int get_allocated_height ()
Returns the height that has currently been allocated to this.
public int get_allocated_width ()
Returns the width that has currently been allocated to this.
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 this with type widget_type.
public int get_baseline ()
Returns the baseline that has currently been allocated to this.
public bool get_can_focus ()
Determines whether the input focus can enter this or any of its children.
public bool get_can_target ()
Queries whether this can be the target of pointer events.
public bool get_child_visible ()
Gets the value set with set_child_visible.
public unowned Clipboard get_clipboard ()
Gets the clipboard object for this.
public RGBA get_color ()
Gets the current foreground color for the widget’s CSS style.
public string[] get_css_classes ()
Returns the list of style classes applied to this .
public class unowned string get_css_name ()
Gets the name used by this class for matching in CSS code.
public unowned Cursor? get_cursor ()
Queries the cursor set on this.
public TextDirection get_direction ()
Gets the reading direction for a particular widget.
public unowned Display get_display ()
Get the `GdkDisplay` for the toplevel window associated with this widget.
public unowned Widget? get_first_child ()
Returns the widget’s first child.
public unowned Widget? get_focus_child ()
Returns the current focus child of this.
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 this can own the input focus.
public unowned FontMap? get_font_map ()
Gets the font map of this.
public unowned FontOptions? get_font_options ()
Returns the `cairo_font_options_t` of widget.
public unowned FrameClock? get_frame_clock ()
Obtains the frame clock for a widget.
public Align get_halign ()
Gets the horizontal alignment of this.
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 set_hexpand has been used to explicitly set the expand flag on this widget.
public unowned Widget? get_last_child ()
Returns the widget’s last child.
public unowned LayoutManager? get_layout_manager ()
Retrieves the layout manager used by this.
public class Type get_layout_manager_type ()
Retrieves the type of the [class@Gtk.
public bool get_mapped ()
Whether the widget is mapped.
public int get_margin_bottom ()
Gets the bottom margin of this.
public int get_margin_end ()
Gets the end margin of this.
public int get_margin_start ()
Gets the start margin of this.
public int get_margin_top ()
Gets the top margin of this.
public unowned string get_name ()
Retrieves the name of a widget.
public unowned Native? get_native ()
Returns the nearest `GtkNative` ancestor of this .
public unowned Widget? get_next_sibling ()
Returns the widget’s next sibling.
public double get_opacity ()
Fetchess the requested opacity for this widget.
public Overflow get_overflow ()
Returns the widget’s overflow value.
public unowned Context get_pango_context ()
Gets a `PangoContext` with the appropriate font map, font description, and base direction for this widget.
public unowned Widget? get_parent ()
Returns the parent widget of this.
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 this.
public bool get_realized ()
Determines whether this is realized.
public bool get_receives_default ()
Determines whether this 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 this.
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 this 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 using set_size_request.
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 this .
public unowned Object get_template_child (Type widget_type, string name)
Fetch an object build from the template XML for widget_type in this this instance.
public unowned string? get_tooltip_markup ()
Gets the contents of the tooltip for this.
public unowned string? get_tooltip_text ()
Gets the contents of the tooltip for this.
public Align get_valign ()
Gets the vertical alignment of this.
public bool get_vexpand ()
Gets whether the widget would like any available extra vertical space.
public bool get_vexpand_set ()
Gets whether set_vexpand has been used to explicitly set the expand flag on this widget.
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 `GtkWindow` it's inside.
public bool has_css_class (string css_class)
Returns whether css_class is currently applied to this.
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 group into this.
public void insert_after (Widget parent, Widget? previous_sibling)
Inserts this into the child widget list of parent.
public void insert_before (Widget parent, Widget? next_sibling)
Inserts this into the child widget list of parent.
public class void install_action (string action_name, string? parameter_type, WidgetActionActivateFunc activate)
This should be called at class initialization time to specify actions to be added for all instances of this 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 this is somewhere inside ancestor, possibly with intermediate containers.
public bool is_drawable ()
Determines whether this 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 `GListModel` to track the children of this.
public ListModel observe_controllers ()
Returns a `GListModel` to track the [class@Gtk.
public unowned Widget? pick (double x, double y, PickFlags flags)
Finds the descendant of this closest to the point (x, y).
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 the index_-th action that has been installed for this during class initialization.
public void queue_allocate ()
Flags the widget for a rerun of the [vfunc@Gtk.
public void queue_draw ()
Schedules this widget to be redrawn in the paint phase of the current or the next frame.
public void queue_resize ()
Flags a widget to have its size renegotiated.
public void remove_controller (EventController controller)
Removes controller from this, so that it doesn't process events anymore.
public void remove_css_class (string css_class)
Removes a style from this.
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 add_tick_callback.
public class void set_accessible_role (AccessibleRole accessible_role)
Sets the accessible role used by the given `GtkWidget` class.
public class void set_activate_signal (uint signal_id)
Sets the `GtkWidgetClass.
public class void set_activate_signal_from_name (string signal_name)
Sets the `GtkWidgetClass.
public void set_can_focus (bool can_focus)
Specifies whether the input focus can enter the widget or any of its children.
public void set_can_target (bool can_target)
Sets whether this can be the target of pointer events.
public void set_child_visible (bool child_visible)
Sets whether this should be mapped along with its parent.
public void set_css_classes (string[] classes)
Clear all style classes applied to this and replace them 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 pointer devices point towards this.
public void set_cursor_from_name (string? name)
Sets a named cursor to be shown when pointer devices point towards this.
public void set_direction (TextDirection dir)
Sets the reading direction on a particular widget.
public virtual void set_focus_child (Widget? child)
Set child as the current focus child of this.
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)
Specifies whether this can own the input focus.
public void set_font_map (FontMap? font_map)
Sets the font map to use for Pango rendering.
public void set_font_options (FontOptions? options)
Sets the `cairo_font_options_t` used for Pango rendering in this widget.
public void set_halign (Align align)
Sets the horizontal alignment of this.
public void set_has_tooltip (bool has_tooltip)
Sets the `has-tooltip` property on this to has_tooltip.
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 delegate instance that provides an implementation for measuring and allocating the children of this.
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_margin_bottom (int margin)
Sets the bottom margin of this.
public void set_margin_end (int margin)
Sets the end margin of this.
public void set_margin_start (int margin)
Sets the start margin of this.
public void set_margin_top (int margin)
Sets the top margin of this.
public void set_name (string name)
Sets a widgets name.
public void set_opacity (double opacity)
Request the this to be rendered partially transparent.
public void set_overflow (Overflow overflow)
Sets how this treats content that is drawn outside the widget's content area.
public void set_parent (Widget parent)
Sets parent as the parent widget of this.
public void set_receives_default (bool receives_default)
Specifies whether this 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 a widget.
public void set_size_request (int width, int height)
Sets the minimum size of a 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)
For use in language bindings, this will override the default `GtkBuilderScope` to be used when parsing GtkBuilder XML from this class’s template data.
public void set_tooltip_markup (string? markup)
Sets markup as the contents of the tooltip, which is marked up with Pango markup.
public void set_tooltip_text (string? text)
Sets text as the contents of the tooltip.
public void set_valign (Align align)
Sets the vertical alignment of this.
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 this 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)
Snapshot the a child of this.
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)
Translate 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 where the toplevel of this is located.
public void unparent ()
Dissociate 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