Widget

Object Hierarchy:

Description:

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

GtkWidget is the base class all widgets in GTK derive from.

It manages the widget lifecycle, 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:

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 Widget subclass that supports height-for-width or width-for-height geometry management for itself or its child widgets, the 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 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 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 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 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 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, Widget 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 SizeRequestModes even if the widget in question only trades sizes in a single orientation.

For instance, a Label that does height-for-width word wrapping will not expect to have 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:

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 measure inside your own GtkWidgetClass.size-allocate() implementation. These return a request adjusted by 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 measure. Otherwise, you would not properly consider widget margins, 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 of gtk_align_baseline, 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 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 get_allocated_baseline . If this 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 a custom <accelerator> element, which has attributes named ”key”, ”modifiers” and ”signal” and allows to specify accelerators.

An example of a UI definition fragment specifying an accelerator:

<object class="GtkButton">
  <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/>
</object>

If the parent widget uses a LayoutManager, Widget supports a custom <layout> element, used to define layout properties:

<object class="MyGrid" id="grid1">
  <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="col-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="col-span">1</property>
      </layout>
    </object>
  </child>
</object>

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

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

Building composite widgets from template XML #

GtkWidget exposes some facilities to automate the procedure of creating composite widgets using Builder interface description language.

To create composite widgets with Builder XML, one must associate the interface description with the widget class at class initialization time using set_template.

The interface description semantics expected in composite template descriptions is slightly different from regular Builder XML.

Unlike regular interface descriptions, 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 the GtkBuilder but required for Glade 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 widget itself. You may set properties on widget by inserting <property> tags into the <template> tag, and also add <child > tags to add children and extend 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.

An example of a GtkBuilder Template Definition:

<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 Resource. In order to load the template, you need to call set_template_from_resource from the class initialization of your Widget type:

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 init_template from the instance initialization function:

static void
foo_widget_init (FooWidget *self)
{
  // ...
  gtk_widget_init_template (GTK_WIDGET (self));
}

You can access widgets defined in the template using the 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 gtk_widget_class_bind_template_child_private with that name, e.g.

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

G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)

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_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)
{

}

You can also use 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.

