Package: gtk

Class gtk-widget

Superclasses

g-initially-unowned, gtk-buildable, g-object, common-lisp:standard-object, common-lisp:t

Documented Subclasses

Direct Slots

app-paintable
The app-paintable property of type :boolean (Read / Write)
Whether the application will paint directly on the widget.
Default value: nil
can-default
The can-default property of type :boolean (Read / Write)
Whether the widget can be the default widget.
Default value: nil
can-focus
The can-focus property of type :boolean (Read / Write)
Whether the widget can accept the input focus.
Default value: nil
composite-child
The composite-child property of type :boolean (Read)
Whether the widget is part of a composite widget.
Default value: nil
double-buffered
The double-buffered property of type :boolean (Read / Write)
Whether the widget is double buffered.
Warning: The double-buffered property has been deprecated since version 3.14 and should not be used in newly-written code. Widgets should not use this property.
Default value: true
Since 2.18
events
The events property of type gdk-event-mask (Read / Write)
The event mask that decides what kind of gdk-event this widget gets.
Default value: :structure-mask
expand
The expand property of type :boolean (Read / Write)
Whether to expand in both directions. Setting expand sets both properties hexpand and vexpand.
Default value: nil
Since 3.0
halign
The halign property of type gtk-align (Read / Write)
How to distribute horizontal space if widget gets extra space.
Default value: :fill
Since 3.0
has-default
The has-default property of type :boolean (Read / Write)
Whether the widget is the default widget.
Default value: nil
has-focus
The has-focus property of type :boolean (Read / Write)
Whether the widget has the input focus.
Default value: nil
has-tooltip
The has-tooltip property of type :boolean (Read / Write)
Enables or disables the emission of the "query-tooltip" signal on a widget. A value of true indicates that the widget can have a tooltip, in this case the widget will be queried using the "query-tooltip" signal 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 gdk-window instances of this widget to include "leave-notify" and "motion-notify" events. This cannot and will not be undone when the property is set to nil again.
Default value: nil
Since 2.12
height-request
The height-request property of type :int (Read / Write)
Override for height request of the widget, or -1 if natural request should be used.
Allowed values: >= -1
Default value: -1
hexpand
The hexpand property of type :boolean (Read / Write)
Whether to expand horizontally. See the function gtk-widget-hexpand.
Default value: nil
Since 3.0
hexpand-set
The hexpand-set property of type :boolean (Read / Write)
Whether to use the hexpand property. See the function gtk-widget-hexpand-set.
Default value: nil
Since 3.0
is-focus
The is-focus property of type :boolean (Read / Write)
Whether the widget is the focus widget within the toplevel.
Default value: nil
margin
The margin property of type :int (Read / Write)
Sets all four sides' margin at once. If read, returns max margin on any side.
Allowed values: [0,32767]
Default value: 0
Since 3.0
margin-bottom
The margin-bottom property of type :int (Read / Write)
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 the function gtk-widget-size-request for example.
Allowed values: [0,32767]
Default value: 0
Since 3.0
margin-end
The margin-end property of type :int (Read / Write)
Margin on end of widget, horizontally. This property supports left-to-right 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 gkt-widget-size-request for example.
Allowed values: [0,32767]
Default value: 0
Since 3.12
margin-left
The margin-left property of type :int (Read / Write)
Margin on left 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 the function gtk-widget-size-request for example.
Warning: The margin-left property has been deprecated since version 3.12 and should not be used in newly-written code. Use the margin-start property instead.
Allowed values: [0,32767]
Default value: 0
Since 3.0
margin-right
The margin-right property of type :int (Read / Write)
Margin on right 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 the function gtk-widget-size-request for example.
Warning: The margin-right property has been deprecated since version 3.12 and should not be used in newly-written code. Use the margin-end property instead.
Allowed values: [0,32767]
Default value: 0
Since 3.0
margin-start
The margin-start property of type :int (Read / Write)
Margin on start of the 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 gtk-widget-size-request for example.
Allowed values: [0,32767]
Default value: 0
Since 3.12
margin-top
The margin-top property of type :int (Read / Write)
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 the function gtk-widget-size-request for example.
Allowed values: [0,32767]
Default value: 0
Since 3.0
name
The name property of type :string (Read / Write)
The name of the widget.
Default value: nil
no-show-all
The no-show-all property of type :boolean (Read / Write)
Whether the function gtk-widget-show-all should not affect this widget.
Default value: nil
opacity
The opacity property of type :double (Read / Write)
The requested opacity of the widget. See the function gtk-widget-opacity for more details about window opacity. Before version 3.8 this was only available in gtk-window.
Allowed values: [0,1]
Default value: 1
Since 3.8
parent
The parent property of type gtk-container (Read / Write)
The parent widget of this widget. Must be a gtk-container widget.
receives-default
The receives-default property of type :boolean (Read / Write)
If true, the widget will receive the default action when it is focused.
Default value: nil
scale-factor
The scale-factor property of type :int (Read)
The scale factor of the widget. See the function gtk-widget-scale-factor for more details about widget scaling.
Allowed values: >= 1
Default value: 1
Since 3.10
sensitive
The sensitive property of type :boolean (Read / Write)
Whether the widget responds to input.
Default value: true
style
The style property of type gtk-style (Read / Write)
The style of the widget, which contains information about how it will look (colors etc).
tooltip-markup
The tooltip-markup property of type :string (Read / Write)
Sets the text of tooltip to be the given string, which is marked up with the Pango text markup language. Also see the function gtk-tooltip-set-markup. This is a convenience property which will take care of getting the tooltip shown if the given string is not nil. The has-tooltip property will automatically be set to true and there will be taken care of the "query-tooltip" signal in the default signal handler.
Default value: nil
Since 2.12
tooltip-text
The tooltip-text property of type :string (Read / Write)
Sets the text of tooltip to be the given string. Also see the function gtk-tooltip-set-text. This is a convenience property which will take care of getting the tooltip shown if the given string is not nil. The has-tooltip property will automatically be set to true and there will be taken care of the "query-tooltip" signal in the default signal handler.
Default value: nil
Since 2.12
valign
The valign property of type gtk-align (Read / Write)
How to distribute vertical space if widget gets extra space.
Default value: :fill
Since 3.0
vexpand
The vexpand property of type :boolean (Read / Write)
Whether to expand vertically. See the function gtk-widget-vexpand.
Default value: nil
Since 3.0
vexpand-set
The vexpand-set property of type :boolean (Read / Write)
Whether to use the vexpand property. See the function gtk-widget-vexpand-set.
Default value: nil
Since 3.0
visible
The visible property of type :boolean (Read / Write)
Whether the widget is visible.
Default value: nil
width-request
The width-request property of type :int (Read / Write)
Override for width request of the widget, or -1 if natural request should be used.
Allowed values: >= -1
Default value: -1
window
The window property of type gdk-window (Read)
The widget's window if it is realized, nil otherwise.
Since 2.14

