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 Buildable interface supports a custom elements to
specify various aspects of widgets that are not directly expressed as properties.
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="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:
<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:
<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
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);
}
- public void action_set_enabled (string action_name, bool enabled)
- 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 class uint get_activate_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 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 ()
- 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 ()
- 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 ()
- public unowned FontOptions? get_font_options ()
- 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 ()
- 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 ()
- public int get_margin_end ()
- public int get_margin_start ()
- public int get_margin_top ()
- 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 ()
- 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 ()
- 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 ()
- 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)
- public class void set_accessible_role (AccessibleRole accessible_role)
Sets the accessible role used by the given
Widget class.
- public class void set_activate_signal (uint signal_id)
Sets the GtkWidgetClass.activate_signal
field with the given
signal_id
; the signal will be emitted when calling activate.
- public class void set_activate_signal_from_name (string signal_name)
Sets the GtkWidgetClass.activate_signal
field with the signal
id for the given signal_name
; the signal will be emitted when calling
activate.
- 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)
- 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.