GI.Gtk.Objects.Widget

GtkWidget is the base class all widgets in GTK+ derive from. It manages the widget lifecycle, states and style.

{geometry-management}

GTK+ uses a height-for-width (and width-for-height) geometry management system. Height-for-width means that a widget can change how much vertical space it needs, depending on the amount of horizontal space that it is given (and similar for width-for-height). The most common example is a label that reflows to fill up the available width, wraps to fewer lines, and therefore needs less height.

Height-for-width geometry management is implemented in GTK+ by way of two virtual methods:

• WidgetClass.get_request_mode()
• WidgetClass.measure()

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

If you implement a direct Widget subclass that supports height-for-width or width-for-height geometry management for itself or its child widgets, the WidgetClass.get_request_mode() virtual function must be implemented as well and return the widget's preferred request mode. The default implementation of this virtual function returns SizeRequestModeConstantSize, which means that the widget will only ever get -1 passed as the for_size value to its WidgetClass.measure() implementation.

The geometry management system will query a widget hierarchy in only one orientation at a time. When widgets are initially queried for their minimum sizes it is generally done in two initial passes in the SizeRequestMode chosen by the toplevel.

For example, when queried in the normal SizeRequestModeHeightForWidth mode: First, the default minimum and natural width for each widget in the interface will be computed using widgetMeasure with an orientation of OrientationHorizontal and a for_size of -1. Because the preferred widths for each widget depend on the preferred widths of their children, this information propagates up the hierarchy, and finally a minimum and natural width is determined for the entire toplevel. Next, the toplevel will use the minimum width to query for the minimum height contextual to that width using widgetMeasure with an orientation of OrientationVertical and a for_size of the just computed width. This will also be a highly recursive operation. The minimum height for the minimum width is normally used to set the minimum size constraint on the toplevel (unless 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 windowSetDefaultSize). During the recursive allocation process it’s important to note that request cycles will be recursively executed while widgets allocate their children. Each widget, once allocated a size, will go on to first share the space in one orientation among its children and then request each child's height for its target allocated width or its width for allocated height, depending. In this way a Widget will typically be requested its size a number of times before actually being allocated a size. The size a widget is finally allocated can of course differ from the size it has requested. For this reason, Widget caches a small number of results to avoid re-querying for the same sizes in one allocation cycle.

If a widget does move content around to intelligently use up the allocated size then it must support the request in both GtkSizeRequestModes even if the widget in question only trades sizes in a single orientation.

For instance, a Label that does height-for-width word wrapping will not expect to have WidgetClass.measure() with an orientation of OrientationVertical 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 SizeRequestModeHeightForWidth widget generally deals with width-for-height requests:

C code

static void
foo_widget_measure (GtkWidget      *widget,
                    GtkOrientation  orientation,
                    int             for_size,
                    int            *minimum_size,
                    int            *natural_size,
                    int            *minimum_baseline,
                    int            *natural_baseline)
{
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      // Calculate minimum and natural width
    }
  else // VERTICAL
    {
       if (i_am_in_height_for_width_mode)
         {
           int min_width, dummy;

           // First, get the minimum width of our widget
           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
                                                   &min_width, &dummy, &dummy, &dummy);

           // Now use the minimum width to retrieve the minimum and natural height to display
           // that width.
           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_VERTICAL, min_width,
                                                   minimum_size, natural_size, &dummy, &dummy);
         }
       else
         {
           // ... some widgets do both.
         }
   }
}

Often a widget needs to get its own request during size request or allocation. For example, when computing height it may need to also compute width. Or when deciding how to use an allocation, the widget may need to know its natural size. In these cases, the widget should be careful to call its virtual methods directly, like in the code example above.

It will not work to use the wrapper function widgetMeasure inside your own WidgetClass.size-allocate() implementation. These return a request adjusted by SizeGroup, the widget's align and expand flags as well as its CSS style. If a widget used the wrappers inside its virtual method implementations, then the adjustments (such as widget margins) would be applied twice. GTK+ therefore does not allow this and will warn if you try to do it.

Of course if you are getting the size request for another widget, such as a child widget, you must use widgetMeasure. Otherwise, you would not properly consider widget margins, SizeGroup, and so forth.

GTK+ also supports baseline vertical alignment of widgets. This means that widgets are positioned such that the typographical baseline of widgets in the same row are aligned. This happens if a widget supports baselines, has a vertical alignment of AlignBaseline, and is inside a widget that supports baselines and has a natural “row” that it aligns to the baseline, or a baseline assigned to it by the grandparent.

Baseline alignment support for a widget is also done by the WidgetClass.measure() virtual function. It allows you to report a both a minimum and natural

If a widget ends up baseline aligned it will be allocated all the space in the parent as if it was AlignFill, but the selected baseline can be found via widgetGetAllocatedBaseline. If this has a value other than -1 you need to align the widget such that the baseline appears at the position.

GtkWidget as GtkBuildable

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

An example of a UI definition fragment specifying an accelerator: > >class="GtkButton" > key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/ >/object

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

An example of a UI definition fragment specifying an accessible: > >class="GtkLabel" id="label1"/ > name="label"I am a Label for a Button/property >/object >class="GtkButton" id="button1" > accessibility > action_name="click" translatable="yes"Click the button./action > target="label1" type="labelled-by"/ > /accessibility > internal-child="accessible" > class="AtkObject" id="a11y-button1" > name="accessible-name"Clickable Button/property > /object > /child >/object

If the parent widget uses a LayoutManager, Widget supports a custom <layout> element, used to define layout properties:

<object class="MyGrid" id="grid1">
  <child>
    <object class="GtkLabel" id="label1">
      <property name="label">Description</property>
      <layout>
        <property name="left-attach">0</property>
        <property name="top-attach">0</property>
        <property name="row-span">1</property>
        <property name="col-span">1</property>
      </layout>
    </object>
  </child>
  <child>
    <object class="GtkEntry" id="description_entry">
      <layout>
        <property name="left-attach">1</property>
        <property name="top-attach">0</property>
        <property name="row-span">1</property>
        <property name="col-span">1</property>
      </layout>
    </object>
  </child>
</object>

Finally, GtkWidget allows style information such as style classes to be associated with widgets, using the custom <style> element: > >class="GtkButton" id="button1" > style > name="my-special-button-class"/ > name="dark-button"/ > /style >/object

# {composite-templates}

GtkWidget exposes some facilities to automate the procedure of creating composite widgets using Builder interface description language.

To create composite widgets with Builder XML, one must associate the interface description with the widget class at class initialization time using widgetClassSetTemplate.

The interface description semantics expected in composite template descriptions is slightly different from regular Builder XML.

Unlike regular interface descriptions, widgetClassSetTemplate will expect a <template> tag as a direct child of the toplevel <interface> tag. The <template> tag must specify the “class” attribute which must be the type name of the widget. Optionally, the “parent” attribute may be specified to specify the direct parent type of the widget type, this is ignored by the GtkBuilder but required for Glade to introspect what kind of properties and internal children exist for a given type when the actual type does not exist.

The XML which is contained inside the <template> tag behaves as if it were added to the <object> tag defining widget itself. You may set properties on widget by inserting <property> tags into the <template> tag, and also add <child> tags to add children and extend widget in the normal way you would with <object> tags.

Additionally, <object> tags can also be added before and after the initial <template> tag in the normal way, allowing one to define auxiliary objects which might be referenced by other widgets declared as children of the <template> tag.

An example of a GtkBuilder Template Definition: > >interface > class="FooWidget" parent="GtkBox" > name="orientation"GTK_ORIENTATION_HORIZONTAL/property > name="spacing"4/property > child > class="GtkButton" id="hello_button" > name="label"Hello World/property > name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/ > /object > /child > child > class="GtkButton" id="goodbye_button" > name="label"Goodbye World/property > /object > /child > /template >/interface

Typically, you'll place the template fragment into a file that is bundled with your project, using Resource. In order to load the template, you need to call widgetClassSetTemplateFromResource from the class initialization of your Widget type:

C code

static void
foo_widget_class_init (FooWidgetClass *klass)
{
  // ...

  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
                                               "/com/example/ui/foowidget.ui");
}

You will also need to call widgetInitTemplate from the instance initialization function:

C code

static void
foo_widget_init (FooWidget *self)
{
  // ...
  gtk_widget_init_template (GTK_WIDGET (self));
}

You can access widgets defined in the template using the widgetGetTemplateChild function, but you will typically declare a pointer in the instance private data structure of your type using the same name as the widget in the template definition, and call gtk_widget_class_bind_template_child_private() with that name, e.g.

C code

typedef struct {
  GtkWidget *hello_button;
  GtkWidget *goodbye_button;
} FooWidgetPrivate;

G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)

static void
foo_widget_class_init (FooWidgetClass *klass)
{
  // ...
  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
                                               "/com/example/ui/foowidget.ui");
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
                                                FooWidget, hello_button);
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
                                                FooWidget, goodbye_button);
}

static void
foo_widget_init (FooWidget *widget)
{

}

You can also use gtk_widget_class_bind_template_callback() to connect a signal callback defined in the template with a function visible in the scope of the class, e.g.

C code

// the signal handler has the instance and user data swapped
// because of the swapped="yes" attribute in the template XML
static void
hello_button_clicked (FooWidget *self,
                      GtkButton *button)
{
  g_print ("Hello, world!\n");
}

static void
foo_widget_class_init (FooWidgetClass *klass)
{
  // ...
  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
                                               "/com/example/ui/foowidget.ui");
  gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
}

Exported types

newtype Widget

Memory-managed wrapper type.

Constructors

Widget (ManagedPtr Widget)

Instances

Eq Widget

Defined in GI.Gtk.Objects.Widget

Methods

(==) :: Widget -> Widget -> Bool

(/=) :: Widget -> Widget -> Bool

IsGValue Widget

Convert Widget to and from GValue with toGValue and fromGValue.

Defined in GI.Gtk.Objects.Widget

Methods

toGValue :: Widget -> IO GValue

fromGValue :: GValue -> IO Widget

GObject Widget

Defined in GI.Gtk.Objects.Widget

Methods

gobjectType :: IO GType

HasParentTypes Widget

Defined in GI.Gtk.Objects.Widget

type ParentTypes Widget

Defined in GI.Gtk.Objects.Widget

type ParentTypes Widget = '[Object, ImplementorIface, Buildable]

class (GObject o, IsDescendantOf Widget o) => IsWidget o

Type class for types which can be safely cast to Widget, for instance with toWidget.

Instances

(GObject o, IsDescendantOf Widget o) => IsWidget o

Defined in GI.Gtk.Objects.Widget

toWidget :: (MonadIO m, IsWidget o) => o -> m Widget

Cast to Widget, for types for which this is known to be safe. For general casts, use castTo.

noWidget :: Maybe Widget

A convenience alias for Nothing :: Maybe Widget.

Methods

Overloaded methods

activate

widgetActivate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s activatable

-> m Bool

Returns: True if the widget was activatable

For widgets that can be “activated” (buttons, menu items, etc.) this function activates them. Activation is what happens when you press Enter on a widget during key navigation. If widget isn't activatable, the function returns False.

activateAction

widgetActivateAction

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

name: a prefixed action name

-> GVariant

parameter: parameters that required by the action

-> m ()

Looks up the action in the action groups associated with widget and its ancestors, and activates it.

The action name is expected to be prefixed with the prefix that was used when adding the action group with widgetInsertActionGroup.

The parameter must match the actions expected parameter type, as returned by actionGetParameterType.

activateDefault

widgetActivateDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Activate the default.activate action from widget.

addAccelerator

widgetAddAccelerator

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b)

=> a

widget: widget to install an accelerator on

-> Text

accelSignal: widget signal to emit on accelerator activation

-> b

accelGroup: accel group for this widget, added to its toplevel

-> Word32

accelKey: GDK keyval of the accelerator

-> [ModifierType]

accelMods: modifier key combination of the accelerator

-> [AccelFlags]

accelFlags: flag accelerators, e.g. AccelFlagsVisible

-> m ()

Installs an accelerator for this widget in accelGroup that causes accelSignal to be emitted if the accelerator is activated. The accelGroup needs to be added to the widget’s toplevel via windowAddAccelGroup, and the signal must be of type SignalFlagsAction. Accelerators added through this function are not user changeable during runtime. If you want to support accelerators that can be changed by the user, use accelMapAddEntry and widgetSetAccelPath or menuItemSetAccelPath instead.

addController

widgetAddController

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsEventController b)

=> a

widget: a Widget

-> b

controller: a EventController that hasn't been added to a widget yet

-> m ()

Adds controller to widget so that it will receive events. You will usually want to call this function right after creating any kind of EventController.

addMnemonicLabel

widgetAddMnemonicLabel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

label: a Widget that acts as a mnemonic label for widget

-> m ()

Adds a widget to the list of mnemonic labels for this widget. (See widgetListMnemonicLabels). Note the list of mnemonic labels for the widget is cleared when the widget is destroyed, so the caller must make sure to update its internal state at this point as well, by using a connection to the destroy signal or a weak notifier.

addTickCallback

widgetAddTickCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> TickCallback

callback: function to call for updating animations

-> m Word32

Returns: an id for the connection of this callback. Remove the callback by passing the id returned from this function to widgetRemoveTickCallback

Queues an animation frame update and adds a callback to be called before each frame. Until the tick callback is removed, it will be called frequently (usually at the frame rate of the output device or as quickly as the application can be repainted, whichever is slower). For this reason, is most suitable for handling graphics that change every frame or every few frames. The tick callback does not automatically imply a relayout or repaint. If you want a repaint or relayout, and aren’t changing widget properties that would trigger that (for example, changing the text of a Label), then you will have to call widgetQueueResize or widgetQueueDraw yourself.

frameClockGetFrameTime should generally be used for timing continuous animations and frameTimingsGetPredictedPresentationTime if you are trying to display isolated frames at particular times.

This is a more convenient alternative to connecting directly to the update signal of FrameClock, since you don't have to worry about when a FrameClock is assigned to a widget.

allocate

widgetAllocate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: A Widget

-> Int32

width: New width of widget

-> Int32

height: New height of widget

-> Int32

baseline: New baseline of widget, or -1

-> Maybe Transform

transform: Transformation to be applied to widget

-> m ()

This function is only used by Widget subclasses, to assign a size, position and (optionally) baseline to their child widgets.

In this function, the allocation and baseline may be adjusted. The given allocation will be forced to be bigger than the widget's minimum size, as well as at least 0×0 in size.

For a version that does not take a transform, see widgetSizeAllocate

canActivateAccel

widgetCanActivateAccel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Word32

signalId: the ID of a signal installed on widget

-> m Bool

Returns: True if the accelerator can be activated.

Determines whether an accelerator that activates the signal identified by signalId can currently be activated. This is done by emitting the canActivateAccel signal on widget; if the signal isn’t overridden by a handler or in a derived widget, then the default check is that the widget must be sensitive, and the widget and all its ancestors mapped.

childFocus

widgetChildFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> DirectionType

direction: direction of focus movement

-> m Bool

Returns: True if focus ended up inside widget

This function is used by custom widget implementations; if you're writing an app, you’d use widgetGrabFocus to move the focus to a particular widget.

widgetChildFocus is called by containers as the user moves around the window using keyboard shortcuts. direction indicates what kind of motion is taking place (up, down, left, right, tab forward, tab backward). widgetChildFocus emits the Widget::focus signal; widgets override the default handler for this signal in order to implement appropriate focus behavior.

The default focus handler for a widget should return True if moving in direction left the focus on a focusable location inside that widget, and False if moving in direction moved the focus outside the widget. If returning True, widgets normally call widgetGrabFocus to place the focus accordingly; if returning False, they don’t modify the current focus location.

computeBounds

widgetComputeBounds

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: the Widget to query

-> b

target: the Widget

-> m (Bool, Rect)

Returns: True if the bounds could be computed

Computes the bounds for widget in the coordinate space of target. FIXME: Explain what "bounds" are.

If the operation is successful, True is returned. If widget has no bounds or the bounds cannot be expressed in target's coordinate space (for example if both widgets are in different windows), False is returned and bounds is set to the zero rectangle.

It is valid for widget and target to be the same widget.

computeExpand

widgetComputeExpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Orientation

orientation: expand direction

-> m Bool

Returns: whether widget tree rooted here should be expanded

Computes whether a container should give this widget extra space when possible. Containers should check this, rather than looking at widgetGetHexpand or widgetGetVexpand.

This function already checks whether the widget is visible, so visibility does not need to be checked separately. Non-visible widgets are not expanded.

The computed expand value uses either the expand setting explicitly set on the widget itself, or, if none has been explicitly set, the widget may expand if some of its children do.

computePoint

widgetComputePoint

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: the Widget to query

-> b

target: the Widget to transform into

-> Point

point: a point in widget's coordinate system

-> m (Bool, Point)

Returns: True if the point could be determined, False on failure. In this case, 0 is stored in outPoint.

Translates the given point in widget's coordinates to coordinates relative to target’s coodinate system. In order to perform this operation, both widgets must share a common ancestor.

computeTransform

widgetComputeTransform

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

target: the target widget that the matrix will transform to

-> m (Bool, Matrix)