Details

gtk-widget 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 six virtual methods:
 GtkWidgetClass.get_request_mode()
 GtkWidgetClass.get_preferred_width()
 GtkWidgetClass.get_preferred_height()
 GtkWidgetClass.get_preferred_height_for_width()
 GtkWidgetClass.get_preferred_width_for_height()
 GtkWidgetClass.get_preferred_height_and_baseline_for_width()    
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 gtk-size-request-mode chosen by the toplevel.

For example, when queried in the normal :height-for-width mode: First, the default minimum and natural width for each widget in the interface will be computed using the function gtk-widget-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 the function gtk-widget-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 the function gtk-window-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 the function gtk-window-default-size. During the recursive allocation process it is 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 gtk-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, gtk-widget caches a small number of results to avoid re-querying for the same sizes in one allocation cycle.

See gtk-container'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 gtk-size-request-mode's even if the widget in question only trades sizes in a single orientation.

For instance, a gtk-label that does height-for-width word wrapping will not expect to have GtkWidgetClass.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 :height-for-width widget generally deals with width-for-height requests, for GtkWidgetClass.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;

GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, &min_width, NULL); 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 GtkWidgetClass.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:

Example: Widget calling its own size request method.
 GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget),
                               &min, &natural);    
It will not work to use the wrapper functions, such as the function gtk-widget-get-preferred-width inside your own size request implementation. These return a request adjusted by gtk-size-group and by the GtkWidgetClass.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, gtk-size-group, 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 :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 GtkWidgetClass.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 GtkWidgetClass.get_preferred_height() and GtkWidgetClass.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 :fill, but the selected baseline can be found via gtk-widget-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
gtk-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 the function gtk-widget-class-install-style-property to install style properties for a widget class, the functions gtk-widget-class-find-style-property or gtk-widget-class-list-style-properties to get information about existing style properties and the functions gtk-widget-style-get-property or gtk-widget-style-get to obtain the value of a style property.

GtkWidget as GtkBuildable
The gtk-widget implementation of the gtk-buildable interface supports a custom <accelerator> element, which has attributes named key, modifiers and signal and allows to specify accelerators.

Example: A UI definition fragment specifying an accelerator
 <object class="GtkButton">
   <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/>
 </object>    
In addition to accelerators, gtk-widget 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 gtk-widget.

Example: A UI definition fragment specifying an accessible
 <object class="GtkButton" 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="AtkObject::name">Clickable Button</property>
     </object>
   </child>
 </object>    
Finally, gtk-widget allows style information such as style classes to be associated with widgets, using the custom <style> element:

Example: A UI definition fragment specifying an style class
 <object class="GtkButton" id="button1">
   <style>
     <class name="my-special-button-class"/>
     <class name="dark-button"/>
   </style>
 </object>    


