Widget

Object Hierarchy:

Gtk.Widget Gtk.Widget Gtk.Widget GLib.InitiallyUnowned GLib.InitiallyUnowned GLib.InitiallyUnowned->Gtk.Widget GLib.Object GLib.Object GLib.Object->GLib.InitiallyUnowned Atk.Implementor Atk.Implementor Atk.Implementor->Gtk.Widget Gtk.Buildable Gtk.Buildable Gtk.Buildable->Gtk.Widget

Description:

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

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 five virtual methods:

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

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 get_preferred_width. Because the preferred widths for each container 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 get_preferred_height_for_width, which 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 (unless set_geometry_hints is explicitly used instead).

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 container widgets allocate their children. Each container 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.

See GtkContainer’s geometry management section to learn more about how height-for-width allocations are performed by container widgets.

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 get_preferred_height 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, for get_preferred_height it will do:

static void
foo_widget_get_preferred_height (GtkWidget *widget,
                                 gint *min_height,
                                 gint *nat_height)
{
   if (i_am_in_height_for_width_mode)
     {
       gint min_width, nat_width;

       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
                                                           &min_width,
                                                           &nat_width);
       GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width
                                                          (widget,
                                                           min_width,
                                                           min_height,
                                                           nat_height);
     }
   else
     {
        ... some widgets do both. For instance, if a GtkLabel is
        rotated to 90 degrees it will return the minimum and
        natural height for the rotated label here.
     }
}

And in get_preferred_width_for_height it will simply return the minimum and natural width: 

static void
foo_widget_get_preferred_width_for_height (GtkWidget *widget,
                                           gint for_height,
                                           gint *min_width,
                                           gint *nat_width)
{
   if (i_am_in_height_for_width_mode)
     {
       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
                                                           min_width,
                                                           nat_width);
     }
   else
     {
        ... again if a widget is sometimes operating in
        width-for-height mode (like a rotated GtkLabel) it can go
        ahead and do its real width for height calculation here.
     }
}

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 this:

GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget,
                                                   &min,
                                                   &natural);

It will not work to use the wrapper functions, such as get_preferred_width inside your own size request implementation. These return a request adjusted by SizeGroup and by the adjust_size_request virtual method. 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 of a container, you must use the wrapper APIs. Otherwise, you would not properly consider widget margins, SizeGroup, and so forth.

Since 3.10 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 container 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 done by the get_preferred_height_and_baseline_for_width virtual function. It allows you to report a baseline in combination with the minimum and natural height. If there is no baseline you can return -1 to indicate this. The default implementation of this virtual function calls into the get_preferred_height and get_preferred_height_for_width, so if baselines are not supported it doesn’t need to be implemented.

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.

Style Properties

Widget introduces “style properties” - these are basically object properties that are stored not on the object, but in the style object associated to the widget. Style properties are set in resource files. This mechanism is used for configuring such things as the location of the scrollbar arrows through the theme, giving theme authors more control over the look of applications without the need to write a theme engine in C.

Use install_style_property to install style properties for a widget class, find_style_property or list_style_properties to get information about existing style properties and style_get_property, style_get or style_get_valist to obtain the value of a style property.

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>

In addition to accelerators, GtkWidget also support a custom `<accessible>` element, which supports actions and relations. Properties on the accessible implementation of an object can be set by accessing the internal child “accessible” of a Widget.

An example of a UI definition fragment specifying an accessible:

<object class="GtkLabel" id="label1"/>
  <property name="label">I am a Label for a Button</property>
</object>
<object class="GtkButton" id="button1">
  <accessibility>
    <action action_name="click" translatable="yes">Click the button.</action>
    <relation target="label1" type="labelled-by"/>
  </accessibility>
  <child internal-child="accessible">
    <object class="AtkObject" id="a11y-button1">
      <property name="accessible-name">Clickable Button</property>
    </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">GTK_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:

Namespace: Gtk
Package: gtk+-3.0

Content:

Properties:

Static methods:

Creation methods:

  • public Widget (...)
    This is a convenience function for creating a widget and setting its properties in one go.