Returns: True if the transform could be computed, False otherwise. The transform can not be computed in certain cases, for example when widget and target do not share a common ancestor. In that case outTransform gets set to the identity matrix.

Computes a matrix suitable to describe a transformation from widget's coordinate system into target's coordinate system.

contains

widgetContains

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget to query

-> Double

x: X coordinate to test, relative to widget's origin

-> Double

y: Y coordinate to test, relative to widget's origin

-> m Bool

Returns: True if widget contains (x, y).

Tests if the point at (x, y) is contained in widget.

The coordinates for (x, y) must be in widget coordinates, so (0, 0) is assumed to be the top left of widget's content area.

createPangoContext

widgetCreatePangoContext

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Context

Returns: the new Context

Creates a new Context with the appropriate font map, font options, font description, and base direction for drawing text for this widget. See also widgetGetPangoContext.

createPangoLayout

widgetCreatePangoLayout

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Text

text: text to set on the layout (can be Nothing)

-> m Layout

Returns: the new Layout

Creates a new Layout with the appropriate font map, font description, and base direction for drawing text for this widget.

If you keep a Layout created in this way around, you need to re-create it when the widget Context is replaced. This can be tracked by using the Widget::display-changed signal on the widget.

destroy

widgetDestroy

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Destroys a widget.

When a widget is destroyed all references it holds on other objects will be released:

• if the widget is inside a container, it will be removed from its parent
• if the widget is a container, all its children will be destroyed, recursively
• if the widget is a top level, it will be removed from the list of top level widgets that GTK+ maintains internally

It's expected that all references held on the widget will also be released; you should connect to the destroy signal if you hold a reference to widget and you wish to remove it when this function is called. It is not necessary to do so if you are implementing a Container, as you'll be able to use the ContainerClass.remove() virtual function for that.

It's important to notice that widgetDestroy will only cause the widget to be finalized if no additional references, acquired using objectRef, are held on it. In case additional references are in place, the widget will be in an "inert" state after calling this function; widget will still point to valid memory, allowing you to release the references you hold, but you may not query the widget's own state.

You should typically call this function on top level widgets, and rarely on child widgets.

See also: containerRemove

destroyed

widgetDestroyed

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

widgetPointer: address of a variable that contains widget

-> m Widget

This function sets *widgetPointer to Nothing if widgetPointer != Nothing. It’s intended to be used as a callback connected to the “destroy” signal of a widget. You connect widgetDestroyed as a signal handler, and pass the address of your widget variable as user data. Then when the widget is destroyed, the variable will be set to Nothing. Useful for example to avoid multiple copies of the same dialog.

deviceIsShadowed

widgetDeviceIsShadowed

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b)

=> a

widget: a Widget

-> b

device: a Device

-> m Bool

Returns: True if there is an ongoing grab on device by another Widget than widget.

Returns True if device has been shadowed by a GTK+ device grab on another widget, so it would stop sending events to widget. This may be used in the grabNotify signal to check for specific devices. See deviceGrabAdd.

dragBegin

widgetDragBegin

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDevice b)

=> a

widget: the source widget

-> Maybe b

device: the device that starts the drag or Nothing to use the default pointer

-> ContentFormats

targets: The targets (data formats) in which the source can provide the data

-> [DragAction]

actions: A bitmask of the allowed drag actions for this drag

-> Int32

x: The initial x coordinate to start dragging from, in the coordinate space of widget.

-> Int32

y: The initial y coordinate to start dragging from, in the coordinate space of widget.

-> m Drag

Returns: the context for this drag

Initiates a drag on the source side. The function only needs to be used when the application is starting drags itself, and is not needed when widgetDragSourceSet is used.

dragCheckThreshold

widgetDragCheckThreshold

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

startX: X coordinate of start of drag

-> Int32

startY: Y coordinate of start of drag

-> Int32

currentX: current X coordinate

-> Int32

currentY: current Y coordinate

-> m Bool

Returns: True if the drag threshold has been passed.

Checks to see if a mouse drag starting at (startX, startY) and ending at (currentX, currentY) has passed the GTK+ drag threshold, and thus should trigger the beginning of a drag-and-drop operation.

dragDestAddImageTargets

widgetDragDestAddImageTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> m ()

Add the image targets supported by SelectionData to the target list of the drag destination. The targets are added with info = 0. If you need another value, use gtk_target_list_add_image_targets() and widgetDragDestSetTargetList.

dragDestAddTextTargets

widgetDragDestAddTextTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> m ()

Add the text targets supported by SelectionData to the target list of the drag destination. The targets are added with info = 0. If you need another value, use gtk_target_list_add_text_targets() and widgetDragDestSetTargetList.

dragDestAddUriTargets

widgetDragDestAddUriTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> m ()

Add the URI targets supported by SelectionData to the target list of the drag destination. The targets are added with info = 0. If you need another value, use gtk_target_list_add_uri_targets() and widgetDragDestSetTargetList.

dragDestFindTarget

widgetDragDestFindTarget

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDrop b)

=> a

widget: drag destination widget

-> b

drop: Drop

-> Maybe ContentFormats

targetList: list of droppable targets, or Nothing to use gtk_drag_dest_get_target_list (widget).

-> m (Maybe Text)

Returns: first target that the source offers and the dest can accept, or Nothing

Looks for a match between the supported targets of drop and the destTargetList, returning the first matching target, otherwise returning Nothing. destTargetList should usually be the return value from widgetDragDestGetTargetList, but some widgets may have different valid targets for different parts of the widget; in that case, they will have to implement a drag_motion handler that passes the correct target list to this function.

dragDestGetTargetList

widgetDragDestGetTargetList

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe ContentFormats)

Returns: the ContentFormats, or Nothing if none

Returns the list of targets this widget can accept from drag-and-drop.

dragDestGetTrackMotion

widgetDragDestGetTrackMotion

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> m Bool

Returns: True if the widget always emits dragMotion events

Returns whether the widget has been configured to always emit dragMotion signals.

dragDestSet

widgetDragDestSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [DestDefaults]

flags: which types of default drag behavior to use

-> Maybe ContentFormats

targets: the drop types that this widget will accept, or Nothing. Later you can access the list with widgetDragDestGetTargetList and widgetDragDestFindTarget.

-> [DragAction]

actions: a bitmask of possible actions for a drop onto this widget.

-> m ()

Sets a widget as a potential drop destination, and adds default behaviors.

The default behaviors listed in flags have an effect similar to installing default handlers for the widget’s drag-and-drop signals ([dragMotion](GI.Gtk.Objects.Widget), dragDrop, ...). They all exist for convenience. When passing GTK_DEST_DEFAULT_ALL for instance it is sufficient to connect to the widget’s dragDataReceived signal to get primitive, but consistent drag-and-drop support.

Things become more complicated when you try to preview the dragged data, as described in the documentation for dragMotion. The default behaviors described by flags make some assumptions, that can conflict with your own signal handlers. For instance GTK_DEST_DEFAULT_DROP causes invokations of gdk_drag_status() in the context of dragMotion, and invokations of gdk_drag_finish() in dragDataReceived. Especially the later is dramatic, when your own dragMotion handler calls widgetDragGetData to inspect the dragged data.

There’s no way to set a default action here, you can use the dragMotion callback for that. Here’s an example which selects the action to use depending on whether the control key is pressed or not:

C code

static void
drag_motion (GtkWidget *widget,
             GdkDrag *drag,
             gint x,
             gint y,
             guint time)
{
  GdkModifierType mask;

  gdk_surface_get_pointer (gtk_widget_get_surface (widget),
                          NULL, NULL, &mask);
  if (mask & GDK_CONTROL_MASK)
    gdk_drag_status (context, GDK_ACTION_COPY, time);
  else
    gdk_drag_status (context, GDK_ACTION_MOVE, time);
}

dragDestSetTargetList

widgetDragDestSetTargetList

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> Maybe ContentFormats

targetList: list of droppable targets, or Nothing for none

-> m ()

Sets the target types that this widget can accept from drag-and-drop. The widget must first be made into a drag destination with widgetDragDestSet.

dragDestSetTrackMotion

widgetDragDestSetTrackMotion

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag destination

-> Bool

trackMotion: whether to accept all targets

-> m ()

Tells the widget to emit dragMotion and dragLeave events regardless of the targets and the DestDefaultsMotion flag.

This may be used when a widget wants to do generic actions regardless of the targets that the source offers.

dragDestUnset

widgetDragDestUnset

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Clears information about a drop destination set with widgetDragDestSet. The widget will no longer receive notification of drags.

dragGetData

widgetDragGetData

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsDrop b)

=> a

widget: the widget that will receive the dragDataReceived signal

-> b

drop: the Drop

-> Text

target: the target (form of the data) to retrieve

-> m ()

Gets the data associated with a drag. When the data is received or the retrieval fails, GTK+ will emit a dragDataReceived signal. Failure of the retrieval is indicated by the length field of the selectionData signal parameter being negative. However, when widgetDragGetData is called implicitely because the DestDefaultsDrop was set, then the widget will not receive notification of failed drops.

dragHighlight

widgetDragHighlight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a widget to highlight

-> m ()

Highlights a widget as a currently hovered drop target. To end the highlight, call widgetDragUnhighlight. GTK+ calls this automatically if DestDefaultsHighlight is set.

dragSourceAddImageTargets

widgetDragSourceAddImageTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s is a drag source

-> m ()

Add the writable image targets supported by SelectionData to the target list of the drag source. The targets are added with info = 0. If you need another value, use gtk_target_list_add_image_targets() and widgetDragSourceSetTargetList.

dragSourceAddTextTargets

widgetDragSourceAddTextTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s is a drag source

-> m ()

Add the text targets supported by SelectionData to the target list of the drag source. The targets are added with info = 0. If you need another value, use contentFormatsAddTextTargets and widgetDragSourceSetTargetList.

dragSourceAddUriTargets

widgetDragSourceAddUriTargets

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s is a drag source

-> m ()

Add the URI targets supported by SelectionData to the target list of the drag source. The targets are added with info = 0. If you need another value, use contentFormatsAddUriTargets and widgetDragSourceSetTargetList.

dragSourceGetTargetList

widgetDragSourceGetTargetList

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe ContentFormats)

Returns: the ContentFormats, or Nothing if none

Gets the list of targets this widget can provide for drag-and-drop.

dragSourceSet

widgetDragSourceSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [ModifierType]

startButtonMask: the bitmask of buttons that can start the drag

-> Maybe ContentFormats

targets: the targets that the drag will support, may be Nothing

-> [DragAction]

actions: the bitmask of possible actions for a drag from this widget

-> m ()

Sets up a widget so that GTK+ will start a drag operation when the user clicks and drags on the widget. The widget must have a window.

dragSourceSetIconGicon

widgetDragSourceSetIconGicon

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsIcon b)

=> a

widget: a Widget

-> b

icon: A Icon

-> m ()

Sets the icon that will be used for drags from a particular source to icon. See the docs for IconTheme for more details.

dragSourceSetIconName

widgetDragSourceSetIconName

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

iconName: name of icon to use

-> m ()

Sets the icon that will be used for drags from a particular source to a themed icon. See the docs for IconTheme for more details.

dragSourceSetIconPaintable

widgetDragSourceSetIconPaintable

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsPaintable b)

=> a

widget: a Widget

-> b

paintable: A Paintable

-> m ()

Sets the icon that will be used for drags from a particular source to paintable.

dragSourceSetTargetList

widgetDragSourceSetTargetList

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget that’s a drag source

-> Maybe ContentFormats

targetList: list of draggable targets, or Nothing for none

-> m ()

Changes the target types that this widget offers for drag-and-drop. The widget must first be made into a drag source with widgetDragSourceSet.

dragSourceUnset

widgetDragSourceUnset

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Undoes the effects of widgetDragSourceSet.

dragUnhighlight

widgetDragUnhighlight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a widget to remove the highlight from

-> m ()

Removes a highlight set by widgetDragHighlight from a widget.

errorBell

widgetErrorBell

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Notifies the user about an input-related error on this widget. If the Settings:gtk-error-bell setting is True, it calls surfaceBeep, otherwise it does nothing.

Note that the effect of surfaceBeep can be configured in many ways, depending on the windowing backend and the desktop environment or window manager that is used.

event

widgetEvent

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsEvent b)

=> a

widget: a Widget

-> b

event: a GdkEvent

-> m Bool

Returns: return from the event signal emission (True if the event was handled)

Rarely-used function. This function is used to emit the event signals on a widget (those signals should never be emitted without using this function to do so). If you want to synthesize an event though, don’t use this function; instead, use mainDoEvent so the event will behave as if it were in the event queue.

getAccessible

widgetGetAccessible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Object

Returns: the Object associated with widget

Returns the accessible object that describes the widget to an assistive technology.

If accessibility support is not available, this Object instance may be a no-op. Likewise, if no class-specific Object implementation is available for the widget instance in question, it will inherit an Object implementation from the first ancestor class for which such an implementation is defined.

The documentation of the ATK library contains more information about accessible objects and their uses.

getActionGroup

widgetGetActionGroup

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: A Widget

-> Text

prefix: The “prefix” of the action group.

-> m (Maybe ActionGroup)

Returns: A ActionGroup or Nothing.

Retrieves the ActionGroup that was registered using prefix. The resulting ActionGroup may have been registered to widget or any Widget in its ancestry.

If no action group was found matching prefix, then Nothing is returned.

getAllocatedBaseline

widgetGetAllocatedBaseline

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget to query

-> m Int32

Returns: the baseline of the widget, or -1 if none

Returns the baseline that has currently been allocated to widget. This function is intended to be used when implementing handlers for the Widget::snapshot function, and when allocating child widgets in Widget::size_allocate.

getAllocatedHeight

widgetGetAllocatedHeight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget to query

-> m Int32

Returns: the height of the widget

Returns the height that has currently been allocated to widget.

getAllocatedWidth

widgetGetAllocatedWidth

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget to query

-> m Int32

Returns: the width of the widget

Returns the width that has currently been allocated to widget.

getAllocation

widgetGetAllocation

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Rectangle

Retrieves the widget’s allocation.

Note, when implementing a Container: a widget’s allocation will be its “adjusted” allocation, that is, the widget’s parent container typically calls widgetSizeAllocate with an allocation, and that allocation is then adjusted (to handle margin and alignment for example) before assignment to the widget. widgetGetAllocation returns the adjusted allocation that was actually assigned to the widget. The adjusted allocation is guaranteed to be completely contained within the widgetSizeAllocate allocation, however. So a Container is guaranteed that its children stay inside the assigned bounds, but not that they have exactly the bounds the container assigned.

getAncestor

widgetGetAncestor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> GType

widgetType: ancestor type

-> m (Maybe Widget)

Returns: the ancestor widget, or Nothing if not found

Gets the first ancestor of widget with type widgetType. For example, gtk_widget_get_ancestor (widget, GTK_TYPE_BOX) gets the first Box that’s an ancestor of widget. No reference will be added to the returned widget; it should not be unreferenced. See note about checking for a toplevel Window in the docs for widgetGetToplevel.

Note that unlike widgetIsAncestor, widgetGetAncestor considers widget to be an ancestor of itself.

getCanFocus

widgetGetCanFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget can own the input focus, False otherwise

Determines whether widget can own the input focus. See widgetSetCanFocus.

getCanTarget

widgetGetCanTarget

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget can receive pointer events

Queries whether widget can be the target of pointer events.

getChildVisible

widgetGetChildVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is mapped with the parent.

Gets the value set with widgetSetChildVisible. If you feel a need to use this function, your code probably needs reorganization.

This function is only useful for container implementations and never should be called by an application.

getClipboard

widgetGetClipboard

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Clipboard

Returns: the appropriate clipboard object.

This is a utility function to get the clipboard object for the Display that widget is using.

Note that this function always works, even when widget is not realized yet.

getCursor

widgetGetCursor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Cursor)

Returns: the cursor currently in use or Nothing to use the default.

Queries the cursor set via widgetSetCursor. See that function for details.

getDefaultDirection

widgetGetDefaultDirection

Arguments

:: (HasCallStack, MonadIO m)

=> m TextDirection

Returns: the current default direction.

Obtains the current default reading direction. See widgetSetDefaultDirection.

getDirection

widgetGetDirection

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m TextDirection

Returns: the reading direction for the widget.

Gets the reading direction for a particular widget. See widgetSetDirection.

getDisplay

widgetGetDisplay

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Display

Returns: the Display for the toplevel for this widget.

Get the Display for the toplevel window associated with this widget. This function can only be called after the widget has been added to a widget hierarchy with a Window at the top.

In general, you should only create display specific resources when a widget has been realized, and you should free those resources when the widget is unrealized.

getFirstChild

widgetGetFirstChild

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Widget)

Returns: The widget's first child

No description available in the introspection data.

getFocusChild

widgetGetFocusChild

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Widget)

Returns: The current focus child of widget, or Nothing in case the focus child is unset.

Returns the current focus child of widget.

getFocusOnClick

widgetGetFocusOnClick

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget should grab focus when it is clicked with the mouse.

Returns whether the widget should grab focus when it is clicked with the mouse. See widgetSetFocusOnClick.

getFontMap

widgetGetFontMap

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe FontMap)

Returns: A FontMap, or Nothing

Gets the font map that has been set with widgetSetFontMap.