Building composite widgets from template XML
gtk-widget exposes some facilities to automate the proceedure of creating composite widgets using the gtk-builder interface description language.

To create composite widgets with gtk-builder XML, one must associate the interface description with the widget class at class initialization time using the function gtk-widget-class-set-template.

The interface description semantics expected in composite template descriptions is slightly different from regulare gtk-builder XML.

Unlike regular interface descriptions, gtk-widget-class-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 gtk-builder 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 auxilary objects which might be referenced by other widgets declared as children of the <template> tag.

Example: A btk-builder 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>
      </object>
    </child>
    <child>
      <object class="GtkButton" id="goodbye_button">
        <property name="label">Goodbye World</property>
      </object>
    </child>
  </template>
</interface>      

Style Property Details

The "cursor-aspect-ratio" style property
"cursor-aspect-ratio" of type :float (Read)
Aspect ratio with which to draw insertion cursor.
Allowed values: [0,1]
Default value: 0.04

The "cursor-color" style property
"cursor-color" of type gdk-color (Read )
Color with which to draw insertion cursor.

The "focus-line-pattern" style property
"focus-line-pattern" of type :string (Read)
Dash pattern used to draw the focus indicator.
Warning: The "focus-line-pattern" style property has been deprecated since version 3.14 and should not be used in newly-written code. Use the outline-style CSS property instead.
Default value: "001001"

The "focus-line-width" style property
"focus-line-width" of type :int (Read)
Width, in pixels, of the focus indicator line.
Warning: The "focus-line-width" style property has been deprecated since version 3.14 and should not be used in newly-written code. Use the outline-width CSS property instead.
Allowed values: >= 0
Default value: 1

The "focus-padding" style property
"focus-padding" of type :int (Read)
Width, in pixels, between focus indicator and the widget 'box'.
Warning: The "focus-padding" style property has been deprecated since version 3.14 and should not be used in newly-written code. Use the padding CSS property instead.
Allowed values: >= 0
Default value: 1

The "interior-focus" style property
"interior-focus" of type :boolean (Read)
Whether to draw the focus indicator inside widgets.
Warning: The "interior-focus" style property has been deprecated since version 3.14 and should not be used in newly-written code. Use the outline CSS property instead.
Default value: true

The "link-color" style property
"link-color" of type gdk-color (Read)
The "link-color" style property defines the color of unvisited links.
Warning: The "link-color" style property has been deprecated since version 3.12 and should not be used in newly-written code. Links now use a separate state flags for selecting different theming, this style property is ignored.
Since 2.10

The "scroll-arrow-hlength" style property
"scroll-arrow-hlength" of type :int (Read)
The "scroll-arrow-hlength" style property defines the length of horizontal scroll arrows.
Allowed values: >= 1
Default value: 16
Since 2.10

The "scroll-arrow-vlength" style property
"scroll-arrow-vlength" of type :int (Read)
The "scroll-arrow-vlength" style property defines the length of vertical scroll arrows.
Allowed values: >= 1
Default value: 16
Since 2.10

The "secondary-cursor-color" style property
"secondary-cursor-color" of type gdk-color (Read)
Color with which to draw the secondary insertion cursor when editing mixed right-to-left and left-to-right text.

The "separator-height" style property
"separator-height" of type :int (Read)
The "separator-height" style property defines the height of separators. This property only takes effect if the "wide-separators" style property is true.
Allowed values: >= 0
Default value: 0
Since 2.10

The "separator-width" style property
"separator-width" of type :int (Read)
The "separator-width" style property defines the width of separators. This property only takes effect if the "wide-separators" style property is true.
Allowed values: >= 0
Default value: 0
Since 2.10

The "text-handle-height" style property
"text-handle-height" of type :int (Read)
Height of text selection handles.
Allowed values: >= 1
Default value: 20

The "text-handle-width" style property
"text-handle-width" of type :int (Read)
Width of text selection handles.
Allowed values: >= 1
Default value: 16

The "visited-link-color" style property
"visited-link-color" of type gdk-color (Read)
The "visited-link-color" style property defines the color of visited links.
Warning: The "visited-link-color" style property has been deprecated since version 3.12 and should not be used in newly-written code. Links now use a separate state flags for selecting different theming, this style property is ignored.
Since 2.10

The "wide-separators" style property
"wide-separators" of type :boolean (Read)
The "wide-separators" style property defines whether separators have configurable width and should be drawn using a box instead of a line.
Default value: nil
Since 2.10

The "window-dragging" style property
"window-dragging" of type :boolean (Read)
Whether windows can be dragged by clicking on empty areas.
Default value: nil

Signal Details

The "accel-closures-changed" signal
 lambda (widget)      
widget
The gtk-widget object which received the signal.
The "button-press-event" signal
 lambda (widget event)   : Run Last      
