The signal to emit when a widget of this class is activated, gtk.widget.Widget.activate handles the emission. Implementation of this signal is optional.
Convert an initial size allocation assigned by a #GtkContainer using gtk.widget.Widget.sizeAllocate, into an actual size allocation to be used by the widget. adjust_size_allocation adjusts to a child widget’s actual allocation from what a parent container computed for the child. The adjusted allocation must be entirely within the original allocation. In any custom implementation, chain up to the default #GtkWidget implementation of this method, which applies the margin and alignment properties of #GtkWidget. Chain up before performing your own adjustments so your own adjustments remove more allocation after the #GtkWidget base class has already removed margin and alignment. The natural size passed in should be adjusted in the same way as the allocated size, which allows adjustments to perform alignments or other changes based on natural size.
Convert an initial size request from a widget's #GtkSizeRequestMode virtual method implementations into a size request to be used by parent containers in laying out the widget. adjust_size_request adjusts from a child widget's original request to what a parent container should use for layout. The @for_size argument will be -1 if the request should not be for a particular size in the opposing orientation, i.e. if the request is not height-for-width or width-for-height. If @for_size is greater than -1, it is the proposed allocation in the opposing orientation that we need the request for. Implementations of adjust_size_request should chain up to the default implementation, which applies #GtkWidget’s margin properties and imposes any values from gtk.widget.Widget.setSizeRequest. Chaining up should be last, after your subclass adjusts the request, so #GtkWidget can apply constraints and add the margin properly.
Signal will be emitted when a button (typically from a mouse) is pressed.
Signal will be emitted when a button (typically from a mouse) is released.
Signal allows applications and derived widgets to override the default GtkWidget handling for determining whether an accelerator can be activated.
Signal emitted for each child property that has changed on an object.
Signal emitted when the composited status of widgets screen changes. See gdk.screen.Screen.isComposited.
Computes whether a container should give this widget extra space when possible.
Signal will be emitted when the size, position or stacking of the widget’s window has changed.
Signal emitted when a redirected window belonging to widget gets drawn into.
Signal emitted if a user requests that a toplevel window is closed.
Signals that all holders of a reference to the widget should release the reference that they hold.
Signal is emitted when a #GdkWindow is destroyed.
Signal emitted when the text direction of a widget changes.
Seldomly overidden.
Signal emitted on the drag source when a drag is started.
Signal emitted on the drag source when a drag with the action gdk.types.DragAction.Move is successfully completed.
Signal emitted on the drag source when the drop site requests the data which is dragged.
Signal emitted on the drop site when the dragged data has been received.
Signal emitted on the drop site when the user drops the data onto the widget.
Signal emitted on the drag source when a drag is finished.
Signal emitted on the drag source when a drag has failed.
Signal emitted on the drop site when the cursor leaves the widget.
signal emitted on the drop site when the user moves the cursor over the widget during a drag.
Signal emitted when a widget is supposed to render itself.
Signal event will be emitted when the pointer enters the widget’s window.
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. "key-press-event") and finally a generic "event-after" signal.
Signal emitted when the keyboard focus enters the widget’s window.
Signal emitted when the keyboard focus leaves the widget’s window.
Returns the accessible object that describes the widget to an assistive technology.
This is called by containers to obtain the minimum and natural height of a widget. A widget that does not actually trade any height for width or width for height only has to implement these two virtual methods (#GtkWidgetClass.get_preferred_width() and #GtkWidgetClass.get_preferred_height()).
This is similar to #GtkWidgetClass.get_preferred_height() except that it is passed a contextual width to request height for. By implementing this virtual method it is possible for a #GtkLabel to tell its parent how much height would be required if the label were to be allocated a said width.
This is called by containers to obtain the minimum and natural width of a widget. A widget will never be allocated a width less than its minimum and will only ever be allocated a width greater than the natural width once all of the said widget’s siblings have received their natural widths. Furthermore, a widget will only ever be allocated a width greater than its natural width if it was configured to receive extra expand space from its parent container.
This is analogous to #GtkWidgetClass.get_preferred_height_for_width() except that it operates in the oposite orientation. It’s rare that a widget actually does gtk.types.SizeRequestMode.WidthForHeight requests but this can happen when, for example, a widget or container gets additional columns to compensate for a smaller allocated height.
This allows a widget to tell its parent container whether it prefers to be allocated in gtk.types.SizeRequestMode.HeightForWidth or gtk.types.SizeRequestMode.WidthForHeight mode. gtk.types.SizeRequestMode.HeightForWidth means the widget prefers to have #GtkWidgetClass.get_preferred_width() called and then #GtkWidgetClass.get_preferred_height_for_width(). gtk.types.SizeRequestMode.ConstantSize disables any height-for-width or width-for-height geometry management for a said widget and is the default return. It’s important to note (as described below) that any widget which trades height-for-width or width-for-height must respond properly to both of the virtual methods #GtkWidgetClass.get_preferred_height_for_width() and #GtkWidgetClass.get_preferred_width_for_height() since it might be queried in either #GtkSizeRequestMode by its parent container.
Signal emitted when a pointer or keyboard grab on a window belonging to widget gets broken.
Causes @widget to have the keyboard focus for the #GtkWindow it’s inside.
Signal 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.
Signal emitted when widget is hidden.
Signal emitted when the anchored state of a widget changes.
Signal emitted when a key is pressed.
Signal is emitted when a key is released.
Signal emitted if keyboard navigation fails.
Will be emitted when the pointer leaves the widget’s window.
Signal emitted when widget is going to be mapped, that is when the widget is visible (which is controlled with gtk.widget.Widget.setVisible) and all its parents up to the toplevel widget are also visible.
Signal emitted when the widget’s window is mapped.
Activates the @widget if @group_cycling is false, and just grabs the focus if @group_cycling is true.
Signal emitted when the pointer moves over the widget’s #GdkWindow.
Signal emitted when a change of focus is requested
The object class structure needs to be the first element in the widget class structure in order for the class mechanism to work correctly. This allows a GtkWidgetClass pointer to be cast to a GObjectClass pointer.
Signal emitted when a new parent has been set on a widget.
Signal emitted whenever a widget should pop up a context menu.
Signal will be emitted when a property on the widget’s window has been changed or deleted.
Signal 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.
Invalidates the area of widget defined by region by calling gdk.window.Window.invalidateRegion on the widget's window and all its child windows.
Signal emitted when widget is associated with a #GdkWindow, which means that gtk.widget.Widget.realize has been called or the widget has been mapped (that is, it is going to be drawn).
Signal emitted when the screen of a widget has changed.
Signal emitted when a button in the 4 to 7 range is pressed.
Signal will be emitted when the the widget’s window has lost ownership of a selection.
Signal will be emitted when another client requests ownership of the selection owned by the widget's window.
Signal emitted when widget is shown
Recursively shows a widget, and any child widgets (if the widget is a container).
Signal emitted to get the widget allocation.
Signal emitted when the widget state changes. Deprecated: 3.0
Signal emitted when the widget state changes, see gtk.widget.Widget.getStateFlags.
Signal emitted when a new style has been set on a widget. Deprecated: 3.0
Signal emitted when the GtkStyleContext of a widget is changed.
Signal emitted when a touch event happens
Signal 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.
Signal will be emitted when the widget’s window is unmapped.
Signal emitted when the GdkWindow associated with widget is destroyed, which means that gtk.widget.Widget.unrealize has been called or the widget has been unmapped (that is, it is going to be hidden).
Signal emitted when the widget’s window is obscured or unobscured.
Signal emitted when the state of the toplevel window associated to the widget changes.