getFontOptions

widgetGetFontOptions

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe FontOptions)

Returns: the FontOptions or Nothing if not set

Returns the FontOptions used for Pango rendering. When not set, the defaults font options for the Display will be used.

getFrameClock

widgetGetFrameClock

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe FrameClock)

Returns: a FrameClock, or Nothing if widget is unrealized

Obtains the frame clock for a widget. The frame clock is a global “ticker” that can be used to drive animations and repaints. The most common reason to get the frame clock is to call frameClockGetFrameTime, in order to get a time to use for animating. For example you might record the start of the animation with an initial value from frameClockGetFrameTime, and then update the animation by calling frameClockGetFrameTime again during each repaint.

frameClockRequestPhase will result in a new frame on the clock, but won’t necessarily repaint any widgets. To repaint a widget, you have to use widgetQueueDraw which invalidates the widget (thus scheduling it to receive a draw on the next frame). widgetQueueDraw will also end up requesting a frame on the appropriate frame clock.

A widget’s frame clock will not change while the widget is mapped. Reparenting a widget (which implies a temporary unmap) can change the widget’s frame clock.

Unrealized widgets do not have a frame clock.

getHalign

widgetGetHalign

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Align

Returns: the horizontal alignment of widget

Gets the value of the Widget:halign property.

For backwards compatibility reasons this method will never return AlignBaseline, but instead it will convert it to AlignFill. Baselines are not supported for horizontal alignment.

getHasSurface

widgetGetHasSurface

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget has a surface, False otherwise

Determines whether widget has a Surface of its own. See widgetSetHasSurface.

getHasTooltip

widgetGetHasTooltip

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: current value of has-tooltip on widget.

Returns the current value of the has-tooltip property. See Widget:has-tooltip for more information.

getHeight

widgetGetHeight

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The height of widget

Returns the content height of the widget, as passed to its size-allocate implementation. This is the size you should be using in GtkWidgetClass.snapshot(). For pointer events, see widgetContains.

getHexpand

widgetGetHexpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> m Bool

Returns: whether hexpand flag is set

Gets whether the widget would like any available extra horizontal space. When a user resizes a Window, widgets with expand=TRUE generally receive the extra space. For example, a list or scrollable area or document in your window would often be set to expand.

Containers should use widgetComputeExpand rather than this function, to see whether a widget, or any of its children, has the expand flag set. If any child of a widget wants to expand, the parent may ask to expand also.

This function only looks at the widget’s own hexpand flag, rather than computing whether the entire widget tree rooted at this widget wants to expand.

getHexpandSet

widgetGetHexpandSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> m Bool

Returns: whether hexpand has been explicitly set

Gets whether widgetSetHexpand has been used to explicitly set the expand flag on this widget.

If hexpand is set, then it overrides any computed expand value based on child widgets. If hexpand is not set, then the expand value depends on whether any children of the widget would like to expand.

There are few reasons to use this function, but it’s here for completeness and consistency.

getLastChild

widgetGetLastChild

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Widget)

Returns: The widget's last child

No description available in the introspection data.

getLayoutManager

widgetGetLayoutManager

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe LayoutManager)

Returns: a LayoutManager

Retrieves the layout manager set using widgetSetLayoutManager.

getMapped

widgetGetMapped

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is mapped, False otherwise.

Whether the widget is mapped.

getMarginBottom

widgetGetMarginBottom

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The bottom margin of widget

Gets the value of the Widget:margin-bottom property.

getMarginEnd

widgetGetMarginEnd

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The end margin of widget

Gets the value of the Widget:margin-end property.

getMarginStart

widgetGetMarginStart

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The start margin of widget

Gets the value of the Widget:margin-start property.

getMarginTop

widgetGetMarginTop

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The top margin of widget

Gets the value of the Widget:margin-top property.

getModifierMask

widgetGetModifierMask

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> ModifierIntent

intent: the use case for the modifier mask

-> m [ModifierType]

Returns: the modifier mask used for intent.

Returns the modifier mask the widget’s windowing system backend uses for a particular purpose.

See keymapGetModifierMask.

getName

widgetGetName

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Text

Returns: name of the widget. This string is owned by GTK+ and should not be modified or freed

Retrieves the name of a widget. See widgetSetName for the significance of widget names.

getNextSibling

widgetGetNextSibling

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Widget)

Returns: The widget's next sibling

No description available in the introspection data.

getOpacity

widgetGetOpacity

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Double

Returns: the requested opacity for this widget.

Fetches the requested opacity for this widget. See widgetSetOpacity.

getOverflow

widgetGetOverflow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Overflow

Returns: The widget's overflow.

Returns the value set via widgetSetOverflow.

getPangoContext

widgetGetPangoContext

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Context

Returns: the Context for the widget.

Gets a Context with the appropriate font map, font description, and base direction for this widget. Unlike the context returned by widgetCreatePangoContext, this context is owned by the widget (it can be used until the screen for the widget changes or the widget is removed from its toplevel), and will be updated to match any changes to the widget’s attributes. This can be tracked by using the Widget::display-changed signal on the widget.

getParent

widgetGetParent

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Widget)

Returns: the parent widget of widget, or Nothing

Returns the parent widget of widget.

getPath

widgetGetPath

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m WidgetPath

Returns: The WidgetPath representing widget

Returns the WidgetPath representing widget, if the widget is not connected to a toplevel widget, a partial path will be created.

getPreferredSize

widgetGetPreferredSize

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget instance

-> m (Requisition, Requisition)

Retrieves the minimum and natural size of a widget, taking into account the widget’s preference for height-for-width management.

This is used to retrieve a suitable size by container widgets which do not impose any restrictions on the child placement. It can be used to deduce toplevel window and menu sizes as well as child widgets in free-form containers such as GtkLayout.

Handle with care. Note that the natural height of a height-for-width widget will generally be a smaller size than the minimum height, since the required height for the natural width is generally smaller than the required height for the minimum width.

Use widgetMeasure if you want to support baseline alignment.

getPrevSibling

widgetGetPrevSibling

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Widget)

Returns: The widget's previous sibling

No description available in the introspection data.

getPrimaryClipboard

widgetGetPrimaryClipboard

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Clipboard

Returns: the appropriate clipboard object.

This is a utility function to get the primary clipboard object for the Display that widget is using.

Note that this function always works, even when widget is not realized yet.

getRealized

widgetGetRealized

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is realized, False otherwise

Determines whether widget is realized.

getReceivesDefault

widgetGetReceivesDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget acts as the default widget when focused, False otherwise

Determines whether widget is always treated as the default widget within its toplevel when it has the focus, even if another widget is the default.

See widgetSetReceivesDefault.

getRequestMode

widgetGetRequestMode

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget instance

-> m SizeRequestMode

Returns: The SizeRequestMode preferred by widget.

Gets whether the widget prefers a height-for-width layout or a width-for-height layout.

Bin widgets generally propagate the preference of their child, container widgets need to request something either in context of their children or in context of their allocation capabilities.

getRoot

widgetGetRoot

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Root)

Returns: the root widget of widget, or Nothing

Returns the Root widget of widget or Nothing if the widget is not contained inside a widget tree with a root widget.

Root widgets will return themselves here.

getScaleFactor

widgetGetScaleFactor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: the scale factor for widget

Retrieves the internal scale factor that maps from window coordinates to the actual device pixels. On traditional systems this is 1, on high density outputs, it can be a higher value (typically 2).

See surfaceGetScaleFactor.

getSensitive

widgetGetSensitive

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is sensitive

Returns the widget’s sensitivity (in the sense of returning the value that has been set using widgetSetSensitive).

The effective sensitivity of a widget is however determined by both its own and its parent widget’s sensitivity. See widgetIsSensitive.

getSettings

widgetGetSettings

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Settings

Returns: the relevant Settings object

Gets the settings object holding the settings used for this widget.

Note that this function can only be called when the Widget is attached to a toplevel, since the settings object is specific to a particular Display.

getSizeRequest

widgetGetSizeRequest

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Int32, Int32)

Gets the size request that was explicitly set for the widget using widgetSetSizeRequest. A value of -1 stored in width or height indicates that that dimension has not been set explicitly and the natural requisition of the widget will be used instead. See widgetSetSizeRequest. To get the size a widget will actually request, call widgetMeasure instead of this function.

getStateFlags

widgetGetStateFlags

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m [StateFlags]

Returns: The state flags for widget

Returns the widget state as a flag set. It is worth mentioning that the effective StateFlagsInsensitive state will be returned, that is, also based on parent insensitivity, even if widget itself is sensitive.

Also note that if you are looking for a way to obtain the StateFlags to pass to a StyleContext method, you should look at styleContextGetState.

getStyleContext

widgetGetStyleContext

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m StyleContext

Returns: a StyleContext. This memory is owned by widget and must not be freed.

Returns the style context associated to widget. The returned object is guaranteed to be the same for the lifetime of widget.

getSupportMultidevice

widgetGetSupportMultidevice

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is multidevice aware.

Returns True if widget is multiple pointer aware. See widgetSetSupportMultidevice for more information.

getSurface

widgetGetSurface

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Surface)

Returns: widget’s surface.

Returns the widget’s surface if it is realized, Nothing otherwise

getTemplateChild

widgetGetTemplateChild

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: A Widget

-> GType

widgetType: The GType to get a template child for

-> Text

name: The “id” of the child defined in the template XML

-> m Object

Returns: The object built in the template XML with the id name

Fetch an object build from the template XML for widgetType in this widget instance.

This will only report children which were previously declared with widgetClassBindTemplateChildFull or one of its variants.

This function is only meant to be called for code which is private to the widgetType which declared the child and is meant for language bindings which cannot easily make use of the GObject structure offsets.

getTooltipMarkup

widgetGetTooltipMarkup

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Text)

Returns: the tooltip text, or Nothing. You should free the returned string with free when done.

Gets the contents of the tooltip for widget.

getTooltipText

widgetGetTooltipText

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m (Maybe Text)

Returns: the tooltip text, or Nothing. You should free the returned string with free when done.

Gets the contents of the tooltip for widget.

getTooltipWindow

widgetGetTooltipWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Window

Returns: The Window of the current tooltip.

Returns the Window of the current tooltip. This can be the GtkWindow created by default, or the custom tooltip window set using widgetSetTooltipWindow.

getToplevel

widgetGetToplevel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Widget

Returns: the topmost ancestor of widget, or widget itself if there’s no ancestor.

This function returns the topmost widget in the container hierarchy widget is a part of. If widget has no parent widgets, it will be returned as the topmost widget. No reference will be added to the returned widget; it should not be unreferenced.

Note the difference in behavior vs. widgetGetAncestor; gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW) would return Nothing if widget wasn’t inside a toplevel window, and if the window was inside a Window-derived widget which was in turn inside the toplevel Window.

To reliably find the toplevel Window, use widgetGetToplevel and call GTK_IS_WINDOW() on the result. For instance, to get the title of a widget's toplevel window, one might use:

C code

static const char *
get_widget_toplevel_title (GtkWidget *widget)
{
  GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
  if (GTK_IS_WINDOW (toplevel))
    {
      return gtk_window_get_title (GTK_WINDOW (toplevel));
    }

  return NULL;
}

getValign

widgetGetValign

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Align

Returns: the vertical alignment of widget

Gets the value of the Widget:valign property.

getVexpand

widgetGetVexpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> m Bool

Returns: whether vexpand flag is set

Gets whether the widget would like any available extra vertical space.

See widgetGetHexpand for more detail.

getVexpandSet

widgetGetVexpandSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> m Bool

Returns: whether vexpand has been explicitly set

Gets whether widgetSetVexpand has been used to explicitly set the expand flag on this widget.

See widgetGetHexpandSet for more detail.

getVisible

widgetGetVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is visible

Determines whether the widget is visible. If you want to take into account whether the widget’s parent is also marked as visible, use widgetIsVisible instead.

This function does not check if the widget is obscured in any way.

See widgetSetVisible.

getWidth

widgetGetWidth

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Int32

Returns: The width of widget

Returns the content width of the widget, as passed to its size-allocate implementation. This is the size you should be using in GtkWidgetClass.snapshot(). For pointer events, see widgetContains.

grabAdd

widgetGrabAdd

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: The widget that grabs keyboard and pointer events

-> m ()

Makes widget the current grabbed widget.

This means that interaction with other widgets in the same application is blocked and mouse as well as keyboard events are delivered to this widget.

If widget is not sensitive, it is not set as the current grabbed widget and this function does nothing.

grabFocus

widgetGrabFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Causes widget (or one of its descendents) to have the keyboard focus for the Window it's inside.

widget must be focusable, or have a grab_focus implementation that transfers the focus to a descendant of widget that is focusable.

grabRemove

widgetGrabRemove

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: The widget which gives up the grab

-> m ()

Removes the grab from the given widget.

You have to pair calls to widgetGrabAdd and widgetGrabRemove.

If widget does not have the grab, this function does nothing.

hasDefault

widgetHasDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is the current default widget within its toplevel, False otherwise

Determines whether widget is the current default widget within its toplevel.

hasFocus

widgetHasFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget has the global input focus.

Determines if the widget has the global input focus. See widgetIsFocus for the difference between having the global input focus, and only having the focus within a toplevel.

hasGrab

widgetHasGrab

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is in the grab_widgets stack

Determines whether the widget is currently grabbing events, so it is the only widget receiving input events (keyboard and mouse).

See also widgetGrabAdd.

hasVisibleFocus

widgetHasVisibleFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget should display a “focus rectangle”

Determines if the widget should show a visible indication that it has the global input focus. This is a convenience function for use in draw handlers that takes into account whether focus indication should currently be shown in the toplevel window of widget. See windowGetFocusVisible for more information about focus indication.

To find out if the widget has the global input focus, use widgetHasFocus.

hide

widgetHide

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Reverses the effects of widgetShow, causing the widget to be hidden (invisible to the user).

inDestruction

widgetInDestruction

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is being destroyed

Returns whether the widget is currently being destroyed. This information can sometimes be used to avoid doing unnecessary work.

initTemplate

widgetInitTemplate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Creates and initializes child widgets defined in templates. This function must be called in the instance initializer for any class which assigned itself a template using widgetClassSetTemplate

It is important to call this function in the instance initializer of a Widget subclass and not in Object.constructed() or Object.constructor() for two reasons.

One reason is that generally derived widgets will assume that parent class composite widgets have been created in their instance initializers.

Another reason is that when calling g_object_new() on a widget with composite templates, it’s important to build the composite widgets before the construct properties are set. Properties passed to g_object_new() should take precedence over properties set in the private template XML.

inputShapeCombineRegion

widgetInputShapeCombineRegion

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Region

region: shape to be added, or Nothing to remove an existing shape

-> m ()

Sets an input shape for this widget’s GDK surface. This allows for windows which react to mouse click in a nonrectangular region, see surfaceInputShapeCombineRegion for more information.

insertActionGroup

widgetInsertActionGroup

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsActionGroup b)

=> a

widget: a Widget

-> Text

name: the prefix for actions in group

-> Maybe b

group: a ActionGroup, or Nothing

-> m ()

Inserts group into widget. Children of widget that implement Actionable can then be associated with actions in group by setting their “action-name” to prefix.action-name.

If group is Nothing, a previously inserted group for name is removed from widget.

insertAfter

widgetInsertAfter

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b, IsWidget c)

=> a

widget: a Widget

-> b

parent: the parent Widget to insert widget into

-> Maybe c

previousSibling: the new previous sibling of widget or Nothing

-> m ()

Inserts widget into the child widget list of parent. It will be placed after previousSibling, or at the beginning if previousSibling is Nothing.

After calling this function, gtk_widget_get_prev_sibling(widget) will return previousSibling.

If parent is already set as the parent widget of widget, this function can also be used to reorder widget in the child widget list of parent.

insertBefore

widgetInsertBefore

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b, IsWidget c)

=> a

widget: a Widget

-> b

parent: the parent Widget to insert widget into

-> Maybe c

nextSibling: the new next sibling of widget or Nothing

-> m ()

Inserts widget into the child widget list of parent. It will be placed before nextSibling, or at the end if nextSibling is Nothing.

After calling this function, gtk_widget_get_next_sibling(widget) will return nextSibling.

If parent is already set as the parent widget of widget, this function can also be used to reorder widget in the child widget list of parent.

isAncestor

widgetIsAncestor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

ancestor: another Widget

-> m Bool

Returns: True if ancestor contains widget as a child, grandchild, great grandchild, etc.

Determines whether widget is somewhere inside ancestor, possibly with intermediate containers.

isDrawable

widgetIsDrawable

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is drawable, False otherwise

Determines whether widget can be drawn to. A widget can be drawn if it is mapped and visible.

isFocus

widgetIsFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is the focus widget.

Determines if the widget is the focus widget within its toplevel. (This does not mean that the Widget:has-focus property is necessarily set; Widget:has-focus will only be set if the toplevel widget additionally has the global input focus.)

isSensitive

widgetIsSensitive

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget is effectively sensitive

Returns the widget’s effective sensitivity, which means it is sensitive itself and also its parent widget is sensitive

isToplevel

widgetIsToplevel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if widget is a toplevel, False otherwise

Determines whether widget is a toplevel widget.