The "button-press-event" signal will be emitted when a button typically from a mouse is pressed. To receive this signal, the gdk-window associated to the widget needs to enable the :button-press-mask mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The gtk-widget object which received the signal.
event
The gdk-event-button which triggered this signal.
Returns
True to stop other handlers from being invoked for the event, nil to propagate the event further.
The "button-release-event" signal
 lambda (widget event)   : Run Last      
The "button-release-event" signal will be emitted when a button typically from a mouse is released. To receive this signal, the gdk-window associated to the widget needs to enable the :button-realease-mask mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The gtk-widget object which received the signal.
event
The gdk-event-button which triggered this signal.
Returns
True to stop other handlers from being invoked for the event, nil to propagate the event further.
The "can-activate-accel" signal
 lambda (widget signal-id)   : Run Last      
Determines whether an accelerator that activates the signal identified by signal-id can currently be activated. This signal is present to allow applications and derived widgets to override the default gtk-widget handling for determining whether an accelerator can be activated.
widget
The gtk-widget object which received the signal.
signal-id
The ID of a signal installed on widget.
Returns
True if the signal can be activated.
The "child-notify" signal
 lambda (widget pspec)   : No Hooks      
The "child-notify" signal is emitted for each child property that has changed on an object. The signal's detail holds the property name.
widget
The gtk-widget object which received the signal.
pspec
The g-param-spec of the changed child property.
The "composited-changed" signal
 lambda (widget)   : Action      
The "composited-changed" signal is emitted when the composited status of widgets screen changes. See the function gdk-screen-is-composited.
widget
The gtk-widget object on which the signal is emitted.
The "configure-event" signal
 lambda (widget event)   : Run Last      
The "configure-event" signal will be emitted when the size, position or stacking of the widget's window has changed. To receive this signal, the gdk-window associated to the widget needs to enable the :structure-mask mask of type gdk-event-mask. GDK will enable this mask automatically for all new windows.
widget
The gtk-widget object which received the signal.
event
The gdk-event-configure which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "damage-event" signal
 lambda (widget event)   : Run Last      
Emitted when a redirected window belonging to widget gets drawn into. The region/area members of the event shows what area of the redirected drawable was drawn into.
widget
The object which received the signal.
event
The gdk-event-expose event.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
Since 2.14

The "delete-event" signal
 lambda (widget event)   : Run Last      
The "delete-event" signal is emitted if a user requests that a toplevel window is closed. The default handler for this signal destroys the window. Connecting the function gtk-widget-hide-on-delete to this signal will cause the window to be hidden instead, so that it can later be shown again without reconstructing it.
widget
The object which received the signal.
event
The event which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "destroy" signal
 lambda (widget)   :No Hooks      
Signals that all holders of a reference to the widget should release the reference that they hold. May result in finalization of the widget if all references are released.
widget
The object which received the signal.
The "destroy-event" signal
 lambda (widget event)   : Run Last      
The "destroy-event" signal is emitted when a gdk-window window is destroyed. You rarely get this signal, because most widgets disconnect themselves from their window before they destroy it, so no widget owns the window at destroy time. To receive this signal, the gdk-window window associated to the widget needs to enable the :structure-mask mask of type gdk-event-mask. GDK will enable this mask automatically for all new windows.
widget
The object which received the signal.
event
The event which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "direction-changed" signal
 lambda (widget previous-direction)   : Run First      
The "direction-changed" signal is emitted when the text direction of a widget changes.
widget
The object on which the signal is emitted.
previous-direction
The previous text direction of widget.
The "drag-begin" signal
 lambda (widget drag-context)   : Run Last      
The "drag-begin" signal is emitted on the drag source when a drag is started. A typical reason to connect to this signal is to set up a custom drag icon with e. g. the function gtk-drag-source-set-icon-pixbuf. Note that some widgets set up a drag icon in the default handler of this signal, so you may have to use the function g-signal-connect-after to override what the default handler did.
widget
The object which received the signal.
drag-context
The drag context of type gdk-drag-context.
The "drag-data-delete" signal
 lambda (widget drag-context)   : Run Last      
The "drag-data-delete" signal is emitted on the drag source when a drag with the action :move of the type gdk-drag-action is successfully completed. The signal handler is responsible for deleting the data that has been dropped. What "delete" means depends on the context of the drag operation.
widget
The object which received the signal.
drag-context
The drag context of type gdk-drag-context.
The "drag-data-get" signal
 lambda (widget drag-context data info time)   : Run Last      
The "drag-data-get" signal is emitted on the drag source when the drop site requests the data which is dragged. It is the responsibility of the signal handler to fill data with the data in the format which is indicated by info. See the functions gtk-selection-data-set and gtk-selection-data-set-text.
widget
The object which received the signal.
drag-context
The drag context of type gdk-drag-context.
data
The gtk-selection-data to be filled with the dragged data
info
The info that has been registered with the target in the gtk-target-list.
time
The timestamp at which the data was requested.
The "drag-data-received" signal
 lambda (widget drag-context x y data info time)   : Run Last      