// 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; }
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, see Align
public bool has_default { get; }
public bool has_focus { get; }
public bool has_tooltip { get; set; }
Enables or disables the emission of query_tooltip on widget.
public int height_request { get; set; }
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 LayoutManager 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; }
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; }
public bool receives_default { get; set; }
public virtual Root root { get; }
The Root widget of the widget tree containing this widget or null if the widget is not contained in a root widget.
public int scale_factor { get; }
The scale factor of the widget.
public bool sensitive { get; set; }
public string tooltip_markup { get; set; }
Sets the text of tooltip to be the given string, which is marked up with the Pango text markup language.
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, see Align
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; }
public int width_request { get; set; }

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 where the direction has not been explicitly set by set_direction.

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 ()
Activate 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 css_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 Widget 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 get_template_child.
public bool child_focus (DirectionType direction)
This function is used by custom widget implementations; if you're writing an app, you’d use grab_focus to move the focus to a particular widget.
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 Context 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 Layout with the appropriate font map, font description, and base direction for drawing text for this widget.
public virtual void css_changed (CssStyleChange change)
public void error_bell ()
Notifies the user about an input-related error on this widget.
public virtual bool focus (DirectionType direction)
public class AccessibleRole get_accessible_role ()
Retrieves the accessible role used by the given Widget class.
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 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 ()
This is a utility function to get the clipboard object for the Display that this is using.
public string[] get_css_classes ()
Returns the list of css 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 via set_cursor.
public TextDirection get_direction ()
Gets the reading direction for a particular widget.
public unowned Display get_display ()
Get the Display for the toplevel window associated with this widget.
public unowned Widget? get_first_child ()
Returns the widgets 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 that has been set with set_font_map.
public unowned FontOptions? get_font_options ()
Returns the FontOptions used for Pango rendering.
public unowned FrameClock? get_frame_clock ()
Obtains the frame clock for a widget.
public Align get_halign ()
Gets the value of the halign property.
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, as passed to its size-allocate implementation.
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 widgets last child.
public unowned LayoutManager? get_layout_manager ()
Retrieves the layout manager set using set_layout_manager.
public class Type get_layout_manager_type ()
Retrieves the type of the LayoutManager used by the Widget class.
public bool get_mapped ()
Whether the widget is mapped.
public int get_margin_bottom ()
Gets the value of the margin_bottom property.
public int get_margin_end ()
Gets the value of the margin_end property.
public int get_margin_start ()
Gets the value of the margin_start property.
public int get_margin_top ()
Gets the value of the margin_top property.
public unowned string get_name ()
Retrieves the name of a widget.
public unowned Native? get_native ()
Returns the GtkNative widget that contains this , or null if the widget is not contained inside a widget tree with a native ancestor.
public unowned Widget? get_next_sibling ()
Returns the widgets next sibling.
public double get_opacity ()
Fetches the requested opacity for this widget.
public Overflow get_overflow ()
Returns the value set via set_overflow.
public unowned Context get_pango_context ()
Gets a Context 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 widgets previous sibling.
public unowned Clipboard get_primary_clipboard ()
This is a utility function to get the primary clipboard object for the Display that this is using.
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 Root widget of this or null if the widget is not contained inside a widget tree with a root 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 (in the sense of returning the value that has been set using set_sensitive).
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, depending on orientation.
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 set using set_tooltip_markup.
public unowned string? get_tooltip_text ()
Gets the contents of the tooltip for this.
public Align get_valign ()
Gets the value of the valign property.
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, as passed to its size-allocate implementation.
public virtual bool grab_focus ()
Causes this (or one of its descendents) to have the keyboard focus for the Window 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, which means it is sensitive itself and also its parent widget is sensitive
public bool is_visible ()
Determines whether the widget and all its parents are marked as visible.
public List<unowned Widget> list_mnemonic_labels ()
Returns a newly allocated list of the widgets, normally labels, for which this widget is the target of a mnemonic (see for example, set_mnemonic_widget).
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 ListModel to track the children of this.
public ListModel observe_controllers ()
Returns a ListModel to track the EventControllers of this .
public unowned Widget? pick (double x, double y, PickFlags flags)
Finds the descendant of this (including this itself) closest to the screen at the point (x, y).
public class bool query_action (uint index_, out Type owner, out string action_name, out VariantType parameter_type, out string property_name)
Queries the actions that have been installed for a widget class using install_action during class initialization.
public void queue_allocate ()
This function is only for use in widget implementations.
public void queue_draw ()
Schedules this widget to be redrawn in paint phase of the current or the next frame.
public void queue_resize ()
This function is only for use in widget implementations.
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 css_class 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 Widget class.
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 when its parent is mapped and this has been shown with show.
public void set_css_classes (string[] classes)
Will clear all css 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 FontOptions 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 (see get_hexpand) 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)
Widgets can be named, which allows you to refer to them from a CSS file.
public void set_opacity (double opacity)
Request the this to be rendered partially transparent, with opacity 0 being fully transparent and 1 fully opaque.
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)
This function is useful only when implementing subclasses of Widget.
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; that is, the widget’s size request will be at least width by height.
public void set_state_flags (StateFlags flags, bool clear)
This function is for use in widget implementations.
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 to call set_template.
public class void set_template_scope (BuilderScope scope)
For use in language bindings, this will override the default BuilderScope 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 the Pango text markup language.
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 (see get_vexpand) 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)
This is a simple form of allocate that takes the new position of this as part of allocation.
public virtual void snapshot (Snapshot snapshot)
public void snapshot_child (Widget child, Snapshot snapshot)
When a widget receives a call to the snapshot function, it must send synthetic snapshot calls to all children.
public virtual void system_setting_changed (SystemSetting settings)
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 ()
This function is only for use in widget implementations.
public virtual void unroot ()
public void unset_state_flags (StateFlags flags)
This function is for use in widget implementations.

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)
The direction_changed signal is emitted when the text direction of a widget changes.
public virtual signal void hide ()
The hide signal is emitted when widget is hidden, for example with hide.
public virtual signal bool keynav_failed (DirectionType direction)
Gets emitted if keyboard navigation fails.
public virtual signal void map ()
The map signal is emitted when widget is going to be mapped, that is when the widget is visible (which is controlled with set_visible) and all its parents up to the toplevel widget are also visible.
public virtual signal bool mnemonic_activate (bool group_cycling)
The default handler for this signal activates widget if group_cycling is false, or just makes widget grab focus if group_cycling is true.
public virtual signal void move_focus (DirectionType direction)
public virtual signal bool query_tooltip (int x, int y, bool keyboard_tooltip, Tooltip tooltip)
Emitted when has_tooltip is true and the hover timeout has expired with the cursor hovering "above" widget; or emitted when widget got focus in keyboard mode.
public virtual signal void realize ()
The realize signal is emitted when widget is associated with a Surface, which means that realize has been called or the widget has been mapped (that is, it is going to be drawn).
public virtual signal void show ()
The show signal is emitted when widget is shown, for example with show.
public virtual signal void state_flags_changed (StateFlags previous_state_flags)
The state_flags_changed signal is emitted when the widget state changes, see get_state_flags.
public virtual signal void unmap ()
The unmap signal is emitted when widget is going to be unmapped, which means that either it or any of its parents up to the toplevel widget have been set as hidden.
public virtual signal void unrealize ()
The unrealize signal is emitted when the Surface associated with widget is destroyed, which means that unrealize has been called or the widget has been unmapped (that is, it is going to be hidden).

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