Currently only GtkWindows are toplevel widgets. Toplevel widgets have no parent widget and implement the Root interface.

isVisible

widgetIsVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m Bool

Returns: True if the widget and all its parents are visible

Determines whether the widget and all its parents are marked as visible.

This function does not check if the widget is obscured in any way.

See also widgetGetVisible and widgetSetVisible

keynavFailed

widgetKeynavFailed

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> DirectionType

direction: direction of focus movement

-> m Bool

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

This function should be called whenever keyboard navigation within a single widget hits a boundary. The function emits the keynavFailed signal on the widget and its return value should be interpreted in a way similar to the return value of widgetChildFocus:

When True is returned, stay in the widget, the failed keyboard navigation is OK and/or there is nowhere we can/should move the focus to.

When False is returned, the caller should continue with keyboard navigation outside the widget, e.g. by calling widgetChildFocus on the widget’s toplevel.

The default keynavFailed handler returns False for DirectionTypeTabForward and DirectionTypeTabBackward. For the other values of DirectionType it returns True.

Whenever the default handler returns True, it also calls widgetErrorBell to notify the user of the failed keyboard navigation.

A use case for providing an own implementation of keynavFailed (either by connecting to it or by overriding it) would be a row of Entry widgets where the user should be able to navigate the entire row with the cursor keys, as e.g. known from user interfaces that require entering license keys.

listAccelClosures

widgetListAccelClosures

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: widget to list accelerator closures for

-> m [GClosure b]

Returns: a newly allocated List of closures

Lists the closures used by widget for accelerator group connections with accelGroupConnectByPath or accelGroupConnect. The closures can be used to monitor accelerator changes on widget, by connecting to the gtkAccelGroupaccelChanged signal of the AccelGroup of a closure which can be found out with accelGroupFromAccelClosure.

listActionPrefixes

widgetListActionPrefixes

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: A Widget

-> m [Text]

Returns: a Nothing-terminated array of strings.

Retrieves a Nothing-terminated array of strings containing the prefixes of ActionGroup's available to widget.

listMnemonicLabels

widgetListMnemonicLabels

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m [Widget]

Returns: the list of mnemonic labels; free this list with g_list_free() when you are done with it.

Returns a newly allocated list of the widgets, normally labels, for which this widget is the target of a mnemonic (see for example, labelSetMnemonicWidget).

The widgets in the list are not individually referenced. If you want to iterate through the list and perform actions involving callbacks that might destroy the widgets, you must call g_list_foreach (result, (GFunc)g_object_ref, NULL) first, and then unref all the widgets afterwards.

map

widgetMap

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations. Causes a widget to be mapped if it isn’t already.

measure

widgetMeasure

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: A Widget instance

-> Orientation

orientation: the orientation to measure

-> Int32

forSize: Size for the opposite of orientation, i.e. if orientation is OrientationHorizontal, this is the height the widget should be measured with. The OrientationVertical case is analogous. This way, both height-for-width and width-for-height requests can be implemented. If no size is known, -1 can be passed.

-> m (Int32, Int32, Int32, Int32)

Measures widget in the orientation orientation and for the given forSize. As an example, if orientation is OrientationHorizontal and forSize is 300, this functions will compute the minimum and natural width of widget if it is allocated at a height of 300 pixels.

See [GtkWidget’s geometry management section][geometry-management] for a more details on implementing WidgetClass.measure().

mnemonicActivate

widgetMnemonicActivate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

groupCycling: True if there are other widgets with the same mnemonic

-> m Bool

Returns: True if the signal has been handled

Emits the mnemonicActivate signal.

observeChildren

widgetObserveChildren

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ListModel

Returns: a ListModel tracking widget's children

Returns a ListModel to track the children of widget.

Calling this function will enable extra internal bookkeeping to track children and emit signals on the returned listmodel. It may slow down operations a lot.

Applications should try hard to avoid calling this function because of the slowdowns.

observeControllers

widgetObserveControllers

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ListModel

Returns: a ListModel tracking widget's controllers

Returns a ListModel to track the GtkEventControllers of widget.

Calling this function will enable extra internal bookkeeping to track controllers and emit signals on the returned listmodel. It may slow down operations a lot.

Applications should try hard to avoid calling this function because of the slowdowns.

pick

widgetPick

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget to query

-> Double

x: X coordinate to test, relative to widget's origin

-> Double

y: Y coordinate to test, relative to widget's origin

-> [PickFlags]

flags: Flags to influence what is picked

-> m (Maybe Widget)

Returns: The widget descendant at the given coordinate or Nothing if none.

Finds the descendant of widget (including widget itself) closest to the screen at the point (x, y). The point must be given in widget coordinates, so (0, 0) is assumed to be the top left of widget's content area.

Usually widgets will return Nothing if the given coordinate is not contained in widget checked via widgetContains. Otherwise they will recursively try to find a child that does not return Nothing. Widgets are however free to customize their picking algorithm.

This function is used on the toplevel to determine the widget below the mouse cursor for purposes of hover hilighting and delivering events.

queueAllocate

widgetQueueAllocate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations.

Flags the widget for a rerun of the GtkWidgetClass[size_allocate](#signal:size_allocate) function. Use this function instead of widgetQueueResize when the widget's size request didn't change but it wants to reposition its contents.

An example user of this function is widgetSetHalign.

queueComputeExpand

widgetQueueComputeExpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Mark widget as needing to recompute its expand flags. Call this function when setting legacy expand child properties on the child of a container.

See widgetComputeExpand.

queueDraw

widgetQueueDraw

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Schedules this widget to be redrawn in paint phase of the current or the next frame. This means widget's GtkWidgetClass.snapshot() implementation will be called.

queueResize

widgetQueueResize

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations. Flags a widget to have its size renegotiated; should be called when a widget for some reason has a new size request. For example, when you change the text in a Label, Label queues a resize to ensure there’s enough space for the new text.

Note that you cannot call widgetQueueResize on a widget from inside its implementation of the GtkWidgetClass[size_allocate](#signal:size_allocate) virtual method. Calls to widgetQueueResize from inside GtkWidgetClass[size_allocate](#signal:size_allocate) will be silently ignored.

queueResizeNoRedraw

widgetQueueResizeNoRedraw

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function works like widgetQueueResize, except that the widget is not invalidated.

realize

widgetRealize

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Creates the GDK (windowing system) resources associated with a widget. For example, widget->surface will be created when a widget is realized. Normally realization happens implicitly; if you show a widget and all its parent containers, then the widget will be realized and mapped automatically.

Realizing a widget requires all the widget’s parent widgets to be realized; calling widgetRealize realizes the widget’s parents in addition to widget itself. If a widget is not yet inside a toplevel window when you realize it, bad things will happen.

This function is primarily used in widget implementations, and isn’t very useful otherwise. Many times when you think you might need it, a better approach is to connect to a signal that will be called after the widget is realized automatically, such as realize.

registerSurface

widgetRegisterSurface

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsSurface b)

=> a

widget: a Widget

-> b

surface: a Surface

-> m ()

Registers a Surface with the widget and sets it up so that the widget receives events for it. Call widgetUnregisterSurface when destroying the surface.

Before 3.8 you needed to call gdk_surface_set_user_data() directly to set this up. This is now deprecated and you should use widgetRegisterSurface instead. Old code will keep working as is, although some new features like transparency might not work perfectly.

removeAccelerator

widgetRemoveAccelerator

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b)

=> a

widget: widget to install an accelerator on

-> b

accelGroup: accel group for this widget

-> Word32

accelKey: GDK keyval of the accelerator

-> [ModifierType]

accelMods: modifier key combination of the accelerator

-> m Bool

Returns: whether an accelerator was installed and could be removed

Removes an accelerator from widget, previously installed with widgetAddAccelerator.

removeController

widgetRemoveController

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsEventController b)

=> a

widget: a Widget

-> b

controller: a EventController

-> m ()

Removes controller from widget, so that it doesn't process events anymore. It should not be used again.

Widgets will remove all event controllers automatically when they are destroyed, there is normally no need to call this function.

removeMnemonicLabel

widgetRemoveMnemonicLabel

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

label: a Widget that was previously set as a mnemonic label for widget with widgetAddMnemonicLabel.

-> m ()

Removes a widget from the list of mnemonic labels for this widget. (See widgetListMnemonicLabels). The widget must have previously been added to the list with widgetAddMnemonicLabel.

removeTickCallback

widgetRemoveTickCallback

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Word32

id: an id returned by widgetAddTickCallback

-> m ()

Removes a tick callback previously registered with widgetAddTickCallback.

resetStyle

widgetResetStyle

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Updates the style context of widget and all descendants by updating its widget path. GtkContainers may want to use this on a child when reordering it in a way that a different style might apply to it. See also containerGetPathForChild.

setAccelPath

widgetSetAccelPath

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsAccelGroup b)

=> a

widget: a Widget

-> Maybe Text

accelPath: path used to look up the accelerator

-> Maybe b

accelGroup: a AccelGroup.

-> m ()

Given an accelerator group, accelGroup, and an accelerator path, accelPath, sets up an accelerator in accelGroup so whenever the key binding that is defined for accelPath is pressed, widget will be activated. This removes any accelerators (for any accelerator group) installed by previous calls to widgetSetAccelPath. Associating accelerators with paths allows them to be modified by the user and the modifications to be saved for future use. (See accelMapSave.)

This function is a low level function that would most likely be used by a menu creation system.

If you only want to set up accelerators on menu items menuItemSetAccelPath provides a somewhat more convenient interface.

Note that accelPath string will be stored in a GQuark. Therefore, if you pass a static string, you can save some memory by interning it first with internStaticString.

setCanFocus

widgetSetCanFocus

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

canFocus: whether or not widget can own the input focus.

-> m ()

Specifies whether widget can own the input focus.

Note that having canFocus be True is only one of the necessary conditions for being focusable. A widget must also be sensitive and not have a ancestor that is marked as not child-focusable in order to receive input focus.

See widgetGrabFocus for actually setting the input focus on a widget.

setCanTarget

widgetSetCanTarget

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

canTarget: whether this widget should be able to receive pointer events

-> m ()

Sets whether widget can be the target of pointer events.

setChildVisible

widgetSetChildVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

childVisible: if True, widget should be mapped along with its parent.

-> m ()

Sets whether widget should be mapped along with its when its parent is mapped and widget has been shown with widgetShow.

The child visibility can be set for widget before it is added to a container with widgetSetParent, to avoid mapping children unnecessary before immediately unmapping them. However it will be reset to its default state of True when the widget is removed from a container.

Note that changing the child visibility of a widget does not queue a resize on the widget. Most of the time, the size of a widget is computed from all visible children, whether or not they are mapped. If this is not the case, the container can queue a resize itself.

This function is only useful for container implementations and never should be called by an application.

setCursor

widgetSetCursor

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsCursor b)

=> a

widget: a Widget

-> Maybe b

cursor: the new cursor or Nothing to use the default cursor

-> m ()

Sets the cursor to be shown when pointer devices point towards widget.

If the cursor is NULL, widget will use the cursor inherited from the parent widget.

setCursorFromName

widgetSetCursorFromName

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Text

name: The name of the cursor or Nothing to use the default cursor

-> m ()

Sets a named cursor to be shown when pointer devices point towards widget.

This is a utility function that creates a cursor via cursorNewFromName and then sets it on widget with widgetSetCursor. See those 2 functions for details.

On top of that, this function allows name to be Nothing, which will do the same as calling widgetSetCursor with a Nothing cursor.

setDefaultDirection

widgetSetDefaultDirection

Arguments

:: (HasCallStack, MonadIO m)

=> TextDirection

dir: the new default direction. This cannot be TextDirectionNone.

-> m ()

Sets the default reading direction for widgets where the direction has not been explicitly set by widgetSetDirection.

setDirection

widgetSetDirection

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> TextDirection

dir: the new direction

-> m ()

Sets the reading direction on a particular widget. This direction controls the primary direction for widgets containing text, and also the direction in which the children of a container are packed. The ability to set the direction is present in order so that correct localization into languages with right-to-left reading directions can be done. Generally, applications will let the default reading direction present, except for containers where the containers are arranged in an order that is explicitly visual rather than logical (such as buttons for text justification).

If the direction is set to TextDirectionNone, then the value set by widgetSetDefaultDirection will be used.

setFocusChild

widgetSetFocusChild

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> Maybe b

child: a direct child widget of widget or Nothing to unset the focus child of widget

-> m ()

Set child as the current focus child of widget. The previous focus child will be unset.

This function is only suitable for widget implementations. If you want a certain widget to get the input focus, call widgetGrabFocus on it.

setFocusOnClick

widgetSetFocusOnClick

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

focusOnClick: whether the widget should grab focus when clicked with the mouse

-> m ()

Sets whether the widget should grab focus when it is clicked with the mouse. Making mouse clicks not grab focus is useful in places like toolbars where you don’t want the keyboard focus removed from the main area of the application.

setFontMap

widgetSetFontMap

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsFontMap b)

=> a

widget: a Widget

-> Maybe b

fontMap: a FontMap, or Nothing to unset any previously set font map

-> m ()

Sets the font map to use for Pango rendering. When not set, the widget will inherit the font map from its parent.

setFontOptions

widgetSetFontOptions

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe FontOptions

options: a FontOptions, or Nothing to unset any previously set default font options.

-> m ()

Sets the FontOptions used for Pango rendering in this widget. When not set, the default font options for the Display will be used.

setHalign

widgetSetHalign

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Align

align: the horizontal alignment

-> m ()

Sets the horizontal alignment of widget. See the Widget:halign property.

setHasSurface

widgetSetHasSurface

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

hasSurface: whether or not widget has a surface.

-> m ()

Specifies whether widget has a Surface of its own. Note that all realized widgets have a non-Nothing “window” pointer (widgetGetSurface never returns a Nothing surface when a widget is realized), but for many of them it’s actually the Surface of one of its parent widgets. Widgets that do not create a window for themselves in realize must announce this by calling this function with hasSurface = False.

This function should only be called by widget implementations, and they should call it in their init() function.

setHasTooltip

widgetSetHasTooltip

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

hasTooltip: whether or not widget has a tooltip.

-> m ()

Sets the has-tooltip property on widget to hasTooltip. See Widget:has-tooltip for more information.

setHexpand

widgetSetHexpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Bool

expand: whether to expand

-> m ()

Sets whether the widget would like any available extra horizontal space. When a user resizes a Window, widgets with expand=TRUE generally receive the extra space. For example, a list or scrollable area or document in your window would often be set to expand.

Call this function to set the expand flag if you would like your widget to become larger horizontally when the window has extra room.

By default, widgets automatically expand if any of their children want to expand. (To see if a widget will automatically expand given its current children and state, call widgetComputeExpand. A container can decide how the expandability of children affects the expansion of the container by overriding the compute_expand virtual method on Widget.).

Setting hexpand explicitly with this function will override the automatic expand behavior.

This function forces the widget to expand or not to expand, regardless of children. The override occurs because widgetSetHexpand sets the hexpand-set property (see widgetSetHexpandSet) which causes the widget’s hexpand value to be used, rather than looking at children and widget state.

setHexpandSet

widgetSetHexpandSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Bool

set: value for hexpand-set property

-> m ()

Sets whether the hexpand flag (see widgetGetHexpand) will be used.

The hexpand-set property will be set automatically when you call widgetSetHexpand to set hexpand, so the most likely reason to use this function would be to unset an explicit expand flag.

If hexpand is set, then it overrides any computed expand value based on child widgets. If hexpand is not set, then the expand value depends on whether any children of the widget would like to expand.

There are few reasons to use this function, but it’s here for completeness and consistency.

setLayoutManager

widgetSetLayoutManager

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsLayoutManager b)

=> a

widget: a Widget

-> Maybe b

layoutManager: a LayoutManager

-> m ()

Sets the layout manager delegate instance that provides an implementation for measuring and allocating the children of widget.

setMarginBottom

widgetSetMarginBottom

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the bottom margin

-> m ()

Sets the bottom margin of widget. See the Widget:margin-bottom property.

setMarginEnd

widgetSetMarginEnd

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the end margin

-> m ()

Sets the end margin of widget. See the Widget:margin-end property.

setMarginStart

widgetSetMarginStart

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the start margin

-> m ()

Sets the start margin of widget. See the Widget:margin-start property.

setMarginTop

widgetSetMarginTop

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

margin: the top margin

-> m ()

Sets the top margin of widget. See the Widget:margin-top property.

setName

widgetSetName

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Text

name: name for the widget

-> m ()

Widgets can be named, which allows you to refer to them from a CSS file. You can apply a style to widgets with a particular name in the CSS file. See the documentation for the CSS syntax (on the same page as the docs for StyleContext).