The "drag-data-received" signal is emitted on the drop site when the dragged data has been received. If the data was received in order to determine whether the drop will be accepted, the handler is expected to call the function gdk-drag-status and not finish the drag. If the data was received in response to a "drag-drop" signal and this is the last target to be received, the handler for this signal is expected to process the received data and then call the function gtk-drag-finish, setting the success parameter depending on whether the data was processed successfully. The handler may inspect and modify drag_context->action before calling the function gtk-drag-finish, e. g. to implement :ask of type gdk-drag-action as shown in the following example:
 void
 drag_data_received (GtkWidget          *widget,
                     GdkDragContext     *drag_context,
                     gint                x,
                     gint                y,
                     GtkSelectionData   *data,
                     guint               info,
                     guint               time)
 {
   if ((data->length >= 0) && (data->format == 8))
     {
       if (drag_context->action == GDK_ACTION_ASK)
         {
           GtkWidget *dialog;
           gint response;
           dialog = gtk_message_dialog_new (NULL,
                                            GTK_DIALOG_MODAL |
                                            GTK_DIALOG_DESTROY_WITH_PARENT,
                                            GTK_MESSAGE_INFO,
                                            GTK_BUTTONS_YES_NO,
                                            "Move the data ?n");
           response = gtk_dialog_run (GTK_DIALOG (dialog));
           gtk_widget_destroy (dialog);

if (response == GTK_RESPONSE_YES) drag_context->action = GDK_ACTION_MOVE; else drag_context->action = GDK_ACTION_COPY; }

gtk_drag_finish (drag_context, TRUE, FALSE, time); return; }

gtk_drag_finish (drag_context, FALSE, FALSE, time); }
widget
The object which received the signal.
drag-context
The drag context of type gdk-drag-context.
x
Where the drop happened.
y
Where the drop happened.
data
The received data of type gtk-selection-data.
info
The info that has been registered with the target in the gtk-target-list.
time
The timestamp at which the data was received.
The "drag-drop" signal
 lambda (widget drag-context x y time)   : Run Last      
The "drag-drop" signal is emitted on the drop site when the user drops the data onto the widget. The signal handler must determine whether the cursor position is in a drop zone or not. If it is not in a drop zone, it returns nil and no further processing is necessary. Otherwise, the handler returns true. In this case, the handler must ensure that the function gtk-drag-finish is called to let the source know that the drop is done. The call to the function gtk-drag-finish can be done either directly or in a "drag-data-received" signal handler which gets triggered by calling the function gtk-drag-get-data to receive the data for one or more of the supported targets.
widget
The object which received the signal.
drag-context
The drag context of type gdk-drag-context.
x
The x coordinate of the current cursor position.
y
The y coordinate of the current cursor position.
time
The timestamp of the motion event.
Returns
Whether the cursor position is in a drop zone.
The "drag-end" signal
 lambda (widget drag-context)   : Run Last      
The "drag-end" signal is emitted on the drag source when a drag is finished. A typical reason to connect to this signal is to undo things done in the "drag-begin" signal handler.
widget
The object which received the signal.
drag-context
The drag context of type gdk-drag-context.
The "drag-failed" signal
 lambda (widget drag-context result)   : Run Last      
The "drag-failed" signal is emitted on the drag source when a drag has failed. The signal handler may hook custom code to handle a failed DND operation based on the type of error, it returns true if the failure has been already handled, not showing the default "drag operation failed" animation, otherwise it returns nil.
widget
The object which received the signal.
drag-context
The drag context of type gdk-drag-context.
result
The result of the drag operation.
Returns
True if the failed drag operation has been already handled.
Since 2.12

The "drag-leave" signal
 lambda (widget drag-context time)   : Run Last      
The "drag-leave signal" is emitted on the drop site when the cursor leaves the widget. A typical reason to connect to this signal is to undo things done in a "drag-motion" signal handler, e. g. undo highlighting with the function gtk-drag-unhighlight.
widget
The object which received the signal.
drag-context
The drag context of type gdk-drag-context.
time
The timestamp of the motion event.
The "drag-motion" signal
 lambda (widget drag-context x y time)   : Run Last      
The "drag-motion" signal is emitted on the drop site when the user moves the cursor over the widget during a drag. The signal handler must determine whether the cursor position is in a drop zone or not. If it is not in a drop zone, it returns nil and no further processing is necessary. Otherwise, the handler returns true. In this case, the handler is responsible for providing the necessary information for displaying feedback to the user, by calling the function gdk-drag-status.

If the decision whether the drop will be accepted or rejected cannot be made based solely on the cursor position and the type of the data, the handler may inspect the dragged data by calling the function gtk-drag-get-data and defer the gdk-drag-status call to the "drag-data-received" signal handler. Note that you cannot not pass :drop, :motion or :all of the gtk-dest-defaults enumeration to the function gtk-drag-dest-set when using the drag-motion signal that way.

