### ----------------------------------------------------
### -- Gnome::Gtk3
### -- Licenses: Artistic-2.0
### -- Authors: Marcel Timmerman
### -- File: docs/content-docs/reference/Gtk3/Widget.md
### ----------------------------------------------------
### -- Chunk 4 of 4
. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventFocus): the event which triggered this signal.

### focus-out-event

The *focus-out-event* signal will be emitted when the keyboard focus leaves the *widget*'s window.

To receive this signal, the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-FOCUS-CHANGE-MASK` mask.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventFocus): the event which triggered this signal.

### grab-broken-event

Emitted when a pointer or keyboard grab on a window belonging to *widget* gets broken.

On X11, this happens when the grab window becomes unviewable (i.e. it or one of its ancestors is unmapped), or if the same application grabs the pointer or keyboard again.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventGrabBroken): the event event

### grab-focus

    method handler (
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

### grab-notify

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.

A widget is shadowed by a `gtk-grab-add()` when the topmost grab widget in the grab stack of its window group is not its ancestor.

    method handler (
      Int $was_grabbed,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $was_grabbed; `False` if the widget becomes shadowed, `True` if it becomes unshadowed

### hide

The *hide* signal is emitted when *widget* is hidden, for example with `hide()`.

    method handler (
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

### hierarchy-changed

The *hierarchy-changed* signal is emitted when the anchored state of a widget changes. A widget is “anchored” when its toplevel ancestor is a **Gnome::Gtk3::Window**. This signal is emitted when a widget changes from un-anchored to anchored or vice-versa.

    method handler (
      N-GObject $previous_toplevel,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object on which the signal is emitted

  * $_handle_id; the registered event handler id

  * $previous_toplevel; (allow-none): the previous toplevel ancestor, or `undefined` if the widget was previously unanchored

### key-press-event

The *key-press-event* signal is emitted when a key is pressed. The signal emission will reoccur at the key-repeat rate when the key is kept pressed.

To receive this signal, the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-KEY-PRESS-MASK` mask.

This signal will be sent to the grab widget if there is one.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventKey): the event which triggered this signal.

### key-release-event

The *key-release-event* signal is emitted when a key is released.

To receive this signal, the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-KEY-RELEASE-MASK` mask.

This signal will be sent to the grab widget if there is one.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventKey): the event which triggered this signal.

### keynav-failed

Gets emitted if keyboard navigation fails. See `keynav-failed()` for details.

Returns: `1` if stopping keyboard navigation is fine, `0` if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s).

    method handler (
      Int $direction,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $direction; the direction of movement, an enum GtkDirectionType value

### leave-notify-event

The *leave-notify-event* will be emitted when the pointer leaves the *widget*'s window.

To receive this signal, the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-LEAVE-NOTIFY-MASK` mask.

This signal will be sent to the grab widget if there is one.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventCrossing): the event which triggered this signal.

### 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. Once the map has occurred, *map-event* will be emitted.

The *map* signal can be used to determine whether a widget will be drawn, for instance it can resume an animation that was stopped during the emission of *unmap*.

    method handler (
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

### map-event

The *map-event* signal will be emitted when the *widget*'s window is mapped. A window is mapped when it becomes visible on the screen.

To receive this signal, the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-STRUCTURE-MASK` mask. GDK will enable this mask automatically for all new windows.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventAny): the event which triggered this signal.

### mnemonic-activate

The default handler for this signal activates *widget* if *group-cycling* is `False`, or just makes *widget* grab focus if *group-cycling* is `True`.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      Bool $group_cycling,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $group_cycling; `True` if there are other widgets with the same mnemonic

### motion-notify-event

The *motion-notify-event* signal is emitted when the pointer moves over the widget's **Gnome::Gtk3::Window**.

To receive this signal, the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-POINTER-MOTION-MASK` mask.

This signal will be sent to the grab widget if there is one.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventMotion): the event which triggered this signal.