Note that the CSS syntax has certain special characters to delimit and represent elements in a selector (period, #, >, *...), so using these will make your widget impossible to match by name. Any combination of alphanumeric symbols, dashes and underscores will suffice.

setOpacity

widgetSetOpacity

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Double

opacity: desired opacity, between 0 and 1

-> m ()

Request the widget to be rendered partially transparent, with opacity 0 being fully transparent and 1 fully opaque. (Opacity values are clamped to the [0,1] range.). This works on both toplevel widget, and child widgets, although there are some limitations:

For toplevel widgets this depends on the capabilities of the windowing system. On X11 this has any effect only on X displays with a compositing manager running. See displayIsComposited. On Windows it should work always, although setting a window’s opacity after the window has been shown causes it to flicker once on Windows.

For child widgets it doesn’t work if any affected widget has a native window.

setOverflow

widgetSetOverflow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Overflow

overflow: desired overflow

-> m ()

Sets how widget treats content that is drawn outside the widget's content area. See the definition of Overflow for details.

This setting is provided for widget implementations and should not be used by application code.

The default value is OverflowVisible.

setParent

widgetSetParent

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

widget: a Widget

-> b

parent: parent widget

-> m ()

This function is useful only when implementing subclasses of Widget. Sets parent as the parent widget of widget, and takes care of some details such as updating the state and style of the child to reflect its new location and resizing the parent. The opposite function is widgetUnparent.

setReceivesDefault

widgetSetReceivesDefault

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

receivesDefault: whether or not widget can be a default widget.

-> m ()

Specifies whether widget will be treated as the default widget within its toplevel when it has the focus, even if another widget is the default.

setSensitive

widgetSetSensitive

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

sensitive: True to make the widget sensitive

-> m ()

Sets the sensitivity of a widget. A widget is sensitive if the user can interact with it. Insensitive widgets are “grayed out” and the user can’t interact with them. Insensitive widgets are known as “inactive”, “disabled”, or “ghosted” in some other toolkits.

setSizeRequest

widgetSetSizeRequest

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Int32

width: width widget should request, or -1 to unset

-> Int32

height: height widget should request, or -1 to unset

-> m ()

Sets the minimum size of a widget; that is, the widget’s size request will be at least width by height. You can use this function to force a widget to be larger than it normally would be.

In most cases, windowSetDefaultSize is a better choice for toplevel windows than this function; setting the default size will still allow users to shrink the window. Setting the size request will force them to leave the window at least as large as the size request. When dealing with window sizes, gtk_window_set_geometry_hints() can be a useful function as well.

Note the inherent danger of setting any fixed size - themes, translations into other languages, different fonts, and user action can all change the appropriate size for a given widget. So, it's basically impossible to hardcode a size that will always be correct.

The size request of a widget is the smallest size a widget can accept while still functioning well and drawing itself correctly. However in some strange cases a widget may be allocated less than its requested size, and in many cases a widget may be allocated more space than it requested.

If the size request in a given direction is -1 (unset), then the “natural” size request of the widget will be used instead.

The size request set here does not include any margin from the Widget properties margin-left, margin-right, margin-top, and margin-bottom, but it does include pretty much all other padding or border properties set by any subclass of Widget.

setStateFlags

widgetSetStateFlags

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [StateFlags]

flags: State flags to turn on

-> Bool

clear: Whether to clear state before turning on flags

-> m ()

This function is for use in widget implementations. Turns on flag values in the current widget state (insensitive, prelighted, etc.).

This function accepts the values StateFlagsDirLtr and StateFlagsDirRtl but ignores them. If you want to set the widget's direction, use widgetSetDirection.

It is worth mentioning that any other state than StateFlagsInsensitive, will be propagated down to all non-internal children if widget is a Container, while StateFlagsInsensitive itself will be propagated down to all Container children by different means than turning on the state flag down the hierarchy, both widgetGetStateFlags and widgetIsSensitive will make use of these.

setSupportMultidevice

widgetSetSupportMultidevice

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

supportMultidevice: True to support input from multiple devices.

-> m ()

Enables or disables multiple pointer awareness. If this setting is True, widget will start receiving multiple, per device enter/leave events. Note that if custom GdkSurfaces are created in realize, surfaceSetSupportMultidevice will have to be called manually on them.

setSurface

widgetSetSurface

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsSurface b)

=> a

widget: a Widget

-> b

surface: a Surface

-> m ()

Sets a widget’s surface. This function should only be used in a widget’s realize implementation. The surface passed is usually either new surface created with gdk_surface_new(), or the surface of its parent widget as returned by gtk_widget_get_parent_surface().

Widgets must indicate whether they will create their own Surface by calling widgetSetHasSurface. This is usually done in the widget’s init() function.

Note that this function does not add any reference to surface.

setTooltipMarkup

widgetSetTooltipMarkup

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Text

markup: the contents of the tooltip for widget, or Nothing

-> m ()

Sets markup as the contents of the tooltip, which is marked up with the [Pango text markup language][PangoMarkupFormat].

This function will take care of setting Widget:has-tooltip to True and of the default handler for the queryTooltip signal.

See also the Widget:tooltip-markup property and tooltipSetMarkup.

setTooltipText

widgetSetTooltipText

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Maybe Text

text: the contents of the tooltip for widget

-> m ()

Sets text as the contents of the tooltip. This function will take care of setting Widget:has-tooltip to True and of the default handler for the queryTooltip signal.

See also the Widget:tooltip-text property and tooltipSetText.

setTooltipWindow

widgetSetTooltipWindow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWindow b)

=> a

widget: a Widget

-> Maybe b

customWindow: a Window, or Nothing

-> m ()

Replaces the default window used for displaying tooltips with customWindow. GTK+ will take care of showing and hiding customWindow at the right moment, to behave likewise as the default tooltip window. If customWindow is Nothing, the default tooltip window will be used.

setValign

widgetSetValign

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Align

align: the vertical alignment

-> m ()

Sets the vertical alignment of widget. See the Widget:valign property.

setVexpand

widgetSetVexpand

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Bool

expand: whether to expand

-> m ()

Sets whether the widget would like any available extra vertical space.

See widgetSetHexpand for more detail.

setVexpandSet

widgetSetVexpandSet

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: the widget

-> Bool

set: value for vexpand-set property

-> m ()

Sets whether the vexpand flag (see widgetGetVexpand) will be used.

See widgetSetHexpandSet for more detail.

setVisible

widgetSetVisible

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Bool

visible: whether the widget should be shown or not

-> m ()

Sets the visibility state of widget. Note that setting this to True doesn’t mean the widget is actually viewable, see widgetGetVisible.

This function simply calls widgetShow or widgetHide but is nicer to use when the visibility of the widget depends on some condition.

show

widgetShow

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Flags a widget to be displayed. Any widget that isn’t shown will not appear on the screen.

Remember that you have to show the containers containing a widget, in addition to the widget itself, before it will appear onscreen.

When a toplevel container is shown, it is immediately realized and mapped; other shown widgets are realized and mapped when their toplevel container is realized and mapped.

sizeAllocate

widgetSizeAllocate

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> Rectangle

allocation: position and size to be allocated to widget

-> Int32

baseline: The baseline of the child, or -1

-> m ()

This is a simple form of widgetAllocate that takes the new position of widget as part of allocation.

snapshotChild

widgetSnapshotChild

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b, IsSnapshot c)

=> a

widget: a Widget

-> b

child: a child of widget

-> c

snapshot: GtkSnapshot as passed to the widget. In particular, no calls to snapshotTranslate or other transform calls should have been made.

-> m ()

When a widget receives a call to the snapshot function, it must send synthetic Widget::snapshot calls to all children. This function provides a convenient way of doing this. A widget, when it receives a call to its Widget::snapshot function, calls widgetSnapshotChild once for each child, passing in the snapshot the widget received.

widgetSnapshotChild takes care of translating the origin of snapshot, and deciding whether the child needs to be snapshot.

translateCoordinates

widgetTranslateCoordinates

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsWidget b)

=> a

srcWidget: a Widget

-> b

destWidget: a Widget

-> Int32

srcX: X position relative to srcWidget

-> Int32

srcY: Y position relative to srcWidget

-> m (Bool, Int32, Int32)

Returns: False if srcWidget and destWidget have no common ancestor. In this case, 0 is stored in *destX and *destY. Otherwise True.

Translate coordinates relative to srcWidget’s allocation to coordinates relative to destWidget’s allocations. In order to perform this operation, both widget must share a common toplevel.

triggerTooltipQuery

widgetTriggerTooltipQuery

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

Triggers a tooltip query on the display where the toplevel of widget is located. See gtk_tooltip_trigger_tooltip_query() for more information.

unmap

widgetUnmap

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations. Causes a widget to be unmapped if it’s currently mapped.

unparent

widgetUnparent

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only for use in widget implementations. Should be called by parent widgets to dissociate widget from the parent.

unrealize

widgetUnrealize

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> m ()

This function is only useful in widget implementations. Causes a widget to be unrealized (frees all GDK resources associated with the widget, such as widget->surface).

unregisterSurface

widgetUnregisterSurface

Arguments

:: (HasCallStack, MonadIO m, IsWidget a, IsSurface b)

=> a

widget: a Widget

-> b

surface: a Surface

-> m ()

Unregisters a Surface from the widget that was previously set up with widgetRegisterSurface. You need to call this when the surface is no longer used by the widget, such as when you destroy it.

unsetStateFlags

widgetUnsetStateFlags

Arguments

:: (HasCallStack, MonadIO m, IsWidget a)

=> a

widget: a Widget

-> [StateFlags]

flags: State flags to turn off

-> m ()

This function is for use in widget implementations. Turns off flag values for the current widget state (insensitive, prelighted, etc.). See widgetSetStateFlags.

Properties

canFocus

No description available in the introspection data.

constructWidgetCanFocus :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “can-focus” property. This is rarely needed directly, but it is used by new.

getWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “can-focus” property. When overloading is enabled, this is equivalent to

get widget #canFocus

setWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “can-focus” property. When overloading is enabled, this is equivalent to