Also note that there is no "drag-enter" signal. The drag receiver has to keep track of whether he has received any "drag-motion" signals since the last "drag-leave" signal and if not, treat the "drag-motion" signal as an "enter" signal. Upon an "enter", the handler will typically highlight the drop site with the function gtk-drag-highlight.
 static void
 drag_motion (GtkWidget *widget,
              GdkDragContext *context,
              gint x,
              gint y,
              guint time)
 {
   GdkAtom target;

PrivateData *private_data = GET_PRIVATE_DATA (widget);

if (!private_data->drag_highlight) { private_data->drag_highlight = 1; gtk_drag_highlight (widget); }

target = gtk_drag_dest_find_target (widget, context, NULL); if (target == GDK_NONE) gdk_drag_status (context, 0, time); else { private_data->pending_status = context->suggested_action; gtk_drag_get_data (widget, context, target, time); }

return TRUE; }

static void drag_data_received (GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *selection_data, guint info, guint time) { PrivateData *private_data = GET_PRIVATE_DATA (widget);

if (private_data->suggested_action) { private_data->suggested_action = 0;

/* We are getting this data due to a request in drag_motion, * rather than due to a request in drag_drop, so we are just * supposed to call gdk_drag_status (), not actually paste in * the data. */ str = gtk_selection_data_get_text (selection_data); if (!data_is_acceptable (str)) gdk_drag_status (context, 0, time); else gdk_drag_status (context, private_data->suggested_action, time); } else { /* accept the drop */ } }
widget
The object which received the signal.
drag-context
The drag context of type gdk-drag-context.
x
The x coordinate of the current cursor position.
y
The y coordinate of the current cursor position.
time
The timestamp of the motion event.
Returns
Whether the cursor position is in a drop zone.
The "draw" signal
 lambda (widget cr)   : Run Last      
This signal is emitted when a widget is supposed to render itself. The widget's top left corner must be painted at the origin of the passed in context and be sized to the values returned by the functions gtk-widget-get-allocated-width and gtk-widget-get-allocated-height. Signal handlers connected to this signal can modify the cairo context passed as cr in any way they like and do not need to restore it. The signal emission takes care of calling the functions cairo-save before and cairo-restore after invoking the handler.
widget
The object which received the signal.
cr
The cairo context of type cairo-context to draw to.
Since 3.0

The "enter-notify-event" signal
 lambda (widget event)   : Run Last      
The "enter-notify-event" will be emitted when the pointer enters the widget's window. To receive this signal, the gdk-window associated to the widget needs to enable the flag :enter-notify-mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The object which received the signal.
event
The gdk-event-crossing which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "event" signal
 lambda (widget event)   : Run Last      
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. g. the "key-press-event" signal, and finally a generic "event-after" signal.
widget
The object which received the signal.
event
The gdk-event which triggered this signal.
Returns
True to stop other handlers from being invoked for the event and to cancel the emission of the second specific "event" signal. Nil to propagate the event further and to allow the emission of the second signal. The "event-after" signal is emitted regardless of the return value.
The "event-after" signal
 lambda (widget event)      
After the emission of the "event" signal and optionally the second more specific signal, the signal "event-after" will be emitted regardless of the previous two signals handlers return values.
widget
The object which received the signal.
event
The gdk-event which triggered this signal.
The "focus" signal
 lambda (widget direction)   : Run Last      
widget
The object which received the signal.
direction
The direction of type gtk-direction-type.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "focus-in-event" signal
 lambda (widget event)   : Run Last      
The "focus-in-event" signal will be emitted when the keyboard focus enters the widget's window. To receive this signal, the gdk-window associated to the widget needs to enable the mask :focus-change-mask of type gdk-event-mask.
widget
The object which received the signal.
event
The gdk-event-focus which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "focus-out-event" signal
 lambda (widget event)   : Run Last      
The "focus-out-event" signal will be emitted when the keyboard focus leaves the widget's window. To receive this signal, the gdk-window associated to the widget needs to enable the mask :focus-change-mask of type gdk-event-mask.
widget
The object which received the signal.
event
The gdk-event-focus which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil topropagate the event further.
The "grab-broken-event" signal
 lambda (widget event)   : Run Last      
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.
widget
The object which received the signal.
event
The gdk-event-grab-broken event.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
Since 2.8

The "grab-focus" signal
 lambda (widget)   : Action      
widget
The object which received the signal.
The "grab-notify" signal
 lambda (widget was-grabbed)   : Run First      
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 the function gtk-grab-add when the topmost grab widget in the grab stack of its window group is not its ancestor.
widget
The object which received the signal.
was-grabbed
Nil if the widget becomes shadowed, true if it becomes unshadowed.
The "hide" signal
 lambda (widget)   : Run First      
The "hide" signal is emitted when widget is hidden, for example with the function gtk-widget-hide.
widget
The object which received the signal.
The "hierarchy-changed" signal
 lambda (widget previous-toplevel)   : Run Last      