### move-focus

    method handler (
      Unknown type GTK_TYPE_DIRECTION_TYPE $direction,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $direction;

### parent-set

The *parent-set* signal is emitted when a new parent has been set on a widget.

    method handler (
      N-GObject #`{ is widget } $old_parent,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object on which the signal is emitted

  * $_handle_id; the registered event handler id

  * $old_parent; (allow-none): the previous parent, or `undefined` if the widget just got its initial parent.

### popup-menu

This signal gets emitted whenever a widget should pop up a context menu. This usually happens through the standard key binding mechanism; by pressing a certain key while a widget is focused, the user can cause the widget to pop up a menu. For example, the **Gnome::Gtk3::Entry** widget creates a menu with clipboard commands. See the Popup Menu Migration Checklist for an example of how to use this signal.

Returns: `True` if a menu was activated

    method handler (
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

### property-notify-event

The *property-notify-event* signal will be emitted when a property on the *widget*'s window has been changed or deleted.

To receive this signal, the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-PROPERTY-CHANGE-MASK` mask.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventProperty): the event which triggered this signal.

### proximity-in-event

To receive this signal the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-PROXIMITY-IN-MASK` mask.

This signal will be sent to the grab widget if there is one.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      Unknown type GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventProximity): the event which triggered this signal.

### proximity-out-event

To receive this signal the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-PROXIMITY-OUT-MASK` mask.

This signal will be sent to the grab widget if there is one.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventProximity): the event which triggered this signal.

### query-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.

Using the given coordinates, the signal handler should determine whether a tooltip should be shown for *widget*. If this is the case `True` should be returned, `False` otherwise. Note that if *keyboard-mode* is `True`, the values of *x* and *y* are undefined and should not be used.

The signal handler is free to manipulate *tooltip* with the therefore destined function calls.

Returns: `True` if *tooltip* should be shown right now, `False` otherwise.

    method handler (
      Unknown type GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE $x,
      - $y,
      - $keyboard_mode,
      - $tooltip,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $x; the x coordinate of the cursor position where the request has been emitted, relative to *widget*'s left side

  * $y; the y coordinate of the cursor position where the request has been emitted, relative to *widget*'s top

  * $keyboard_mode; `True` if the tooltip was triggered using the keyboard

  * $tooltip; a **Gnome::Gtk3::Tooltip**

### realize

The *realize* signal is emitted when *widget* is associated with a **Gnome::Gtk3::Window**, which means that `realize()` has been called or the widget has been mapped (that is, it is going to be drawn).

    method handler (
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

### screen-changed

The *screen-changed* signal gets emitted when the screen of a widget has changed.

    method handler (
      - $previous_screen,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object on which the signal is emitted

  * $_handle_id; the registered event handler id

  * $previous_screen; (allow-none): the previous screen, or `undefined` if the widget was not associated with a screen before

### scroll-event

The *scroll-event* signal is emitted when a button in the 4 to 7 range is pressed. Wheel mice are usually configured to generate button press events for buttons 4 and 5 when the wheel is turned.

To receive this signal, the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK_SCROLL_MASK` mask.

This signal will be sent to the grab widget if there is one.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventScroll): the event which triggered this signal.

### selection-clear-event

The *selection-clear-event* signal will be emitted when the the *widget*'s window has lost ownership of a selection.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventSelection): the event which triggered this signal.

### selection-get

    method handler (
      N-GObject $data,
      UInt $info,
      UInt $time,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $data; a native GtkSelectionData object

  * $info; ?

  * $time;

### selection-notify-event

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventSelection): the event which triggered this signal.

### selection-received

    method handler (
      N-GObject $data,
      UInt $time,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $data; a native GtkSelectionData object

  * $time;

### selection-request-event

The *selection-request-event* signal will be emitted when another client requests ownership of the selection owned by the *widget*'s window.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventSelection): the event which triggered this signal.

### show

The *show* signal is emitted when *widget* is shown, for example with `show()`.

    method handler (
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

### show-help

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      - $help_type,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $help_type;

### size-allocate

    method handler (
      Unknown type GDK_TYPE_RECTANGLE | G_SIGNAL_TYPE_STATIC_SCOPE $allocation,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $allocation; (type Gtk.Allocation): the region which has been allocated to the widget.

### state-flags-changed

The *state-flags-changed* signal is emitted when the widget state changes, see `get-state-flags()`.

    method handler (
      Unknown type GTK_TYPE_STATE_FLAGS $flags,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

  * $flags; The previous state flags.

### style-updated

The *style-updated* signal is a convenience signal that is emitted when the *changed* signal is emitted on the *widget*'s associated **Gnome::Gtk3::StyleContext** as returned by `get-style-context()`.

Note that style-modifying functions like `override-color()` also cause this signal to be emitted.

    method handler (
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object on which the signal is emitted

  * $_handle_id; the registered event handler id

### 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.

As *unmap* indicates that a widget will not be shown any longer, it can be used to, for example, stop an animation on the widget.

    method handler (
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

### unmap-event

The *unmap-event* signal will be emitted when the *widget*'s window is unmapped. A window is unmapped when it becomes invisible on the screen.

To receive this signal, the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-STRUCTURE-MASK` mask. GDK will enable this mask automatically for all new windows.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventAny): the event which triggered this signal

### unrealize

The *unrealize* signal is emitted when the **Gnome::Gtk3::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).

    method handler (
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
    );

  * $widget; the object which received the signal.

  * $_handle_id; the registered event handler id

### window-state-event

The *window-state-event* will be emitted when the state of the toplevel window associated to the *widget* changes.

To receive this signal the **Gnome::Gtk3::Window** associated to the widget needs to enable the `GDK-STRUCTURE-MASK` mask. GDK will enable this mask automatically for all new windows.

Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

    method handler (
      N-GdkEvent $event,
      Int :$_handle_id,
      Gnome::GObject::Object :_widget($widget),
      *%user-options
      --> Int
    );

  * $widget; the object which received the signal

  * $_handle_id; the registered event handler id

  * $event; (type N-GdkEventWindowState): the event which triggered this signal.

Properties
==========

An example of using a string type property of a **Gnome::Gtk3::Label** object. This is just showing how to set/read a property, not that it is the best way to do it. This is because a) The class initialization often provides some options to set some of the properties and b) the classes provide many methods to modify just those properties. In the case below one can use `new(:label('my text label'))` or `set-text('my text label')`.

    my Gnome::Gtk3::Label $label .= new;
    my Gnome::GObject::Value $gv .= new(:init(G_TYPE_STRING));
    $label.get-property( 'label', $gv);
    $gv.set-string('my text label');

Supported properties
--------------------

### Application paintable: app-paintable

Whether the application will paint directly on the widget Default value: False

The **Gnome::GObject::Value** type of property *app-paintable* is `G_TYPE_BOOLEAN`.

### Can default: can-default

Whether the widget can be the default widget Default value: False

The **Gnome::GObject::Value** type of property *can-default* is `G_TYPE_BOOLEAN`.

### Can focus: can-focus

Whether the widget can accept the input focus Default value: False

The **Gnome::GObject::Value** type of property *can-focus* is `G_TYPE_BOOLEAN`.

### Composite child: composite-child

Whether the widget is part of a composite widget Default value: False

The **Gnome::GObject::Value** type of property *composite-child* is `G_TYPE_BOOLEAN`. Value is read only.

### Events: events

The event mask that decides what kind of GdkEvents this widget gets.

The **Gnome::GObject::Value** type of property *events* is `G_TYPE_FLAGS`.

### Expand Both: expand

Whether to expand in both directions. Setting this sets both *hexpand* and *vexpand*

The **Gnome::GObject::Value** type of property *expand* is `G_TYPE_BOOLEAN`.

### Focus on click: focus-on-click

Whether the widget should grab focus when it is clicked with the mouse.

This property is only relevant for widgets that can take focus.

Before 3.20, several widgets (GtkButton, GtkFileChooserButton, GtkComboBox) implemented this property individually.

The **Gnome::GObject::Value** type of property *focus-on-click* is `G_TYPE_BOOLEAN`.

### Horizontal Alignment: halign

How to distribute horizontal space if widget gets extra space, see **Gnome::Gtk3::Align**

The **Gnome::GObject::Value** type of property *halign* is `G_TYPE_ENUM`.

### Has default: has-default

Whether the widget is the default widget. Default value: False

The **Gnome::GObject::Value** type of property *has-default* is `G_TYPE_BOOLEAN`.

### Has focus: has-focus

Whether the widget has the input focus. Default value: False

The **Gnome::GObject::Value** type of property *has-focus* is `G_TYPE_BOOLEAN`.

### Has tooltip: has-tooltip

Enables or disables the emission of *query-tooltip* on *widget*. A value of `True` indicates that *widget* can have a tooltip, in this case the widget will be queried using *query-tooltip* to determine whether it will provide a tooltip or not.

Note that setting this property to `True` for the first time will change the event masks of the GdkWindows of this widget to include leave-notify and motion-notify events. This cannot and will not be undone when the property is set to `False` again.

The **Gnome::GObject::Value** type of property *has-tooltip* is `G_TYPE_BOOLEAN`.

### Height request: height-request

The **Gnome::GObject::Value** type of property *height-request* is `G_TYPE_INT`.

### Horizontal Expand: hexpand

Whether to expand horizontally. See `set-hexpand()`.

The **Gnome::GObject::Value** type of property *hexpand* is `G_TYPE_BOOLEAN`.

### Horizontal Expand Set: hexpand-set

Whether to use the *hexpand* property. See `get-hexpand-set()`.

The **Gnome::GObject::Value** type of property *hexpand-set* is `G_TYPE_BOOLEAN`.

### Is focus: is-focus

Whether the widget is the focus widget within the toplevel. Default value: False

The **Gnome::GObject::Value** type of property *is-focus* is `G_TYPE_BOOLEAN`.

### All Margins: margin

Sets all four sides' margin at once. If read, returns max margin on any side.

The **Gnome::GObject::Value** type of property *margin* is `G_TYPE_INT`.

### Margin on Bottom: margin-bottom

Margin on bottom side of widget.

This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from `set-size-request()` for example.

The **Gnome::GObject::Value** type of property *margin-bottom* is `G_TYPE_INT`.

### Margin on End: margin-end

Margin on end of widget, horizontally. This property supports left-to-right and right-to-left text directions.

This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from `set-size-request()` for example.

The **Gnome::GObject::Value** type of property *margin-end* is `G_TYPE_INT`.

### Margin on Start: margin-start

Margin on start of widget, horizontally. This property supports left-to-right and right-to-left text directions.

This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from `set-size-request()` for example.

The **Gnome::GObject::Value** type of property *margin-start* is `G_TYPE_INT`.

### Margin on Top: margin-top

Margin on top side of widget.

This property adds margin outside of the widget's normal size request, the margin will be added in addition to the size from `set-size-request()` for example.

The **Gnome::GObject::Value** type of property *margin-top* is `G_TYPE_INT`.

### Widget name: name

The name of the widget Default value: Any

The **Gnome::GObject::Value** type of property *name* is `G_TYPE_STRING`.

### No show all: no-show-all

Whether show-all should not affect this widget. Default value: False

The **Gnome::GObject::Value** type of property *no-show-all* is `G_TYPE_BOOLEAN`.

### Opacity for Widget: opacity

The requested opacity of the widget. See `set-opacity()` for more details about window opacity.

The **Gnome::GObject::Value** type of property *opacity* is `G_TYPE_DOUBLE`.

### Parent widget: parent

The parent widget of this widget. Must be a Container widget Widget type: GTK-TYPE-CONTAINER

The **Gnome::GObject::Value** type of property *parent* is `G_TYPE_OBJECT`.

### Receives default: receives-default

If TRUE, the widget will receive the default action when it is focused Default value: False

The **Gnome::GObject::Value** type of property *receives-default* is `G_TYPE_BOOLEAN`.

### Scale factor: scale-factor

The scale factor of the widget. See `get-scale-factor()` for more details about widget scaling.

The **Gnome::GObject::Value** type of property *scale-factor* is `G_TYPE_INT`.

### Sensitive: sensitive

Whether the widget responds to input Default value: True

The **Gnome::GObject::Value** type of property *sensitive* is `G_TYPE_BOOLEAN`.

### Tooltip markup: tooltip-markup

Sets the text of tooltip to be the given string, which is marked up with the [Pango text markup language][PangoMarkupFormat]. Also see `gtk-tooltip-set-markup()`.

This is a convenience property which will take care of getting the tooltip shown if the given string is not `undefined`: *has-tooltip* will automatically be set to `True` and there will be taken care of *query-tooltip* in the default signal handler.

Note that if both *tooltip-text* and *tooltip-markup* are set, the last one wins.

The **Gnome::GObject::Value** type of property *tooltip-markup* is `G_TYPE_STRING`.

### Tooltip Text: tooltip-text

Sets the text of tooltip to be the given string.

Also see `gtk-tooltip-set-text()`.

This is a convenience property which will take care of getting the tooltip shown if the given string is not `undefined`: *has-tooltip* will automatically be set to `True` and there will be taken care of *query-tooltip* in the default signal handler.

Note that if both *tooltip-text* and *tooltip-markup* are set, the last one wins.

The **Gnome::GObject::Value** type of property *tooltip-text* is `G_TYPE_STRING`.

### Vertical Alignment: valign

How to distribute vertical space if widget gets extra space, see **Gnome::Gtk3::Align**

Widget type: GTK_TYPE_ALIGN

The **Gnome::GObject::Value** type of property *valign* is `G_TYPE_ENUM`.

### Vertical Expand: vexpand

Whether to expand vertically. See `set-vexpand()`.

The **Gnome::GObject::Value** type of property *vexpand* is `G_TYPE_BOOLEAN`.

### Vertical Expand Set: vexpand-set

Whether to use the *vexpand* property. See `get-vexpand-set()`.

The **Gnome::GObject::Value** type of property *vexpand-set* is `G_TYPE_BOOLEAN`.

### Visible: visible

Whether the widget is visible Default value: False

The **Gnome::GObject::Value** type of property *visible* is `G_TYPE_BOOLEAN`.

### Width request: width-request

The **Gnome::GObject::Value** type of property *width-request* is `G_TYPE_INT`.

### Window: window

The widget's window if it is realized, `undefined` otherwise.

Widget type: GDK_TYPE_WINDOW

The **Gnome::GObject::Value** type of property *window* is `G_TYPE_OBJECT`.