Methods:

Signals:

  • public signal void accel_closures_changed ()
  • public virtual signal bool button_press_event (EventButton event)
    The button_press_event signal will be emitted when a button (typically from a mouse) is pressed.
  • public virtual signal bool button_release_event (EventButton event)
    The button_release_event signal will be emitted when a button (typically from a mouse) is released.
  • public virtual signal bool can_activate_accel (uint signal_id)
    Determines whether an accelerator that activates the signal identified by signal_id can currently be activated.
  • public virtual signal void child_notify (ParamSpec child_property)
    The child_notify signal is emitted for each child property that has changed on an object.
  • public virtual signal void composited_changed ()
    The composited_changed signal is emitted when the composited status of widgets screen changes.
  • public virtual signal bool configure_event (EventConfigure event)
    The configure_event signal will be emitted when the size, position or stacking of the widget's window has changed.
  • public virtual signal bool damage_event (EventExpose event)
    Emitted when a redirected window belonging to widget gets drawn into.
  • public virtual signal bool delete_event (EventAny event)
    The delete_event signal is emitted if a user requests that a toplevel window is closed.
  • public virtual signal void destroy ()
    Signals that all holders of a reference to the widget should release the reference that they hold.
  • public virtual signal bool destroy_event (EventAny event)
    The destroy_event signal is emitted when a Window is destroyed.
  • 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 drag_begin (DragContext context)
    The drag_begin signal is emitted on the drag source when a drag is started.
  • public virtual signal void drag_data_delete (DragContext context)
    The drag_data_delete signal is emitted on the drag source when a drag with the action gdk_action_move is successfully completed.
  • public virtual signal void drag_data_get (DragContext context, SelectionData selection_data, uint info, uint time_)
    The drag_data_get signal is emitted on the drag source when the drop site requests the data which is dragged.
  • public virtual signal void drag_data_received (DragContext context, int x, int y, SelectionData selection_data, uint info, uint time_)
    The drag_data_received signal is emitted on the drop site when the dragged data has been received.
  • public virtual signal bool drag_drop (DragContext context, int x, int y, uint time_)
    The drag_drop signal is emitted on the drop site when the user drops the data onto the widget.
  • public virtual signal void drag_end (DragContext context)
    The drag_end signal is emitted on the drag source when a drag is finished.
  • public virtual signal bool drag_failed (DragContext context, DragResult result)
    The drag_failed signal is emitted on the drag source when a drag has failed.
  • public virtual signal void drag_leave (DragContext context, uint time_)
    The drag_leave signal is emitted on the drop site when the cursor leaves the widget.
  • public virtual signal bool drag_motion (DragContext context, int x, int y, uint time_)
    The drag_motion signal is emitted on the drop site when the user moves the cursor over the widget during a drag.
  • public virtual signal bool draw (Context cr)
    This signal is emitted when a widget is supposed to render itself.
  • public virtual signal bool enter_notify_event (EventCrossing event)
    The enter_notify_event will be emitted when the pointer enters the widget's window.
  • public virtual signal bool event (Event event)
    The GTK+ main loop will emit three signals for each GDK event delivered to a widget: one generic event signal, another, more specific, signal that matches the type of event delivered (e.
  • public signal void event_after (Event event)
    After the emission of the event signal and (optionally) the second more specific signal, event_after will be emitted regardless of the previous two signals handlers return values.
  • public virtual signal bool focus (DirectionType direction)
  • public virtual signal bool focus_in_event (EventFocus event)
    The focus_in_event signal will be emitted when the keyboard focus enters the widget's window.
  • public virtual signal bool focus_out_event (EventFocus event)
    The focus_out_event signal will be emitted when the keyboard focus leaves the widget's window.
  • public virtual signal bool grab_broken_event (EventGrabBroken event)
    Emitted when a pointer or keyboard grab on a window belonging to widget gets broken.
  • public virtual signal void grab_focus ()
    Causes this to have the keyboard focus for the Window it's inside.
  • public virtual signal void grab_notify (bool was_grabbed)
    The grab_notify signal is emitted when a widget becomes shadowed by a GTK+ grab (not a pointer or keyboard grab) on another widget, or when it becomes unshadowed due to a grab being removed.
  • public virtual signal void hide ()
    The hide signal is emitted when widget is hidden, for example with hide.
  • public virtual signal void hierarchy_changed (Widget? previous_toplevel)
    The hierarchy_changed signal is emitted when the anchored state of a widget changes.
  • public virtual signal bool key_press_event (EventKey event)
    The key_press_event signal is emitted when a key is pressed.
  • public virtual signal bool key_release_event (EventKey event)
    The key_release_event signal is emitted when a key is released.
  • public virtual signal bool keynav_failed (DirectionType direction)
    Gets emitted if keyboard navigation fails.
  • public virtual signal bool leave_notify_event (EventCrossing event)
    The leave_notify_event will be emitted when the pointer leaves the widget's window.
  • 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 map_event (EventAny event)
    The map_event signal will be emitted when the widget's window is mapped.
  • 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 bool motion_notify_event (EventMotion event)
    The motion_notify_event signal is emitted when the pointer moves over the widget's Window.
  • public virtual signal void move_focus (DirectionType direction)
  • public virtual signal void parent_set (Widget? previous_parent)
    The parent_set signal is emitted when a new parent has been set on a widget.
  • public virtual signal bool popup_menu ()
    This signal gets emitted whenever a widget should pop up a context menu.
  • public virtual signal bool property_notify_event (EventProperty event)
    The property_notify_event signal will be emitted when a property on the widget's window has been changed or deleted.
  • public virtual signal bool proximity_in_event (EventProximity event)
    To receive this signal the Window associated to the widget needs to enable the PROXIMITY_IN_MASK mask.
  • public virtual signal bool proximity_out_event (EventProximity event)
    To receive this signal the Window associated to the widget needs to enable the PROXIMITY_OUT_MASK mask.
  • 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 Window, 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 screen_changed (Screen? previous_screen)
    The screen_changed signal gets emitted when the screen of a widget has changed.
  • public virtual signal bool scroll_event (EventScroll event)
    The scroll_event signal is emitted when a button in the 4 to 7 range is pressed.
  • public virtual signal bool selection_clear_event (EventSelection event)
    The selection_clear_event signal will be emitted when the the widget's window has lost ownership of a selection.
  • public virtual signal void selection_get (SelectionData selection_data, uint info, uint time_)
  • public virtual signal bool selection_notify_event (EventSelection event)
  • public virtual signal void selection_received (SelectionData selection_data, uint time_)
  • public virtual signal bool selection_request_event (EventSelection event)
    The selection_request_event signal will be emitted when another client requests ownership of the selection owned by the widget's window.
  • public virtual signal void show ()
    The show signal is emitted when widget is shown, for example with show.
  • public virtual signal bool show_help (WidgetHelpType help_type)
  • public virtual signal void size_allocate (Allocation allocation)
  • public virtual signal void state_changed (StateType previous_state)
    The state_changed signal is emitted when the widget state changes.
  • 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 style_set (Style? previous_style)
    The style_set signal is emitted when a new style has been set on a widget.
  • public virtual signal void style_updated ()
    The style_updated signal is a convenience signal that is emitted when the changed signal is emitted on the widget 's associated StyleContext as returned by get_style_context.
  • public virtual signal bool touch_event (Event event)
  • 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 bool unmap_event (EventAny event)
    The unmap_event signal will be emitted when the widget's window is unmapped.
  • public virtual signal void unrealize ()
    The unrealize signal is emitted when the Window 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).
  • public virtual signal bool visibility_notify_event (EventVisibility event)
    The visibility_notify_event will be emitted when the widget's window is obscured or unobscured.
  • public virtual signal bool window_state_event (EventWindowState event)
    The window_state_event will be emitted when the state of the toplevel window associated to the widget changes.

Inherited Members:

All known members inherited from class GLib.Object
All known members inherited from interface Atk.Implementor
All known members inherited from interface Gtk.Buildable