The "hierarchy-changed" signal is emitted when the anchored state of a widget changes. A widget is anchored when its toplevel ancestor is a gtk-window. This signal is emitted when a widget changes from un-anchored to anchored or vice-versa.
widget
The object on which the signal is emitted.
previous-toplevel
The previous toplevel ancestor, or nil if the widget was previously unanchored.
The "key-press-event" signal
 lambda (widget event)   : Run Last      
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 gdk-window associated to the widget needs to enable the mask :key-press-mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The object which received the signal.
event
The gdk-event-key which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "key-release-event" signal
 lambda (widget event)   : Run Last      
The "key-release-event" signal is emitted when a key is released. To receive this signal, the gdk-window associated to the widget needs to enable the mask :key-release-mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The object which received the signal.
event
The gdk-event-key which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "keynav-failed" signal
 lambda (widget direction)   : Run Last      
Gets emitted if keyboard navigation fails. See the function gtk-widget-keynav-failed for details.
widget
The object which received the signal.
direction
The direction of type gtk-direction-type of movement.
Returns
True if stopping keyboard navigation is fine, nil if the emitting widget should try to handle the keyboard navigation attempt in its parent container(s).
Since 2.12

The "leave-notify-event" signal
 lambda (widget event)   : Run Last      
The "leave-notify-event" will be emitted when the pointer leaves the widget's window. To receive this signal, the gdk-window associated to the widget needs to enable the mask :leave-notify-mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The object which received the signal.
event
The gdk-event-crossing which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "map" signal
 lambda (widget)   : Run First      
The "map" signal is emitted when widget is going to be mapped, that is when the widget is visible (which is controlled with gtk-widget-visible) and all its parents up to the toplevel widget are also visible. Once the map has occurred, the "map-event" signal 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".
widget
The object which received the signal.
The "map-event" signal
 lambda (widget event)   : Run Last      
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 gdk-window associated to the widget needs to enable the mask :structure-mask of type gdk-event-mask. GDK will enable this mask automatically for all new windows.
widget
The object which received the signal.
event
The gdk-event which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "mnemonic-activate" signal
 lambda (widget arg)   : Run Last      
widget
The object which received the signal.
arg
No documentation.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "motion-notify-event" signal
 lambda (widget event)   : Run Last      
The "motion-notify-event" signal is emitted when the pointer moves over the widget's gdk-window. To receive this signal, the gdk-window associated to the widget needs to enable the :pointer-motion-mask mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The object which received the signal.
event
The gdk-event-motion which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "move-focus" signal
 lambda (widget direction)   : Action      
widget
The object which received the signal.
direction
The direction of type gtk-direction-type.
The "parent-set" signal
 lambda (widget old-parent)   : Run First      
The "parent-set" signal is emitted when a new parent has been set on a widget.
widget
The object on which the signal is emitted.
old-parent
The previous parent, or nil if the widget just got its initial parent.
The "popup-menu" signal
 lambda (widget)   : Action      
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 gtk-entry widget creates a menu with clipboard commands.
widget
The object which received the signal.
Returns
True if a menu was activated.
The "property-notify-event" signal
 lambda (widget event)   : Run Last      
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 gdk-window associated to the widget needs to enable the :property-change-mask mask of type gdk-event-mask.
widget
The object which received the signal.
event
The gdk-event-property which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "proximity-in-event" signal
 lambda (widget event)   : Run Last      
To receive this signal the gdk-window associated to the widget needs to enable the :proximity-in-mask mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The object which received the signal.
event
The gdk-event-proximity which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "proximity-out-event" signal
 lambda (widget event)   : Run Last      
To receive this signal the gdk-window associated to the widget needs to enable the :proximity-out-mask mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The object which received the signal.
event
The gdk-event-proximity which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "query-tooltip" signal
 lambda (widget x y keyboard-mode tooltip)   : Run Last     
Emitted when the has-tooltip property is true and the gtk-tooltip-timeout property of the gtk-settings class 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, nil 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.
widget
The object which received the signal.
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 trigged using the keyboard.
tooltip
A gtk-tooltip object.
Returns
True if tooltip should be shown right now, nil otherwise.
Since 2.12

The "realize" signal
 lambda (widget)   : Run First      
The "realize" signal is emitted when widget is associated with a gdk-window, which means that the function gtk-widget-realize has been called or the widget has been mapped (that is, it is going to be drawn).
widget
The object which received the signal.
The "screen-changed" signal
 lambda (widget previous-screen)   : Run Last      
The "screen-changed" signal gets emitted when the screen of a widget has changed.
widget
The object on which the signal is emitted.
previous-screen
The previous screen, or nil if the widget was not associated with a screen before.
The "scroll-event" signal
 lambda (widget event)   : Run Last      
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 gdk-window associated to the widget needs to enable the :button-press-mask mask of type gdk-event-mask. This signal will be sent to the grab widget if there is one.
widget
The object which received the signal.
event
The gdk-event-scroll which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "selection-clear-event" signal
 lambda (widget event)   : Run Last      