set widget [ #canFocus := value ]

canTarget

No description available in the introspection data.

constructWidgetCanTarget :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “can-target” property. This is rarely needed directly, but it is used by new.

getWidgetCanTarget :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “can-target” property. When overloading is enabled, this is equivalent to

get widget #canTarget

setWidgetCanTarget :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “can-target” property. When overloading is enabled, this is equivalent to

set widget [ #canTarget := value ]

cssName

The name of this widget in the CSS tree.

constructWidgetCssName :: IsWidget o => Text -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “css-name” property. This is rarely needed directly, but it is used by new.

getWidgetCssName :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

Get the value of the “css-name” property. When overloading is enabled, this is equivalent to

get widget #cssName

cursor

The cursor used by widget. See widgetSetCursor for details.

clearWidgetCursor :: (MonadIO m, IsWidget o) => o -> m ()

Set the value of the “cursor” property to Nothing. When overloading is enabled, this is equivalent to

clear #cursor

constructWidgetCursor :: (IsWidget o, IsCursor a) => a -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “cursor” property. This is rarely needed directly, but it is used by new.

getWidgetCursor :: (MonadIO m, IsWidget o) => o -> m (Maybe Cursor)

Get the value of the “cursor” property. When overloading is enabled, this is equivalent to

get widget #cursor

setWidgetCursor :: (MonadIO m, IsWidget o, IsCursor a) => o -> a -> m ()

Set the value of the “cursor” property. When overloading is enabled, this is equivalent to

set widget [ #cursor := value ]

expand

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

constructWidgetExpand :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “expand” property. This is rarely needed directly, but it is used by new.

getWidgetExpand :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “expand” property. When overloading is enabled, this is equivalent to

get widget #expand

setWidgetExpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “expand” property. When overloading is enabled, this is equivalent to

set widget [ #expand := value ]

focusOnClick

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.

constructWidgetFocusOnClick :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “focus-on-click” property. This is rarely needed directly, but it is used by new.

getWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “focus-on-click” property. When overloading is enabled, this is equivalent to

get widget #focusOnClick

setWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “focus-on-click” property. When overloading is enabled, this is equivalent to

set widget [ #focusOnClick := value ]

halign

How to distribute horizontal space if widget gets extra space, see Align

constructWidgetHalign :: IsWidget o => Align -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “halign” property. This is rarely needed directly, but it is used by new.

getWidgetHalign :: (MonadIO m, IsWidget o) => o -> m Align

Get the value of the “halign” property. When overloading is enabled, this is equivalent to

get widget #halign

setWidgetHalign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

Set the value of the “halign” property. When overloading is enabled, this is equivalent to

set widget [ #halign := value ]

hasDefault

No description available in the introspection data.

getWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “has-default” property. When overloading is enabled, this is equivalent to

get widget #hasDefault

hasFocus

No description available in the introspection data.

constructWidgetHasFocus :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “has-focus” property. This is rarely needed directly, but it is used by new.

getWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “has-focus” property. When overloading is enabled, this is equivalent to

get widget #hasFocus

setWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “has-focus” property. When overloading is enabled, this is equivalent to

set widget [ #hasFocus := value ]

hasTooltip

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

constructWidgetHasTooltip :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “has-tooltip” property. This is rarely needed directly, but it is used by new.

getWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “has-tooltip” property. When overloading is enabled, this is equivalent to

get widget #hasTooltip

setWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “has-tooltip” property. When overloading is enabled, this is equivalent to

set widget [ #hasTooltip := value ]

heightRequest

No description available in the introspection data.

constructWidgetHeightRequest :: IsWidget o => Int32 -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “height-request” property. This is rarely needed directly, but it is used by new.

getWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> m Int32

Get the value of the “height-request” property. When overloading is enabled, this is equivalent to

get widget #heightRequest

setWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

Set the value of the “height-request” property. When overloading is enabled, this is equivalent to

set widget [ #heightRequest := value ]

hexpand

Whether to expand horizontally. See widgetSetHexpand.

constructWidgetHexpand :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “hexpand” property. This is rarely needed directly, but it is used by new.

getWidgetHexpand :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “hexpand” property. When overloading is enabled, this is equivalent to

get widget #hexpand

setWidgetHexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “hexpand” property. When overloading is enabled, this is equivalent to

set widget [ #hexpand := value ]

hexpandSet

Whether to use the Widget:hexpand property. See widgetGetHexpandSet.

constructWidgetHexpandSet :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “hexpand-set” property. This is rarely needed directly, but it is used by new.

getWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “hexpand-set” property. When overloading is enabled, this is equivalent to

get widget #hexpandSet

setWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “hexpand-set” property. When overloading is enabled, this is equivalent to

set widget [ #hexpandSet := value ]

isFocus

No description available in the introspection data.

constructWidgetIsFocus :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “is-focus” property. This is rarely needed directly, but it is used by new.

getWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “is-focus” property. When overloading is enabled, this is equivalent to

get widget #isFocus

setWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “is-focus” property. When overloading is enabled, this is equivalent to

set widget [ #isFocus := value ]

layoutManager

The LayoutManager instance to use to compute the preferred size of the widget, and allocate its children.

clearWidgetLayoutManager :: (MonadIO m, IsWidget o) => o -> m ()

Set the value of the “layout-manager” property to Nothing. When overloading is enabled, this is equivalent to

clear #layoutManager

constructWidgetLayoutManager :: (IsWidget o, IsLayoutManager a) => a -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “layout-manager” property. This is rarely needed directly, but it is used by new.

getWidgetLayoutManager :: (MonadIO m, IsWidget o) => o -> m (Maybe LayoutManager)

Get the value of the “layout-manager” property. When overloading is enabled, this is equivalent to

get widget #layoutManager

setWidgetLayoutManager :: (MonadIO m, IsWidget o, IsLayoutManager a) => o -> a -> m ()

Set the value of the “layout-manager” property. When overloading is enabled, this is equivalent to

set widget [ #layoutManager := value ]

margin

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

constructWidgetMargin :: IsWidget o => Int32 -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “margin” property. This is rarely needed directly, but it is used by new.

getWidgetMargin :: (MonadIO m, IsWidget o) => o -> m Int32

Get the value of the “margin” property. When overloading is enabled, this is equivalent to

get widget #margin

setWidgetMargin :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

Set the value of the “margin” property. When overloading is enabled, this is equivalent to

set widget [ #margin := value ]

marginBottom

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 widgetSetSizeRequest for example.

constructWidgetMarginBottom :: IsWidget o => Int32 -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “margin-bottom” property. This is rarely needed directly, but it is used by new.

getWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> m Int32

Get the value of the “margin-bottom” property. When overloading is enabled, this is equivalent to

get widget #marginBottom

setWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

Set the value of the “margin-bottom” property. When overloading is enabled, this is equivalent to

set widget [ #marginBottom := value ]

marginEnd

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 widgetSetSizeRequest for example.

constructWidgetMarginEnd :: IsWidget o => Int32 -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “margin-end” property. This is rarely needed directly, but it is used by new.

getWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> m Int32

Get the value of the “margin-end” property. When overloading is enabled, this is equivalent to

get widget #marginEnd

setWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

Set the value of the “margin-end” property. When overloading is enabled, this is equivalent to

set widget [ #marginEnd := value ]

marginStart

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 widgetSetSizeRequest for example.

constructWidgetMarginStart :: IsWidget o => Int32 -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “margin-start” property. This is rarely needed directly, but it is used by new.

getWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> m Int32

Get the value of the “margin-start” property. When overloading is enabled, this is equivalent to

get widget #marginStart

setWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

Set the value of the “margin-start” property. When overloading is enabled, this is equivalent to

set widget [ #marginStart := value ]

marginTop

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 widgetSetSizeRequest for example.

constructWidgetMarginTop :: IsWidget o => Int32 -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “margin-top” property. This is rarely needed directly, but it is used by new.

getWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> m Int32

Get the value of the “margin-top” property. When overloading is enabled, this is equivalent to

get widget #marginTop

setWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

Set the value of the “margin-top” property. When overloading is enabled, this is equivalent to

set widget [ #marginTop := value ]

name

No description available in the introspection data.

constructWidgetName :: IsWidget o => Text -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “name” property. This is rarely needed directly, but it is used by new.

getWidgetName :: (MonadIO m, IsWidget o) => o -> m Text

Get the value of the “name” property. When overloading is enabled, this is equivalent to

get widget #name

setWidgetName :: (MonadIO m, IsWidget o) => o -> Text -> m ()

Set the value of the “name” property. When overloading is enabled, this is equivalent to

set widget [ #name := value ]

opacity

The requested opacity of the widget. See widgetSetOpacity for more details about window opacity.

Before 3.8 this was only available in GtkWindow

constructWidgetOpacity :: IsWidget o => Double -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “opacity” property. This is rarely needed directly, but it is used by new.

getWidgetOpacity :: (MonadIO m, IsWidget o) => o -> m Double

Get the value of the “opacity” property. When overloading is enabled, this is equivalent to

get widget #opacity

setWidgetOpacity :: (MonadIO m, IsWidget o) => o -> Double -> m ()

Set the value of the “opacity” property. When overloading is enabled, this is equivalent to

set widget [ #opacity := value ]

overflow

How content outside the widget's content area is treated.

constructWidgetOverflow :: IsWidget o => Overflow -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “overflow” property. This is rarely needed directly, but it is used by new.

getWidgetOverflow :: (MonadIO m, IsWidget o) => o -> m Overflow

Get the value of the “overflow” property. When overloading is enabled, this is equivalent to

get widget #overflow

setWidgetOverflow :: (MonadIO m, IsWidget o) => o -> Overflow -> m ()

Set the value of the “overflow” property. When overloading is enabled, this is equivalent to

set widget [ #overflow := value ]

parent

No description available in the introspection data.

getWidgetParent :: (MonadIO m, IsWidget o) => o -> m (Maybe Widget)

Get the value of the “parent” property. When overloading is enabled, this is equivalent to

get widget #parent

receivesDefault

No description available in the introspection data.

constructWidgetReceivesDefault :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “receives-default” property. This is rarely needed directly, but it is used by new.

getWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “receives-default” property. When overloading is enabled, this is equivalent to

get widget #receivesDefault

setWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “receives-default” property. When overloading is enabled, this is equivalent to

set widget [ #receivesDefault := value ]

root

The Root widget of the widget tree containing this widget or Nothing if the widget is not contained in a root widget.

getWidgetRoot :: (MonadIO m, IsWidget o) => o -> m (Maybe Root)

Get the value of the “root” property. When overloading is enabled, this is equivalent to

get widget #root

scaleFactor

The scale factor of the widget. See widgetGetScaleFactor for more details about widget scaling.

getWidgetScaleFactor :: (MonadIO m, IsWidget o) => o -> m Int32

Get the value of the “scale-factor” property. When overloading is enabled, this is equivalent to

get widget #scaleFactor

sensitive

No description available in the introspection data.

constructWidgetSensitive :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “sensitive” property. This is rarely needed directly, but it is used by new.

getWidgetSensitive :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “sensitive” property. When overloading is enabled, this is equivalent to

get widget #sensitive

setWidgetSensitive :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “sensitive” property. When overloading is enabled, this is equivalent to

set widget [ #sensitive := value ]

surface

The widget's surface if it is realized, Nothing otherwise.

getWidgetSurface :: (MonadIO m, IsWidget o) => o -> m (Maybe Surface)

Get the value of the “surface” property. When overloading is enabled, this is equivalent to

get widget #surface

tooltipMarkup

Sets the text of tooltip to be the given string, which is marked up with the [Pango text markup language][PangoMarkupFormat]. Also see tooltipSetMarkup.

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

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

clearWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m ()

Set the value of the “tooltip-markup” property to Nothing. When overloading is enabled, this is equivalent to

clear #tooltipMarkup

constructWidgetTooltipMarkup :: IsWidget o => Text -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “tooltip-markup” property. This is rarely needed directly, but it is used by new.

getWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

Get the value of the “tooltip-markup” property. When overloading is enabled, this is equivalent to

get widget #tooltipMarkup

setWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> Text -> m ()

Set the value of the “tooltip-markup” property. When overloading is enabled, this is equivalent to

set widget [ #tooltipMarkup := value ]

tooltipText

Sets the text of tooltip to be the given string.

Also see tooltipSetText.

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

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

clearWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m ()

Set the value of the “tooltip-text” property to Nothing. When overloading is enabled, this is equivalent to

clear #tooltipText

constructWidgetTooltipText :: IsWidget o => Text -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “tooltip-text” property. This is rarely needed directly, but it is used by new.

getWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m (Maybe Text)

Get the value of the “tooltip-text” property. When overloading is enabled, this is equivalent to

get widget #tooltipText

setWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> Text -> m ()

Set the value of the “tooltip-text” property. When overloading is enabled, this is equivalent to

set widget [ #tooltipText := value ]

valign

How to distribute vertical space if widget gets extra space, see Align

constructWidgetValign :: IsWidget o => Align -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “valign” property. This is rarely needed directly, but it is used by new.

getWidgetValign :: (MonadIO m, IsWidget o) => o -> m Align

Get the value of the “valign” property. When overloading is enabled, this is equivalent to

get widget #valign

setWidgetValign :: (MonadIO m, IsWidget o) => o -> Align -> m ()

Set the value of the “valign” property. When overloading is enabled, this is equivalent to

set widget [ #valign := value ]

vexpand

Whether to expand vertically. See widgetSetVexpand.

constructWidgetVexpand :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “vexpand” property. This is rarely needed directly, but it is used by new.

getWidgetVexpand :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “vexpand” property. When overloading is enabled, this is equivalent to

get widget #vexpand

setWidgetVexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “vexpand” property. When overloading is enabled, this is equivalent to

set widget [ #vexpand := value ]

vexpandSet

Whether to use the Widget:vexpand property. See widgetGetVexpandSet.

constructWidgetVexpandSet :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “vexpand-set” property. This is rarely needed directly, but it is used by new.

getWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “vexpand-set” property. When overloading is enabled, this is equivalent to

get widget #vexpandSet

setWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “vexpand-set” property. When overloading is enabled, this is equivalent to

set widget [ #vexpandSet := value ]

visible

No description available in the introspection data.

constructWidgetVisible :: IsWidget o => Bool -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “visible” property. This is rarely needed directly, but it is used by new.

getWidgetVisible :: (MonadIO m, IsWidget o) => o -> m Bool

Get the value of the “visible” property. When overloading is enabled, this is equivalent to

get widget #visible

setWidgetVisible :: (MonadIO m, IsWidget o) => o -> Bool -> m ()

Set the value of the “visible” property. When overloading is enabled, this is equivalent to

set widget [ #visible := value ]

widthRequest

No description available in the introspection data.

constructWidgetWidthRequest :: IsWidget o => Int32 -> IO (GValueConstruct o)

Construct a GValueConstruct with valid value for the “width-request” property. This is rarely needed directly, but it is used by new.

getWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> m Int32

Get the value of the “width-request” property. When overloading is enabled, this is equivalent to

get widget #widthRequest

setWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()

Set the value of the “width-request” property. When overloading is enabled, this is equivalent to

set widget [ #widthRequest := value ]

Signals

accelClosuresChanged

type C_WidgetAccelClosuresChangedCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetAccelClosuresChangedCallback = IO ()

The accelClosuresChanged signal gets emitted when accelerators for this widget get added, removed or changed.

afterWidgetAccelClosuresChanged :: (IsWidget a, MonadIO m) => a -> WidgetAccelClosuresChangedCallback -> m SignalHandlerId

Connect a signal handler for the accelClosuresChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #accelClosuresChanged callback

genClosure_WidgetAccelClosuresChanged :: MonadIO m => WidgetAccelClosuresChangedCallback -> m (GClosure C_WidgetAccelClosuresChangedCallback)

Wrap the callback into a GClosure.

mk_WidgetAccelClosuresChangedCallback :: C_WidgetAccelClosuresChangedCallback -> IO (FunPtr C_WidgetAccelClosuresChangedCallback)

Generate a function pointer callable from C code, from a C_WidgetAccelClosuresChangedCallback.

noWidgetAccelClosuresChangedCallback :: Maybe WidgetAccelClosuresChangedCallback

A convenience synonym for Nothing :: Maybe WidgetAccelClosuresChangedCallback.

onWidgetAccelClosuresChanged :: (IsWidget a, MonadIO m) => a -> WidgetAccelClosuresChangedCallback -> m SignalHandlerId

Connect a signal handler for the accelClosuresChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #accelClosuresChanged callback

wrap_WidgetAccelClosuresChangedCallback :: WidgetAccelClosuresChangedCallback -> C_WidgetAccelClosuresChangedCallback

Wrap a WidgetAccelClosuresChangedCallback into a C_WidgetAccelClosuresChangedCallback.

canActivateAccel

type C_WidgetCanActivateAccelCallback = Ptr () -> Word32 -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WidgetCanActivateAccelCallback

Arguments

 = Word32

signalId: the ID of a signal installed on widget

-> IO Bool

Returns: True if the signal can be activated.

Determines whether an accelerator that activates the signal identified by signalId can currently be activated. This signal is present to allow applications and derived widgets to override the default Widget handling for determining whether an accelerator can be activated.

afterWidgetCanActivateAccel :: (IsWidget a, MonadIO m) => a -> WidgetCanActivateAccelCallback -> m SignalHandlerId

Connect a signal handler for the canActivateAccel signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #canActivateAccel callback

genClosure_WidgetCanActivateAccel :: MonadIO m => WidgetCanActivateAccelCallback -> m (GClosure C_WidgetCanActivateAccelCallback)

Wrap the callback into a GClosure.

mk_WidgetCanActivateAccelCallback :: C_WidgetCanActivateAccelCallback -> IO (FunPtr C_WidgetCanActivateAccelCallback)

Generate a function pointer callable from C code, from a C_WidgetCanActivateAccelCallback.

noWidgetCanActivateAccelCallback :: Maybe WidgetCanActivateAccelCallback

A convenience synonym for Nothing :: Maybe WidgetCanActivateAccelCallback.

onWidgetCanActivateAccel :: (IsWidget a, MonadIO m) => a -> WidgetCanActivateAccelCallback -> m SignalHandlerId

Connect a signal handler for the canActivateAccel signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #canActivateAccel callback

wrap_WidgetCanActivateAccelCallback :: WidgetCanActivateAccelCallback -> C_WidgetCanActivateAccelCallback

Wrap a WidgetCanActivateAccelCallback into a C_WidgetCanActivateAccelCallback.

destroy

type C_WidgetDestroyCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetDestroyCallback = IO ()

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.

This signal is not suitable for saving widget state.

afterWidgetDestroy :: (IsWidget a, MonadIO m) => a -> WidgetDestroyCallback -> m SignalHandlerId

Connect a signal handler for the destroy signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #destroy callback

genClosure_WidgetDestroy :: MonadIO m => WidgetDestroyCallback -> m (GClosure C_WidgetDestroyCallback)

Wrap the callback into a GClosure.

mk_WidgetDestroyCallback :: C_WidgetDestroyCallback -> IO (FunPtr C_WidgetDestroyCallback)

Generate a function pointer callable from C code, from a C_WidgetDestroyCallback.

noWidgetDestroyCallback :: Maybe WidgetDestroyCallback

A convenience synonym for Nothing :: Maybe WidgetDestroyCallback.

onWidgetDestroy :: (IsWidget a, MonadIO m) => a -> WidgetDestroyCallback -> m SignalHandlerId

Connect a signal handler for the destroy signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #destroy callback

wrap_WidgetDestroyCallback :: WidgetDestroyCallback -> C_WidgetDestroyCallback

Wrap a WidgetDestroyCallback into a C_WidgetDestroyCallback.

directionChanged

type C_WidgetDirectionChangedCallback = Ptr () -> CUInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetDirectionChangedCallback

Arguments

 = TextDirection

previousDirection: the previous text direction of widget

-> IO ()

The directionChanged signal is emitted when the text direction of a widget changes.

afterWidgetDirectionChanged :: (IsWidget a, MonadIO m) => a -> WidgetDirectionChangedCallback -> m SignalHandlerId

Connect a signal handler for the directionChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #directionChanged callback

genClosure_WidgetDirectionChanged :: MonadIO m => WidgetDirectionChangedCallback -> m (GClosure C_WidgetDirectionChangedCallback)

Wrap the callback into a GClosure.

mk_WidgetDirectionChangedCallback :: C_WidgetDirectionChangedCallback -> IO (FunPtr C_WidgetDirectionChangedCallback)

Generate a function pointer callable from C code, from a C_WidgetDirectionChangedCallback.

noWidgetDirectionChangedCallback :: Maybe WidgetDirectionChangedCallback

A convenience synonym for Nothing :: Maybe WidgetDirectionChangedCallback.

onWidgetDirectionChanged :: (IsWidget a, MonadIO m) => a -> WidgetDirectionChangedCallback -> m SignalHandlerId

Connect a signal handler for the directionChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #directionChanged callback

wrap_WidgetDirectionChangedCallback :: WidgetDirectionChangedCallback -> C_WidgetDirectionChangedCallback

Wrap a WidgetDirectionChangedCallback into a C_WidgetDirectionChangedCallback.

dragBegin

type C_WidgetDragBeginCallback = Ptr () -> Ptr Drag -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetDragBeginCallback

Arguments

 = Drag

context: the drag context

-> IO ()

The dragBegin 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. widgetDragSourceSetIconPaintable.

Note that some widgets set up a drag icon in the default handler of this signal, so you may have to use g_signal_connect_after() to override what the default handler did.

afterWidgetDragBegin :: (IsWidget a, MonadIO m) => a -> WidgetDragBeginCallback -> m SignalHandlerId

Connect a signal handler for the dragBegin signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #dragBegin callback

genClosure_WidgetDragBegin :: MonadIO m => WidgetDragBeginCallback -> m (GClosure C_WidgetDragBeginCallback)

Wrap the callback into a GClosure.

mk_WidgetDragBeginCallback :: C_WidgetDragBeginCallback -> IO (FunPtr C_WidgetDragBeginCallback)

Generate a function pointer callable from C code, from a C_WidgetDragBeginCallback.

noWidgetDragBeginCallback :: Maybe WidgetDragBeginCallback

A convenience synonym for Nothing :: Maybe WidgetDragBeginCallback.

onWidgetDragBegin :: (IsWidget a, MonadIO m) => a -> WidgetDragBeginCallback -> m SignalHandlerId

Connect a signal handler for the dragBegin signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #dragBegin callback

wrap_WidgetDragBeginCallback :: WidgetDragBeginCallback -> C_WidgetDragBeginCallback

Wrap a WidgetDragBeginCallback into a C_WidgetDragBeginCallback.

dragDataDelete

type C_WidgetDragDataDeleteCallback = Ptr () -> Ptr Drag -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetDragDataDeleteCallback

Arguments

 = Drag

context: the drag context

-> IO ()

The dragDataDelete signal is emitted on the drag source when a drag with the action DragActionMove 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.

afterWidgetDragDataDelete :: (IsWidget a, MonadIO m) => a -> WidgetDragDataDeleteCallback -> m SignalHandlerId

Connect a signal handler for the dragDataDelete signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #dragDataDelete callback

genClosure_WidgetDragDataDelete :: MonadIO m => WidgetDragDataDeleteCallback -> m (GClosure C_WidgetDragDataDeleteCallback)

Wrap the callback into a GClosure.

mk_WidgetDragDataDeleteCallback :: C_WidgetDragDataDeleteCallback -> IO (FunPtr C_WidgetDragDataDeleteCallback)

Generate a function pointer callable from C code, from a C_WidgetDragDataDeleteCallback.

noWidgetDragDataDeleteCallback :: Maybe WidgetDragDataDeleteCallback

A convenience synonym for Nothing :: Maybe WidgetDragDataDeleteCallback.

onWidgetDragDataDelete :: (IsWidget a, MonadIO m) => a -> WidgetDragDataDeleteCallback -> m SignalHandlerId

Connect a signal handler for the dragDataDelete signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #dragDataDelete callback

wrap_WidgetDragDataDeleteCallback :: WidgetDragDataDeleteCallback -> C_WidgetDragDataDeleteCallback

Wrap a WidgetDragDataDeleteCallback into a C_WidgetDragDataDeleteCallback.

dragDataGet

type C_WidgetDragDataGetCallback = Ptr () -> Ptr Drag -> Ptr SelectionData -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetDragDataGetCallback

Arguments

 = Drag

context: the drag context

-> SelectionData

data: the SelectionData to be filled with the dragged data

-> IO ()

The dragDataGet 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 selectionDataSet and selectionDataSetText.

afterWidgetDragDataGet :: (IsWidget a, MonadIO m) => a -> WidgetDragDataGetCallback -> m SignalHandlerId

Connect a signal handler for the dragDataGet signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #dragDataGet callback

genClosure_WidgetDragDataGet :: MonadIO m => WidgetDragDataGetCallback -> m (GClosure C_WidgetDragDataGetCallback)

Wrap the callback into a GClosure.

mk_WidgetDragDataGetCallback :: C_WidgetDragDataGetCallback -> IO (FunPtr C_WidgetDragDataGetCallback)

Generate a function pointer callable from C code, from a C_WidgetDragDataGetCallback.

noWidgetDragDataGetCallback :: Maybe WidgetDragDataGetCallback

A convenience synonym for Nothing :: Maybe WidgetDragDataGetCallback.

onWidgetDragDataGet :: (IsWidget a, MonadIO m) => a -> WidgetDragDataGetCallback -> m SignalHandlerId

Connect a signal handler for the dragDataGet signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #dragDataGet callback

wrap_WidgetDragDataGetCallback :: WidgetDragDataGetCallback -> C_WidgetDragDataGetCallback

Wrap a WidgetDragDataGetCallback into a C_WidgetDragDataGetCallback.

dragDataReceived

type C_WidgetDragDataReceivedCallback = Ptr () -> Ptr Drop -> Ptr SelectionData -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetDragDataReceivedCallback

Arguments

 = Drop

drop: the Drop

-> SelectionData

x: where the drop happened

-> IO ()

The dragDataReceived 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 gdk_drag_status() and not finish the drag. If the data was received in response to a dragDrop 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 gdk_drag_finish(), setting the success parameter depending on whether the data was processed successfully.

Applications must create some means to determine why the signal was emitted and therefore whether to call gdk_drag_status() or gdk_drag_finish().

The handler may inspect the selected action with gdk_drag_context_get_selected_action() before calling gdk_drag_finish(), e.g. to implement DragActionAsk as shown in the following example:

C code

void
drag_data_received (GtkWidget          *widget,
                    GdkDrop            *drop,
                    GtkSelectionData   *data)
{
  if ((data->length >= 0) && (data->format == 8))
    {
      GdkDragAction action;

      // handle data here

      action = gdk_drop_get_actions (drop);
      if (!gdk_drag_action_is_unique (action))
        {
          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)
            action = GDK_ACTION_MOVE;
          else
            action = GDK_ACTION_COPY;
         }

      gdk_drop_finish (context, action);
    }
  else
    gdk_drop_finish (context, 0);
 }

afterWidgetDragDataReceived :: (IsWidget a, MonadIO m) => a -> WidgetDragDataReceivedCallback -> m SignalHandlerId

Connect a signal handler for the dragDataReceived signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #dragDataReceived callback

genClosure_WidgetDragDataReceived :: MonadIO m => WidgetDragDataReceivedCallback -> m (GClosure C_WidgetDragDataReceivedCallback)

Wrap the callback into a GClosure.

mk_WidgetDragDataReceivedCallback :: C_WidgetDragDataReceivedCallback -> IO (FunPtr C_WidgetDragDataReceivedCallback)

Generate a function pointer callable from C code, from a C_WidgetDragDataReceivedCallback.

noWidgetDragDataReceivedCallback :: Maybe WidgetDragDataReceivedCallback

A convenience synonym for Nothing :: Maybe WidgetDragDataReceivedCallback.

onWidgetDragDataReceived :: (IsWidget a, MonadIO m) => a -> WidgetDragDataReceivedCallback -> m SignalHandlerId

Connect a signal handler for the dragDataReceived signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #dragDataReceived callback

wrap_WidgetDragDataReceivedCallback :: WidgetDragDataReceivedCallback -> C_WidgetDragDataReceivedCallback

Wrap a WidgetDragDataReceivedCallback into a C_WidgetDragDataReceivedCallback.

dragDrop

type C_WidgetDragDropCallback = Ptr () -> Ptr Drop -> Int32 -> Int32 -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WidgetDragDropCallback

Arguments

 = Drop

drop: the Drop

-> Int32

x: the x coordinate of the current cursor position

-> Int32

y: the y coordinate of the current cursor position

-> IO Bool

Returns: whether the cursor position is in a drop zone

The dragDrop 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 False and no further processing is necessary. Otherwise, the handler returns True. In this case, the handler must ensure that gdk_drag_finish() is called to let the source know that the drop is done. The call to gdk_drag_finish() can be done either directly or in a dragDataReceived handler which gets triggered by calling widgetDragGetData to receive the data for one or more of the supported targets.

afterWidgetDragDrop :: (IsWidget a, MonadIO m) => a -> WidgetDragDropCallback -> m SignalHandlerId

Connect a signal handler for the dragDrop signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #dragDrop callback

genClosure_WidgetDragDrop :: MonadIO m => WidgetDragDropCallback -> m (GClosure C_WidgetDragDropCallback)

Wrap the callback into a GClosure.

mk_WidgetDragDropCallback :: C_WidgetDragDropCallback -> IO (FunPtr C_WidgetDragDropCallback)

Generate a function pointer callable from C code, from a C_WidgetDragDropCallback.

noWidgetDragDropCallback :: Maybe WidgetDragDropCallback

A convenience synonym for Nothing :: Maybe WidgetDragDropCallback.

onWidgetDragDrop :: (IsWidget a, MonadIO m) => a -> WidgetDragDropCallback -> m SignalHandlerId

Connect a signal handler for the dragDrop signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #dragDrop callback

wrap_WidgetDragDropCallback :: WidgetDragDropCallback -> C_WidgetDragDropCallback

Wrap a WidgetDragDropCallback into a C_WidgetDragDropCallback.

dragEnd

type C_WidgetDragEndCallback = Ptr () -> Ptr Drag -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetDragEndCallback

Arguments

 = Drag

context: the drag context

-> IO ()

The dragEnd 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 dragBegin.

afterWidgetDragEnd :: (IsWidget a, MonadIO m) => a -> WidgetDragEndCallback -> m SignalHandlerId

Connect a signal handler for the dragEnd signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #dragEnd callback

genClosure_WidgetDragEnd :: MonadIO m => WidgetDragEndCallback -> m (GClosure C_WidgetDragEndCallback)

Wrap the callback into a GClosure.

mk_WidgetDragEndCallback :: C_WidgetDragEndCallback -> IO (FunPtr C_WidgetDragEndCallback)

Generate a function pointer callable from C code, from a C_WidgetDragEndCallback.

noWidgetDragEndCallback :: Maybe WidgetDragEndCallback

A convenience synonym for Nothing :: Maybe WidgetDragEndCallback.

onWidgetDragEnd :: (IsWidget a, MonadIO m) => a -> WidgetDragEndCallback -> m SignalHandlerId

Connect a signal handler for the dragEnd signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #dragEnd callback

wrap_WidgetDragEndCallback :: WidgetDragEndCallback -> C_WidgetDragEndCallback

Wrap a WidgetDragEndCallback into a C_WidgetDragEndCallback.

dragFailed

type C_WidgetDragFailedCallback = Ptr () -> Ptr Drag -> CUInt -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WidgetDragFailedCallback

Arguments

 = Drag

context: the drag context

-> DragResult

result: the result of the drag operation

-> IO Bool

Returns: True if the failed drag operation has been already handled.

The dragFailed 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 is the failure has been already handled (not showing the default "drag operation failed" animation), otherwise it returns False.

afterWidgetDragFailed :: (IsWidget a, MonadIO m) => a -> WidgetDragFailedCallback -> m SignalHandlerId

Connect a signal handler for the dragFailed signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #dragFailed callback

genClosure_WidgetDragFailed :: MonadIO m => WidgetDragFailedCallback -> m (GClosure C_WidgetDragFailedCallback)

Wrap the callback into a GClosure.

mk_WidgetDragFailedCallback :: C_WidgetDragFailedCallback -> IO (FunPtr C_WidgetDragFailedCallback)

Generate a function pointer callable from C code, from a C_WidgetDragFailedCallback.

noWidgetDragFailedCallback :: Maybe WidgetDragFailedCallback

A convenience synonym for Nothing :: Maybe WidgetDragFailedCallback.

onWidgetDragFailed :: (IsWidget a, MonadIO m) => a -> WidgetDragFailedCallback -> m SignalHandlerId

Connect a signal handler for the dragFailed signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #dragFailed callback

wrap_WidgetDragFailedCallback :: WidgetDragFailedCallback -> C_WidgetDragFailedCallback

Wrap a WidgetDragFailedCallback into a C_WidgetDragFailedCallback.

dragLeave

type C_WidgetDragLeaveCallback = Ptr () -> Ptr Drop -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetDragLeaveCallback

Arguments

 = Drop

context: the drag context

-> IO ()

The dragLeave 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 dragMotion, e.g. undo highlighting with widgetDragUnhighlight.

Likewise, the dragLeave signal is also emitted before the dragDrop signal, for instance to allow cleaning up of a preview item created in the dragMotion signal handler.

afterWidgetDragLeave :: (IsWidget a, MonadIO m) => a -> WidgetDragLeaveCallback -> m SignalHandlerId

Connect a signal handler for the dragLeave signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #dragLeave callback

genClosure_WidgetDragLeave :: MonadIO m => WidgetDragLeaveCallback -> m (GClosure C_WidgetDragLeaveCallback)

Wrap the callback into a GClosure.

mk_WidgetDragLeaveCallback :: C_WidgetDragLeaveCallback -> IO (FunPtr C_WidgetDragLeaveCallback)

Generate a function pointer callable from C code, from a C_WidgetDragLeaveCallback.

noWidgetDragLeaveCallback :: Maybe WidgetDragLeaveCallback

A convenience synonym for Nothing :: Maybe WidgetDragLeaveCallback.

onWidgetDragLeave :: (IsWidget a, MonadIO m) => a -> WidgetDragLeaveCallback -> m SignalHandlerId

Connect a signal handler for the dragLeave signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #dragLeave callback

wrap_WidgetDragLeaveCallback :: WidgetDragLeaveCallback -> C_WidgetDragLeaveCallback

Wrap a WidgetDragLeaveCallback into a C_WidgetDragLeaveCallback.

dragMotion

type C_WidgetDragMotionCallback = Ptr () -> Ptr Drop -> Int32 -> Int32 -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WidgetDragMotionCallback

Arguments

 = Drop

drop: the Drop

-> Int32

x: the x coordinate of the current cursor position

-> Int32

y: the y coordinate of the current cursor position

-> IO Bool

Returns: whether the cursor position is in a drop zone

The dragMotion 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 False 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 gdk_drag_status().

If the decision whether the drop will be accepted or rejected can't be made based solely on the cursor position and the type of the data, the handler may inspect the dragged data by calling widgetDragGetData and defer the gdk_drag_status() call to the dragDataReceived handler. Note that you must pass GTK_DEST_DEFAULT_DROP, GTK_DEST_DEFAULT_MOTION or GTK_DEST_DEFAULT_ALL to widgetDragDestSet 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 dragLeave and if not, treat the drag-motion signal as an "enter" signal. Upon an "enter", the handler will typically highlight the drop site with widgetDragHighlight.

C code

static void
drag_motion (GtkWidget *widget,
             GdkDrop   *drop,
             gint       x,
             gint       y,
{
  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, drop, NULL);
  if (target == NULL)
    gdk_drop_status (drop, 0);
  else
   {
     private_data->pending_status
        = gdk_drop_get_actions (drop);
     gtk_drag_get_data (widget, drop, target);
   }

  return TRUE;
}

static void
drag_data_received (GtkWidget        *widget,
                    GdkDrop          *drop,
                    GtkSelectionData *selection_data)
{
  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_drop_status (drop, 0);
     else
       gdk_drag_status (drop, GDK_ACTION_ALL);
   }
  else
   {
     // accept the drop
   }
}

afterWidgetDragMotion :: (IsWidget a, MonadIO m) => a -> WidgetDragMotionCallback -> m SignalHandlerId

Connect a signal handler for the dragMotion signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #dragMotion callback

genClosure_WidgetDragMotion :: MonadIO m => WidgetDragMotionCallback -> m (GClosure C_WidgetDragMotionCallback)

Wrap the callback into a GClosure.

mk_WidgetDragMotionCallback :: C_WidgetDragMotionCallback -> IO (FunPtr C_WidgetDragMotionCallback)

Generate a function pointer callable from C code, from a C_WidgetDragMotionCallback.

noWidgetDragMotionCallback :: Maybe WidgetDragMotionCallback

A convenience synonym for Nothing :: Maybe WidgetDragMotionCallback.

onWidgetDragMotion :: (IsWidget a, MonadIO m) => a -> WidgetDragMotionCallback -> m SignalHandlerId

Connect a signal handler for the dragMotion signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #dragMotion callback

wrap_WidgetDragMotionCallback :: WidgetDragMotionCallback -> C_WidgetDragMotionCallback

Wrap a WidgetDragMotionCallback into a C_WidgetDragMotionCallback.

grabNotify

type C_WidgetGrabNotifyCallback = Ptr () -> CInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetGrabNotifyCallback

Arguments

 = Bool

wasGrabbed: False if the widget becomes shadowed, True if it becomes unshadowed

-> IO ()

The grabNotify 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 widgetGrabAdd when the topmost grab widget in the grab stack of its window group is not its ancestor.

afterWidgetGrabNotify :: (IsWidget a, MonadIO m) => a -> WidgetGrabNotifyCallback -> m SignalHandlerId

Connect a signal handler for the grabNotify signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #grabNotify callback

genClosure_WidgetGrabNotify :: MonadIO m => WidgetGrabNotifyCallback -> m (GClosure C_WidgetGrabNotifyCallback)

Wrap the callback into a GClosure.

mk_WidgetGrabNotifyCallback :: C_WidgetGrabNotifyCallback -> IO (FunPtr C_WidgetGrabNotifyCallback)

Generate a function pointer callable from C code, from a C_WidgetGrabNotifyCallback.

noWidgetGrabNotifyCallback :: Maybe WidgetGrabNotifyCallback

A convenience synonym for Nothing :: Maybe WidgetGrabNotifyCallback.

onWidgetGrabNotify :: (IsWidget a, MonadIO m) => a -> WidgetGrabNotifyCallback -> m SignalHandlerId

Connect a signal handler for the grabNotify signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #grabNotify callback

wrap_WidgetGrabNotifyCallback :: WidgetGrabNotifyCallback -> C_WidgetGrabNotifyCallback

Wrap a WidgetGrabNotifyCallback into a C_WidgetGrabNotifyCallback.

hide

type C_WidgetHideCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetHideCallback = IO ()

The hide signal is emitted when widget is hidden, for example with widgetHide.

afterWidgetHide :: (IsWidget a, MonadIO m) => a -> WidgetHideCallback -> m SignalHandlerId

Connect a signal handler for the hide signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #hide callback

genClosure_WidgetHide :: MonadIO m => WidgetHideCallback -> m (GClosure C_WidgetHideCallback)

Wrap the callback into a GClosure.

mk_WidgetHideCallback :: C_WidgetHideCallback -> IO (FunPtr C_WidgetHideCallback)

Generate a function pointer callable from C code, from a C_WidgetHideCallback.

noWidgetHideCallback :: Maybe WidgetHideCallback

A convenience synonym for Nothing :: Maybe WidgetHideCallback.

onWidgetHide :: (IsWidget a, MonadIO m) => a -> WidgetHideCallback -> m SignalHandlerId

Connect a signal handler for the hide signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #hide callback

wrap_WidgetHideCallback :: WidgetHideCallback -> C_WidgetHideCallback

Wrap a WidgetHideCallback into a C_WidgetHideCallback.

keynavFailed

type C_WidgetKeynavFailedCallback = Ptr () -> CUInt -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WidgetKeynavFailedCallback

Arguments

 = DirectionType

direction: the direction of movement

-> IO Bool

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

Gets emitted if keyboard navigation fails. See widgetKeynavFailed for details.

afterWidgetKeynavFailed :: (IsWidget a, MonadIO m) => a -> WidgetKeynavFailedCallback -> m SignalHandlerId

Connect a signal handler for the keynavFailed signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #keynavFailed callback

genClosure_WidgetKeynavFailed :: MonadIO m => WidgetKeynavFailedCallback -> m (GClosure C_WidgetKeynavFailedCallback)

Wrap the callback into a GClosure.

mk_WidgetKeynavFailedCallback :: C_WidgetKeynavFailedCallback -> IO (FunPtr C_WidgetKeynavFailedCallback)

Generate a function pointer callable from C code, from a C_WidgetKeynavFailedCallback.

noWidgetKeynavFailedCallback :: Maybe WidgetKeynavFailedCallback

A convenience synonym for Nothing :: Maybe WidgetKeynavFailedCallback.

onWidgetKeynavFailed :: (IsWidget a, MonadIO m) => a -> WidgetKeynavFailedCallback -> m SignalHandlerId

Connect a signal handler for the keynavFailed signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #keynavFailed callback

wrap_WidgetKeynavFailedCallback :: WidgetKeynavFailedCallback -> C_WidgetKeynavFailedCallback

Wrap a WidgetKeynavFailedCallback into a C_WidgetKeynavFailedCallback.

map

type C_WidgetMapCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetMapCallback = IO ()

The map signal is emitted when widget is going to be mapped, that is when the widget is visible (which is controlled with widgetSetVisible) and all its parents up to the toplevel widget are also visible.

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.

afterWidgetMap :: (IsWidget a, MonadIO m) => a -> WidgetMapCallback -> m SignalHandlerId

Connect a signal handler for the map signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #map callback

genClosure_WidgetMap :: MonadIO m => WidgetMapCallback -> m (GClosure C_WidgetMapCallback)

Wrap the callback into a GClosure.

mk_WidgetMapCallback :: C_WidgetMapCallback -> IO (FunPtr C_WidgetMapCallback)

Generate a function pointer callable from C code, from a C_WidgetMapCallback.

noWidgetMapCallback :: Maybe WidgetMapCallback

A convenience synonym for Nothing :: Maybe WidgetMapCallback.

onWidgetMap :: (IsWidget a, MonadIO m) => a -> WidgetMapCallback -> m SignalHandlerId

Connect a signal handler for the map signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #map callback

wrap_WidgetMapCallback :: WidgetMapCallback -> C_WidgetMapCallback

Wrap a WidgetMapCallback into a C_WidgetMapCallback.

mnemonicActivate

type C_WidgetMnemonicActivateCallback = Ptr () -> CInt -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WidgetMnemonicActivateCallback

Arguments

 = Bool

groupCycling: True if there are other widgets with the same mnemonic

-> IO Bool

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

The default handler for this signal activates widget if groupCycling is False, or just makes widget grab focus if groupCycling is True.

afterWidgetMnemonicActivate :: (IsWidget a, MonadIO m) => a -> WidgetMnemonicActivateCallback -> m SignalHandlerId

Connect a signal handler for the mnemonicActivate signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #mnemonicActivate callback

genClosure_WidgetMnemonicActivate :: MonadIO m => WidgetMnemonicActivateCallback -> m (GClosure C_WidgetMnemonicActivateCallback)

Wrap the callback into a GClosure.

mk_WidgetMnemonicActivateCallback :: C_WidgetMnemonicActivateCallback -> IO (FunPtr C_WidgetMnemonicActivateCallback)

Generate a function pointer callable from C code, from a C_WidgetMnemonicActivateCallback.

noWidgetMnemonicActivateCallback :: Maybe WidgetMnemonicActivateCallback

A convenience synonym for Nothing :: Maybe WidgetMnemonicActivateCallback.

onWidgetMnemonicActivate :: (IsWidget a, MonadIO m) => a -> WidgetMnemonicActivateCallback -> m SignalHandlerId

Connect a signal handler for the mnemonicActivate signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #mnemonicActivate callback

wrap_WidgetMnemonicActivateCallback :: WidgetMnemonicActivateCallback -> C_WidgetMnemonicActivateCallback

Wrap a WidgetMnemonicActivateCallback into a C_WidgetMnemonicActivateCallback.

moveFocus

type C_WidgetMoveFocusCallback = Ptr () -> CUInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetMoveFocusCallback = DirectionType -> IO ()

No description available in the introspection data.

afterWidgetMoveFocus :: (IsWidget a, MonadIO m) => a -> WidgetMoveFocusCallback -> m SignalHandlerId

Connect a signal handler for the moveFocus signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #moveFocus callback

genClosure_WidgetMoveFocus :: MonadIO m => WidgetMoveFocusCallback -> m (GClosure C_WidgetMoveFocusCallback)

Wrap the callback into a GClosure.

mk_WidgetMoveFocusCallback :: C_WidgetMoveFocusCallback -> IO (FunPtr C_WidgetMoveFocusCallback)

Generate a function pointer callable from C code, from a C_WidgetMoveFocusCallback.

noWidgetMoveFocusCallback :: Maybe WidgetMoveFocusCallback

A convenience synonym for Nothing :: Maybe WidgetMoveFocusCallback.

onWidgetMoveFocus :: (IsWidget a, MonadIO m) => a -> WidgetMoveFocusCallback -> m SignalHandlerId

Connect a signal handler for the moveFocus signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #moveFocus callback

wrap_WidgetMoveFocusCallback :: WidgetMoveFocusCallback -> C_WidgetMoveFocusCallback

Wrap a WidgetMoveFocusCallback into a C_WidgetMoveFocusCallback.

popupMenu

type C_WidgetPopupMenuCallback = Ptr () -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WidgetPopupMenuCallback

Arguments

 = IO Bool

Returns: True if a menu was activated

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 Entry widget creates a menu with clipboard commands. See the [Popup Menu Migration Checklist][checklist-popup-menu] for an example of how to use this signal.

afterWidgetPopupMenu :: (IsWidget a, MonadIO m) => a -> WidgetPopupMenuCallback -> m SignalHandlerId

Connect a signal handler for the popupMenu signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #popupMenu callback

genClosure_WidgetPopupMenu :: MonadIO m => WidgetPopupMenuCallback -> m (GClosure C_WidgetPopupMenuCallback)

Wrap the callback into a GClosure.

mk_WidgetPopupMenuCallback :: C_WidgetPopupMenuCallback -> IO (FunPtr C_WidgetPopupMenuCallback)

Generate a function pointer callable from C code, from a C_WidgetPopupMenuCallback.

noWidgetPopupMenuCallback :: Maybe WidgetPopupMenuCallback

A convenience synonym for Nothing :: Maybe WidgetPopupMenuCallback.

onWidgetPopupMenu :: (IsWidget a, MonadIO m) => a -> WidgetPopupMenuCallback -> m SignalHandlerId

Connect a signal handler for the popupMenu signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #popupMenu callback

wrap_WidgetPopupMenuCallback :: WidgetPopupMenuCallback -> C_WidgetPopupMenuCallback

Wrap a WidgetPopupMenuCallback into a C_WidgetPopupMenuCallback.

queryTooltip

type C_WidgetQueryTooltipCallback = Ptr () -> Int32 -> Int32 -> CInt -> Ptr Tooltip -> Ptr () -> IO CInt

Type for the callback on the (unwrapped) C side.

type WidgetQueryTooltipCallback

Arguments

 = Int32

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

-> Int32

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

-> Bool

keyboardMode: True if the tooltip was triggered using the keyboard

-> Tooltip

tooltip: a Tooltip

-> IO Bool

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

Emitted when Widget: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 keyboardMode 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.

afterWidgetQueryTooltip :: (IsWidget a, MonadIO m) => a -> WidgetQueryTooltipCallback -> m SignalHandlerId

Connect a signal handler for the queryTooltip signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #queryTooltip callback

genClosure_WidgetQueryTooltip :: MonadIO m => WidgetQueryTooltipCallback -> m (GClosure C_WidgetQueryTooltipCallback)

Wrap the callback into a GClosure.

mk_WidgetQueryTooltipCallback :: C_WidgetQueryTooltipCallback -> IO (FunPtr C_WidgetQueryTooltipCallback)

Generate a function pointer callable from C code, from a C_WidgetQueryTooltipCallback.

noWidgetQueryTooltipCallback :: Maybe WidgetQueryTooltipCallback

A convenience synonym for Nothing :: Maybe WidgetQueryTooltipCallback.

onWidgetQueryTooltip :: (IsWidget a, MonadIO m) => a -> WidgetQueryTooltipCallback -> m SignalHandlerId

Connect a signal handler for the queryTooltip signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #queryTooltip callback

wrap_WidgetQueryTooltipCallback :: WidgetQueryTooltipCallback -> C_WidgetQueryTooltipCallback

Wrap a WidgetQueryTooltipCallback into a C_WidgetQueryTooltipCallback.

realize

type C_WidgetRealizeCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetRealizeCallback = IO ()

The realize signal is emitted when widget is associated with a Surface, which means that widgetRealize has been called or the widget has been mapped (that is, it is going to be drawn).

afterWidgetRealize :: (IsWidget a, MonadIO m) => a -> WidgetRealizeCallback -> m SignalHandlerId

Connect a signal handler for the realize signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #realize callback

genClosure_WidgetRealize :: MonadIO m => WidgetRealizeCallback -> m (GClosure C_WidgetRealizeCallback)

Wrap the callback into a GClosure.

mk_WidgetRealizeCallback :: C_WidgetRealizeCallback -> IO (FunPtr C_WidgetRealizeCallback)

Generate a function pointer callable from C code, from a C_WidgetRealizeCallback.

noWidgetRealizeCallback :: Maybe WidgetRealizeCallback

A convenience synonym for Nothing :: Maybe WidgetRealizeCallback.

onWidgetRealize :: (IsWidget a, MonadIO m) => a -> WidgetRealizeCallback -> m SignalHandlerId

Connect a signal handler for the realize signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #realize callback

wrap_WidgetRealizeCallback :: WidgetRealizeCallback -> C_WidgetRealizeCallback

Wrap a WidgetRealizeCallback into a C_WidgetRealizeCallback.

show

type C_WidgetShowCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetShowCallback = IO ()

The show signal is emitted when widget is shown, for example with widgetShow.

afterWidgetShow :: (IsWidget a, MonadIO m) => a -> WidgetShowCallback -> m SignalHandlerId

Connect a signal handler for the show signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #show callback

genClosure_WidgetShow :: MonadIO m => WidgetShowCallback -> m (GClosure C_WidgetShowCallback)

Wrap the callback into a GClosure.

mk_WidgetShowCallback :: C_WidgetShowCallback -> IO (FunPtr C_WidgetShowCallback)

Generate a function pointer callable from C code, from a C_WidgetShowCallback.

noWidgetShowCallback :: Maybe WidgetShowCallback

A convenience synonym for Nothing :: Maybe WidgetShowCallback.

onWidgetShow :: (IsWidget a, MonadIO m) => a -> WidgetShowCallback -> m SignalHandlerId

Connect a signal handler for the show signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #show callback

wrap_WidgetShowCallback :: WidgetShowCallback -> C_WidgetShowCallback

Wrap a WidgetShowCallback into a C_WidgetShowCallback.

sizeAllocate

type C_WidgetSizeAllocateCallback = Ptr () -> Int32 -> Int32 -> Int32 -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetSizeAllocateCallback

Arguments

 = Int32

width: the content width of the widget

-> Int32

height: the content height of the widget

-> Int32

baseline: the baseline

-> IO ()

No description available in the introspection data.

afterWidgetSizeAllocate :: (IsWidget a, MonadIO m) => a -> WidgetSizeAllocateCallback -> m SignalHandlerId

Connect a signal handler for the sizeAllocate signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #sizeAllocate callback

genClosure_WidgetSizeAllocate :: MonadIO m => WidgetSizeAllocateCallback -> m (GClosure C_WidgetSizeAllocateCallback)

Wrap the callback into a GClosure.

mk_WidgetSizeAllocateCallback :: C_WidgetSizeAllocateCallback -> IO (FunPtr C_WidgetSizeAllocateCallback)

Generate a function pointer callable from C code, from a C_WidgetSizeAllocateCallback.

noWidgetSizeAllocateCallback :: Maybe WidgetSizeAllocateCallback

A convenience synonym for Nothing :: Maybe WidgetSizeAllocateCallback.

onWidgetSizeAllocate :: (IsWidget a, MonadIO m) => a -> WidgetSizeAllocateCallback -> m SignalHandlerId

Connect a signal handler for the sizeAllocate signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #sizeAllocate callback

wrap_WidgetSizeAllocateCallback :: WidgetSizeAllocateCallback -> C_WidgetSizeAllocateCallback

Wrap a WidgetSizeAllocateCallback into a C_WidgetSizeAllocateCallback.

stateFlagsChanged

type C_WidgetStateFlagsChangedCallback = Ptr () -> CUInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetStateFlagsChangedCallback

Arguments

 = [StateFlags]

flags: The previous state flags.

-> IO ()

The stateFlagsChanged signal is emitted when the widget state changes, see widgetGetStateFlags.

afterWidgetStateFlagsChanged :: (IsWidget a, MonadIO m) => a -> WidgetStateFlagsChangedCallback -> m SignalHandlerId

Connect a signal handler for the stateFlagsChanged signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #stateFlagsChanged callback

genClosure_WidgetStateFlagsChanged :: MonadIO m => WidgetStateFlagsChangedCallback -> m (GClosure C_WidgetStateFlagsChangedCallback)

Wrap the callback into a GClosure.

mk_WidgetStateFlagsChangedCallback :: C_WidgetStateFlagsChangedCallback -> IO (FunPtr C_WidgetStateFlagsChangedCallback)

Generate a function pointer callable from C code, from a C_WidgetStateFlagsChangedCallback.

noWidgetStateFlagsChangedCallback :: Maybe WidgetStateFlagsChangedCallback

A convenience synonym for Nothing :: Maybe WidgetStateFlagsChangedCallback.

onWidgetStateFlagsChanged :: (IsWidget a, MonadIO m) => a -> WidgetStateFlagsChangedCallback -> m SignalHandlerId

Connect a signal handler for the stateFlagsChanged signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #stateFlagsChanged callback

wrap_WidgetStateFlagsChangedCallback :: WidgetStateFlagsChangedCallback -> C_WidgetStateFlagsChangedCallback

Wrap a WidgetStateFlagsChangedCallback into a C_WidgetStateFlagsChangedCallback.

styleUpdated

type C_WidgetStyleUpdatedCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetStyleUpdatedCallback = IO ()

The styleUpdated signal is a convenience signal that is emitted when the changed signal is emitted on the widget's associated StyleContext as returned by widgetGetStyleContext.

afterWidgetStyleUpdated :: (IsWidget a, MonadIO m) => a -> WidgetStyleUpdatedCallback -> m SignalHandlerId

Connect a signal handler for the styleUpdated signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #styleUpdated callback

genClosure_WidgetStyleUpdated :: MonadIO m => WidgetStyleUpdatedCallback -> m (GClosure C_WidgetStyleUpdatedCallback)

Wrap the callback into a GClosure.

mk_WidgetStyleUpdatedCallback :: C_WidgetStyleUpdatedCallback -> IO (FunPtr C_WidgetStyleUpdatedCallback)

Generate a function pointer callable from C code, from a C_WidgetStyleUpdatedCallback.

noWidgetStyleUpdatedCallback :: Maybe WidgetStyleUpdatedCallback

A convenience synonym for Nothing :: Maybe WidgetStyleUpdatedCallback.

onWidgetStyleUpdated :: (IsWidget a, MonadIO m) => a -> WidgetStyleUpdatedCallback -> m SignalHandlerId

Connect a signal handler for the styleUpdated signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #styleUpdated callback

wrap_WidgetStyleUpdatedCallback :: WidgetStyleUpdatedCallback -> C_WidgetStyleUpdatedCallback

Wrap a WidgetStyleUpdatedCallback into a C_WidgetStyleUpdatedCallback.

unmap

type C_WidgetUnmapCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetUnmapCallback = IO ()

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.

afterWidgetUnmap :: (IsWidget a, MonadIO m) => a -> WidgetUnmapCallback -> m SignalHandlerId

Connect a signal handler for the unmap signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #unmap callback

genClosure_WidgetUnmap :: MonadIO m => WidgetUnmapCallback -> m (GClosure C_WidgetUnmapCallback)

Wrap the callback into a GClosure.

mk_WidgetUnmapCallback :: C_WidgetUnmapCallback -> IO (FunPtr C_WidgetUnmapCallback)

Generate a function pointer callable from C code, from a C_WidgetUnmapCallback.

noWidgetUnmapCallback :: Maybe WidgetUnmapCallback

A convenience synonym for Nothing :: Maybe WidgetUnmapCallback.

onWidgetUnmap :: (IsWidget a, MonadIO m) => a -> WidgetUnmapCallback -> m SignalHandlerId

Connect a signal handler for the unmap signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #unmap callback

wrap_WidgetUnmapCallback :: WidgetUnmapCallback -> C_WidgetUnmapCallback

Wrap a WidgetUnmapCallback into a C_WidgetUnmapCallback.

unrealize

type C_WidgetUnrealizeCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type WidgetUnrealizeCallback = IO ()

The unrealize signal is emitted when the Surface associated with widget is destroyed, which means that widgetUnrealize has been called or the widget has been unmapped (that is, it is going to be hidden).

afterWidgetUnrealize :: (IsWidget a, MonadIO m) => a -> WidgetUnrealizeCallback -> m SignalHandlerId

Connect a signal handler for the unrealize signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after widget #unrealize callback

genClosure_WidgetUnrealize :: MonadIO m => WidgetUnrealizeCallback -> m (GClosure C_WidgetUnrealizeCallback)

Wrap the callback into a GClosure.

mk_WidgetUnrealizeCallback :: C_WidgetUnrealizeCallback -> IO (FunPtr C_WidgetUnrealizeCallback)

Generate a function pointer callable from C code, from a C_WidgetUnrealizeCallback.

noWidgetUnrealizeCallback :: Maybe WidgetUnrealizeCallback

A convenience synonym for Nothing :: Maybe WidgetUnrealizeCallback.

onWidgetUnrealize :: (IsWidget a, MonadIO m) => a -> WidgetUnrealizeCallback -> m SignalHandlerId

Connect a signal handler for the unrealize signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on widget #unrealize callback

wrap_WidgetUnrealizeCallback :: WidgetUnrealizeCallback -> C_WidgetUnrealizeCallback

Wrap a WidgetUnrealizeCallback into a C_WidgetUnrealizeCallback.