The "selection-clear-event" signal will be emitted when the the widget's window has lost ownership of a selection.
widget
The object which received the signal.
event
The gdk-event-selection which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "selection-get" signal
 lambda (widget data info time)   : Run Last      
widget
The object which received the signal.
data
The gtk-selection-data.
info
The info that has been registered with the target.
time
The timestamp at which the data was requested.
The "selection-notify-event" signal
 lambda (widget event)   : Run Last      
widget
The object which received the signal.
event
The gdk-event-selection.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "selection-received" signal
 lambda (widget data time)   : Run Last      
widget
The object which received the signal.
data
The gtk-selection-data.
time
A timestamp.
The "selection-request-event" signal
 lambda (widget event)   : Run Last      
The "selection-request-event" signal will be emitted when another client requests ownership of the selection owned by the widget's window.
widget
The object which received the signal.
event
The gdk-event-selection which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "show" signal
 lambda (widget)      
The "show" signal is emitted when widget is shown, for example with the function gtk-widget-show.
widget
The object which received the signal.
The "show-help" signal
 lambda (widget help-type)   : Action      
widget
The object which received the signal.
help-type
A value of the gtk-widget-help-type enumeration.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "size-allocate" signal
 lambda (widget allocation)   : Run First      
widget
The object which received the signal.
The "state-changed" signal
 lambda (widget state)   : Run First      
Warning: The "state-changed" signal is deprecated since version 3.0 and should not be used in newly-written code. Use the "state-flags-changed" signal instead.

The "state-changed" signal is emitted when the widget state changes.
widget
The object which received the signal.
state
The previous state.
The "state-flags-changed" signal
 lambda (widget flags)   : Run First      
The "state-flags-changed" signal is emitted when the widget state changes, see the function gtk-widget-get-state-flags.
widget
The object which received the signal.
flags
The previous state flags.
Since 3.0

The "style-set" signal
 lambda (widget previous-style)   : Run First      
Warning: The "style-set" signal has been deprecated since version 3.0 and should not be used in newly-written code. Use the "style-updated" signal.

The "style-set" signal is emitted when a new style has been set on a widget. Note that style-modifying functions like the function gtk-widget-modify-base also cause this signal to be emitted. Note that this signal is emitted for changes to the deprecated gtk-style. To track changes to the gtk-style-context associated with a widget, use the "style-updated" signal.
widget
The object on which the signal is emitted.
previous-style
The previous style, or nil if the widget just got its initial style.
The "style-updated" signal
 lambda (widget)   : Run First      
The "style-updated" signal is emitted when the gtk-style-context of a widget is changed. Note that style-modifying functions like gtk-widget-override-color also cause this signal to be emitted.
widget
The object on which the signal is emitted.
Since 3.0

The "touch-event" signal
 lambda (widget arg)   : Run Last      
widget
The object on which the signal is emitted.
arg
The "unmap" signal
 lambda (widget)   : Run First      
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.
widget
The object which received the signal.
The "unmap-event" signal
 lambda (widget event)   : Run Last      
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 gdk-window associated to the widget needs to enable the :structure-mask mask of type gdk-event-mask. GDK will enable this mask automatically for all new windows.
widget
The object which received the signal.
event
The gdk-event which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "unrealize" signal
 lambda (widget)   : Run Last      
The "unrealize" signal is emitted when the gdk-window associated with widget is destroyed, which means that the function gtk-widget-unrealize has been called or the widget has been unmapped (that is, it is going to be hidden).
widget
The object which received the signal.
The "visibility-notify-event" signal
 lambda (widget event)   : Run Last      
Warning: The "visibility-notify-event" signal has been deprecated since version 3.12 and should not be used in newly-written code. Modern composited windowing systems with pervasive transparency make it impossible to track the visibility of a window reliably, so this signal can not be guaranteed to provide useful information.

The "visibility-notify-event" will be emitted when the widget's window is obscured or unobscured. To receive this signal the gdk-window associated to the widget needs to enable the :visibility-notify-mask mask of type gdk-event-mask.
widget
The object which received the signal.
event
The gdk-event-visibility which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
The "window-state-event" signal
 lambda (widget event)   : Run Last      
The "window-state-event" signal will be emitted when the state of the toplevel window associated to the widget changes. To receive this signal the gdk-window associated to the widget needs to enable the :structure-mask mask of type gdk-event-mask. GDK will enable this mask automatically for all new windows.
widget
The object which received the signal.
event
The gdk-event-window-state which triggered this signal.
Returns
True to stop other handlers from being invoked for the event. Nil to propagate the event further.
 

Slot Access Functions

Inherited Slot Access Functions

See also

2015-12-29