{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

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

# Height-for-width Geometry Management # {@/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 five virtual methods:

* 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_request_mode/@()
* 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_width/@()
* 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_height/@()
* 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_height_for_width/@()
* 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_width_for_height/@()
* 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_height_and_baseline_for_width/@()


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

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

For example, when queried in the normal
'GI.Gtk.Enums.SizeRequestModeHeightForWidth' mode:
First, the default minimum and natural width for each widget
in the interface will be computed using 'GI.Gtk.Objects.Widget.widgetGetPreferredWidth'.
Because the preferred widths for each container depend on the preferred
widths of their children, this information propagates up the hierarchy,
and finally a minimum and natural width is determined for the entire
toplevel. Next, the toplevel will use the minimum width to query for the
minimum height contextual to that width using
'GI.Gtk.Objects.Widget.widgetGetPreferredHeightForWidth', which will also be a highly
recursive operation. The minimum height for the minimum width is normally
used to set the minimum size constraint on the toplevel
(unless 'GI.Gtk.Objects.Window.windowSetGeometryHints' 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 'GI.Gtk.Objects.Window.windowSetDefaultSize'). During the
recursive allocation process it’s important to note that request cycles
will be recursively executed while container widgets allocate their children.
Each container widget, once allocated a size, will go on to first share the
space in one orientation among its children and then request each child\'s
height for its target allocated width or its width for allocated height,
depending. In this way a 'GI.Gtk.Objects.Widget.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, 'GI.Gtk.Objects.Widget.Widget' caches a  small number of results
to avoid re-querying for the same sizes in one allocation cycle.

See
[GtkContainer’s geometry management section][container-geometry-management]
to learn more about how height-for-width allocations are performed
by container widgets.

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

For instance, a 'GI.Gtk.Objects.Label.Label' that does height-for-width word wrapping
will not expect to have 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_height/@() called
because that call is specific to a width-for-height request. In this
case the label must return the height required for its own minimum
possible width. By following this rule any widget that handles
height-for-width or width-for-height requests will always be allocated
at least enough space to fit its own content.

Here are some examples of how a 'GI.Gtk.Enums.SizeRequestModeHeightForWidth' widget
generally deals with width-for-height requests, for 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_height/@()
it will do:


=== /C code/
>
>static void
>foo_widget_get_preferred_height (GtkWidget *widget,
>                                 gint *min_height,
>                                 gint *nat_height)
>{
>   if (i_am_in_height_for_width_mode)
>     {
>       gint min_width, nat_width;
>
>       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
>                                                           &min_width,
>                                                           &nat_width);
>       GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width
>                                                          (widget,
>                                                           min_width,
>                                                           min_height,
>                                                           nat_height);
>     }
>   else
>     {
>        ... some widgets do both. For instance, if a GtkLabel is
>        rotated to 90 degrees it will return the minimum and
>        natural height for the rotated label here.
>     }
>}


And in 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_width_for_height/@() it will simply return
the minimum and natural width:

=== /C code/
>
>static void
>foo_widget_get_preferred_width_for_height (GtkWidget *widget,
>                                           gint for_height,
>                                           gint *min_width,
>                                           gint *nat_width)
>{
>   if (i_am_in_height_for_width_mode)
>     {
>       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
>                                                           min_width,
>                                                           nat_width);
>     }
>   else
>     {
>        ... again if a widget is sometimes operating in
>        width-for-height mode (like a rotated GtkLabel) it can go
>        ahead and do its real width for height calculation here.
>     }
>}


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


=== /C code/
>
>GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget,
>                                                   &min,
>                                                   &natural);


It will not work to use the wrapper functions, such as
'GI.Gtk.Objects.Widget.widgetGetPreferredWidth' inside your own size request
implementation. These return a request adjusted by 'GI.Gtk.Objects.SizeGroup.SizeGroup'
and by the 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/adjust_size_request/@() virtual method. If a
widget used the wrappers inside its virtual method implementations,
then the adjustments (such as widget margins) would be applied
twice. GTK+ therefore does not allow this and will warn if you try
to do it.

Of course if you are getting the size request for
another widget, such as a child of a
container, you must use the wrapper APIs.
Otherwise, you would not properly consider widget margins,
'GI.Gtk.Objects.SizeGroup.SizeGroup', and so forth.

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

Baseline alignment support for a widget is done by the 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_height_and_baseline_for_width/@()
virtual function. It allows you to report a baseline in combination with the
minimum and natural height. If there is no baseline you can return -1 to indicate
this. The default implementation of this virtual function calls into the
'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_height/@() and 'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/get_preferred_height_for_width/@(),
so if baselines are not supported it doesn’t need to be implemented.

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

= Style Properties

'GI.Gtk.Objects.Widget.Widget' introduces “style
properties” - these are basically object properties that are stored
not on the object, but in the style object associated to the widget. Style
properties are set in [resource files][gtk3-Resource-Files].
This mechanism is used for configuring such things as the location of the
scrollbar arrows through the theme, giving theme authors more control over the
look of applications without the need to write a theme engine in C.

Use 'GI.Gtk.Structs.WidgetClass.widgetClassInstallStyleProperty' to install style properties for
a widget class, 'GI.Gtk.Structs.WidgetClass.widgetClassFindStyleProperty' or
'GI.Gtk.Structs.WidgetClass.widgetClassListStyleProperties' to get information about existing
style properties and 'GI.Gtk.Objects.Widget.widgetStyleGetProperty', @/gtk_widget_style_get()/@ or
@/gtk_widget_style_get_valist()/@ to obtain the value of a style property.

= 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:
>
><object class="GtkButton">
>  <accelerator 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 'GI.Gtk.Objects.Widget.Widget'.

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


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


# Building composite widgets from template XML ## {@/composite/@-templates}

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

To create composite widgets with 'GI.Gtk.Objects.Builder.Builder' XML, one must associate
the interface description with the widget class at class initialization
time using 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.

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

Unlike regular interface descriptions, 'GI.Gtk.Structs.WidgetClass.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>
>  <template class="FooWidget" parent="GtkBox">
>    <property name="orientation">GTK_ORIENTATION_HORIZONTAL</property>
>    <property name="spacing">4</property>
>    <child>
>      <object class="GtkButton" id="hello_button">
>        <property name="label">Hello World</property>
>        <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/>
>      </object>
>    </child>
>    <child>
>      <object class="GtkButton" id="goodbye_button">
>        <property name="label">Goodbye World</property>
>      </object>
>    </child>
>  </template>
></interface>


Typically, you\'ll place the template fragment into a file that is
bundled with your project, using 'GI.Gio.Structs.Resource.Resource'. In order to load the
template, you need to call 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateFromResource'
from the class initialization of your 'GI.Gtk.Objects.Widget.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 'GI.Gtk.Objects.Widget.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
'GI.Gtk.Objects.Widget.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);
>}


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);
>}

-}

module GI.Gtk.Objects.Widget
    ( 

-- * Exported types
    Widget(..)                              ,
    IsWidget                                ,
    toWidget                                ,
    noWidget                                ,


 -- * Methods
-- ** activate #method:activate#
    WidgetActivateMethodInfo                ,
    widgetActivate                          ,


-- ** addAccelerator #method:addAccelerator#
    WidgetAddAcceleratorMethodInfo          ,
    widgetAddAccelerator                    ,


-- ** addDeviceEvents #method:addDeviceEvents#
    WidgetAddDeviceEventsMethodInfo         ,
    widgetAddDeviceEvents                   ,


-- ** addEvents #method:addEvents#
    WidgetAddEventsMethodInfo               ,
    widgetAddEvents                         ,


-- ** addMnemonicLabel #method:addMnemonicLabel#
    WidgetAddMnemonicLabelMethodInfo        ,
    widgetAddMnemonicLabel                  ,


-- ** addTickCallback #method:addTickCallback#
    WidgetAddTickCallbackMethodInfo         ,
    widgetAddTickCallback                   ,


-- ** canActivateAccel #method:canActivateAccel#
    WidgetCanActivateAccelMethodInfo        ,
    widgetCanActivateAccel                  ,


-- ** childFocus #method:childFocus#
    WidgetChildFocusMethodInfo              ,
    widgetChildFocus                        ,


-- ** childNotify #method:childNotify#
    WidgetChildNotifyMethodInfo             ,
    widgetChildNotify                       ,


-- ** classPath #method:classPath#
    WidgetClassPathMethodInfo               ,
    widgetClassPath                         ,


-- ** computeExpand #method:computeExpand#
    WidgetComputeExpandMethodInfo           ,
    widgetComputeExpand                     ,


-- ** createPangoContext #method:createPangoContext#
    WidgetCreatePangoContextMethodInfo      ,
    widgetCreatePangoContext                ,


-- ** createPangoLayout #method:createPangoLayout#
    WidgetCreatePangoLayoutMethodInfo       ,
    widgetCreatePangoLayout                 ,


-- ** destroy #method:destroy#
    WidgetDestroyMethodInfo                 ,
    widgetDestroy                           ,


-- ** destroyed #method:destroyed#
    WidgetDestroyedMethodInfo               ,
    widgetDestroyed                         ,


-- ** deviceIsShadowed #method:deviceIsShadowed#
    WidgetDeviceIsShadowedMethodInfo        ,
    widgetDeviceIsShadowed                  ,


-- ** dragBegin #method:dragBegin#
    WidgetDragBeginMethodInfo               ,
    widgetDragBegin                         ,


-- ** dragBeginWithCoordinates #method:dragBeginWithCoordinates#
    WidgetDragBeginWithCoordinatesMethodInfo,
    widgetDragBeginWithCoordinates          ,


-- ** dragCheckThreshold #method:dragCheckThreshold#
    WidgetDragCheckThresholdMethodInfo      ,
    widgetDragCheckThreshold                ,


-- ** dragDestAddImageTargets #method:dragDestAddImageTargets#
    WidgetDragDestAddImageTargetsMethodInfo ,
    widgetDragDestAddImageTargets           ,


-- ** dragDestAddTextTargets #method:dragDestAddTextTargets#
    WidgetDragDestAddTextTargetsMethodInfo  ,
    widgetDragDestAddTextTargets            ,


-- ** dragDestAddUriTargets #method:dragDestAddUriTargets#
    WidgetDragDestAddUriTargetsMethodInfo   ,
    widgetDragDestAddUriTargets             ,


-- ** dragDestFindTarget #method:dragDestFindTarget#
    WidgetDragDestFindTargetMethodInfo      ,
    widgetDragDestFindTarget                ,


-- ** dragDestGetTargetList #method:dragDestGetTargetList#
    WidgetDragDestGetTargetListMethodInfo   ,
    widgetDragDestGetTargetList             ,


-- ** dragDestGetTrackMotion #method:dragDestGetTrackMotion#
    WidgetDragDestGetTrackMotionMethodInfo  ,
    widgetDragDestGetTrackMotion            ,


-- ** dragDestSet #method:dragDestSet#
    WidgetDragDestSetMethodInfo             ,
    widgetDragDestSet                       ,


-- ** dragDestSetProxy #method:dragDestSetProxy#
    WidgetDragDestSetProxyMethodInfo        ,
    widgetDragDestSetProxy                  ,


-- ** dragDestSetTargetList #method:dragDestSetTargetList#
    WidgetDragDestSetTargetListMethodInfo   ,
    widgetDragDestSetTargetList             ,


-- ** dragDestSetTrackMotion #method:dragDestSetTrackMotion#
    WidgetDragDestSetTrackMotionMethodInfo  ,
    widgetDragDestSetTrackMotion            ,


-- ** dragDestUnset #method:dragDestUnset#
    WidgetDragDestUnsetMethodInfo           ,
    widgetDragDestUnset                     ,


-- ** dragGetData #method:dragGetData#
    WidgetDragGetDataMethodInfo             ,
    widgetDragGetData                       ,


-- ** dragHighlight #method:dragHighlight#
    WidgetDragHighlightMethodInfo           ,
    widgetDragHighlight                     ,


-- ** dragSourceAddImageTargets #method:dragSourceAddImageTargets#
    WidgetDragSourceAddImageTargetsMethodInfo,
    widgetDragSourceAddImageTargets         ,


-- ** dragSourceAddTextTargets #method:dragSourceAddTextTargets#
    WidgetDragSourceAddTextTargetsMethodInfo,
    widgetDragSourceAddTextTargets          ,


-- ** dragSourceAddUriTargets #method:dragSourceAddUriTargets#
    WidgetDragSourceAddUriTargetsMethodInfo ,
    widgetDragSourceAddUriTargets           ,


-- ** dragSourceGetTargetList #method:dragSourceGetTargetList#
    WidgetDragSourceGetTargetListMethodInfo ,
    widgetDragSourceGetTargetList           ,


-- ** dragSourceSet #method:dragSourceSet#
    WidgetDragSourceSetMethodInfo           ,
    widgetDragSourceSet                     ,


-- ** dragSourceSetIconGicon #method:dragSourceSetIconGicon#
    WidgetDragSourceSetIconGiconMethodInfo  ,
    widgetDragSourceSetIconGicon            ,


-- ** dragSourceSetIconName #method:dragSourceSetIconName#
    WidgetDragSourceSetIconNameMethodInfo   ,
    widgetDragSourceSetIconName             ,


-- ** dragSourceSetIconPixbuf #method:dragSourceSetIconPixbuf#
    WidgetDragSourceSetIconPixbufMethodInfo ,
    widgetDragSourceSetIconPixbuf           ,


-- ** dragSourceSetIconStock #method:dragSourceSetIconStock#
    WidgetDragSourceSetIconStockMethodInfo  ,
    widgetDragSourceSetIconStock            ,


-- ** dragSourceSetTargetList #method:dragSourceSetTargetList#
    WidgetDragSourceSetTargetListMethodInfo ,
    widgetDragSourceSetTargetList           ,


-- ** dragSourceUnset #method:dragSourceUnset#
    WidgetDragSourceUnsetMethodInfo         ,
    widgetDragSourceUnset                   ,


-- ** dragUnhighlight #method:dragUnhighlight#
    WidgetDragUnhighlightMethodInfo         ,
    widgetDragUnhighlight                   ,


-- ** draw #method:draw#
    WidgetDrawMethodInfo                    ,
    widgetDraw                              ,


-- ** ensureStyle #method:ensureStyle#
    WidgetEnsureStyleMethodInfo             ,
    widgetEnsureStyle                       ,


-- ** errorBell #method:errorBell#
    WidgetErrorBellMethodInfo               ,
    widgetErrorBell                         ,


-- ** event #method:event#
    WidgetEventMethodInfo                   ,
    widgetEvent                             ,


-- ** freezeChildNotify #method:freezeChildNotify#
    WidgetFreezeChildNotifyMethodInfo       ,
    widgetFreezeChildNotify                 ,


-- ** getAccessible #method:getAccessible#
    WidgetGetAccessibleMethodInfo           ,
    widgetGetAccessible                     ,


-- ** getActionGroup #method:getActionGroup#
    WidgetGetActionGroupMethodInfo          ,
    widgetGetActionGroup                    ,


-- ** getAllocatedBaseline #method:getAllocatedBaseline#
    WidgetGetAllocatedBaselineMethodInfo    ,
    widgetGetAllocatedBaseline              ,


-- ** getAllocatedHeight #method:getAllocatedHeight#
    WidgetGetAllocatedHeightMethodInfo      ,
    widgetGetAllocatedHeight                ,


-- ** getAllocatedSize #method:getAllocatedSize#
    WidgetGetAllocatedSizeMethodInfo        ,
    widgetGetAllocatedSize                  ,


-- ** getAllocatedWidth #method:getAllocatedWidth#
    WidgetGetAllocatedWidthMethodInfo       ,
    widgetGetAllocatedWidth                 ,


-- ** getAllocation #method:getAllocation#
    WidgetGetAllocationMethodInfo           ,
    widgetGetAllocation                     ,


-- ** getAncestor #method:getAncestor#
    WidgetGetAncestorMethodInfo             ,
    widgetGetAncestor                       ,


-- ** getAppPaintable #method:getAppPaintable#
    WidgetGetAppPaintableMethodInfo         ,
    widgetGetAppPaintable                   ,


-- ** getCanDefault #method:getCanDefault#
    WidgetGetCanDefaultMethodInfo           ,
    widgetGetCanDefault                     ,


-- ** getCanFocus #method:getCanFocus#
    WidgetGetCanFocusMethodInfo             ,
    widgetGetCanFocus                       ,


-- ** getChildRequisition #method:getChildRequisition#
    WidgetGetChildRequisitionMethodInfo     ,
    widgetGetChildRequisition               ,


-- ** getChildVisible #method:getChildVisible#
    WidgetGetChildVisibleMethodInfo         ,
    widgetGetChildVisible                   ,


-- ** getClip #method:getClip#
    WidgetGetClipMethodInfo                 ,
    widgetGetClip                           ,


-- ** getClipboard #method:getClipboard#
    WidgetGetClipboardMethodInfo            ,
    widgetGetClipboard                      ,


-- ** getCompositeName #method:getCompositeName#
    WidgetGetCompositeNameMethodInfo        ,
    widgetGetCompositeName                  ,


-- ** getDefaultDirection #method:getDefaultDirection#
    widgetGetDefaultDirection               ,


-- ** getDefaultStyle #method:getDefaultStyle#
    widgetGetDefaultStyle                   ,


-- ** getDeviceEnabled #method:getDeviceEnabled#
    WidgetGetDeviceEnabledMethodInfo        ,
    widgetGetDeviceEnabled                  ,


-- ** getDeviceEvents #method:getDeviceEvents#
    WidgetGetDeviceEventsMethodInfo         ,
    widgetGetDeviceEvents                   ,


-- ** getDirection #method:getDirection#
    WidgetGetDirectionMethodInfo            ,
    widgetGetDirection                      ,


-- ** getDisplay #method:getDisplay#
    WidgetGetDisplayMethodInfo              ,
    widgetGetDisplay                        ,


-- ** getDoubleBuffered #method:getDoubleBuffered#
    WidgetGetDoubleBufferedMethodInfo       ,
    widgetGetDoubleBuffered                 ,


-- ** getEvents #method:getEvents#
    WidgetGetEventsMethodInfo               ,
    widgetGetEvents                         ,


-- ** getFocusOnClick #method:getFocusOnClick#
    WidgetGetFocusOnClickMethodInfo         ,
    widgetGetFocusOnClick                   ,


-- ** getFontMap #method:getFontMap#
    WidgetGetFontMapMethodInfo              ,
    widgetGetFontMap                        ,


-- ** getFontOptions #method:getFontOptions#
    WidgetGetFontOptionsMethodInfo          ,
    widgetGetFontOptions                    ,


-- ** getFrameClock #method:getFrameClock#
    WidgetGetFrameClockMethodInfo           ,
    widgetGetFrameClock                     ,


-- ** getHalign #method:getHalign#
    WidgetGetHalignMethodInfo               ,
    widgetGetHalign                         ,


-- ** getHasTooltip #method:getHasTooltip#
    WidgetGetHasTooltipMethodInfo           ,
    widgetGetHasTooltip                     ,


-- ** getHasWindow #method:getHasWindow#
    WidgetGetHasWindowMethodInfo            ,
    widgetGetHasWindow                      ,


-- ** getHexpand #method:getHexpand#
    WidgetGetHexpandMethodInfo              ,
    widgetGetHexpand                        ,


-- ** getHexpandSet #method:getHexpandSet#
    WidgetGetHexpandSetMethodInfo           ,
    widgetGetHexpandSet                     ,


-- ** getMapped #method:getMapped#
    WidgetGetMappedMethodInfo               ,
    widgetGetMapped                         ,


-- ** getMarginBottom #method:getMarginBottom#
    WidgetGetMarginBottomMethodInfo         ,
    widgetGetMarginBottom                   ,


-- ** getMarginEnd #method:getMarginEnd#
    WidgetGetMarginEndMethodInfo            ,
    widgetGetMarginEnd                      ,


-- ** getMarginLeft #method:getMarginLeft#
    WidgetGetMarginLeftMethodInfo           ,
    widgetGetMarginLeft                     ,


-- ** getMarginRight #method:getMarginRight#
    WidgetGetMarginRightMethodInfo          ,
    widgetGetMarginRight                    ,


-- ** getMarginStart #method:getMarginStart#
    WidgetGetMarginStartMethodInfo          ,
    widgetGetMarginStart                    ,


-- ** getMarginTop #method:getMarginTop#
    WidgetGetMarginTopMethodInfo            ,
    widgetGetMarginTop                      ,


-- ** getModifierMask #method:getModifierMask#
    WidgetGetModifierMaskMethodInfo         ,
    widgetGetModifierMask                   ,


-- ** getModifierStyle #method:getModifierStyle#
    WidgetGetModifierStyleMethodInfo        ,
    widgetGetModifierStyle                  ,


-- ** getName #method:getName#
    WidgetGetNameMethodInfo                 ,
    widgetGetName                           ,


-- ** getNoShowAll #method:getNoShowAll#
    WidgetGetNoShowAllMethodInfo            ,
    widgetGetNoShowAll                      ,


-- ** getOpacity #method:getOpacity#
    WidgetGetOpacityMethodInfo              ,
    widgetGetOpacity                        ,


-- ** getPangoContext #method:getPangoContext#
    WidgetGetPangoContextMethodInfo         ,
    widgetGetPangoContext                   ,


-- ** getParent #method:getParent#
    WidgetGetParentMethodInfo               ,
    widgetGetParent                         ,


-- ** getParentWindow #method:getParentWindow#
    WidgetGetParentWindowMethodInfo         ,
    widgetGetParentWindow                   ,


-- ** getPath #method:getPath#
    WidgetGetPathMethodInfo                 ,
    widgetGetPath                           ,


-- ** getPointer #method:getPointer#
    WidgetGetPointerMethodInfo              ,
    widgetGetPointer                        ,


-- ** getPreferredHeight #method:getPreferredHeight#
    WidgetGetPreferredHeightMethodInfo      ,
    widgetGetPreferredHeight                ,


-- ** getPreferredHeightAndBaselineForWidth #method:getPreferredHeightAndBaselineForWidth#
    WidgetGetPreferredHeightAndBaselineForWidthMethodInfo,
    widgetGetPreferredHeightAndBaselineForWidth,


-- ** getPreferredHeightForWidth #method:getPreferredHeightForWidth#
    WidgetGetPreferredHeightForWidthMethodInfo,
    widgetGetPreferredHeightForWidth        ,


-- ** getPreferredSize #method:getPreferredSize#
    WidgetGetPreferredSizeMethodInfo        ,
    widgetGetPreferredSize                  ,


-- ** getPreferredWidth #method:getPreferredWidth#
    WidgetGetPreferredWidthMethodInfo       ,
    widgetGetPreferredWidth                 ,


-- ** getPreferredWidthForHeight #method:getPreferredWidthForHeight#
    WidgetGetPreferredWidthForHeightMethodInfo,
    widgetGetPreferredWidthForHeight        ,


-- ** getRealized #method:getRealized#
    WidgetGetRealizedMethodInfo             ,
    widgetGetRealized                       ,


-- ** getReceivesDefault #method:getReceivesDefault#
    WidgetGetReceivesDefaultMethodInfo      ,
    widgetGetReceivesDefault                ,


-- ** getRequestMode #method:getRequestMode#
    WidgetGetRequestModeMethodInfo          ,
    widgetGetRequestMode                    ,


-- ** getRequisition #method:getRequisition#
    WidgetGetRequisitionMethodInfo          ,
    widgetGetRequisition                    ,


-- ** getRootWindow #method:getRootWindow#
    WidgetGetRootWindowMethodInfo           ,
    widgetGetRootWindow                     ,


-- ** getScaleFactor #method:getScaleFactor#
    WidgetGetScaleFactorMethodInfo          ,
    widgetGetScaleFactor                    ,


-- ** getScreen #method:getScreen#
    WidgetGetScreenMethodInfo               ,
    widgetGetScreen                         ,


-- ** getSensitive #method:getSensitive#
    WidgetGetSensitiveMethodInfo            ,
    widgetGetSensitive                      ,


-- ** getSettings #method:getSettings#
    WidgetGetSettingsMethodInfo             ,
    widgetGetSettings                       ,


-- ** getSizeRequest #method:getSizeRequest#
    WidgetGetSizeRequestMethodInfo          ,
    widgetGetSizeRequest                    ,


-- ** getState #method:getState#
    WidgetGetStateMethodInfo                ,
    widgetGetState                          ,


-- ** getStateFlags #method:getStateFlags#
    WidgetGetStateFlagsMethodInfo           ,
    widgetGetStateFlags                     ,


-- ** getStyle #method:getStyle#
    WidgetGetStyleMethodInfo                ,
    widgetGetStyle                          ,


-- ** getStyleContext #method:getStyleContext#
    WidgetGetStyleContextMethodInfo         ,
    widgetGetStyleContext                   ,


-- ** getSupportMultidevice #method:getSupportMultidevice#
    WidgetGetSupportMultideviceMethodInfo   ,
    widgetGetSupportMultidevice             ,


-- ** getTemplateChild #method:getTemplateChild#
    WidgetGetTemplateChildMethodInfo        ,
    widgetGetTemplateChild                  ,


-- ** getTooltipMarkup #method:getTooltipMarkup#
    WidgetGetTooltipMarkupMethodInfo        ,
    widgetGetTooltipMarkup                  ,


-- ** getTooltipText #method:getTooltipText#
    WidgetGetTooltipTextMethodInfo          ,
    widgetGetTooltipText                    ,


-- ** getTooltipWindow #method:getTooltipWindow#
    WidgetGetTooltipWindowMethodInfo        ,
    widgetGetTooltipWindow                  ,


-- ** getToplevel #method:getToplevel#
    WidgetGetToplevelMethodInfo             ,
    widgetGetToplevel                       ,


-- ** getValign #method:getValign#
    WidgetGetValignMethodInfo               ,
    widgetGetValign                         ,


-- ** getValignWithBaseline #method:getValignWithBaseline#
    WidgetGetValignWithBaselineMethodInfo   ,
    widgetGetValignWithBaseline             ,


-- ** getVexpand #method:getVexpand#
    WidgetGetVexpandMethodInfo              ,
    widgetGetVexpand                        ,


-- ** getVexpandSet #method:getVexpandSet#
    WidgetGetVexpandSetMethodInfo           ,
    widgetGetVexpandSet                     ,


-- ** getVisible #method:getVisible#
    WidgetGetVisibleMethodInfo              ,
    widgetGetVisible                        ,


-- ** getVisual #method:getVisual#
    WidgetGetVisualMethodInfo               ,
    widgetGetVisual                         ,


-- ** getWindow #method:getWindow#
    WidgetGetWindowMethodInfo               ,
    widgetGetWindow                         ,


-- ** grabAdd #method:grabAdd#
    WidgetGrabAddMethodInfo                 ,
    widgetGrabAdd                           ,


-- ** grabDefault #method:grabDefault#
    WidgetGrabDefaultMethodInfo             ,
    widgetGrabDefault                       ,


-- ** grabFocus #method:grabFocus#
    WidgetGrabFocusMethodInfo               ,
    widgetGrabFocus                         ,


-- ** grabRemove #method:grabRemove#
    WidgetGrabRemoveMethodInfo              ,
    widgetGrabRemove                        ,


-- ** hasDefault #method:hasDefault#
    WidgetHasDefaultMethodInfo              ,
    widgetHasDefault                        ,


-- ** hasFocus #method:hasFocus#
    WidgetHasFocusMethodInfo                ,
    widgetHasFocus                          ,


-- ** hasGrab #method:hasGrab#
    WidgetHasGrabMethodInfo                 ,
    widgetHasGrab                           ,


-- ** hasRcStyle #method:hasRcStyle#
    WidgetHasRcStyleMethodInfo              ,
    widgetHasRcStyle                        ,


-- ** hasScreen #method:hasScreen#
    WidgetHasScreenMethodInfo               ,
    widgetHasScreen                         ,


-- ** hasVisibleFocus #method:hasVisibleFocus#
    WidgetHasVisibleFocusMethodInfo         ,
    widgetHasVisibleFocus                   ,


-- ** hide #method:hide#
    WidgetHideMethodInfo                    ,
    widgetHide                              ,


-- ** hideOnDelete #method:hideOnDelete#
    WidgetHideOnDeleteMethodInfo            ,
    widgetHideOnDelete                      ,


-- ** inDestruction #method:inDestruction#
    WidgetInDestructionMethodInfo           ,
    widgetInDestruction                     ,


-- ** initTemplate #method:initTemplate#
    WidgetInitTemplateMethodInfo            ,
    widgetInitTemplate                      ,


-- ** inputShapeCombineRegion #method:inputShapeCombineRegion#
    WidgetInputShapeCombineRegionMethodInfo ,
    widgetInputShapeCombineRegion           ,


-- ** insertActionGroup #method:insertActionGroup#
    WidgetInsertActionGroupMethodInfo       ,
    widgetInsertActionGroup                 ,


-- ** intersect #method:intersect#
    WidgetIntersectMethodInfo               ,
    widgetIntersect                         ,


-- ** isAncestor #method:isAncestor#
    WidgetIsAncestorMethodInfo              ,
    widgetIsAncestor                        ,


-- ** isComposited #method:isComposited#
    WidgetIsCompositedMethodInfo            ,
    widgetIsComposited                      ,


-- ** isDrawable #method:isDrawable#
    WidgetIsDrawableMethodInfo              ,
    widgetIsDrawable                        ,


-- ** isFocus #method:isFocus#
    WidgetIsFocusMethodInfo                 ,
    widgetIsFocus                           ,


-- ** isSensitive #method:isSensitive#
    WidgetIsSensitiveMethodInfo             ,
    widgetIsSensitive                       ,


-- ** isToplevel #method:isToplevel#
    WidgetIsToplevelMethodInfo              ,
    widgetIsToplevel                        ,


-- ** isVisible #method:isVisible#
    WidgetIsVisibleMethodInfo               ,
    widgetIsVisible                         ,


-- ** keynavFailed #method:keynavFailed#
    WidgetKeynavFailedMethodInfo            ,
    widgetKeynavFailed                      ,


-- ** listAccelClosures #method:listAccelClosures#
    WidgetListAccelClosuresMethodInfo       ,
    widgetListAccelClosures                 ,


-- ** listActionPrefixes #method:listActionPrefixes#
    WidgetListActionPrefixesMethodInfo      ,
    widgetListActionPrefixes                ,


-- ** listMnemonicLabels #method:listMnemonicLabels#
    WidgetListMnemonicLabelsMethodInfo      ,
    widgetListMnemonicLabels                ,


-- ** map #method:map#
    WidgetMapMethodInfo                     ,
    widgetMap                               ,


-- ** mnemonicActivate #method:mnemonicActivate#
    WidgetMnemonicActivateMethodInfo        ,
    widgetMnemonicActivate                  ,


-- ** modifyBase #method:modifyBase#
    WidgetModifyBaseMethodInfo              ,
    widgetModifyBase                        ,


-- ** modifyBg #method:modifyBg#
    WidgetModifyBgMethodInfo                ,
    widgetModifyBg                          ,


-- ** modifyCursor #method:modifyCursor#
    WidgetModifyCursorMethodInfo            ,
    widgetModifyCursor                      ,


-- ** modifyFg #method:modifyFg#
    WidgetModifyFgMethodInfo                ,
    widgetModifyFg                          ,


-- ** modifyFont #method:modifyFont#
    WidgetModifyFontMethodInfo              ,
    widgetModifyFont                        ,


-- ** modifyStyle #method:modifyStyle#
    WidgetModifyStyleMethodInfo             ,
    widgetModifyStyle                       ,


-- ** modifyText #method:modifyText#
    WidgetModifyTextMethodInfo              ,
    widgetModifyText                        ,


-- ** overrideBackgroundColor #method:overrideBackgroundColor#
    WidgetOverrideBackgroundColorMethodInfo ,
    widgetOverrideBackgroundColor           ,


-- ** overrideColor #method:overrideColor#
    WidgetOverrideColorMethodInfo           ,
    widgetOverrideColor                     ,


-- ** overrideCursor #method:overrideCursor#
    WidgetOverrideCursorMethodInfo          ,
    widgetOverrideCursor                    ,


-- ** overrideFont #method:overrideFont#
    WidgetOverrideFontMethodInfo            ,
    widgetOverrideFont                      ,


-- ** overrideSymbolicColor #method:overrideSymbolicColor#
    WidgetOverrideSymbolicColorMethodInfo   ,
    widgetOverrideSymbolicColor             ,


-- ** path #method:path#
    WidgetPathMethodInfo                    ,
    widgetPath                              ,


-- ** popCompositeChild #method:popCompositeChild#
    widgetPopCompositeChild                 ,


-- ** pushCompositeChild #method:pushCompositeChild#
    widgetPushCompositeChild                ,


-- ** queueAllocate #method:queueAllocate#
    WidgetQueueAllocateMethodInfo           ,
    widgetQueueAllocate                     ,


-- ** queueComputeExpand #method:queueComputeExpand#
    WidgetQueueComputeExpandMethodInfo      ,
    widgetQueueComputeExpand                ,


-- ** queueDraw #method:queueDraw#
    WidgetQueueDrawMethodInfo               ,
    widgetQueueDraw                         ,


-- ** queueDrawArea #method:queueDrawArea#
    WidgetQueueDrawAreaMethodInfo           ,
    widgetQueueDrawArea                     ,


-- ** queueDrawRegion #method:queueDrawRegion#
    WidgetQueueDrawRegionMethodInfo         ,
    widgetQueueDrawRegion                   ,


-- ** queueResize #method:queueResize#
    WidgetQueueResizeMethodInfo             ,
    widgetQueueResize                       ,


-- ** queueResizeNoRedraw #method:queueResizeNoRedraw#
    WidgetQueueResizeNoRedrawMethodInfo     ,
    widgetQueueResizeNoRedraw               ,


-- ** realize #method:realize#
    WidgetRealizeMethodInfo                 ,
    widgetRealize                           ,


-- ** regionIntersect #method:regionIntersect#
    WidgetRegionIntersectMethodInfo         ,
    widgetRegionIntersect                   ,


-- ** registerWindow #method:registerWindow#
    WidgetRegisterWindowMethodInfo          ,
    widgetRegisterWindow                    ,


-- ** removeAccelerator #method:removeAccelerator#
    WidgetRemoveAcceleratorMethodInfo       ,
    widgetRemoveAccelerator                 ,


-- ** removeMnemonicLabel #method:removeMnemonicLabel#
    WidgetRemoveMnemonicLabelMethodInfo     ,
    widgetRemoveMnemonicLabel               ,


-- ** removeTickCallback #method:removeTickCallback#
    WidgetRemoveTickCallbackMethodInfo      ,
    widgetRemoveTickCallback                ,


-- ** renderIcon #method:renderIcon#
    WidgetRenderIconMethodInfo              ,
    widgetRenderIcon                        ,


-- ** renderIconPixbuf #method:renderIconPixbuf#
    WidgetRenderIconPixbufMethodInfo        ,
    widgetRenderIconPixbuf                  ,


-- ** reparent #method:reparent#
    WidgetReparentMethodInfo                ,
    widgetReparent                          ,


-- ** resetRcStyles #method:resetRcStyles#
    WidgetResetRcStylesMethodInfo           ,
    widgetResetRcStyles                     ,


-- ** resetStyle #method:resetStyle#
    WidgetResetStyleMethodInfo              ,
    widgetResetStyle                        ,


-- ** sendExpose #method:sendExpose#
    WidgetSendExposeMethodInfo              ,
    widgetSendExpose                        ,


-- ** sendFocusChange #method:sendFocusChange#
    WidgetSendFocusChangeMethodInfo         ,
    widgetSendFocusChange                   ,


-- ** setAccelPath #method:setAccelPath#
    WidgetSetAccelPathMethodInfo            ,
    widgetSetAccelPath                      ,


-- ** setAllocation #method:setAllocation#
    WidgetSetAllocationMethodInfo           ,
    widgetSetAllocation                     ,


-- ** setAppPaintable #method:setAppPaintable#
    WidgetSetAppPaintableMethodInfo         ,
    widgetSetAppPaintable                   ,


-- ** setCanDefault #method:setCanDefault#
    WidgetSetCanDefaultMethodInfo           ,
    widgetSetCanDefault                     ,


-- ** setCanFocus #method:setCanFocus#
    WidgetSetCanFocusMethodInfo             ,
    widgetSetCanFocus                       ,


-- ** setChildVisible #method:setChildVisible#
    WidgetSetChildVisibleMethodInfo         ,
    widgetSetChildVisible                   ,


-- ** setClip #method:setClip#
    WidgetSetClipMethodInfo                 ,
    widgetSetClip                           ,


-- ** setCompositeName #method:setCompositeName#
    WidgetSetCompositeNameMethodInfo        ,
    widgetSetCompositeName                  ,


-- ** setDefaultDirection #method:setDefaultDirection#
    widgetSetDefaultDirection               ,


-- ** setDeviceEnabled #method:setDeviceEnabled#
    WidgetSetDeviceEnabledMethodInfo        ,
    widgetSetDeviceEnabled                  ,


-- ** setDeviceEvents #method:setDeviceEvents#
    WidgetSetDeviceEventsMethodInfo         ,
    widgetSetDeviceEvents                   ,


-- ** setDirection #method:setDirection#
    WidgetSetDirectionMethodInfo            ,
    widgetSetDirection                      ,


-- ** setDoubleBuffered #method:setDoubleBuffered#
    WidgetSetDoubleBufferedMethodInfo       ,
    widgetSetDoubleBuffered                 ,


-- ** setEvents #method:setEvents#
    WidgetSetEventsMethodInfo               ,
    widgetSetEvents                         ,


-- ** setFocusOnClick #method:setFocusOnClick#
    WidgetSetFocusOnClickMethodInfo         ,
    widgetSetFocusOnClick                   ,


-- ** setFontMap #method:setFontMap#
    WidgetSetFontMapMethodInfo              ,
    widgetSetFontMap                        ,


-- ** setFontOptions #method:setFontOptions#
    WidgetSetFontOptionsMethodInfo          ,
    widgetSetFontOptions                    ,


-- ** setHalign #method:setHalign#
    WidgetSetHalignMethodInfo               ,
    widgetSetHalign                         ,


-- ** setHasTooltip #method:setHasTooltip#
    WidgetSetHasTooltipMethodInfo           ,
    widgetSetHasTooltip                     ,


-- ** setHasWindow #method:setHasWindow#
    WidgetSetHasWindowMethodInfo            ,
    widgetSetHasWindow                      ,


-- ** setHexpand #method:setHexpand#
    WidgetSetHexpandMethodInfo              ,
    widgetSetHexpand                        ,


-- ** setHexpandSet #method:setHexpandSet#
    WidgetSetHexpandSetMethodInfo           ,
    widgetSetHexpandSet                     ,


-- ** setMapped #method:setMapped#
    WidgetSetMappedMethodInfo               ,
    widgetSetMapped                         ,


-- ** setMarginBottom #method:setMarginBottom#
    WidgetSetMarginBottomMethodInfo         ,
    widgetSetMarginBottom                   ,


-- ** setMarginEnd #method:setMarginEnd#
    WidgetSetMarginEndMethodInfo            ,
    widgetSetMarginEnd                      ,


-- ** setMarginLeft #method:setMarginLeft#
    WidgetSetMarginLeftMethodInfo           ,
    widgetSetMarginLeft                     ,


-- ** setMarginRight #method:setMarginRight#
    WidgetSetMarginRightMethodInfo          ,
    widgetSetMarginRight                    ,


-- ** setMarginStart #method:setMarginStart#
    WidgetSetMarginStartMethodInfo          ,
    widgetSetMarginStart                    ,


-- ** setMarginTop #method:setMarginTop#
    WidgetSetMarginTopMethodInfo            ,
    widgetSetMarginTop                      ,


-- ** setName #method:setName#
    WidgetSetNameMethodInfo                 ,
    widgetSetName                           ,


-- ** setNoShowAll #method:setNoShowAll#
    WidgetSetNoShowAllMethodInfo            ,
    widgetSetNoShowAll                      ,


-- ** setOpacity #method:setOpacity#
    WidgetSetOpacityMethodInfo              ,
    widgetSetOpacity                        ,


-- ** setParent #method:setParent#
    WidgetSetParentMethodInfo               ,
    widgetSetParent                         ,


-- ** setParentWindow #method:setParentWindow#
    WidgetSetParentWindowMethodInfo         ,
    widgetSetParentWindow                   ,


-- ** setRealized #method:setRealized#
    WidgetSetRealizedMethodInfo             ,
    widgetSetRealized                       ,


-- ** setReceivesDefault #method:setReceivesDefault#
    WidgetSetReceivesDefaultMethodInfo      ,
    widgetSetReceivesDefault                ,


-- ** setRedrawOnAllocate #method:setRedrawOnAllocate#
    WidgetSetRedrawOnAllocateMethodInfo     ,
    widgetSetRedrawOnAllocate               ,


-- ** setSensitive #method:setSensitive#
    WidgetSetSensitiveMethodInfo            ,
    widgetSetSensitive                      ,


-- ** setSizeRequest #method:setSizeRequest#
    WidgetSetSizeRequestMethodInfo          ,
    widgetSetSizeRequest                    ,


-- ** setState #method:setState#
    WidgetSetStateMethodInfo                ,
    widgetSetState                          ,


-- ** setStateFlags #method:setStateFlags#
    WidgetSetStateFlagsMethodInfo           ,
    widgetSetStateFlags                     ,


-- ** setStyle #method:setStyle#
    WidgetSetStyleMethodInfo                ,
    widgetSetStyle                          ,


-- ** setSupportMultidevice #method:setSupportMultidevice#
    WidgetSetSupportMultideviceMethodInfo   ,
    widgetSetSupportMultidevice             ,


-- ** setTooltipMarkup #method:setTooltipMarkup#
    WidgetSetTooltipMarkupMethodInfo        ,
    widgetSetTooltipMarkup                  ,


-- ** setTooltipText #method:setTooltipText#
    WidgetSetTooltipTextMethodInfo          ,
    widgetSetTooltipText                    ,


-- ** setTooltipWindow #method:setTooltipWindow#
    WidgetSetTooltipWindowMethodInfo        ,
    widgetSetTooltipWindow                  ,


-- ** setValign #method:setValign#
    WidgetSetValignMethodInfo               ,
    widgetSetValign                         ,


-- ** setVexpand #method:setVexpand#
    WidgetSetVexpandMethodInfo              ,
    widgetSetVexpand                        ,


-- ** setVexpandSet #method:setVexpandSet#
    WidgetSetVexpandSetMethodInfo           ,
    widgetSetVexpandSet                     ,


-- ** setVisible #method:setVisible#
    WidgetSetVisibleMethodInfo              ,
    widgetSetVisible                        ,


-- ** setVisual #method:setVisual#
    WidgetSetVisualMethodInfo               ,
    widgetSetVisual                         ,


-- ** setWindow #method:setWindow#
    WidgetSetWindowMethodInfo               ,
    widgetSetWindow                         ,


-- ** shapeCombineRegion #method:shapeCombineRegion#
    WidgetShapeCombineRegionMethodInfo      ,
    widgetShapeCombineRegion                ,


-- ** show #method:show#
    WidgetShowMethodInfo                    ,
    widgetShow                              ,


-- ** showAll #method:showAll#
    WidgetShowAllMethodInfo                 ,
    widgetShowAll                           ,


-- ** showNow #method:showNow#
    WidgetShowNowMethodInfo                 ,
    widgetShowNow                           ,


-- ** sizeAllocate #method:sizeAllocate#
    WidgetSizeAllocateMethodInfo            ,
    widgetSizeAllocate                      ,


-- ** sizeAllocateWithBaseline #method:sizeAllocateWithBaseline#
    WidgetSizeAllocateWithBaselineMethodInfo,
    widgetSizeAllocateWithBaseline          ,


-- ** sizeRequest #method:sizeRequest#
    WidgetSizeRequestMethodInfo             ,
    widgetSizeRequest                       ,


-- ** styleAttach #method:styleAttach#
    WidgetStyleAttachMethodInfo             ,
    widgetStyleAttach                       ,


-- ** styleGetProperty #method:styleGetProperty#
    WidgetStyleGetPropertyMethodInfo        ,
    widgetStyleGetProperty                  ,


-- ** thawChildNotify #method:thawChildNotify#
    WidgetThawChildNotifyMethodInfo         ,
    widgetThawChildNotify                   ,


-- ** translateCoordinates #method:translateCoordinates#
    WidgetTranslateCoordinatesMethodInfo    ,
    widgetTranslateCoordinates              ,


-- ** triggerTooltipQuery #method:triggerTooltipQuery#
    WidgetTriggerTooltipQueryMethodInfo     ,
    widgetTriggerTooltipQuery               ,


-- ** unmap #method:unmap#
    WidgetUnmapMethodInfo                   ,
    widgetUnmap                             ,


-- ** unparent #method:unparent#
    WidgetUnparentMethodInfo                ,
    widgetUnparent                          ,


-- ** unrealize #method:unrealize#
    WidgetUnrealizeMethodInfo               ,
    widgetUnrealize                         ,


-- ** unregisterWindow #method:unregisterWindow#
    WidgetUnregisterWindowMethodInfo        ,
    widgetUnregisterWindow                  ,


-- ** unsetStateFlags #method:unsetStateFlags#
    WidgetUnsetStateFlagsMethodInfo         ,
    widgetUnsetStateFlags                   ,




 -- * Properties
-- ** appPaintable #attr:appPaintable#
    WidgetAppPaintablePropertyInfo          ,
    constructWidgetAppPaintable             ,
    getWidgetAppPaintable                   ,
    setWidgetAppPaintable                   ,
    widgetAppPaintable                      ,


-- ** canDefault #attr:canDefault#
    WidgetCanDefaultPropertyInfo            ,
    constructWidgetCanDefault               ,
    getWidgetCanDefault                     ,
    setWidgetCanDefault                     ,
    widgetCanDefault                        ,


-- ** canFocus #attr:canFocus#
    WidgetCanFocusPropertyInfo              ,
    constructWidgetCanFocus                 ,
    getWidgetCanFocus                       ,
    setWidgetCanFocus                       ,
    widgetCanFocus                          ,


-- ** compositeChild #attr:compositeChild#
    WidgetCompositeChildPropertyInfo        ,
    getWidgetCompositeChild                 ,
    widgetCompositeChild                    ,


-- ** doubleBuffered #attr:doubleBuffered#
    WidgetDoubleBufferedPropertyInfo        ,
    constructWidgetDoubleBuffered           ,
    getWidgetDoubleBuffered                 ,
    setWidgetDoubleBuffered                 ,
    widgetDoubleBuffered                    ,


-- ** events #attr:events#
    WidgetEventsPropertyInfo                ,
    constructWidgetEvents                   ,
    getWidgetEvents                         ,
    setWidgetEvents                         ,
    widgetEvents                            ,


-- ** expand #attr:expand#
    WidgetExpandPropertyInfo                ,
    constructWidgetExpand                   ,
    getWidgetExpand                         ,
    setWidgetExpand                         ,
    widgetExpand                            ,


-- ** focusOnClick #attr:focusOnClick#
    WidgetFocusOnClickPropertyInfo          ,
    constructWidgetFocusOnClick             ,
    getWidgetFocusOnClick                   ,
    setWidgetFocusOnClick                   ,
    widgetFocusOnClick                      ,


-- ** halign #attr:halign#
    WidgetHalignPropertyInfo                ,
    constructWidgetHalign                   ,
    getWidgetHalign                         ,
    setWidgetHalign                         ,
    widgetHalign                            ,


-- ** hasDefault #attr:hasDefault#
    WidgetHasDefaultPropertyInfo            ,
    constructWidgetHasDefault               ,
    getWidgetHasDefault                     ,
    setWidgetHasDefault                     ,


-- ** hasFocus #attr:hasFocus#
    WidgetHasFocusPropertyInfo              ,
    constructWidgetHasFocus                 ,
    getWidgetHasFocus                       ,
    setWidgetHasFocus                       ,


-- ** hasTooltip #attr:hasTooltip#
    WidgetHasTooltipPropertyInfo            ,
    constructWidgetHasTooltip               ,
    getWidgetHasTooltip                     ,
    setWidgetHasTooltip                     ,
    widgetHasTooltip                        ,


-- ** heightRequest #attr:heightRequest#
    WidgetHeightRequestPropertyInfo         ,
    constructWidgetHeightRequest            ,
    getWidgetHeightRequest                  ,
    setWidgetHeightRequest                  ,
    widgetHeightRequest                     ,


-- ** hexpand #attr:hexpand#
    WidgetHexpandPropertyInfo               ,
    constructWidgetHexpand                  ,
    getWidgetHexpand                        ,
    setWidgetHexpand                        ,
    widgetHexpand                           ,


-- ** hexpandSet #attr:hexpandSet#
    WidgetHexpandSetPropertyInfo            ,
    constructWidgetHexpandSet               ,
    getWidgetHexpandSet                     ,
    setWidgetHexpandSet                     ,
    widgetHexpandSet                        ,


-- ** isFocus #attr:isFocus#
    WidgetIsFocusPropertyInfo               ,
    constructWidgetIsFocus                  ,
    getWidgetIsFocus                        ,
    setWidgetIsFocus                        ,


-- ** margin #attr:margin#
    WidgetMarginPropertyInfo                ,
    constructWidgetMargin                   ,
    getWidgetMargin                         ,
    setWidgetMargin                         ,
    widgetMargin                            ,


-- ** marginBottom #attr:marginBottom#
    WidgetMarginBottomPropertyInfo          ,
    constructWidgetMarginBottom             ,
    getWidgetMarginBottom                   ,
    setWidgetMarginBottom                   ,
    widgetMarginBottom                      ,


-- ** marginEnd #attr:marginEnd#
    WidgetMarginEndPropertyInfo             ,
    constructWidgetMarginEnd                ,
    getWidgetMarginEnd                      ,
    setWidgetMarginEnd                      ,
    widgetMarginEnd                         ,


-- ** marginLeft #attr:marginLeft#
    WidgetMarginLeftPropertyInfo            ,
    constructWidgetMarginLeft               ,
    getWidgetMarginLeft                     ,
    setWidgetMarginLeft                     ,
    widgetMarginLeft                        ,


-- ** marginRight #attr:marginRight#
    WidgetMarginRightPropertyInfo           ,
    constructWidgetMarginRight              ,
    getWidgetMarginRight                    ,
    setWidgetMarginRight                    ,
    widgetMarginRight                       ,


-- ** marginStart #attr:marginStart#
    WidgetMarginStartPropertyInfo           ,
    constructWidgetMarginStart              ,
    getWidgetMarginStart                    ,
    setWidgetMarginStart                    ,
    widgetMarginStart                       ,


-- ** marginTop #attr:marginTop#
    WidgetMarginTopPropertyInfo             ,
    constructWidgetMarginTop                ,
    getWidgetMarginTop                      ,
    setWidgetMarginTop                      ,
    widgetMarginTop                         ,


-- ** name #attr:name#
    WidgetNamePropertyInfo                  ,
    constructWidgetName                     ,
    getWidgetName                           ,
    setWidgetName                           ,
    widgetName                              ,


-- ** noShowAll #attr:noShowAll#
    WidgetNoShowAllPropertyInfo             ,
    constructWidgetNoShowAll                ,
    getWidgetNoShowAll                      ,
    setWidgetNoShowAll                      ,
    widgetNoShowAll                         ,


-- ** opacity #attr:opacity#
    WidgetOpacityPropertyInfo               ,
    constructWidgetOpacity                  ,
    getWidgetOpacity                        ,
    setWidgetOpacity                        ,
    widgetOpacity                           ,


-- ** parent #attr:parent#
    WidgetParentPropertyInfo                ,
    clearWidgetParent                       ,
    constructWidgetParent                   ,
    getWidgetParent                         ,
    setWidgetParent                         ,
    widgetParent                            ,


-- ** receivesDefault #attr:receivesDefault#
    WidgetReceivesDefaultPropertyInfo       ,
    constructWidgetReceivesDefault          ,
    getWidgetReceivesDefault                ,
    setWidgetReceivesDefault                ,
    widgetReceivesDefault                   ,


-- ** scaleFactor #attr:scaleFactor#
    WidgetScaleFactorPropertyInfo           ,
    getWidgetScaleFactor                    ,
    widgetScaleFactor                       ,


-- ** sensitive #attr:sensitive#
    WidgetSensitivePropertyInfo             ,
    constructWidgetSensitive                ,
    getWidgetSensitive                      ,
    setWidgetSensitive                      ,
    widgetSensitive                         ,


-- ** style #attr:style#
    WidgetStylePropertyInfo                 ,
    clearWidgetStyle                        ,
    constructWidgetStyle                    ,
    getWidgetStyle                          ,
    setWidgetStyle                          ,
    widgetStyle                             ,


-- ** tooltipMarkup #attr:tooltipMarkup#
    WidgetTooltipMarkupPropertyInfo         ,
    clearWidgetTooltipMarkup                ,
    constructWidgetTooltipMarkup            ,
    getWidgetTooltipMarkup                  ,
    setWidgetTooltipMarkup                  ,
    widgetTooltipMarkup                     ,


-- ** tooltipText #attr:tooltipText#
    WidgetTooltipTextPropertyInfo           ,
    clearWidgetTooltipText                  ,
    constructWidgetTooltipText              ,
    getWidgetTooltipText                    ,
    setWidgetTooltipText                    ,
    widgetTooltipText                       ,


-- ** valign #attr:valign#
    WidgetValignPropertyInfo                ,
    constructWidgetValign                   ,
    getWidgetValign                         ,
    setWidgetValign                         ,
    widgetValign                            ,


-- ** vexpand #attr:vexpand#
    WidgetVexpandPropertyInfo               ,
    constructWidgetVexpand                  ,
    getWidgetVexpand                        ,
    setWidgetVexpand                        ,
    widgetVexpand                           ,


-- ** vexpandSet #attr:vexpandSet#
    WidgetVexpandSetPropertyInfo            ,
    constructWidgetVexpandSet               ,
    getWidgetVexpandSet                     ,
    setWidgetVexpandSet                     ,
    widgetVexpandSet                        ,


-- ** visible #attr:visible#
    WidgetVisiblePropertyInfo               ,
    constructWidgetVisible                  ,
    getWidgetVisible                        ,
    setWidgetVisible                        ,
    widgetVisible                           ,


-- ** widthRequest #attr:widthRequest#
    WidgetWidthRequestPropertyInfo          ,
    constructWidgetWidthRequest             ,
    getWidgetWidthRequest                   ,
    setWidgetWidthRequest                   ,
    widgetWidthRequest                      ,


-- ** window #attr:window#
    WidgetWindowPropertyInfo                ,
    getWidgetWindow                         ,
    widgetWindow                            ,




 -- * Signals
-- ** accelClosuresChanged #signal:accelClosuresChanged#
    C_WidgetAccelClosuresChangedCallback    ,
    WidgetAccelClosuresChangedCallback      ,
    WidgetAccelClosuresChangedSignalInfo    ,
    afterWidgetAccelClosuresChanged         ,
    genClosure_WidgetAccelClosuresChanged   ,
    mk_WidgetAccelClosuresChangedCallback   ,
    noWidgetAccelClosuresChangedCallback    ,
    onWidgetAccelClosuresChanged            ,
    wrap_WidgetAccelClosuresChangedCallback ,


-- ** buttonPressEvent #signal:buttonPressEvent#
    C_WidgetButtonPressEventCallback        ,
    WidgetButtonPressEventCallback          ,
    WidgetButtonPressEventSignalInfo        ,
    afterWidgetButtonPressEvent             ,
    genClosure_WidgetButtonPressEvent       ,
    mk_WidgetButtonPressEventCallback       ,
    noWidgetButtonPressEventCallback        ,
    onWidgetButtonPressEvent                ,
    wrap_WidgetButtonPressEventCallback     ,


-- ** buttonReleaseEvent #signal:buttonReleaseEvent#
    C_WidgetButtonReleaseEventCallback      ,
    WidgetButtonReleaseEventCallback        ,
    WidgetButtonReleaseEventSignalInfo      ,
    afterWidgetButtonReleaseEvent           ,
    genClosure_WidgetButtonReleaseEvent     ,
    mk_WidgetButtonReleaseEventCallback     ,
    noWidgetButtonReleaseEventCallback      ,
    onWidgetButtonReleaseEvent              ,
    wrap_WidgetButtonReleaseEventCallback   ,


-- ** canActivateAccel #signal:canActivateAccel#
    C_WidgetCanActivateAccelCallback        ,
    WidgetCanActivateAccelCallback          ,
    WidgetCanActivateAccelSignalInfo        ,
    afterWidgetCanActivateAccel             ,
    genClosure_WidgetCanActivateAccel       ,
    mk_WidgetCanActivateAccelCallback       ,
    noWidgetCanActivateAccelCallback        ,
    onWidgetCanActivateAccel                ,
    wrap_WidgetCanActivateAccelCallback     ,


-- ** childNotify #signal:childNotify#
    C_WidgetChildNotifyCallback             ,
    WidgetChildNotifyCallback               ,
    WidgetChildNotifySignalInfo             ,
    afterWidgetChildNotify                  ,
    genClosure_WidgetChildNotify            ,
    mk_WidgetChildNotifyCallback            ,
    noWidgetChildNotifyCallback             ,
    onWidgetChildNotify                     ,
    wrap_WidgetChildNotifyCallback          ,


-- ** compositedChanged #signal:compositedChanged#
    C_WidgetCompositedChangedCallback       ,
    WidgetCompositedChangedCallback         ,
    WidgetCompositedChangedSignalInfo       ,
    afterWidgetCompositedChanged            ,
    genClosure_WidgetCompositedChanged      ,
    mk_WidgetCompositedChangedCallback      ,
    noWidgetCompositedChangedCallback       ,
    onWidgetCompositedChanged               ,
    wrap_WidgetCompositedChangedCallback    ,


-- ** configureEvent #signal:configureEvent#
    C_WidgetConfigureEventCallback          ,
    WidgetConfigureEventCallback            ,
    WidgetConfigureEventSignalInfo          ,
    afterWidgetConfigureEvent               ,
    genClosure_WidgetConfigureEvent         ,
    mk_WidgetConfigureEventCallback         ,
    noWidgetConfigureEventCallback          ,
    onWidgetConfigureEvent                  ,
    wrap_WidgetConfigureEventCallback       ,


-- ** damageEvent #signal:damageEvent#
    C_WidgetDamageEventCallback             ,
    WidgetDamageEventCallback               ,
    WidgetDamageEventSignalInfo             ,
    afterWidgetDamageEvent                  ,
    genClosure_WidgetDamageEvent            ,
    mk_WidgetDamageEventCallback            ,
    noWidgetDamageEventCallback             ,
    onWidgetDamageEvent                     ,
    wrap_WidgetDamageEventCallback          ,


-- ** deleteEvent #signal:deleteEvent#
    C_WidgetDeleteEventCallback             ,
    WidgetDeleteEventCallback               ,
    WidgetDeleteEventSignalInfo             ,
    afterWidgetDeleteEvent                  ,
    genClosure_WidgetDeleteEvent            ,
    mk_WidgetDeleteEventCallback            ,
    noWidgetDeleteEventCallback             ,
    onWidgetDeleteEvent                     ,
    wrap_WidgetDeleteEventCallback          ,


-- ** destroy #signal:destroy#
    C_WidgetDestroyCallback                 ,
    WidgetDestroyCallback                   ,
    WidgetDestroySignalInfo                 ,
    afterWidgetDestroy                      ,
    genClosure_WidgetDestroy                ,
    mk_WidgetDestroyCallback                ,
    noWidgetDestroyCallback                 ,
    onWidgetDestroy                         ,
    wrap_WidgetDestroyCallback              ,


-- ** destroyEvent #signal:destroyEvent#
    C_WidgetDestroyEventCallback            ,
    WidgetDestroyEventCallback              ,
    WidgetDestroyEventSignalInfo            ,
    afterWidgetDestroyEvent                 ,
    genClosure_WidgetDestroyEvent           ,
    mk_WidgetDestroyEventCallback           ,
    noWidgetDestroyEventCallback            ,
    onWidgetDestroyEvent                    ,
    wrap_WidgetDestroyEventCallback         ,


-- ** directionChanged #signal:directionChanged#
    C_WidgetDirectionChangedCallback        ,
    WidgetDirectionChangedCallback          ,
    WidgetDirectionChangedSignalInfo        ,
    afterWidgetDirectionChanged             ,
    genClosure_WidgetDirectionChanged       ,
    mk_WidgetDirectionChangedCallback       ,
    noWidgetDirectionChangedCallback        ,
    onWidgetDirectionChanged                ,
    wrap_WidgetDirectionChangedCallback     ,


-- ** dragBegin #signal:dragBegin#
    C_WidgetDragBeginCallback               ,
    WidgetDragBeginCallback                 ,
    WidgetDragBeginSignalInfo               ,
    afterWidgetDragBegin                    ,
    genClosure_WidgetDragBegin              ,
    mk_WidgetDragBeginCallback              ,
    noWidgetDragBeginCallback               ,
    onWidgetDragBegin                       ,
    wrap_WidgetDragBeginCallback            ,


-- ** dragDataDelete #signal:dragDataDelete#
    C_WidgetDragDataDeleteCallback          ,
    WidgetDragDataDeleteCallback            ,
    WidgetDragDataDeleteSignalInfo          ,
    afterWidgetDragDataDelete               ,
    genClosure_WidgetDragDataDelete         ,
    mk_WidgetDragDataDeleteCallback         ,
    noWidgetDragDataDeleteCallback          ,
    onWidgetDragDataDelete                  ,
    wrap_WidgetDragDataDeleteCallback       ,


-- ** dragDataGet #signal:dragDataGet#
    C_WidgetDragDataGetCallback             ,
    WidgetDragDataGetCallback               ,
    WidgetDragDataGetSignalInfo             ,
    afterWidgetDragDataGet                  ,
    genClosure_WidgetDragDataGet            ,
    mk_WidgetDragDataGetCallback            ,
    noWidgetDragDataGetCallback             ,
    onWidgetDragDataGet                     ,
    wrap_WidgetDragDataGetCallback          ,


-- ** dragDataReceived #signal:dragDataReceived#
    C_WidgetDragDataReceivedCallback        ,
    WidgetDragDataReceivedCallback          ,
    WidgetDragDataReceivedSignalInfo        ,
    afterWidgetDragDataReceived             ,
    genClosure_WidgetDragDataReceived       ,
    mk_WidgetDragDataReceivedCallback       ,
    noWidgetDragDataReceivedCallback        ,
    onWidgetDragDataReceived                ,
    wrap_WidgetDragDataReceivedCallback     ,


-- ** dragDrop #signal:dragDrop#
    C_WidgetDragDropCallback                ,
    WidgetDragDropCallback                  ,
    WidgetDragDropSignalInfo                ,
    afterWidgetDragDrop                     ,
    genClosure_WidgetDragDrop               ,
    mk_WidgetDragDropCallback               ,
    noWidgetDragDropCallback                ,
    onWidgetDragDrop                        ,
    wrap_WidgetDragDropCallback             ,


-- ** dragEnd #signal:dragEnd#
    C_WidgetDragEndCallback                 ,
    WidgetDragEndCallback                   ,
    WidgetDragEndSignalInfo                 ,
    afterWidgetDragEnd                      ,
    genClosure_WidgetDragEnd                ,
    mk_WidgetDragEndCallback                ,
    noWidgetDragEndCallback                 ,
    onWidgetDragEnd                         ,
    wrap_WidgetDragEndCallback              ,


-- ** dragFailed #signal:dragFailed#
    C_WidgetDragFailedCallback              ,
    WidgetDragFailedCallback                ,
    WidgetDragFailedSignalInfo              ,
    afterWidgetDragFailed                   ,
    genClosure_WidgetDragFailed             ,
    mk_WidgetDragFailedCallback             ,
    noWidgetDragFailedCallback              ,
    onWidgetDragFailed                      ,
    wrap_WidgetDragFailedCallback           ,


-- ** dragLeave #signal:dragLeave#
    C_WidgetDragLeaveCallback               ,
    WidgetDragLeaveCallback                 ,
    WidgetDragLeaveSignalInfo               ,
    afterWidgetDragLeave                    ,
    genClosure_WidgetDragLeave              ,
    mk_WidgetDragLeaveCallback              ,
    noWidgetDragLeaveCallback               ,
    onWidgetDragLeave                       ,
    wrap_WidgetDragLeaveCallback            ,


-- ** dragMotion #signal:dragMotion#
    C_WidgetDragMotionCallback              ,
    WidgetDragMotionCallback                ,
    WidgetDragMotionSignalInfo              ,
    afterWidgetDragMotion                   ,
    genClosure_WidgetDragMotion             ,
    mk_WidgetDragMotionCallback             ,
    noWidgetDragMotionCallback              ,
    onWidgetDragMotion                      ,
    wrap_WidgetDragMotionCallback           ,


-- ** draw #signal:draw#
    C_WidgetDrawCallback                    ,
    WidgetDrawCallback                      ,
    WidgetDrawSignalInfo                    ,
    afterWidgetDraw                         ,
    genClosure_WidgetDraw                   ,
    mk_WidgetDrawCallback                   ,
    noWidgetDrawCallback                    ,
    onWidgetDraw                            ,
    wrap_WidgetDrawCallback                 ,


-- ** enterNotifyEvent #signal:enterNotifyEvent#
    C_WidgetEnterNotifyEventCallback        ,
    WidgetEnterNotifyEventCallback          ,
    WidgetEnterNotifyEventSignalInfo        ,
    afterWidgetEnterNotifyEvent             ,
    genClosure_WidgetEnterNotifyEvent       ,
    mk_WidgetEnterNotifyEventCallback       ,
    noWidgetEnterNotifyEventCallback        ,
    onWidgetEnterNotifyEvent                ,
    wrap_WidgetEnterNotifyEventCallback     ,


-- ** event #signal:event#
    C_WidgetEventCallback                   ,
    WidgetEventCallback                     ,
    WidgetEventSignalInfo                   ,
    afterWidgetEvent                        ,
    genClosure_WidgetEvent                  ,
    mk_WidgetEventCallback                  ,
    noWidgetEventCallback                   ,
    onWidgetEvent                           ,
    wrap_WidgetEventCallback                ,


-- ** eventAfter #signal:eventAfter#
    C_WidgetEventAfterCallback              ,
    WidgetEventAfterCallback                ,
    WidgetEventAfterSignalInfo              ,
    afterWidgetEventAfter                   ,
    genClosure_WidgetEventAfter             ,
    mk_WidgetEventAfterCallback             ,
    noWidgetEventAfterCallback              ,
    onWidgetEventAfter                      ,
    wrap_WidgetEventAfterCallback           ,


-- ** focus #signal:focus#
    C_WidgetFocusCallback                   ,
    WidgetFocusCallback                     ,
    WidgetFocusSignalInfo                   ,
    afterWidgetFocus                        ,
    genClosure_WidgetFocus                  ,
    mk_WidgetFocusCallback                  ,
    noWidgetFocusCallback                   ,
    onWidgetFocus                           ,
    wrap_WidgetFocusCallback                ,


-- ** focusInEvent #signal:focusInEvent#
    C_WidgetFocusInEventCallback            ,
    WidgetFocusInEventCallback              ,
    WidgetFocusInEventSignalInfo            ,
    afterWidgetFocusInEvent                 ,
    genClosure_WidgetFocusInEvent           ,
    mk_WidgetFocusInEventCallback           ,
    noWidgetFocusInEventCallback            ,
    onWidgetFocusInEvent                    ,
    wrap_WidgetFocusInEventCallback         ,


-- ** focusOutEvent #signal:focusOutEvent#
    C_WidgetFocusOutEventCallback           ,
    WidgetFocusOutEventCallback             ,
    WidgetFocusOutEventSignalInfo           ,
    afterWidgetFocusOutEvent                ,
    genClosure_WidgetFocusOutEvent          ,
    mk_WidgetFocusOutEventCallback          ,
    noWidgetFocusOutEventCallback           ,
    onWidgetFocusOutEvent                   ,
    wrap_WidgetFocusOutEventCallback        ,


-- ** grabBrokenEvent #signal:grabBrokenEvent#
    C_WidgetGrabBrokenEventCallback         ,
    WidgetGrabBrokenEventCallback           ,
    WidgetGrabBrokenEventSignalInfo         ,
    afterWidgetGrabBrokenEvent              ,
    genClosure_WidgetGrabBrokenEvent        ,
    mk_WidgetGrabBrokenEventCallback        ,
    noWidgetGrabBrokenEventCallback         ,
    onWidgetGrabBrokenEvent                 ,
    wrap_WidgetGrabBrokenEventCallback      ,


-- ** grabFocus #signal:grabFocus#
    C_WidgetGrabFocusCallback               ,
    WidgetGrabFocusCallback                 ,
    WidgetGrabFocusSignalInfo               ,
    afterWidgetGrabFocus                    ,
    genClosure_WidgetGrabFocus              ,
    mk_WidgetGrabFocusCallback              ,
    noWidgetGrabFocusCallback               ,
    onWidgetGrabFocus                       ,
    wrap_WidgetGrabFocusCallback            ,


-- ** grabNotify #signal:grabNotify#
    C_WidgetGrabNotifyCallback              ,
    WidgetGrabNotifyCallback                ,
    WidgetGrabNotifySignalInfo              ,
    afterWidgetGrabNotify                   ,
    genClosure_WidgetGrabNotify             ,
    mk_WidgetGrabNotifyCallback             ,
    noWidgetGrabNotifyCallback              ,
    onWidgetGrabNotify                      ,
    wrap_WidgetGrabNotifyCallback           ,


-- ** hide #signal:hide#
    C_WidgetHideCallback                    ,
    WidgetHideCallback                      ,
    WidgetHideSignalInfo                    ,
    afterWidgetHide                         ,
    genClosure_WidgetHide                   ,
    mk_WidgetHideCallback                   ,
    noWidgetHideCallback                    ,
    onWidgetHide                            ,
    wrap_WidgetHideCallback                 ,


-- ** hierarchyChanged #signal:hierarchyChanged#
    C_WidgetHierarchyChangedCallback        ,
    WidgetHierarchyChangedCallback          ,
    WidgetHierarchyChangedSignalInfo        ,
    afterWidgetHierarchyChanged             ,
    genClosure_WidgetHierarchyChanged       ,
    mk_WidgetHierarchyChangedCallback       ,
    noWidgetHierarchyChangedCallback        ,
    onWidgetHierarchyChanged                ,
    wrap_WidgetHierarchyChangedCallback     ,


-- ** keyPressEvent #signal:keyPressEvent#
    C_WidgetKeyPressEventCallback           ,
    WidgetKeyPressEventCallback             ,
    WidgetKeyPressEventSignalInfo           ,
    afterWidgetKeyPressEvent                ,
    genClosure_WidgetKeyPressEvent          ,
    mk_WidgetKeyPressEventCallback          ,
    noWidgetKeyPressEventCallback           ,
    onWidgetKeyPressEvent                   ,
    wrap_WidgetKeyPressEventCallback        ,


-- ** keyReleaseEvent #signal:keyReleaseEvent#
    C_WidgetKeyReleaseEventCallback         ,
    WidgetKeyReleaseEventCallback           ,
    WidgetKeyReleaseEventSignalInfo         ,
    afterWidgetKeyReleaseEvent              ,
    genClosure_WidgetKeyReleaseEvent        ,
    mk_WidgetKeyReleaseEventCallback        ,
    noWidgetKeyReleaseEventCallback         ,
    onWidgetKeyReleaseEvent                 ,
    wrap_WidgetKeyReleaseEventCallback      ,


-- ** keynavFailed #signal:keynavFailed#
    C_WidgetKeynavFailedCallback            ,
    WidgetKeynavFailedCallback              ,
    WidgetKeynavFailedSignalInfo            ,
    afterWidgetKeynavFailed                 ,
    genClosure_WidgetKeynavFailed           ,
    mk_WidgetKeynavFailedCallback           ,
    noWidgetKeynavFailedCallback            ,
    onWidgetKeynavFailed                    ,
    wrap_WidgetKeynavFailedCallback         ,


-- ** leaveNotifyEvent #signal:leaveNotifyEvent#
    C_WidgetLeaveNotifyEventCallback        ,
    WidgetLeaveNotifyEventCallback          ,
    WidgetLeaveNotifyEventSignalInfo        ,
    afterWidgetLeaveNotifyEvent             ,
    genClosure_WidgetLeaveNotifyEvent       ,
    mk_WidgetLeaveNotifyEventCallback       ,
    noWidgetLeaveNotifyEventCallback        ,
    onWidgetLeaveNotifyEvent                ,
    wrap_WidgetLeaveNotifyEventCallback     ,


-- ** map #signal:map#
    C_WidgetMapCallback                     ,
    WidgetMapCallback                       ,
    WidgetMapSignalInfo                     ,
    afterWidgetMap                          ,
    genClosure_WidgetMap                    ,
    mk_WidgetMapCallback                    ,
    noWidgetMapCallback                     ,
    onWidgetMap                             ,
    wrap_WidgetMapCallback                  ,


-- ** mapEvent #signal:mapEvent#
    C_WidgetMapEventCallback                ,
    WidgetMapEventCallback                  ,
    WidgetMapEventSignalInfo                ,
    afterWidgetMapEvent                     ,
    genClosure_WidgetMapEvent               ,
    mk_WidgetMapEventCallback               ,
    noWidgetMapEventCallback                ,
    onWidgetMapEvent                        ,
    wrap_WidgetMapEventCallback             ,


-- ** mnemonicActivate #signal:mnemonicActivate#
    C_WidgetMnemonicActivateCallback        ,
    WidgetMnemonicActivateCallback          ,
    WidgetMnemonicActivateSignalInfo        ,
    afterWidgetMnemonicActivate             ,
    genClosure_WidgetMnemonicActivate       ,
    mk_WidgetMnemonicActivateCallback       ,
    noWidgetMnemonicActivateCallback        ,
    onWidgetMnemonicActivate                ,
    wrap_WidgetMnemonicActivateCallback     ,


-- ** motionNotifyEvent #signal:motionNotifyEvent#
    C_WidgetMotionNotifyEventCallback       ,
    WidgetMotionNotifyEventCallback         ,
    WidgetMotionNotifyEventSignalInfo       ,
    afterWidgetMotionNotifyEvent            ,
    genClosure_WidgetMotionNotifyEvent      ,
    mk_WidgetMotionNotifyEventCallback      ,
    noWidgetMotionNotifyEventCallback       ,
    onWidgetMotionNotifyEvent               ,
    wrap_WidgetMotionNotifyEventCallback    ,


-- ** moveFocus #signal:moveFocus#
    C_WidgetMoveFocusCallback               ,
    WidgetMoveFocusCallback                 ,
    WidgetMoveFocusSignalInfo               ,
    afterWidgetMoveFocus                    ,
    genClosure_WidgetMoveFocus              ,
    mk_WidgetMoveFocusCallback              ,
    noWidgetMoveFocusCallback               ,
    onWidgetMoveFocus                       ,
    wrap_WidgetMoveFocusCallback            ,


-- ** parentSet #signal:parentSet#
    C_WidgetParentSetCallback               ,
    WidgetParentSetCallback                 ,
    WidgetParentSetSignalInfo               ,
    afterWidgetParentSet                    ,
    genClosure_WidgetParentSet              ,
    mk_WidgetParentSetCallback              ,
    noWidgetParentSetCallback               ,
    onWidgetParentSet                       ,
    wrap_WidgetParentSetCallback            ,


-- ** popupMenu #signal:popupMenu#
    C_WidgetPopupMenuCallback               ,
    WidgetPopupMenuCallback                 ,
    WidgetPopupMenuSignalInfo               ,
    afterWidgetPopupMenu                    ,
    genClosure_WidgetPopupMenu              ,
    mk_WidgetPopupMenuCallback              ,
    noWidgetPopupMenuCallback               ,
    onWidgetPopupMenu                       ,
    wrap_WidgetPopupMenuCallback            ,


-- ** propertyNotifyEvent #signal:propertyNotifyEvent#
    C_WidgetPropertyNotifyEventCallback     ,
    WidgetPropertyNotifyEventCallback       ,
    WidgetPropertyNotifyEventSignalInfo     ,
    afterWidgetPropertyNotifyEvent          ,
    genClosure_WidgetPropertyNotifyEvent    ,
    mk_WidgetPropertyNotifyEventCallback    ,
    noWidgetPropertyNotifyEventCallback     ,
    onWidgetPropertyNotifyEvent             ,
    wrap_WidgetPropertyNotifyEventCallback  ,


-- ** proximityInEvent #signal:proximityInEvent#
    C_WidgetProximityInEventCallback        ,
    WidgetProximityInEventCallback          ,
    WidgetProximityInEventSignalInfo        ,
    afterWidgetProximityInEvent             ,
    genClosure_WidgetProximityInEvent       ,
    mk_WidgetProximityInEventCallback       ,
    noWidgetProximityInEventCallback        ,
    onWidgetProximityInEvent                ,
    wrap_WidgetProximityInEventCallback     ,


-- ** proximityOutEvent #signal:proximityOutEvent#
    C_WidgetProximityOutEventCallback       ,
    WidgetProximityOutEventCallback         ,
    WidgetProximityOutEventSignalInfo       ,
    afterWidgetProximityOutEvent            ,
    genClosure_WidgetProximityOutEvent      ,
    mk_WidgetProximityOutEventCallback      ,
    noWidgetProximityOutEventCallback       ,
    onWidgetProximityOutEvent               ,
    wrap_WidgetProximityOutEventCallback    ,


-- ** queryTooltip #signal:queryTooltip#
    C_WidgetQueryTooltipCallback            ,
    WidgetQueryTooltipCallback              ,
    WidgetQueryTooltipSignalInfo            ,
    afterWidgetQueryTooltip                 ,
    genClosure_WidgetQueryTooltip           ,
    mk_WidgetQueryTooltipCallback           ,
    noWidgetQueryTooltipCallback            ,
    onWidgetQueryTooltip                    ,
    wrap_WidgetQueryTooltipCallback         ,


-- ** realize #signal:realize#
    C_WidgetRealizeCallback                 ,
    WidgetRealizeCallback                   ,
    WidgetRealizeSignalInfo                 ,
    afterWidgetRealize                      ,
    genClosure_WidgetRealize                ,
    mk_WidgetRealizeCallback                ,
    noWidgetRealizeCallback                 ,
    onWidgetRealize                         ,
    wrap_WidgetRealizeCallback              ,


-- ** screenChanged #signal:screenChanged#
    C_WidgetScreenChangedCallback           ,
    WidgetScreenChangedCallback             ,
    WidgetScreenChangedSignalInfo           ,
    afterWidgetScreenChanged                ,
    genClosure_WidgetScreenChanged          ,
    mk_WidgetScreenChangedCallback          ,
    noWidgetScreenChangedCallback           ,
    onWidgetScreenChanged                   ,
    wrap_WidgetScreenChangedCallback        ,


-- ** scrollEvent #signal:scrollEvent#
    C_WidgetScrollEventCallback             ,
    WidgetScrollEventCallback               ,
    WidgetScrollEventSignalInfo             ,
    afterWidgetScrollEvent                  ,
    genClosure_WidgetScrollEvent            ,
    mk_WidgetScrollEventCallback            ,
    noWidgetScrollEventCallback             ,
    onWidgetScrollEvent                     ,
    wrap_WidgetScrollEventCallback          ,


-- ** selectionClearEvent #signal:selectionClearEvent#
    C_WidgetSelectionClearEventCallback     ,
    WidgetSelectionClearEventCallback       ,
    WidgetSelectionClearEventSignalInfo     ,
    afterWidgetSelectionClearEvent          ,
    genClosure_WidgetSelectionClearEvent    ,
    mk_WidgetSelectionClearEventCallback    ,
    noWidgetSelectionClearEventCallback     ,
    onWidgetSelectionClearEvent             ,
    wrap_WidgetSelectionClearEventCallback  ,


-- ** selectionGet #signal:selectionGet#
    C_WidgetSelectionGetCallback            ,
    WidgetSelectionGetCallback              ,
    WidgetSelectionGetSignalInfo            ,
    afterWidgetSelectionGet                 ,
    genClosure_WidgetSelectionGet           ,
    mk_WidgetSelectionGetCallback           ,
    noWidgetSelectionGetCallback            ,
    onWidgetSelectionGet                    ,
    wrap_WidgetSelectionGetCallback         ,


-- ** selectionNotifyEvent #signal:selectionNotifyEvent#
    C_WidgetSelectionNotifyEventCallback    ,
    WidgetSelectionNotifyEventCallback      ,
    WidgetSelectionNotifyEventSignalInfo    ,
    afterWidgetSelectionNotifyEvent         ,
    genClosure_WidgetSelectionNotifyEvent   ,
    mk_WidgetSelectionNotifyEventCallback   ,
    noWidgetSelectionNotifyEventCallback    ,
    onWidgetSelectionNotifyEvent            ,
    wrap_WidgetSelectionNotifyEventCallback ,


-- ** selectionReceived #signal:selectionReceived#
    C_WidgetSelectionReceivedCallback       ,
    WidgetSelectionReceivedCallback         ,
    WidgetSelectionReceivedSignalInfo       ,
    afterWidgetSelectionReceived            ,
    genClosure_WidgetSelectionReceived      ,
    mk_WidgetSelectionReceivedCallback      ,
    noWidgetSelectionReceivedCallback       ,
    onWidgetSelectionReceived               ,
    wrap_WidgetSelectionReceivedCallback    ,


-- ** selectionRequestEvent #signal:selectionRequestEvent#
    C_WidgetSelectionRequestEventCallback   ,
    WidgetSelectionRequestEventCallback     ,
    WidgetSelectionRequestEventSignalInfo   ,
    afterWidgetSelectionRequestEvent        ,
    genClosure_WidgetSelectionRequestEvent  ,
    mk_WidgetSelectionRequestEventCallback  ,
    noWidgetSelectionRequestEventCallback   ,
    onWidgetSelectionRequestEvent           ,
    wrap_WidgetSelectionRequestEventCallback,


-- ** show #signal:show#
    C_WidgetShowCallback                    ,
    WidgetShowCallback                      ,
    WidgetShowSignalInfo                    ,
    afterWidgetShow                         ,
    genClosure_WidgetShow                   ,
    mk_WidgetShowCallback                   ,
    noWidgetShowCallback                    ,
    onWidgetShow                            ,
    wrap_WidgetShowCallback                 ,


-- ** showHelp #signal:showHelp#
    C_WidgetShowHelpCallback                ,
    WidgetShowHelpCallback                  ,
    WidgetShowHelpSignalInfo                ,
    afterWidgetShowHelp                     ,
    genClosure_WidgetShowHelp               ,
    mk_WidgetShowHelpCallback               ,
    noWidgetShowHelpCallback                ,
    onWidgetShowHelp                        ,
    wrap_WidgetShowHelpCallback             ,


-- ** sizeAllocate #signal:sizeAllocate#
    C_WidgetSizeAllocateCallback            ,
    WidgetSizeAllocateCallback              ,
    WidgetSizeAllocateSignalInfo            ,
    afterWidgetSizeAllocate                 ,
    genClosure_WidgetSizeAllocate           ,
    mk_WidgetSizeAllocateCallback           ,
    noWidgetSizeAllocateCallback            ,
    onWidgetSizeAllocate                    ,
    wrap_WidgetSizeAllocateCallback         ,


-- ** stateChanged #signal:stateChanged#
    C_WidgetStateChangedCallback            ,
    WidgetStateChangedCallback              ,
    WidgetStateChangedSignalInfo            ,
    afterWidgetStateChanged                 ,
    genClosure_WidgetStateChanged           ,
    mk_WidgetStateChangedCallback           ,
    noWidgetStateChangedCallback            ,
    onWidgetStateChanged                    ,
    wrap_WidgetStateChangedCallback         ,


-- ** stateFlagsChanged #signal:stateFlagsChanged#
    C_WidgetStateFlagsChangedCallback       ,
    WidgetStateFlagsChangedCallback         ,
    WidgetStateFlagsChangedSignalInfo       ,
    afterWidgetStateFlagsChanged            ,
    genClosure_WidgetStateFlagsChanged      ,
    mk_WidgetStateFlagsChangedCallback      ,
    noWidgetStateFlagsChangedCallback       ,
    onWidgetStateFlagsChanged               ,
    wrap_WidgetStateFlagsChangedCallback    ,


-- ** styleSet #signal:styleSet#
    C_WidgetStyleSetCallback                ,
    WidgetStyleSetCallback                  ,
    WidgetStyleSetSignalInfo                ,
    afterWidgetStyleSet                     ,
    genClosure_WidgetStyleSet               ,
    mk_WidgetStyleSetCallback               ,
    noWidgetStyleSetCallback                ,
    onWidgetStyleSet                        ,
    wrap_WidgetStyleSetCallback             ,


-- ** styleUpdated #signal:styleUpdated#
    C_WidgetStyleUpdatedCallback            ,
    WidgetStyleUpdatedCallback              ,
    WidgetStyleUpdatedSignalInfo            ,
    afterWidgetStyleUpdated                 ,
    genClosure_WidgetStyleUpdated           ,
    mk_WidgetStyleUpdatedCallback           ,
    noWidgetStyleUpdatedCallback            ,
    onWidgetStyleUpdated                    ,
    wrap_WidgetStyleUpdatedCallback         ,


-- ** touchEvent #signal:touchEvent#
    C_WidgetTouchEventCallback              ,
    WidgetTouchEventCallback                ,
    WidgetTouchEventSignalInfo              ,
    afterWidgetTouchEvent                   ,
    genClosure_WidgetTouchEvent             ,
    mk_WidgetTouchEventCallback             ,
    noWidgetTouchEventCallback              ,
    onWidgetTouchEvent                      ,
    wrap_WidgetTouchEventCallback           ,


-- ** unmap #signal:unmap#
    C_WidgetUnmapCallback                   ,
    WidgetUnmapCallback                     ,
    WidgetUnmapSignalInfo                   ,
    afterWidgetUnmap                        ,
    genClosure_WidgetUnmap                  ,
    mk_WidgetUnmapCallback                  ,
    noWidgetUnmapCallback                   ,
    onWidgetUnmap                           ,
    wrap_WidgetUnmapCallback                ,


-- ** unmapEvent #signal:unmapEvent#
    C_WidgetUnmapEventCallback              ,
    WidgetUnmapEventCallback                ,
    WidgetUnmapEventSignalInfo              ,
    afterWidgetUnmapEvent                   ,
    genClosure_WidgetUnmapEvent             ,
    mk_WidgetUnmapEventCallback             ,
    noWidgetUnmapEventCallback              ,
    onWidgetUnmapEvent                      ,
    wrap_WidgetUnmapEventCallback           ,


-- ** unrealize #signal:unrealize#
    C_WidgetUnrealizeCallback               ,
    WidgetUnrealizeCallback                 ,
    WidgetUnrealizeSignalInfo               ,
    afterWidgetUnrealize                    ,
    genClosure_WidgetUnrealize              ,
    mk_WidgetUnrealizeCallback              ,
    noWidgetUnrealizeCallback               ,
    onWidgetUnrealize                       ,
    wrap_WidgetUnrealizeCallback            ,


-- ** visibilityNotifyEvent #signal:visibilityNotifyEvent#
    C_WidgetVisibilityNotifyEventCallback   ,
    WidgetVisibilityNotifyEventCallback     ,
    WidgetVisibilityNotifyEventSignalInfo   ,
    afterWidgetVisibilityNotifyEvent        ,
    genClosure_WidgetVisibilityNotifyEvent  ,
    mk_WidgetVisibilityNotifyEventCallback  ,
    noWidgetVisibilityNotifyEventCallback   ,
    onWidgetVisibilityNotifyEvent           ,
    wrap_WidgetVisibilityNotifyEventCallback,


-- ** windowStateEvent #signal:windowStateEvent#
    C_WidgetWindowStateEventCallback        ,
    WidgetWindowStateEventCallback          ,
    WidgetWindowStateEventSignalInfo        ,
    afterWidgetWindowStateEvent             ,
    genClosure_WidgetWindowStateEvent       ,
    mk_WidgetWindowStateEventCallback       ,
    noWidgetWindowStateEventCallback        ,
    onWidgetWindowStateEvent                ,
    wrap_WidgetWindowStateEventCallback     ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
import qualified GI.Atk.Objects.Object as Atk.Object
import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.FontOptions as Cairo.FontOptions
import qualified GI.Cairo.Structs.Region as Cairo.Region
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Enums as Gdk.Enums
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gdk.Objects.Device as Gdk.Device
import qualified GI.Gdk.Objects.Display as Gdk.Display
import qualified GI.Gdk.Objects.DragContext as Gdk.DragContext
import qualified GI.Gdk.Objects.FrameClock as Gdk.FrameClock
import qualified GI.Gdk.Objects.Screen as Gdk.Screen
import qualified GI.Gdk.Objects.Visual as Gdk.Visual
import qualified GI.Gdk.Objects.Window as Gdk.Window
import qualified GI.Gdk.Structs.Atom as Gdk.Atom
import qualified GI.Gdk.Structs.Color as Gdk.Color
import qualified GI.Gdk.Structs.EventAny as Gdk.EventAny
import qualified GI.Gdk.Structs.EventButton as Gdk.EventButton
import qualified GI.Gdk.Structs.EventConfigure as Gdk.EventConfigure
import qualified GI.Gdk.Structs.EventCrossing as Gdk.EventCrossing
import qualified GI.Gdk.Structs.EventExpose as Gdk.EventExpose
import qualified GI.Gdk.Structs.EventFocus as Gdk.EventFocus
import qualified GI.Gdk.Structs.EventGrabBroken as Gdk.EventGrabBroken
import qualified GI.Gdk.Structs.EventKey as Gdk.EventKey
import qualified GI.Gdk.Structs.EventMotion as Gdk.EventMotion
import qualified GI.Gdk.Structs.EventProperty as Gdk.EventProperty
import qualified GI.Gdk.Structs.EventProximity as Gdk.EventProximity
import qualified GI.Gdk.Structs.EventScroll as Gdk.EventScroll
import qualified GI.Gdk.Structs.EventSelection as Gdk.EventSelection
import qualified GI.Gdk.Structs.EventVisibility as Gdk.EventVisibility
import qualified GI.Gdk.Structs.EventWindowState as Gdk.EventWindowState
import qualified GI.Gdk.Structs.RGBA as Gdk.RGBA
import qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
import qualified GI.Gdk.Unions.Event as Gdk.Event
import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gio.Interfaces.ActionGroup as Gio.ActionGroup
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Flags as Gtk.Flags
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Objects.AccelGroup as Gtk.AccelGroup
import {-# SOURCE #-} qualified GI.Gtk.Objects.Clipboard as Gtk.Clipboard
import {-# SOURCE #-} qualified GI.Gtk.Objects.Container as Gtk.Container
import {-# SOURCE #-} qualified GI.Gtk.Objects.RcStyle as Gtk.RcStyle
import {-# SOURCE #-} qualified GI.Gtk.Objects.Settings as Gtk.Settings
import {-# SOURCE #-} qualified GI.Gtk.Objects.Style as Gtk.Style
import {-# SOURCE #-} qualified GI.Gtk.Objects.StyleContext as Gtk.StyleContext
import {-# SOURCE #-} qualified GI.Gtk.Objects.Tooltip as Gtk.Tooltip
import {-# SOURCE #-} qualified GI.Gtk.Objects.Window as Gtk.Window
import {-# SOURCE #-} qualified GI.Gtk.Structs.Requisition as Gtk.Requisition
import {-# SOURCE #-} qualified GI.Gtk.Structs.SelectionData as Gtk.SelectionData
import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetEntry as Gtk.TargetEntry
import {-# SOURCE #-} qualified GI.Gtk.Structs.TargetList as Gtk.TargetList
import {-# SOURCE #-} qualified GI.Gtk.Structs.WidgetPath as Gtk.WidgetPath
import qualified GI.Pango.Objects.Context as Pango.Context
import qualified GI.Pango.Objects.FontMap as Pango.FontMap
import qualified GI.Pango.Objects.Layout as Pango.Layout
import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription

newtype Widget = Widget (ManagedPtr Widget)
foreign import ccall "gtk_widget_get_type"
    c_gtk_widget_get_type :: IO GType

instance GObject Widget where
    gobjectType _ = c_gtk_widget_get_type
    

class GObject o => IsWidget o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Widget a) =>
    IsWidget a
#endif
instance IsWidget Widget
instance GObject.Object.IsObject Widget
instance Atk.ImplementorIface.IsImplementorIface Widget
instance Gtk.Buildable.IsBuildable Widget

toWidget :: IsWidget o => o -> IO Widget
toWidget = unsafeCastTo Widget

noWidget :: Maybe Widget
noWidget = Nothing

type family ResolveWidgetMethod (t :: Symbol) (o :: *) :: * where
    ResolveWidgetMethod "activate" o = WidgetActivateMethodInfo
    ResolveWidgetMethod "addAccelerator" o = WidgetAddAcceleratorMethodInfo
    ResolveWidgetMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveWidgetMethod "addDeviceEvents" o = WidgetAddDeviceEventsMethodInfo
    ResolveWidgetMethod "addEvents" o = WidgetAddEventsMethodInfo
    ResolveWidgetMethod "addMnemonicLabel" o = WidgetAddMnemonicLabelMethodInfo
    ResolveWidgetMethod "addTickCallback" o = WidgetAddTickCallbackMethodInfo
    ResolveWidgetMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWidgetMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWidgetMethod "canActivateAccel" o = WidgetCanActivateAccelMethodInfo
    ResolveWidgetMethod "childFocus" o = WidgetChildFocusMethodInfo
    ResolveWidgetMethod "childNotify" o = WidgetChildNotifyMethodInfo
    ResolveWidgetMethod "classPath" o = WidgetClassPathMethodInfo
    ResolveWidgetMethod "computeExpand" o = WidgetComputeExpandMethodInfo
    ResolveWidgetMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveWidgetMethod "createPangoContext" o = WidgetCreatePangoContextMethodInfo
    ResolveWidgetMethod "createPangoLayout" o = WidgetCreatePangoLayoutMethodInfo
    ResolveWidgetMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveWidgetMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveWidgetMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveWidgetMethod "destroy" o = WidgetDestroyMethodInfo
    ResolveWidgetMethod "destroyed" o = WidgetDestroyedMethodInfo
    ResolveWidgetMethod "deviceIsShadowed" o = WidgetDeviceIsShadowedMethodInfo
    ResolveWidgetMethod "dragBegin" o = WidgetDragBeginMethodInfo
    ResolveWidgetMethod "dragBeginWithCoordinates" o = WidgetDragBeginWithCoordinatesMethodInfo
    ResolveWidgetMethod "dragCheckThreshold" o = WidgetDragCheckThresholdMethodInfo
    ResolveWidgetMethod "dragDestAddImageTargets" o = WidgetDragDestAddImageTargetsMethodInfo
    ResolveWidgetMethod "dragDestAddTextTargets" o = WidgetDragDestAddTextTargetsMethodInfo
    ResolveWidgetMethod "dragDestAddUriTargets" o = WidgetDragDestAddUriTargetsMethodInfo
    ResolveWidgetMethod "dragDestFindTarget" o = WidgetDragDestFindTargetMethodInfo
    ResolveWidgetMethod "dragDestGetTargetList" o = WidgetDragDestGetTargetListMethodInfo
    ResolveWidgetMethod "dragDestGetTrackMotion" o = WidgetDragDestGetTrackMotionMethodInfo
    ResolveWidgetMethod "dragDestSet" o = WidgetDragDestSetMethodInfo
    ResolveWidgetMethod "dragDestSetProxy" o = WidgetDragDestSetProxyMethodInfo
    ResolveWidgetMethod "dragDestSetTargetList" o = WidgetDragDestSetTargetListMethodInfo
    ResolveWidgetMethod "dragDestSetTrackMotion" o = WidgetDragDestSetTrackMotionMethodInfo
    ResolveWidgetMethod "dragDestUnset" o = WidgetDragDestUnsetMethodInfo
    ResolveWidgetMethod "dragGetData" o = WidgetDragGetDataMethodInfo
    ResolveWidgetMethod "dragHighlight" o = WidgetDragHighlightMethodInfo
    ResolveWidgetMethod "dragSourceAddImageTargets" o = WidgetDragSourceAddImageTargetsMethodInfo
    ResolveWidgetMethod "dragSourceAddTextTargets" o = WidgetDragSourceAddTextTargetsMethodInfo
    ResolveWidgetMethod "dragSourceAddUriTargets" o = WidgetDragSourceAddUriTargetsMethodInfo
    ResolveWidgetMethod "dragSourceGetTargetList" o = WidgetDragSourceGetTargetListMethodInfo
    ResolveWidgetMethod "dragSourceSet" o = WidgetDragSourceSetMethodInfo
    ResolveWidgetMethod "dragSourceSetIconGicon" o = WidgetDragSourceSetIconGiconMethodInfo
    ResolveWidgetMethod "dragSourceSetIconName" o = WidgetDragSourceSetIconNameMethodInfo
    ResolveWidgetMethod "dragSourceSetIconPixbuf" o = WidgetDragSourceSetIconPixbufMethodInfo
    ResolveWidgetMethod "dragSourceSetIconStock" o = WidgetDragSourceSetIconStockMethodInfo
    ResolveWidgetMethod "dragSourceSetTargetList" o = WidgetDragSourceSetTargetListMethodInfo
    ResolveWidgetMethod "dragSourceUnset" o = WidgetDragSourceUnsetMethodInfo
    ResolveWidgetMethod "dragUnhighlight" o = WidgetDragUnhighlightMethodInfo
    ResolveWidgetMethod "draw" o = WidgetDrawMethodInfo
    ResolveWidgetMethod "ensureStyle" o = WidgetEnsureStyleMethodInfo
    ResolveWidgetMethod "errorBell" o = WidgetErrorBellMethodInfo
    ResolveWidgetMethod "event" o = WidgetEventMethodInfo
    ResolveWidgetMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWidgetMethod "freezeChildNotify" o = WidgetFreezeChildNotifyMethodInfo
    ResolveWidgetMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWidgetMethod "grabAdd" o = WidgetGrabAddMethodInfo
    ResolveWidgetMethod "grabDefault" o = WidgetGrabDefaultMethodInfo
    ResolveWidgetMethod "grabFocus" o = WidgetGrabFocusMethodInfo
    ResolveWidgetMethod "grabRemove" o = WidgetGrabRemoveMethodInfo
    ResolveWidgetMethod "hasDefault" o = WidgetHasDefaultMethodInfo
    ResolveWidgetMethod "hasFocus" o = WidgetHasFocusMethodInfo
    ResolveWidgetMethod "hasGrab" o = WidgetHasGrabMethodInfo
    ResolveWidgetMethod "hasRcStyle" o = WidgetHasRcStyleMethodInfo
    ResolveWidgetMethod "hasScreen" o = WidgetHasScreenMethodInfo
    ResolveWidgetMethod "hasVisibleFocus" o = WidgetHasVisibleFocusMethodInfo
    ResolveWidgetMethod "hide" o = WidgetHideMethodInfo
    ResolveWidgetMethod "hideOnDelete" o = WidgetHideOnDeleteMethodInfo
    ResolveWidgetMethod "inDestruction" o = WidgetInDestructionMethodInfo
    ResolveWidgetMethod "initTemplate" o = WidgetInitTemplateMethodInfo
    ResolveWidgetMethod "inputShapeCombineRegion" o = WidgetInputShapeCombineRegionMethodInfo
    ResolveWidgetMethod "insertActionGroup" o = WidgetInsertActionGroupMethodInfo
    ResolveWidgetMethod "intersect" o = WidgetIntersectMethodInfo
    ResolveWidgetMethod "isAncestor" o = WidgetIsAncestorMethodInfo
    ResolveWidgetMethod "isComposited" o = WidgetIsCompositedMethodInfo
    ResolveWidgetMethod "isDrawable" o = WidgetIsDrawableMethodInfo
    ResolveWidgetMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWidgetMethod "isFocus" o = WidgetIsFocusMethodInfo
    ResolveWidgetMethod "isSensitive" o = WidgetIsSensitiveMethodInfo
    ResolveWidgetMethod "isToplevel" o = WidgetIsToplevelMethodInfo
    ResolveWidgetMethod "isVisible" o = WidgetIsVisibleMethodInfo
    ResolveWidgetMethod "keynavFailed" o = WidgetKeynavFailedMethodInfo
    ResolveWidgetMethod "listAccelClosures" o = WidgetListAccelClosuresMethodInfo
    ResolveWidgetMethod "listActionPrefixes" o = WidgetListActionPrefixesMethodInfo
    ResolveWidgetMethod "listMnemonicLabels" o = WidgetListMnemonicLabelsMethodInfo
    ResolveWidgetMethod "map" o = WidgetMapMethodInfo
    ResolveWidgetMethod "mnemonicActivate" o = WidgetMnemonicActivateMethodInfo
    ResolveWidgetMethod "modifyBase" o = WidgetModifyBaseMethodInfo
    ResolveWidgetMethod "modifyBg" o = WidgetModifyBgMethodInfo
    ResolveWidgetMethod "modifyCursor" o = WidgetModifyCursorMethodInfo
    ResolveWidgetMethod "modifyFg" o = WidgetModifyFgMethodInfo
    ResolveWidgetMethod "modifyFont" o = WidgetModifyFontMethodInfo
    ResolveWidgetMethod "modifyStyle" o = WidgetModifyStyleMethodInfo
    ResolveWidgetMethod "modifyText" o = WidgetModifyTextMethodInfo
    ResolveWidgetMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWidgetMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWidgetMethod "overrideBackgroundColor" o = WidgetOverrideBackgroundColorMethodInfo
    ResolveWidgetMethod "overrideColor" o = WidgetOverrideColorMethodInfo
    ResolveWidgetMethod "overrideCursor" o = WidgetOverrideCursorMethodInfo
    ResolveWidgetMethod "overrideFont" o = WidgetOverrideFontMethodInfo
    ResolveWidgetMethod "overrideSymbolicColor" o = WidgetOverrideSymbolicColorMethodInfo
    ResolveWidgetMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveWidgetMethod "path" o = WidgetPathMethodInfo
    ResolveWidgetMethod "queueAllocate" o = WidgetQueueAllocateMethodInfo
    ResolveWidgetMethod "queueComputeExpand" o = WidgetQueueComputeExpandMethodInfo
    ResolveWidgetMethod "queueDraw" o = WidgetQueueDrawMethodInfo
    ResolveWidgetMethod "queueDrawArea" o = WidgetQueueDrawAreaMethodInfo
    ResolveWidgetMethod "queueDrawRegion" o = WidgetQueueDrawRegionMethodInfo
    ResolveWidgetMethod "queueResize" o = WidgetQueueResizeMethodInfo
    ResolveWidgetMethod "queueResizeNoRedraw" o = WidgetQueueResizeNoRedrawMethodInfo
    ResolveWidgetMethod "realize" o = WidgetRealizeMethodInfo
    ResolveWidgetMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWidgetMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWidgetMethod "regionIntersect" o = WidgetRegionIntersectMethodInfo
    ResolveWidgetMethod "registerWindow" o = WidgetRegisterWindowMethodInfo
    ResolveWidgetMethod "removeAccelerator" o = WidgetRemoveAcceleratorMethodInfo
    ResolveWidgetMethod "removeMnemonicLabel" o = WidgetRemoveMnemonicLabelMethodInfo
    ResolveWidgetMethod "removeTickCallback" o = WidgetRemoveTickCallbackMethodInfo
    ResolveWidgetMethod "renderIcon" o = WidgetRenderIconMethodInfo
    ResolveWidgetMethod "renderIconPixbuf" o = WidgetRenderIconPixbufMethodInfo
    ResolveWidgetMethod "reparent" o = WidgetReparentMethodInfo
    ResolveWidgetMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveWidgetMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveWidgetMethod "resetRcStyles" o = WidgetResetRcStylesMethodInfo
    ResolveWidgetMethod "resetStyle" o = WidgetResetStyleMethodInfo
    ResolveWidgetMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWidgetMethod "sendExpose" o = WidgetSendExposeMethodInfo
    ResolveWidgetMethod "sendFocusChange" o = WidgetSendFocusChangeMethodInfo
    ResolveWidgetMethod "shapeCombineRegion" o = WidgetShapeCombineRegionMethodInfo
    ResolveWidgetMethod "show" o = WidgetShowMethodInfo
    ResolveWidgetMethod "showAll" o = WidgetShowAllMethodInfo
    ResolveWidgetMethod "showNow" o = WidgetShowNowMethodInfo
    ResolveWidgetMethod "sizeAllocate" o = WidgetSizeAllocateMethodInfo
    ResolveWidgetMethod "sizeAllocateWithBaseline" o = WidgetSizeAllocateWithBaselineMethodInfo
    ResolveWidgetMethod "sizeRequest" o = WidgetSizeRequestMethodInfo
    ResolveWidgetMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWidgetMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWidgetMethod "styleAttach" o = WidgetStyleAttachMethodInfo
    ResolveWidgetMethod "styleGetProperty" o = WidgetStyleGetPropertyMethodInfo
    ResolveWidgetMethod "thawChildNotify" o = WidgetThawChildNotifyMethodInfo
    ResolveWidgetMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWidgetMethod "translateCoordinates" o = WidgetTranslateCoordinatesMethodInfo
    ResolveWidgetMethod "triggerTooltipQuery" o = WidgetTriggerTooltipQueryMethodInfo
    ResolveWidgetMethod "unmap" o = WidgetUnmapMethodInfo
    ResolveWidgetMethod "unparent" o = WidgetUnparentMethodInfo
    ResolveWidgetMethod "unrealize" o = WidgetUnrealizeMethodInfo
    ResolveWidgetMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWidgetMethod "unregisterWindow" o = WidgetUnregisterWindowMethodInfo
    ResolveWidgetMethod "unsetStateFlags" o = WidgetUnsetStateFlagsMethodInfo
    ResolveWidgetMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWidgetMethod "getAccessible" o = WidgetGetAccessibleMethodInfo
    ResolveWidgetMethod "getActionGroup" o = WidgetGetActionGroupMethodInfo
    ResolveWidgetMethod "getAllocatedBaseline" o = WidgetGetAllocatedBaselineMethodInfo
    ResolveWidgetMethod "getAllocatedHeight" o = WidgetGetAllocatedHeightMethodInfo
    ResolveWidgetMethod "getAllocatedSize" o = WidgetGetAllocatedSizeMethodInfo
    ResolveWidgetMethod "getAllocatedWidth" o = WidgetGetAllocatedWidthMethodInfo
    ResolveWidgetMethod "getAllocation" o = WidgetGetAllocationMethodInfo
    ResolveWidgetMethod "getAncestor" o = WidgetGetAncestorMethodInfo
    ResolveWidgetMethod "getAppPaintable" o = WidgetGetAppPaintableMethodInfo
    ResolveWidgetMethod "getCanDefault" o = WidgetGetCanDefaultMethodInfo
    ResolveWidgetMethod "getCanFocus" o = WidgetGetCanFocusMethodInfo
    ResolveWidgetMethod "getChildRequisition" o = WidgetGetChildRequisitionMethodInfo
    ResolveWidgetMethod "getChildVisible" o = WidgetGetChildVisibleMethodInfo
    ResolveWidgetMethod "getClip" o = WidgetGetClipMethodInfo
    ResolveWidgetMethod "getClipboard" o = WidgetGetClipboardMethodInfo
    ResolveWidgetMethod "getCompositeName" o = WidgetGetCompositeNameMethodInfo
    ResolveWidgetMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWidgetMethod "getDeviceEnabled" o = WidgetGetDeviceEnabledMethodInfo
    ResolveWidgetMethod "getDeviceEvents" o = WidgetGetDeviceEventsMethodInfo
    ResolveWidgetMethod "getDirection" o = WidgetGetDirectionMethodInfo
    ResolveWidgetMethod "getDisplay" o = WidgetGetDisplayMethodInfo
    ResolveWidgetMethod "getDoubleBuffered" o = WidgetGetDoubleBufferedMethodInfo
    ResolveWidgetMethod "getEvents" o = WidgetGetEventsMethodInfo
    ResolveWidgetMethod "getFocusOnClick" o = WidgetGetFocusOnClickMethodInfo
    ResolveWidgetMethod "getFontMap" o = WidgetGetFontMapMethodInfo
    ResolveWidgetMethod "getFontOptions" o = WidgetGetFontOptionsMethodInfo
    ResolveWidgetMethod "getFrameClock" o = WidgetGetFrameClockMethodInfo
    ResolveWidgetMethod "getHalign" o = WidgetGetHalignMethodInfo
    ResolveWidgetMethod "getHasTooltip" o = WidgetGetHasTooltipMethodInfo
    ResolveWidgetMethod "getHasWindow" o = WidgetGetHasWindowMethodInfo
    ResolveWidgetMethod "getHexpand" o = WidgetGetHexpandMethodInfo
    ResolveWidgetMethod "getHexpandSet" o = WidgetGetHexpandSetMethodInfo
    ResolveWidgetMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveWidgetMethod "getMapped" o = WidgetGetMappedMethodInfo
    ResolveWidgetMethod "getMarginBottom" o = WidgetGetMarginBottomMethodInfo
    ResolveWidgetMethod "getMarginEnd" o = WidgetGetMarginEndMethodInfo
    ResolveWidgetMethod "getMarginLeft" o = WidgetGetMarginLeftMethodInfo
    ResolveWidgetMethod "getMarginRight" o = WidgetGetMarginRightMethodInfo
    ResolveWidgetMethod "getMarginStart" o = WidgetGetMarginStartMethodInfo
    ResolveWidgetMethod "getMarginTop" o = WidgetGetMarginTopMethodInfo
    ResolveWidgetMethod "getModifierMask" o = WidgetGetModifierMaskMethodInfo
    ResolveWidgetMethod "getModifierStyle" o = WidgetGetModifierStyleMethodInfo
    ResolveWidgetMethod "getName" o = WidgetGetNameMethodInfo
    ResolveWidgetMethod "getNoShowAll" o = WidgetGetNoShowAllMethodInfo
    ResolveWidgetMethod "getOpacity" o = WidgetGetOpacityMethodInfo
    ResolveWidgetMethod "getPangoContext" o = WidgetGetPangoContextMethodInfo
    ResolveWidgetMethod "getParent" o = WidgetGetParentMethodInfo
    ResolveWidgetMethod "getParentWindow" o = WidgetGetParentWindowMethodInfo
    ResolveWidgetMethod "getPath" o = WidgetGetPathMethodInfo
    ResolveWidgetMethod "getPointer" o = WidgetGetPointerMethodInfo
    ResolveWidgetMethod "getPreferredHeight" o = WidgetGetPreferredHeightMethodInfo
    ResolveWidgetMethod "getPreferredHeightAndBaselineForWidth" o = WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
    ResolveWidgetMethod "getPreferredHeightForWidth" o = WidgetGetPreferredHeightForWidthMethodInfo
    ResolveWidgetMethod "getPreferredSize" o = WidgetGetPreferredSizeMethodInfo
    ResolveWidgetMethod "getPreferredWidth" o = WidgetGetPreferredWidthMethodInfo
    ResolveWidgetMethod "getPreferredWidthForHeight" o = WidgetGetPreferredWidthForHeightMethodInfo
    ResolveWidgetMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWidgetMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWidgetMethod "getRealized" o = WidgetGetRealizedMethodInfo
    ResolveWidgetMethod "getReceivesDefault" o = WidgetGetReceivesDefaultMethodInfo
    ResolveWidgetMethod "getRequestMode" o = WidgetGetRequestModeMethodInfo
    ResolveWidgetMethod "getRequisition" o = WidgetGetRequisitionMethodInfo
    ResolveWidgetMethod "getRootWindow" o = WidgetGetRootWindowMethodInfo
    ResolveWidgetMethod "getScaleFactor" o = WidgetGetScaleFactorMethodInfo
    ResolveWidgetMethod "getScreen" o = WidgetGetScreenMethodInfo
    ResolveWidgetMethod "getSensitive" o = WidgetGetSensitiveMethodInfo
    ResolveWidgetMethod "getSettings" o = WidgetGetSettingsMethodInfo
    ResolveWidgetMethod "getSizeRequest" o = WidgetGetSizeRequestMethodInfo
    ResolveWidgetMethod "getState" o = WidgetGetStateMethodInfo
    ResolveWidgetMethod "getStateFlags" o = WidgetGetStateFlagsMethodInfo
    ResolveWidgetMethod "getStyle" o = WidgetGetStyleMethodInfo
    ResolveWidgetMethod "getStyleContext" o = WidgetGetStyleContextMethodInfo
    ResolveWidgetMethod "getSupportMultidevice" o = WidgetGetSupportMultideviceMethodInfo
    ResolveWidgetMethod "getTemplateChild" o = WidgetGetTemplateChildMethodInfo
    ResolveWidgetMethod "getTooltipMarkup" o = WidgetGetTooltipMarkupMethodInfo
    ResolveWidgetMethod "getTooltipText" o = WidgetGetTooltipTextMethodInfo
    ResolveWidgetMethod "getTooltipWindow" o = WidgetGetTooltipWindowMethodInfo
    ResolveWidgetMethod "getToplevel" o = WidgetGetToplevelMethodInfo
    ResolveWidgetMethod "getValign" o = WidgetGetValignMethodInfo
    ResolveWidgetMethod "getValignWithBaseline" o = WidgetGetValignWithBaselineMethodInfo
    ResolveWidgetMethod "getVexpand" o = WidgetGetVexpandMethodInfo
    ResolveWidgetMethod "getVexpandSet" o = WidgetGetVexpandSetMethodInfo
    ResolveWidgetMethod "getVisible" o = WidgetGetVisibleMethodInfo
    ResolveWidgetMethod "getVisual" o = WidgetGetVisualMethodInfo
    ResolveWidgetMethod "getWindow" o = WidgetGetWindowMethodInfo
    ResolveWidgetMethod "setAccelPath" o = WidgetSetAccelPathMethodInfo
    ResolveWidgetMethod "setAllocation" o = WidgetSetAllocationMethodInfo
    ResolveWidgetMethod "setAppPaintable" o = WidgetSetAppPaintableMethodInfo
    ResolveWidgetMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveWidgetMethod "setCanDefault" o = WidgetSetCanDefaultMethodInfo
    ResolveWidgetMethod "setCanFocus" o = WidgetSetCanFocusMethodInfo
    ResolveWidgetMethod "setChildVisible" o = WidgetSetChildVisibleMethodInfo
    ResolveWidgetMethod "setClip" o = WidgetSetClipMethodInfo
    ResolveWidgetMethod "setCompositeName" o = WidgetSetCompositeNameMethodInfo
    ResolveWidgetMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWidgetMethod "setDeviceEnabled" o = WidgetSetDeviceEnabledMethodInfo
    ResolveWidgetMethod "setDeviceEvents" o = WidgetSetDeviceEventsMethodInfo
    ResolveWidgetMethod "setDirection" o = WidgetSetDirectionMethodInfo
    ResolveWidgetMethod "setDoubleBuffered" o = WidgetSetDoubleBufferedMethodInfo
    ResolveWidgetMethod "setEvents" o = WidgetSetEventsMethodInfo
    ResolveWidgetMethod "setFocusOnClick" o = WidgetSetFocusOnClickMethodInfo
    ResolveWidgetMethod "setFontMap" o = WidgetSetFontMapMethodInfo
    ResolveWidgetMethod "setFontOptions" o = WidgetSetFontOptionsMethodInfo
    ResolveWidgetMethod "setHalign" o = WidgetSetHalignMethodInfo
    ResolveWidgetMethod "setHasTooltip" o = WidgetSetHasTooltipMethodInfo
    ResolveWidgetMethod "setHasWindow" o = WidgetSetHasWindowMethodInfo
    ResolveWidgetMethod "setHexpand" o = WidgetSetHexpandMethodInfo
    ResolveWidgetMethod "setHexpandSet" o = WidgetSetHexpandSetMethodInfo
    ResolveWidgetMethod "setMapped" o = WidgetSetMappedMethodInfo
    ResolveWidgetMethod "setMarginBottom" o = WidgetSetMarginBottomMethodInfo
    ResolveWidgetMethod "setMarginEnd" o = WidgetSetMarginEndMethodInfo
    ResolveWidgetMethod "setMarginLeft" o = WidgetSetMarginLeftMethodInfo
    ResolveWidgetMethod "setMarginRight" o = WidgetSetMarginRightMethodInfo
    ResolveWidgetMethod "setMarginStart" o = WidgetSetMarginStartMethodInfo
    ResolveWidgetMethod "setMarginTop" o = WidgetSetMarginTopMethodInfo
    ResolveWidgetMethod "setName" o = WidgetSetNameMethodInfo
    ResolveWidgetMethod "setNoShowAll" o = WidgetSetNoShowAllMethodInfo
    ResolveWidgetMethod "setOpacity" o = WidgetSetOpacityMethodInfo
    ResolveWidgetMethod "setParent" o = WidgetSetParentMethodInfo
    ResolveWidgetMethod "setParentWindow" o = WidgetSetParentWindowMethodInfo
    ResolveWidgetMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWidgetMethod "setRealized" o = WidgetSetRealizedMethodInfo
    ResolveWidgetMethod "setReceivesDefault" o = WidgetSetReceivesDefaultMethodInfo
    ResolveWidgetMethod "setRedrawOnAllocate" o = WidgetSetRedrawOnAllocateMethodInfo
    ResolveWidgetMethod "setSensitive" o = WidgetSetSensitiveMethodInfo
    ResolveWidgetMethod "setSizeRequest" o = WidgetSetSizeRequestMethodInfo
    ResolveWidgetMethod "setState" o = WidgetSetStateMethodInfo
    ResolveWidgetMethod "setStateFlags" o = WidgetSetStateFlagsMethodInfo
    ResolveWidgetMethod "setStyle" o = WidgetSetStyleMethodInfo
    ResolveWidgetMethod "setSupportMultidevice" o = WidgetSetSupportMultideviceMethodInfo
    ResolveWidgetMethod "setTooltipMarkup" o = WidgetSetTooltipMarkupMethodInfo
    ResolveWidgetMethod "setTooltipText" o = WidgetSetTooltipTextMethodInfo
    ResolveWidgetMethod "setTooltipWindow" o = WidgetSetTooltipWindowMethodInfo
    ResolveWidgetMethod "setValign" o = WidgetSetValignMethodInfo
    ResolveWidgetMethod "setVexpand" o = WidgetSetVexpandMethodInfo
    ResolveWidgetMethod "setVexpandSet" o = WidgetSetVexpandSetMethodInfo
    ResolveWidgetMethod "setVisible" o = WidgetSetVisibleMethodInfo
    ResolveWidgetMethod "setVisual" o = WidgetSetVisualMethodInfo
    ResolveWidgetMethod "setWindow" o = WidgetSetWindowMethodInfo
    ResolveWidgetMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWidgetMethod t Widget, O.MethodInfo info Widget p) => O.IsLabelProxy t (Widget -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveWidgetMethod t Widget, O.MethodInfo info Widget p) => O.IsLabel t (Widget -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- signal Widget::accel-closures-changed
type WidgetAccelClosuresChangedCallback =
    IO ()

noWidgetAccelClosuresChangedCallback :: Maybe WidgetAccelClosuresChangedCallback
noWidgetAccelClosuresChangedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WidgetAccelClosuresChangedCallback :: C_WidgetAccelClosuresChangedCallback -> IO (FunPtr C_WidgetAccelClosuresChangedCallback)

genClosure_WidgetAccelClosuresChanged :: WidgetAccelClosuresChangedCallback -> IO Closure
genClosure_WidgetAccelClosuresChanged cb = do
    let cb' = wrap_WidgetAccelClosuresChangedCallback cb
    mk_WidgetAccelClosuresChangedCallback cb' >>= newCClosure


wrap_WidgetAccelClosuresChangedCallback ::
    WidgetAccelClosuresChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetAccelClosuresChangedCallback _cb _ _ = do
    _cb 


onWidgetAccelClosuresChanged :: (GObject a, MonadIO m) => a -> WidgetAccelClosuresChangedCallback -> m SignalHandlerId
onWidgetAccelClosuresChanged obj cb = liftIO $ connectWidgetAccelClosuresChanged obj cb SignalConnectBefore
afterWidgetAccelClosuresChanged :: (GObject a, MonadIO m) => a -> WidgetAccelClosuresChangedCallback -> m SignalHandlerId
afterWidgetAccelClosuresChanged obj cb = connectWidgetAccelClosuresChanged obj cb SignalConnectAfter

connectWidgetAccelClosuresChanged :: (GObject a, MonadIO m) =>
                                     a -> WidgetAccelClosuresChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetAccelClosuresChanged obj cb after = liftIO $ do
    let cb' = wrap_WidgetAccelClosuresChangedCallback cb
    cb'' <- mk_WidgetAccelClosuresChangedCallback cb'
    connectSignalFunPtr obj "accel-closures-changed" cb'' after

-- signal Widget::button-press-event
type WidgetButtonPressEventCallback =
    Gdk.EventButton.EventButton ->
    IO Bool

noWidgetButtonPressEventCallback :: Maybe WidgetButtonPressEventCallback
noWidgetButtonPressEventCallback = Nothing

type C_WidgetButtonPressEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventButton.EventButton ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetButtonPressEventCallback :: C_WidgetButtonPressEventCallback -> IO (FunPtr C_WidgetButtonPressEventCallback)

genClosure_WidgetButtonPressEvent :: WidgetButtonPressEventCallback -> IO Closure
genClosure_WidgetButtonPressEvent cb = do
    let cb' = wrap_WidgetButtonPressEventCallback cb
    mk_WidgetButtonPressEventCallback cb' >>= newCClosure


wrap_WidgetButtonPressEventCallback ::
    WidgetButtonPressEventCallback ->
    Ptr () ->
    Ptr Gdk.EventButton.EventButton ->
    Ptr () ->
    IO CInt
wrap_WidgetButtonPressEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventButton.EventButton) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetButtonPressEvent :: (GObject a, MonadIO m) => a -> WidgetButtonPressEventCallback -> m SignalHandlerId
onWidgetButtonPressEvent obj cb = liftIO $ connectWidgetButtonPressEvent obj cb SignalConnectBefore
afterWidgetButtonPressEvent :: (GObject a, MonadIO m) => a -> WidgetButtonPressEventCallback -> m SignalHandlerId
afterWidgetButtonPressEvent obj cb = connectWidgetButtonPressEvent obj cb SignalConnectAfter

connectWidgetButtonPressEvent :: (GObject a, MonadIO m) =>
                                 a -> WidgetButtonPressEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetButtonPressEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetButtonPressEventCallback cb
    cb'' <- mk_WidgetButtonPressEventCallback cb'
    connectSignalFunPtr obj "button-press-event" cb'' after

-- signal Widget::button-release-event
type WidgetButtonReleaseEventCallback =
    Gdk.EventButton.EventButton ->
    IO Bool

noWidgetButtonReleaseEventCallback :: Maybe WidgetButtonReleaseEventCallback
noWidgetButtonReleaseEventCallback = Nothing

type C_WidgetButtonReleaseEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventButton.EventButton ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetButtonReleaseEventCallback :: C_WidgetButtonReleaseEventCallback -> IO (FunPtr C_WidgetButtonReleaseEventCallback)

genClosure_WidgetButtonReleaseEvent :: WidgetButtonReleaseEventCallback -> IO Closure
genClosure_WidgetButtonReleaseEvent cb = do
    let cb' = wrap_WidgetButtonReleaseEventCallback cb
    mk_WidgetButtonReleaseEventCallback cb' >>= newCClosure


wrap_WidgetButtonReleaseEventCallback ::
    WidgetButtonReleaseEventCallback ->
    Ptr () ->
    Ptr Gdk.EventButton.EventButton ->
    Ptr () ->
    IO CInt
wrap_WidgetButtonReleaseEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventButton.EventButton) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetButtonReleaseEvent :: (GObject a, MonadIO m) => a -> WidgetButtonReleaseEventCallback -> m SignalHandlerId
onWidgetButtonReleaseEvent obj cb = liftIO $ connectWidgetButtonReleaseEvent obj cb SignalConnectBefore
afterWidgetButtonReleaseEvent :: (GObject a, MonadIO m) => a -> WidgetButtonReleaseEventCallback -> m SignalHandlerId
afterWidgetButtonReleaseEvent obj cb = connectWidgetButtonReleaseEvent obj cb SignalConnectAfter

connectWidgetButtonReleaseEvent :: (GObject a, MonadIO m) =>
                                   a -> WidgetButtonReleaseEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetButtonReleaseEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetButtonReleaseEventCallback cb
    cb'' <- mk_WidgetButtonReleaseEventCallback cb'
    connectSignalFunPtr obj "button-release-event" cb'' after

-- signal Widget::can-activate-accel
type WidgetCanActivateAccelCallback =
    Word32 ->
    IO Bool

noWidgetCanActivateAccelCallback :: Maybe WidgetCanActivateAccelCallback
noWidgetCanActivateAccelCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WidgetCanActivateAccelCallback :: C_WidgetCanActivateAccelCallback -> IO (FunPtr C_WidgetCanActivateAccelCallback)

genClosure_WidgetCanActivateAccel :: WidgetCanActivateAccelCallback -> IO Closure
genClosure_WidgetCanActivateAccel cb = do
    let cb' = wrap_WidgetCanActivateAccelCallback cb
    mk_WidgetCanActivateAccelCallback cb' >>= newCClosure


wrap_WidgetCanActivateAccelCallback ::
    WidgetCanActivateAccelCallback ->
    Ptr () ->
    Word32 ->
    Ptr () ->
    IO CInt
wrap_WidgetCanActivateAccelCallback _cb _ signalId _ = do
    result <- _cb  signalId
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetCanActivateAccel :: (GObject a, MonadIO m) => a -> WidgetCanActivateAccelCallback -> m SignalHandlerId
onWidgetCanActivateAccel obj cb = liftIO $ connectWidgetCanActivateAccel obj cb SignalConnectBefore
afterWidgetCanActivateAccel :: (GObject a, MonadIO m) => a -> WidgetCanActivateAccelCallback -> m SignalHandlerId
afterWidgetCanActivateAccel obj cb = connectWidgetCanActivateAccel obj cb SignalConnectAfter

connectWidgetCanActivateAccel :: (GObject a, MonadIO m) =>
                                 a -> WidgetCanActivateAccelCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetCanActivateAccel obj cb after = liftIO $ do
    let cb' = wrap_WidgetCanActivateAccelCallback cb
    cb'' <- mk_WidgetCanActivateAccelCallback cb'
    connectSignalFunPtr obj "can-activate-accel" cb'' after

-- signal Widget::child-notify
type WidgetChildNotifyCallback =
    GParamSpec ->
    IO ()

noWidgetChildNotifyCallback :: Maybe WidgetChildNotifyCallback
noWidgetChildNotifyCallback = Nothing

type C_WidgetChildNotifyCallback =
    Ptr () ->                               -- object
    Ptr GParamSpec ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetChildNotifyCallback :: C_WidgetChildNotifyCallback -> IO (FunPtr C_WidgetChildNotifyCallback)

genClosure_WidgetChildNotify :: WidgetChildNotifyCallback -> IO Closure
genClosure_WidgetChildNotify cb = do
    let cb' = wrap_WidgetChildNotifyCallback cb
    mk_WidgetChildNotifyCallback cb' >>= newCClosure


wrap_WidgetChildNotifyCallback ::
    WidgetChildNotifyCallback ->
    Ptr () ->
    Ptr GParamSpec ->
    Ptr () ->
    IO ()
wrap_WidgetChildNotifyCallback _cb _ childProperty _ = do
    childProperty' <- newGParamSpecFromPtr childProperty
    _cb  childProperty'


onWidgetChildNotify :: (GObject a, MonadIO m) => a -> WidgetChildNotifyCallback -> m SignalHandlerId
onWidgetChildNotify obj cb = liftIO $ connectWidgetChildNotify obj cb SignalConnectBefore
afterWidgetChildNotify :: (GObject a, MonadIO m) => a -> WidgetChildNotifyCallback -> m SignalHandlerId
afterWidgetChildNotify obj cb = connectWidgetChildNotify obj cb SignalConnectAfter

connectWidgetChildNotify :: (GObject a, MonadIO m) =>
                            a -> WidgetChildNotifyCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetChildNotify obj cb after = liftIO $ do
    let cb' = wrap_WidgetChildNotifyCallback cb
    cb'' <- mk_WidgetChildNotifyCallback cb'
    connectSignalFunPtr obj "child-notify" cb'' after

-- signal Widget::composited-changed
{-# DEPRECATED WidgetCompositedChangedCallback ["(Since version 3.22)","Use GdkScreen::composited-changed instead."] #-}
type WidgetCompositedChangedCallback =
    IO ()

noWidgetCompositedChangedCallback :: Maybe WidgetCompositedChangedCallback
noWidgetCompositedChangedCallback = Nothing

type C_WidgetCompositedChangedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetCompositedChangedCallback :: C_WidgetCompositedChangedCallback -> IO (FunPtr C_WidgetCompositedChangedCallback)

genClosure_WidgetCompositedChanged :: WidgetCompositedChangedCallback -> IO Closure
genClosure_WidgetCompositedChanged cb = do
    let cb' = wrap_WidgetCompositedChangedCallback cb
    mk_WidgetCompositedChangedCallback cb' >>= newCClosure


wrap_WidgetCompositedChangedCallback ::
    WidgetCompositedChangedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetCompositedChangedCallback _cb _ _ = do
    _cb 


onWidgetCompositedChanged :: (GObject a, MonadIO m) => a -> WidgetCompositedChangedCallback -> m SignalHandlerId
onWidgetCompositedChanged obj cb = liftIO $ connectWidgetCompositedChanged obj cb SignalConnectBefore
afterWidgetCompositedChanged :: (GObject a, MonadIO m) => a -> WidgetCompositedChangedCallback -> m SignalHandlerId
afterWidgetCompositedChanged obj cb = connectWidgetCompositedChanged obj cb SignalConnectAfter

connectWidgetCompositedChanged :: (GObject a, MonadIO m) =>
                                  a -> WidgetCompositedChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetCompositedChanged obj cb after = liftIO $ do
    let cb' = wrap_WidgetCompositedChangedCallback cb
    cb'' <- mk_WidgetCompositedChangedCallback cb'
    connectSignalFunPtr obj "composited-changed" cb'' after

-- signal Widget::configure-event
type WidgetConfigureEventCallback =
    Gdk.EventConfigure.EventConfigure ->
    IO Bool

noWidgetConfigureEventCallback :: Maybe WidgetConfigureEventCallback
noWidgetConfigureEventCallback = Nothing

type C_WidgetConfigureEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventConfigure.EventConfigure ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetConfigureEventCallback :: C_WidgetConfigureEventCallback -> IO (FunPtr C_WidgetConfigureEventCallback)

genClosure_WidgetConfigureEvent :: WidgetConfigureEventCallback -> IO Closure
genClosure_WidgetConfigureEvent cb = do
    let cb' = wrap_WidgetConfigureEventCallback cb
    mk_WidgetConfigureEventCallback cb' >>= newCClosure


wrap_WidgetConfigureEventCallback ::
    WidgetConfigureEventCallback ->
    Ptr () ->
    Ptr Gdk.EventConfigure.EventConfigure ->
    Ptr () ->
    IO CInt
wrap_WidgetConfigureEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventConfigure.EventConfigure) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetConfigureEvent :: (GObject a, MonadIO m) => a -> WidgetConfigureEventCallback -> m SignalHandlerId
onWidgetConfigureEvent obj cb = liftIO $ connectWidgetConfigureEvent obj cb SignalConnectBefore
afterWidgetConfigureEvent :: (GObject a, MonadIO m) => a -> WidgetConfigureEventCallback -> m SignalHandlerId
afterWidgetConfigureEvent obj cb = connectWidgetConfigureEvent obj cb SignalConnectAfter

connectWidgetConfigureEvent :: (GObject a, MonadIO m) =>
                               a -> WidgetConfigureEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetConfigureEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetConfigureEventCallback cb
    cb'' <- mk_WidgetConfigureEventCallback cb'
    connectSignalFunPtr obj "configure-event" cb'' after

-- signal Widget::damage-event
type WidgetDamageEventCallback =
    Gdk.EventExpose.EventExpose ->
    IO Bool

noWidgetDamageEventCallback :: Maybe WidgetDamageEventCallback
noWidgetDamageEventCallback = Nothing

type C_WidgetDamageEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventExpose.EventExpose ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetDamageEventCallback :: C_WidgetDamageEventCallback -> IO (FunPtr C_WidgetDamageEventCallback)

genClosure_WidgetDamageEvent :: WidgetDamageEventCallback -> IO Closure
genClosure_WidgetDamageEvent cb = do
    let cb' = wrap_WidgetDamageEventCallback cb
    mk_WidgetDamageEventCallback cb' >>= newCClosure


wrap_WidgetDamageEventCallback ::
    WidgetDamageEventCallback ->
    Ptr () ->
    Ptr Gdk.EventExpose.EventExpose ->
    Ptr () ->
    IO CInt
wrap_WidgetDamageEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventExpose.EventExpose) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetDamageEvent :: (GObject a, MonadIO m) => a -> WidgetDamageEventCallback -> m SignalHandlerId
onWidgetDamageEvent obj cb = liftIO $ connectWidgetDamageEvent obj cb SignalConnectBefore
afterWidgetDamageEvent :: (GObject a, MonadIO m) => a -> WidgetDamageEventCallback -> m SignalHandlerId
afterWidgetDamageEvent obj cb = connectWidgetDamageEvent obj cb SignalConnectAfter

connectWidgetDamageEvent :: (GObject a, MonadIO m) =>
                            a -> WidgetDamageEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDamageEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetDamageEventCallback cb
    cb'' <- mk_WidgetDamageEventCallback cb'
    connectSignalFunPtr obj "damage-event" cb'' after

-- signal Widget::delete-event
type WidgetDeleteEventCallback =
    Gdk.Event.Event ->
    IO Bool

noWidgetDeleteEventCallback :: Maybe WidgetDeleteEventCallback
noWidgetDeleteEventCallback = Nothing

type C_WidgetDeleteEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Event.Event ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetDeleteEventCallback :: C_WidgetDeleteEventCallback -> IO (FunPtr C_WidgetDeleteEventCallback)

genClosure_WidgetDeleteEvent :: WidgetDeleteEventCallback -> IO Closure
genClosure_WidgetDeleteEvent cb = do
    let cb' = wrap_WidgetDeleteEventCallback cb
    mk_WidgetDeleteEventCallback cb' >>= newCClosure


wrap_WidgetDeleteEventCallback ::
    WidgetDeleteEventCallback ->
    Ptr () ->
    Ptr Gdk.Event.Event ->
    Ptr () ->
    IO CInt
wrap_WidgetDeleteEventCallback _cb _ event _ = do
    event' <- (newBoxed Gdk.Event.Event) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetDeleteEvent :: (GObject a, MonadIO m) => a -> WidgetDeleteEventCallback -> m SignalHandlerId
onWidgetDeleteEvent obj cb = liftIO $ connectWidgetDeleteEvent obj cb SignalConnectBefore
afterWidgetDeleteEvent :: (GObject a, MonadIO m) => a -> WidgetDeleteEventCallback -> m SignalHandlerId
afterWidgetDeleteEvent obj cb = connectWidgetDeleteEvent obj cb SignalConnectAfter

connectWidgetDeleteEvent :: (GObject a, MonadIO m) =>
                            a -> WidgetDeleteEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDeleteEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetDeleteEventCallback cb
    cb'' <- mk_WidgetDeleteEventCallback cb'
    connectSignalFunPtr obj "delete-event" cb'' after

-- signal Widget::destroy
type WidgetDestroyCallback =
    IO ()

noWidgetDestroyCallback :: Maybe WidgetDestroyCallback
noWidgetDestroyCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WidgetDestroyCallback :: C_WidgetDestroyCallback -> IO (FunPtr C_WidgetDestroyCallback)

genClosure_WidgetDestroy :: WidgetDestroyCallback -> IO Closure
genClosure_WidgetDestroy cb = do
    let cb' = wrap_WidgetDestroyCallback cb
    mk_WidgetDestroyCallback cb' >>= newCClosure


wrap_WidgetDestroyCallback ::
    WidgetDestroyCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetDestroyCallback _cb _ _ = do
    _cb 


onWidgetDestroy :: (GObject a, MonadIO m) => a -> WidgetDestroyCallback -> m SignalHandlerId
onWidgetDestroy obj cb = liftIO $ connectWidgetDestroy obj cb SignalConnectBefore
afterWidgetDestroy :: (GObject a, MonadIO m) => a -> WidgetDestroyCallback -> m SignalHandlerId
afterWidgetDestroy obj cb = connectWidgetDestroy obj cb SignalConnectAfter

connectWidgetDestroy :: (GObject a, MonadIO m) =>
                        a -> WidgetDestroyCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDestroy obj cb after = liftIO $ do
    let cb' = wrap_WidgetDestroyCallback cb
    cb'' <- mk_WidgetDestroyCallback cb'
    connectSignalFunPtr obj "destroy" cb'' after

-- signal Widget::destroy-event
type WidgetDestroyEventCallback =
    Gdk.Event.Event ->
    IO Bool

noWidgetDestroyEventCallback :: Maybe WidgetDestroyEventCallback
noWidgetDestroyEventCallback = Nothing

type C_WidgetDestroyEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Event.Event ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetDestroyEventCallback :: C_WidgetDestroyEventCallback -> IO (FunPtr C_WidgetDestroyEventCallback)

genClosure_WidgetDestroyEvent :: WidgetDestroyEventCallback -> IO Closure
genClosure_WidgetDestroyEvent cb = do
    let cb' = wrap_WidgetDestroyEventCallback cb
    mk_WidgetDestroyEventCallback cb' >>= newCClosure


wrap_WidgetDestroyEventCallback ::
    WidgetDestroyEventCallback ->
    Ptr () ->
    Ptr Gdk.Event.Event ->
    Ptr () ->
    IO CInt
wrap_WidgetDestroyEventCallback _cb _ event _ = do
    event' <- (newBoxed Gdk.Event.Event) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetDestroyEvent :: (GObject a, MonadIO m) => a -> WidgetDestroyEventCallback -> m SignalHandlerId
onWidgetDestroyEvent obj cb = liftIO $ connectWidgetDestroyEvent obj cb SignalConnectBefore
afterWidgetDestroyEvent :: (GObject a, MonadIO m) => a -> WidgetDestroyEventCallback -> m SignalHandlerId
afterWidgetDestroyEvent obj cb = connectWidgetDestroyEvent obj cb SignalConnectAfter

connectWidgetDestroyEvent :: (GObject a, MonadIO m) =>
                             a -> WidgetDestroyEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDestroyEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetDestroyEventCallback cb
    cb'' <- mk_WidgetDestroyEventCallback cb'
    connectSignalFunPtr obj "destroy-event" cb'' after

-- signal Widget::direction-changed
type WidgetDirectionChangedCallback =
    Gtk.Enums.TextDirection ->
    IO ()

noWidgetDirectionChangedCallback :: Maybe WidgetDirectionChangedCallback
noWidgetDirectionChangedCallback = Nothing

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

foreign import ccall "wrapper"
    mk_WidgetDirectionChangedCallback :: C_WidgetDirectionChangedCallback -> IO (FunPtr C_WidgetDirectionChangedCallback)

genClosure_WidgetDirectionChanged :: WidgetDirectionChangedCallback -> IO Closure
genClosure_WidgetDirectionChanged cb = do
    let cb' = wrap_WidgetDirectionChangedCallback cb
    mk_WidgetDirectionChangedCallback cb' >>= newCClosure


wrap_WidgetDirectionChangedCallback ::
    WidgetDirectionChangedCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_WidgetDirectionChangedCallback _cb _ previousDirection _ = do
    let previousDirection' = (toEnum . fromIntegral) previousDirection
    _cb  previousDirection'


onWidgetDirectionChanged :: (GObject a, MonadIO m) => a -> WidgetDirectionChangedCallback -> m SignalHandlerId
onWidgetDirectionChanged obj cb = liftIO $ connectWidgetDirectionChanged obj cb SignalConnectBefore
afterWidgetDirectionChanged :: (GObject a, MonadIO m) => a -> WidgetDirectionChangedCallback -> m SignalHandlerId
afterWidgetDirectionChanged obj cb = connectWidgetDirectionChanged obj cb SignalConnectAfter

connectWidgetDirectionChanged :: (GObject a, MonadIO m) =>
                                 a -> WidgetDirectionChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDirectionChanged obj cb after = liftIO $ do
    let cb' = wrap_WidgetDirectionChangedCallback cb
    cb'' <- mk_WidgetDirectionChangedCallback cb'
    connectSignalFunPtr obj "direction-changed" cb'' after

-- signal Widget::drag-begin
type WidgetDragBeginCallback =
    Gdk.DragContext.DragContext ->
    IO ()

noWidgetDragBeginCallback :: Maybe WidgetDragBeginCallback
noWidgetDragBeginCallback = Nothing

type C_WidgetDragBeginCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DragContext.DragContext ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetDragBeginCallback :: C_WidgetDragBeginCallback -> IO (FunPtr C_WidgetDragBeginCallback)

genClosure_WidgetDragBegin :: WidgetDragBeginCallback -> IO Closure
genClosure_WidgetDragBegin cb = do
    let cb' = wrap_WidgetDragBeginCallback cb
    mk_WidgetDragBeginCallback cb' >>= newCClosure


wrap_WidgetDragBeginCallback ::
    WidgetDragBeginCallback ->
    Ptr () ->
    Ptr Gdk.DragContext.DragContext ->
    Ptr () ->
    IO ()
wrap_WidgetDragBeginCallback _cb _ context _ = do
    context' <- (newObject Gdk.DragContext.DragContext) context
    _cb  context'


onWidgetDragBegin :: (GObject a, MonadIO m) => a -> WidgetDragBeginCallback -> m SignalHandlerId
onWidgetDragBegin obj cb = liftIO $ connectWidgetDragBegin obj cb SignalConnectBefore
afterWidgetDragBegin :: (GObject a, MonadIO m) => a -> WidgetDragBeginCallback -> m SignalHandlerId
afterWidgetDragBegin obj cb = connectWidgetDragBegin obj cb SignalConnectAfter

connectWidgetDragBegin :: (GObject a, MonadIO m) =>
                          a -> WidgetDragBeginCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDragBegin obj cb after = liftIO $ do
    let cb' = wrap_WidgetDragBeginCallback cb
    cb'' <- mk_WidgetDragBeginCallback cb'
    connectSignalFunPtr obj "drag-begin" cb'' after

-- signal Widget::drag-data-delete
type WidgetDragDataDeleteCallback =
    Gdk.DragContext.DragContext ->
    IO ()

noWidgetDragDataDeleteCallback :: Maybe WidgetDragDataDeleteCallback
noWidgetDragDataDeleteCallback = Nothing

type C_WidgetDragDataDeleteCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DragContext.DragContext ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetDragDataDeleteCallback :: C_WidgetDragDataDeleteCallback -> IO (FunPtr C_WidgetDragDataDeleteCallback)

genClosure_WidgetDragDataDelete :: WidgetDragDataDeleteCallback -> IO Closure
genClosure_WidgetDragDataDelete cb = do
    let cb' = wrap_WidgetDragDataDeleteCallback cb
    mk_WidgetDragDataDeleteCallback cb' >>= newCClosure


wrap_WidgetDragDataDeleteCallback ::
    WidgetDragDataDeleteCallback ->
    Ptr () ->
    Ptr Gdk.DragContext.DragContext ->
    Ptr () ->
    IO ()
wrap_WidgetDragDataDeleteCallback _cb _ context _ = do
    context' <- (newObject Gdk.DragContext.DragContext) context
    _cb  context'


onWidgetDragDataDelete :: (GObject a, MonadIO m) => a -> WidgetDragDataDeleteCallback -> m SignalHandlerId
onWidgetDragDataDelete obj cb = liftIO $ connectWidgetDragDataDelete obj cb SignalConnectBefore
afterWidgetDragDataDelete :: (GObject a, MonadIO m) => a -> WidgetDragDataDeleteCallback -> m SignalHandlerId
afterWidgetDragDataDelete obj cb = connectWidgetDragDataDelete obj cb SignalConnectAfter

connectWidgetDragDataDelete :: (GObject a, MonadIO m) =>
                               a -> WidgetDragDataDeleteCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDragDataDelete obj cb after = liftIO $ do
    let cb' = wrap_WidgetDragDataDeleteCallback cb
    cb'' <- mk_WidgetDragDataDeleteCallback cb'
    connectSignalFunPtr obj "drag-data-delete" cb'' after

-- signal Widget::drag-data-get
type WidgetDragDataGetCallback =
    Gdk.DragContext.DragContext ->
    Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    IO ()

noWidgetDragDataGetCallback :: Maybe WidgetDragDataGetCallback
noWidgetDragDataGetCallback = Nothing

type C_WidgetDragDataGetCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DragContext.DragContext ->
    Ptr Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetDragDataGetCallback :: C_WidgetDragDataGetCallback -> IO (FunPtr C_WidgetDragDataGetCallback)

genClosure_WidgetDragDataGet :: WidgetDragDataGetCallback -> IO Closure
genClosure_WidgetDragDataGet cb = do
    let cb' = wrap_WidgetDragDataGetCallback cb
    mk_WidgetDragDataGetCallback cb' >>= newCClosure


wrap_WidgetDragDataGetCallback ::
    WidgetDragDataGetCallback ->
    Ptr () ->
    Ptr Gdk.DragContext.DragContext ->
    Ptr Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_WidgetDragDataGetCallback _cb _ context data_ info time _ = do
    context' <- (newObject Gdk.DragContext.DragContext) context
    data_' <- (newBoxed Gtk.SelectionData.SelectionData) data_
    _cb  context' data_' info time


onWidgetDragDataGet :: (GObject a, MonadIO m) => a -> WidgetDragDataGetCallback -> m SignalHandlerId
onWidgetDragDataGet obj cb = liftIO $ connectWidgetDragDataGet obj cb SignalConnectBefore
afterWidgetDragDataGet :: (GObject a, MonadIO m) => a -> WidgetDragDataGetCallback -> m SignalHandlerId
afterWidgetDragDataGet obj cb = connectWidgetDragDataGet obj cb SignalConnectAfter

connectWidgetDragDataGet :: (GObject a, MonadIO m) =>
                            a -> WidgetDragDataGetCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDragDataGet obj cb after = liftIO $ do
    let cb' = wrap_WidgetDragDataGetCallback cb
    cb'' <- mk_WidgetDragDataGetCallback cb'
    connectSignalFunPtr obj "drag-data-get" cb'' after

-- signal Widget::drag-data-received
type WidgetDragDataReceivedCallback =
    Gdk.DragContext.DragContext ->
    Int32 ->
    Int32 ->
    Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    IO ()

noWidgetDragDataReceivedCallback :: Maybe WidgetDragDataReceivedCallback
noWidgetDragDataReceivedCallback = Nothing

type C_WidgetDragDataReceivedCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DragContext.DragContext ->
    Int32 ->
    Int32 ->
    Ptr Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetDragDataReceivedCallback :: C_WidgetDragDataReceivedCallback -> IO (FunPtr C_WidgetDragDataReceivedCallback)

genClosure_WidgetDragDataReceived :: WidgetDragDataReceivedCallback -> IO Closure
genClosure_WidgetDragDataReceived cb = do
    let cb' = wrap_WidgetDragDataReceivedCallback cb
    mk_WidgetDragDataReceivedCallback cb' >>= newCClosure


wrap_WidgetDragDataReceivedCallback ::
    WidgetDragDataReceivedCallback ->
    Ptr () ->
    Ptr Gdk.DragContext.DragContext ->
    Int32 ->
    Int32 ->
    Ptr Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_WidgetDragDataReceivedCallback _cb _ context x y data_ info time _ = do
    context' <- (newObject Gdk.DragContext.DragContext) context
    data_' <- (newBoxed Gtk.SelectionData.SelectionData) data_
    _cb  context' x y data_' info time


onWidgetDragDataReceived :: (GObject a, MonadIO m) => a -> WidgetDragDataReceivedCallback -> m SignalHandlerId
onWidgetDragDataReceived obj cb = liftIO $ connectWidgetDragDataReceived obj cb SignalConnectBefore
afterWidgetDragDataReceived :: (GObject a, MonadIO m) => a -> WidgetDragDataReceivedCallback -> m SignalHandlerId
afterWidgetDragDataReceived obj cb = connectWidgetDragDataReceived obj cb SignalConnectAfter

connectWidgetDragDataReceived :: (GObject a, MonadIO m) =>
                                 a -> WidgetDragDataReceivedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDragDataReceived obj cb after = liftIO $ do
    let cb' = wrap_WidgetDragDataReceivedCallback cb
    cb'' <- mk_WidgetDragDataReceivedCallback cb'
    connectSignalFunPtr obj "drag-data-received" cb'' after

-- signal Widget::drag-drop
type WidgetDragDropCallback =
    Gdk.DragContext.DragContext ->
    Int32 ->
    Int32 ->
    Word32 ->
    IO Bool

noWidgetDragDropCallback :: Maybe WidgetDragDropCallback
noWidgetDragDropCallback = Nothing

type C_WidgetDragDropCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DragContext.DragContext ->
    Int32 ->
    Int32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetDragDropCallback :: C_WidgetDragDropCallback -> IO (FunPtr C_WidgetDragDropCallback)

genClosure_WidgetDragDrop :: WidgetDragDropCallback -> IO Closure
genClosure_WidgetDragDrop cb = do
    let cb' = wrap_WidgetDragDropCallback cb
    mk_WidgetDragDropCallback cb' >>= newCClosure


wrap_WidgetDragDropCallback ::
    WidgetDragDropCallback ->
    Ptr () ->
    Ptr Gdk.DragContext.DragContext ->
    Int32 ->
    Int32 ->
    Word32 ->
    Ptr () ->
    IO CInt
wrap_WidgetDragDropCallback _cb _ context x y time _ = do
    context' <- (newObject Gdk.DragContext.DragContext) context
    result <- _cb  context' x y time
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetDragDrop :: (GObject a, MonadIO m) => a -> WidgetDragDropCallback -> m SignalHandlerId
onWidgetDragDrop obj cb = liftIO $ connectWidgetDragDrop obj cb SignalConnectBefore
afterWidgetDragDrop :: (GObject a, MonadIO m) => a -> WidgetDragDropCallback -> m SignalHandlerId
afterWidgetDragDrop obj cb = connectWidgetDragDrop obj cb SignalConnectAfter

connectWidgetDragDrop :: (GObject a, MonadIO m) =>
                         a -> WidgetDragDropCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDragDrop obj cb after = liftIO $ do
    let cb' = wrap_WidgetDragDropCallback cb
    cb'' <- mk_WidgetDragDropCallback cb'
    connectSignalFunPtr obj "drag-drop" cb'' after

-- signal Widget::drag-end
type WidgetDragEndCallback =
    Gdk.DragContext.DragContext ->
    IO ()

noWidgetDragEndCallback :: Maybe WidgetDragEndCallback
noWidgetDragEndCallback = Nothing

type C_WidgetDragEndCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DragContext.DragContext ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetDragEndCallback :: C_WidgetDragEndCallback -> IO (FunPtr C_WidgetDragEndCallback)

genClosure_WidgetDragEnd :: WidgetDragEndCallback -> IO Closure
genClosure_WidgetDragEnd cb = do
    let cb' = wrap_WidgetDragEndCallback cb
    mk_WidgetDragEndCallback cb' >>= newCClosure


wrap_WidgetDragEndCallback ::
    WidgetDragEndCallback ->
    Ptr () ->
    Ptr Gdk.DragContext.DragContext ->
    Ptr () ->
    IO ()
wrap_WidgetDragEndCallback _cb _ context _ = do
    context' <- (newObject Gdk.DragContext.DragContext) context
    _cb  context'


onWidgetDragEnd :: (GObject a, MonadIO m) => a -> WidgetDragEndCallback -> m SignalHandlerId
onWidgetDragEnd obj cb = liftIO $ connectWidgetDragEnd obj cb SignalConnectBefore
afterWidgetDragEnd :: (GObject a, MonadIO m) => a -> WidgetDragEndCallback -> m SignalHandlerId
afterWidgetDragEnd obj cb = connectWidgetDragEnd obj cb SignalConnectAfter

connectWidgetDragEnd :: (GObject a, MonadIO m) =>
                        a -> WidgetDragEndCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDragEnd obj cb after = liftIO $ do
    let cb' = wrap_WidgetDragEndCallback cb
    cb'' <- mk_WidgetDragEndCallback cb'
    connectSignalFunPtr obj "drag-end" cb'' after

-- signal Widget::drag-failed
type WidgetDragFailedCallback =
    Gdk.DragContext.DragContext ->
    Gtk.Enums.DragResult ->
    IO Bool

noWidgetDragFailedCallback :: Maybe WidgetDragFailedCallback
noWidgetDragFailedCallback = Nothing

type C_WidgetDragFailedCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DragContext.DragContext ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetDragFailedCallback :: C_WidgetDragFailedCallback -> IO (FunPtr C_WidgetDragFailedCallback)

genClosure_WidgetDragFailed :: WidgetDragFailedCallback -> IO Closure
genClosure_WidgetDragFailed cb = do
    let cb' = wrap_WidgetDragFailedCallback cb
    mk_WidgetDragFailedCallback cb' >>= newCClosure


wrap_WidgetDragFailedCallback ::
    WidgetDragFailedCallback ->
    Ptr () ->
    Ptr Gdk.DragContext.DragContext ->
    CUInt ->
    Ptr () ->
    IO CInt
wrap_WidgetDragFailedCallback _cb _ context result_ _ = do
    context' <- (newObject Gdk.DragContext.DragContext) context
    let result_' = (toEnum . fromIntegral) result_
    result <- _cb  context' result_'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetDragFailed :: (GObject a, MonadIO m) => a -> WidgetDragFailedCallback -> m SignalHandlerId
onWidgetDragFailed obj cb = liftIO $ connectWidgetDragFailed obj cb SignalConnectBefore
afterWidgetDragFailed :: (GObject a, MonadIO m) => a -> WidgetDragFailedCallback -> m SignalHandlerId
afterWidgetDragFailed obj cb = connectWidgetDragFailed obj cb SignalConnectAfter

connectWidgetDragFailed :: (GObject a, MonadIO m) =>
                           a -> WidgetDragFailedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDragFailed obj cb after = liftIO $ do
    let cb' = wrap_WidgetDragFailedCallback cb
    cb'' <- mk_WidgetDragFailedCallback cb'
    connectSignalFunPtr obj "drag-failed" cb'' after

-- signal Widget::drag-leave
type WidgetDragLeaveCallback =
    Gdk.DragContext.DragContext ->
    Word32 ->
    IO ()

noWidgetDragLeaveCallback :: Maybe WidgetDragLeaveCallback
noWidgetDragLeaveCallback = Nothing

type C_WidgetDragLeaveCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DragContext.DragContext ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetDragLeaveCallback :: C_WidgetDragLeaveCallback -> IO (FunPtr C_WidgetDragLeaveCallback)

genClosure_WidgetDragLeave :: WidgetDragLeaveCallback -> IO Closure
genClosure_WidgetDragLeave cb = do
    let cb' = wrap_WidgetDragLeaveCallback cb
    mk_WidgetDragLeaveCallback cb' >>= newCClosure


wrap_WidgetDragLeaveCallback ::
    WidgetDragLeaveCallback ->
    Ptr () ->
    Ptr Gdk.DragContext.DragContext ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_WidgetDragLeaveCallback _cb _ context time _ = do
    context' <- (newObject Gdk.DragContext.DragContext) context
    _cb  context' time


onWidgetDragLeave :: (GObject a, MonadIO m) => a -> WidgetDragLeaveCallback -> m SignalHandlerId
onWidgetDragLeave obj cb = liftIO $ connectWidgetDragLeave obj cb SignalConnectBefore
afterWidgetDragLeave :: (GObject a, MonadIO m) => a -> WidgetDragLeaveCallback -> m SignalHandlerId
afterWidgetDragLeave obj cb = connectWidgetDragLeave obj cb SignalConnectAfter

connectWidgetDragLeave :: (GObject a, MonadIO m) =>
                          a -> WidgetDragLeaveCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDragLeave obj cb after = liftIO $ do
    let cb' = wrap_WidgetDragLeaveCallback cb
    cb'' <- mk_WidgetDragLeaveCallback cb'
    connectSignalFunPtr obj "drag-leave" cb'' after

-- signal Widget::drag-motion
type WidgetDragMotionCallback =
    Gdk.DragContext.DragContext ->
    Int32 ->
    Int32 ->
    Word32 ->
    IO Bool

noWidgetDragMotionCallback :: Maybe WidgetDragMotionCallback
noWidgetDragMotionCallback = Nothing

type C_WidgetDragMotionCallback =
    Ptr () ->                               -- object
    Ptr Gdk.DragContext.DragContext ->
    Int32 ->
    Int32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetDragMotionCallback :: C_WidgetDragMotionCallback -> IO (FunPtr C_WidgetDragMotionCallback)

genClosure_WidgetDragMotion :: WidgetDragMotionCallback -> IO Closure
genClosure_WidgetDragMotion cb = do
    let cb' = wrap_WidgetDragMotionCallback cb
    mk_WidgetDragMotionCallback cb' >>= newCClosure


wrap_WidgetDragMotionCallback ::
    WidgetDragMotionCallback ->
    Ptr () ->
    Ptr Gdk.DragContext.DragContext ->
    Int32 ->
    Int32 ->
    Word32 ->
    Ptr () ->
    IO CInt
wrap_WidgetDragMotionCallback _cb _ context x y time _ = do
    context' <- (newObject Gdk.DragContext.DragContext) context
    result <- _cb  context' x y time
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetDragMotion :: (GObject a, MonadIO m) => a -> WidgetDragMotionCallback -> m SignalHandlerId
onWidgetDragMotion obj cb = liftIO $ connectWidgetDragMotion obj cb SignalConnectBefore
afterWidgetDragMotion :: (GObject a, MonadIO m) => a -> WidgetDragMotionCallback -> m SignalHandlerId
afterWidgetDragMotion obj cb = connectWidgetDragMotion obj cb SignalConnectAfter

connectWidgetDragMotion :: (GObject a, MonadIO m) =>
                           a -> WidgetDragMotionCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDragMotion obj cb after = liftIO $ do
    let cb' = wrap_WidgetDragMotionCallback cb
    cb'' <- mk_WidgetDragMotionCallback cb'
    connectSignalFunPtr obj "drag-motion" cb'' after

-- signal Widget::draw
type WidgetDrawCallback =
    Cairo.Context.Context ->
    IO Bool

noWidgetDrawCallback :: Maybe WidgetDrawCallback
noWidgetDrawCallback = Nothing

type C_WidgetDrawCallback =
    Ptr () ->                               -- object
    Ptr Cairo.Context.Context ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetDrawCallback :: C_WidgetDrawCallback -> IO (FunPtr C_WidgetDrawCallback)

genClosure_WidgetDraw :: WidgetDrawCallback -> IO Closure
genClosure_WidgetDraw cb = do
    let cb' = wrap_WidgetDrawCallback cb
    mk_WidgetDrawCallback cb' >>= newCClosure


wrap_WidgetDrawCallback ::
    WidgetDrawCallback ->
    Ptr () ->
    Ptr Cairo.Context.Context ->
    Ptr () ->
    IO CInt
wrap_WidgetDrawCallback _cb _ cr _ = do
    cr' <- (newBoxed Cairo.Context.Context) cr
    result <- _cb  cr'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetDraw :: (GObject a, MonadIO m) => a -> WidgetDrawCallback -> m SignalHandlerId
onWidgetDraw obj cb = liftIO $ connectWidgetDraw obj cb SignalConnectBefore
afterWidgetDraw :: (GObject a, MonadIO m) => a -> WidgetDrawCallback -> m SignalHandlerId
afterWidgetDraw obj cb = connectWidgetDraw obj cb SignalConnectAfter

connectWidgetDraw :: (GObject a, MonadIO m) =>
                     a -> WidgetDrawCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetDraw obj cb after = liftIO $ do
    let cb' = wrap_WidgetDrawCallback cb
    cb'' <- mk_WidgetDrawCallback cb'
    connectSignalFunPtr obj "draw" cb'' after

-- signal Widget::enter-notify-event
type WidgetEnterNotifyEventCallback =
    Gdk.EventCrossing.EventCrossing ->
    IO Bool

noWidgetEnterNotifyEventCallback :: Maybe WidgetEnterNotifyEventCallback
noWidgetEnterNotifyEventCallback = Nothing

type C_WidgetEnterNotifyEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventCrossing.EventCrossing ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetEnterNotifyEventCallback :: C_WidgetEnterNotifyEventCallback -> IO (FunPtr C_WidgetEnterNotifyEventCallback)

genClosure_WidgetEnterNotifyEvent :: WidgetEnterNotifyEventCallback -> IO Closure
genClosure_WidgetEnterNotifyEvent cb = do
    let cb' = wrap_WidgetEnterNotifyEventCallback cb
    mk_WidgetEnterNotifyEventCallback cb' >>= newCClosure


wrap_WidgetEnterNotifyEventCallback ::
    WidgetEnterNotifyEventCallback ->
    Ptr () ->
    Ptr Gdk.EventCrossing.EventCrossing ->
    Ptr () ->
    IO CInt
wrap_WidgetEnterNotifyEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventCrossing.EventCrossing) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetEnterNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetEnterNotifyEventCallback -> m SignalHandlerId
onWidgetEnterNotifyEvent obj cb = liftIO $ connectWidgetEnterNotifyEvent obj cb SignalConnectBefore
afterWidgetEnterNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetEnterNotifyEventCallback -> m SignalHandlerId
afterWidgetEnterNotifyEvent obj cb = connectWidgetEnterNotifyEvent obj cb SignalConnectAfter

connectWidgetEnterNotifyEvent :: (GObject a, MonadIO m) =>
                                 a -> WidgetEnterNotifyEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetEnterNotifyEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetEnterNotifyEventCallback cb
    cb'' <- mk_WidgetEnterNotifyEventCallback cb'
    connectSignalFunPtr obj "enter-notify-event" cb'' after

-- signal Widget::event
type WidgetEventCallback =
    Gdk.Event.Event ->
    IO Bool

noWidgetEventCallback :: Maybe WidgetEventCallback
noWidgetEventCallback = Nothing

type C_WidgetEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Event.Event ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetEventCallback :: C_WidgetEventCallback -> IO (FunPtr C_WidgetEventCallback)

genClosure_WidgetEvent :: WidgetEventCallback -> IO Closure
genClosure_WidgetEvent cb = do
    let cb' = wrap_WidgetEventCallback cb
    mk_WidgetEventCallback cb' >>= newCClosure


wrap_WidgetEventCallback ::
    WidgetEventCallback ->
    Ptr () ->
    Ptr Gdk.Event.Event ->
    Ptr () ->
    IO CInt
wrap_WidgetEventCallback _cb _ event _ = do
    event' <- (newBoxed Gdk.Event.Event) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetEvent :: (GObject a, MonadIO m) => a -> WidgetEventCallback -> m SignalHandlerId
onWidgetEvent obj cb = liftIO $ connectWidgetEvent obj cb SignalConnectBefore
afterWidgetEvent :: (GObject a, MonadIO m) => a -> WidgetEventCallback -> m SignalHandlerId
afterWidgetEvent obj cb = connectWidgetEvent obj cb SignalConnectAfter

connectWidgetEvent :: (GObject a, MonadIO m) =>
                      a -> WidgetEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetEventCallback cb
    cb'' <- mk_WidgetEventCallback cb'
    connectSignalFunPtr obj "event" cb'' after

-- signal Widget::event-after
type WidgetEventAfterCallback =
    Gdk.Event.Event ->
    IO ()

noWidgetEventAfterCallback :: Maybe WidgetEventAfterCallback
noWidgetEventAfterCallback = Nothing

type C_WidgetEventAfterCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Event.Event ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetEventAfterCallback :: C_WidgetEventAfterCallback -> IO (FunPtr C_WidgetEventAfterCallback)

genClosure_WidgetEventAfter :: WidgetEventAfterCallback -> IO Closure
genClosure_WidgetEventAfter cb = do
    let cb' = wrap_WidgetEventAfterCallback cb
    mk_WidgetEventAfterCallback cb' >>= newCClosure


wrap_WidgetEventAfterCallback ::
    WidgetEventAfterCallback ->
    Ptr () ->
    Ptr Gdk.Event.Event ->
    Ptr () ->
    IO ()
wrap_WidgetEventAfterCallback _cb _ event _ = do
    event' <- (newBoxed Gdk.Event.Event) event
    _cb  event'


onWidgetEventAfter :: (GObject a, MonadIO m) => a -> WidgetEventAfterCallback -> m SignalHandlerId
onWidgetEventAfter obj cb = liftIO $ connectWidgetEventAfter obj cb SignalConnectBefore
afterWidgetEventAfter :: (GObject a, MonadIO m) => a -> WidgetEventAfterCallback -> m SignalHandlerId
afterWidgetEventAfter obj cb = connectWidgetEventAfter obj cb SignalConnectAfter

connectWidgetEventAfter :: (GObject a, MonadIO m) =>
                           a -> WidgetEventAfterCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetEventAfter obj cb after = liftIO $ do
    let cb' = wrap_WidgetEventAfterCallback cb
    cb'' <- mk_WidgetEventAfterCallback cb'
    connectSignalFunPtr obj "event-after" cb'' after

-- signal Widget::focus
type WidgetFocusCallback =
    Gtk.Enums.DirectionType ->
    IO Bool

noWidgetFocusCallback :: Maybe WidgetFocusCallback
noWidgetFocusCallback = Nothing

type C_WidgetFocusCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetFocusCallback :: C_WidgetFocusCallback -> IO (FunPtr C_WidgetFocusCallback)

genClosure_WidgetFocus :: WidgetFocusCallback -> IO Closure
genClosure_WidgetFocus cb = do
    let cb' = wrap_WidgetFocusCallback cb
    mk_WidgetFocusCallback cb' >>= newCClosure


wrap_WidgetFocusCallback ::
    WidgetFocusCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO CInt
wrap_WidgetFocusCallback _cb _ direction _ = do
    let direction' = (toEnum . fromIntegral) direction
    result <- _cb  direction'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetFocus :: (GObject a, MonadIO m) => a -> WidgetFocusCallback -> m SignalHandlerId
onWidgetFocus obj cb = liftIO $ connectWidgetFocus obj cb SignalConnectBefore
afterWidgetFocus :: (GObject a, MonadIO m) => a -> WidgetFocusCallback -> m SignalHandlerId
afterWidgetFocus obj cb = connectWidgetFocus obj cb SignalConnectAfter

connectWidgetFocus :: (GObject a, MonadIO m) =>
                      a -> WidgetFocusCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetFocus obj cb after = liftIO $ do
    let cb' = wrap_WidgetFocusCallback cb
    cb'' <- mk_WidgetFocusCallback cb'
    connectSignalFunPtr obj "focus" cb'' after

-- signal Widget::focus-in-event
type WidgetFocusInEventCallback =
    Gdk.EventFocus.EventFocus ->
    IO Bool

noWidgetFocusInEventCallback :: Maybe WidgetFocusInEventCallback
noWidgetFocusInEventCallback = Nothing

type C_WidgetFocusInEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventFocus.EventFocus ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetFocusInEventCallback :: C_WidgetFocusInEventCallback -> IO (FunPtr C_WidgetFocusInEventCallback)

genClosure_WidgetFocusInEvent :: WidgetFocusInEventCallback -> IO Closure
genClosure_WidgetFocusInEvent cb = do
    let cb' = wrap_WidgetFocusInEventCallback cb
    mk_WidgetFocusInEventCallback cb' >>= newCClosure


wrap_WidgetFocusInEventCallback ::
    WidgetFocusInEventCallback ->
    Ptr () ->
    Ptr Gdk.EventFocus.EventFocus ->
    Ptr () ->
    IO CInt
wrap_WidgetFocusInEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventFocus.EventFocus) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetFocusInEvent :: (GObject a, MonadIO m) => a -> WidgetFocusInEventCallback -> m SignalHandlerId
onWidgetFocusInEvent obj cb = liftIO $ connectWidgetFocusInEvent obj cb SignalConnectBefore
afterWidgetFocusInEvent :: (GObject a, MonadIO m) => a -> WidgetFocusInEventCallback -> m SignalHandlerId
afterWidgetFocusInEvent obj cb = connectWidgetFocusInEvent obj cb SignalConnectAfter

connectWidgetFocusInEvent :: (GObject a, MonadIO m) =>
                             a -> WidgetFocusInEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetFocusInEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetFocusInEventCallback cb
    cb'' <- mk_WidgetFocusInEventCallback cb'
    connectSignalFunPtr obj "focus-in-event" cb'' after

-- signal Widget::focus-out-event
type WidgetFocusOutEventCallback =
    Gdk.EventFocus.EventFocus ->
    IO Bool

noWidgetFocusOutEventCallback :: Maybe WidgetFocusOutEventCallback
noWidgetFocusOutEventCallback = Nothing

type C_WidgetFocusOutEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventFocus.EventFocus ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetFocusOutEventCallback :: C_WidgetFocusOutEventCallback -> IO (FunPtr C_WidgetFocusOutEventCallback)

genClosure_WidgetFocusOutEvent :: WidgetFocusOutEventCallback -> IO Closure
genClosure_WidgetFocusOutEvent cb = do
    let cb' = wrap_WidgetFocusOutEventCallback cb
    mk_WidgetFocusOutEventCallback cb' >>= newCClosure


wrap_WidgetFocusOutEventCallback ::
    WidgetFocusOutEventCallback ->
    Ptr () ->
    Ptr Gdk.EventFocus.EventFocus ->
    Ptr () ->
    IO CInt
wrap_WidgetFocusOutEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventFocus.EventFocus) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetFocusOutEvent :: (GObject a, MonadIO m) => a -> WidgetFocusOutEventCallback -> m SignalHandlerId
onWidgetFocusOutEvent obj cb = liftIO $ connectWidgetFocusOutEvent obj cb SignalConnectBefore
afterWidgetFocusOutEvent :: (GObject a, MonadIO m) => a -> WidgetFocusOutEventCallback -> m SignalHandlerId
afterWidgetFocusOutEvent obj cb = connectWidgetFocusOutEvent obj cb SignalConnectAfter

connectWidgetFocusOutEvent :: (GObject a, MonadIO m) =>
                              a -> WidgetFocusOutEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetFocusOutEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetFocusOutEventCallback cb
    cb'' <- mk_WidgetFocusOutEventCallback cb'
    connectSignalFunPtr obj "focus-out-event" cb'' after

-- signal Widget::grab-broken-event
type WidgetGrabBrokenEventCallback =
    Gdk.EventGrabBroken.EventGrabBroken ->
    IO Bool

noWidgetGrabBrokenEventCallback :: Maybe WidgetGrabBrokenEventCallback
noWidgetGrabBrokenEventCallback = Nothing

type C_WidgetGrabBrokenEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventGrabBroken.EventGrabBroken ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetGrabBrokenEventCallback :: C_WidgetGrabBrokenEventCallback -> IO (FunPtr C_WidgetGrabBrokenEventCallback)

genClosure_WidgetGrabBrokenEvent :: WidgetGrabBrokenEventCallback -> IO Closure
genClosure_WidgetGrabBrokenEvent cb = do
    let cb' = wrap_WidgetGrabBrokenEventCallback cb
    mk_WidgetGrabBrokenEventCallback cb' >>= newCClosure


wrap_WidgetGrabBrokenEventCallback ::
    WidgetGrabBrokenEventCallback ->
    Ptr () ->
    Ptr Gdk.EventGrabBroken.EventGrabBroken ->
    Ptr () ->
    IO CInt
wrap_WidgetGrabBrokenEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventGrabBroken.EventGrabBroken) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetGrabBrokenEvent :: (GObject a, MonadIO m) => a -> WidgetGrabBrokenEventCallback -> m SignalHandlerId
onWidgetGrabBrokenEvent obj cb = liftIO $ connectWidgetGrabBrokenEvent obj cb SignalConnectBefore
afterWidgetGrabBrokenEvent :: (GObject a, MonadIO m) => a -> WidgetGrabBrokenEventCallback -> m SignalHandlerId
afterWidgetGrabBrokenEvent obj cb = connectWidgetGrabBrokenEvent obj cb SignalConnectAfter

connectWidgetGrabBrokenEvent :: (GObject a, MonadIO m) =>
                                a -> WidgetGrabBrokenEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetGrabBrokenEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetGrabBrokenEventCallback cb
    cb'' <- mk_WidgetGrabBrokenEventCallback cb'
    connectSignalFunPtr obj "grab-broken-event" cb'' after

-- signal Widget::grab-focus
type WidgetGrabFocusCallback =
    IO ()

noWidgetGrabFocusCallback :: Maybe WidgetGrabFocusCallback
noWidgetGrabFocusCallback = Nothing

type C_WidgetGrabFocusCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetGrabFocusCallback :: C_WidgetGrabFocusCallback -> IO (FunPtr C_WidgetGrabFocusCallback)

genClosure_WidgetGrabFocus :: WidgetGrabFocusCallback -> IO Closure
genClosure_WidgetGrabFocus cb = do
    let cb' = wrap_WidgetGrabFocusCallback cb
    mk_WidgetGrabFocusCallback cb' >>= newCClosure


wrap_WidgetGrabFocusCallback ::
    WidgetGrabFocusCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetGrabFocusCallback _cb _ _ = do
    _cb 


onWidgetGrabFocus :: (GObject a, MonadIO m) => a -> WidgetGrabFocusCallback -> m SignalHandlerId
onWidgetGrabFocus obj cb = liftIO $ connectWidgetGrabFocus obj cb SignalConnectBefore
afterWidgetGrabFocus :: (GObject a, MonadIO m) => a -> WidgetGrabFocusCallback -> m SignalHandlerId
afterWidgetGrabFocus obj cb = connectWidgetGrabFocus obj cb SignalConnectAfter

connectWidgetGrabFocus :: (GObject a, MonadIO m) =>
                          a -> WidgetGrabFocusCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetGrabFocus obj cb after = liftIO $ do
    let cb' = wrap_WidgetGrabFocusCallback cb
    cb'' <- mk_WidgetGrabFocusCallback cb'
    connectSignalFunPtr obj "grab-focus" cb'' after

-- signal Widget::grab-notify
type WidgetGrabNotifyCallback =
    Bool ->
    IO ()

noWidgetGrabNotifyCallback :: Maybe WidgetGrabNotifyCallback
noWidgetGrabNotifyCallback = Nothing

type C_WidgetGrabNotifyCallback =
    Ptr () ->                               -- object
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetGrabNotifyCallback :: C_WidgetGrabNotifyCallback -> IO (FunPtr C_WidgetGrabNotifyCallback)

genClosure_WidgetGrabNotify :: WidgetGrabNotifyCallback -> IO Closure
genClosure_WidgetGrabNotify cb = do
    let cb' = wrap_WidgetGrabNotifyCallback cb
    mk_WidgetGrabNotifyCallback cb' >>= newCClosure


wrap_WidgetGrabNotifyCallback ::
    WidgetGrabNotifyCallback ->
    Ptr () ->
    CInt ->
    Ptr () ->
    IO ()
wrap_WidgetGrabNotifyCallback _cb _ wasGrabbed _ = do
    let wasGrabbed' = (/= 0) wasGrabbed
    _cb  wasGrabbed'


onWidgetGrabNotify :: (GObject a, MonadIO m) => a -> WidgetGrabNotifyCallback -> m SignalHandlerId
onWidgetGrabNotify obj cb = liftIO $ connectWidgetGrabNotify obj cb SignalConnectBefore
afterWidgetGrabNotify :: (GObject a, MonadIO m) => a -> WidgetGrabNotifyCallback -> m SignalHandlerId
afterWidgetGrabNotify obj cb = connectWidgetGrabNotify obj cb SignalConnectAfter

connectWidgetGrabNotify :: (GObject a, MonadIO m) =>
                           a -> WidgetGrabNotifyCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetGrabNotify obj cb after = liftIO $ do
    let cb' = wrap_WidgetGrabNotifyCallback cb
    cb'' <- mk_WidgetGrabNotifyCallback cb'
    connectSignalFunPtr obj "grab-notify" cb'' after

-- signal Widget::hide
type WidgetHideCallback =
    IO ()

noWidgetHideCallback :: Maybe WidgetHideCallback
noWidgetHideCallback = Nothing

type C_WidgetHideCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetHideCallback :: C_WidgetHideCallback -> IO (FunPtr C_WidgetHideCallback)

genClosure_WidgetHide :: WidgetHideCallback -> IO Closure
genClosure_WidgetHide cb = do
    let cb' = wrap_WidgetHideCallback cb
    mk_WidgetHideCallback cb' >>= newCClosure


wrap_WidgetHideCallback ::
    WidgetHideCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetHideCallback _cb _ _ = do
    _cb 


onWidgetHide :: (GObject a, MonadIO m) => a -> WidgetHideCallback -> m SignalHandlerId
onWidgetHide obj cb = liftIO $ connectWidgetHide obj cb SignalConnectBefore
afterWidgetHide :: (GObject a, MonadIO m) => a -> WidgetHideCallback -> m SignalHandlerId
afterWidgetHide obj cb = connectWidgetHide obj cb SignalConnectAfter

connectWidgetHide :: (GObject a, MonadIO m) =>
                     a -> WidgetHideCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetHide obj cb after = liftIO $ do
    let cb' = wrap_WidgetHideCallback cb
    cb'' <- mk_WidgetHideCallback cb'
    connectSignalFunPtr obj "hide" cb'' after

-- signal Widget::hierarchy-changed
type WidgetHierarchyChangedCallback =
    Maybe Widget ->
    IO ()

noWidgetHierarchyChangedCallback :: Maybe WidgetHierarchyChangedCallback
noWidgetHierarchyChangedCallback = Nothing

type C_WidgetHierarchyChangedCallback =
    Ptr () ->                               -- object
    Ptr Widget ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetHierarchyChangedCallback :: C_WidgetHierarchyChangedCallback -> IO (FunPtr C_WidgetHierarchyChangedCallback)

genClosure_WidgetHierarchyChanged :: WidgetHierarchyChangedCallback -> IO Closure
genClosure_WidgetHierarchyChanged cb = do
    let cb' = wrap_WidgetHierarchyChangedCallback cb
    mk_WidgetHierarchyChangedCallback cb' >>= newCClosure


wrap_WidgetHierarchyChangedCallback ::
    WidgetHierarchyChangedCallback ->
    Ptr () ->
    Ptr Widget ->
    Ptr () ->
    IO ()
wrap_WidgetHierarchyChangedCallback _cb _ previousToplevel _ = do
    maybePreviousToplevel <-
        if previousToplevel == nullPtr
        then return Nothing
        else do
            previousToplevel' <- (newObject Widget) previousToplevel
            return $ Just previousToplevel'
    _cb  maybePreviousToplevel


onWidgetHierarchyChanged :: (GObject a, MonadIO m) => a -> WidgetHierarchyChangedCallback -> m SignalHandlerId
onWidgetHierarchyChanged obj cb = liftIO $ connectWidgetHierarchyChanged obj cb SignalConnectBefore
afterWidgetHierarchyChanged :: (GObject a, MonadIO m) => a -> WidgetHierarchyChangedCallback -> m SignalHandlerId
afterWidgetHierarchyChanged obj cb = connectWidgetHierarchyChanged obj cb SignalConnectAfter

connectWidgetHierarchyChanged :: (GObject a, MonadIO m) =>
                                 a -> WidgetHierarchyChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetHierarchyChanged obj cb after = liftIO $ do
    let cb' = wrap_WidgetHierarchyChangedCallback cb
    cb'' <- mk_WidgetHierarchyChangedCallback cb'
    connectSignalFunPtr obj "hierarchy-changed" cb'' after

-- signal Widget::key-press-event
type WidgetKeyPressEventCallback =
    Gdk.EventKey.EventKey ->
    IO Bool

noWidgetKeyPressEventCallback :: Maybe WidgetKeyPressEventCallback
noWidgetKeyPressEventCallback = Nothing

type C_WidgetKeyPressEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventKey.EventKey ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetKeyPressEventCallback :: C_WidgetKeyPressEventCallback -> IO (FunPtr C_WidgetKeyPressEventCallback)

genClosure_WidgetKeyPressEvent :: WidgetKeyPressEventCallback -> IO Closure
genClosure_WidgetKeyPressEvent cb = do
    let cb' = wrap_WidgetKeyPressEventCallback cb
    mk_WidgetKeyPressEventCallback cb' >>= newCClosure


wrap_WidgetKeyPressEventCallback ::
    WidgetKeyPressEventCallback ->
    Ptr () ->
    Ptr Gdk.EventKey.EventKey ->
    Ptr () ->
    IO CInt
wrap_WidgetKeyPressEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventKey.EventKey) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetKeyPressEvent :: (GObject a, MonadIO m) => a -> WidgetKeyPressEventCallback -> m SignalHandlerId
onWidgetKeyPressEvent obj cb = liftIO $ connectWidgetKeyPressEvent obj cb SignalConnectBefore
afterWidgetKeyPressEvent :: (GObject a, MonadIO m) => a -> WidgetKeyPressEventCallback -> m SignalHandlerId
afterWidgetKeyPressEvent obj cb = connectWidgetKeyPressEvent obj cb SignalConnectAfter

connectWidgetKeyPressEvent :: (GObject a, MonadIO m) =>
                              a -> WidgetKeyPressEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetKeyPressEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetKeyPressEventCallback cb
    cb'' <- mk_WidgetKeyPressEventCallback cb'
    connectSignalFunPtr obj "key-press-event" cb'' after

-- signal Widget::key-release-event
type WidgetKeyReleaseEventCallback =
    Gdk.EventKey.EventKey ->
    IO Bool

noWidgetKeyReleaseEventCallback :: Maybe WidgetKeyReleaseEventCallback
noWidgetKeyReleaseEventCallback = Nothing

type C_WidgetKeyReleaseEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventKey.EventKey ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetKeyReleaseEventCallback :: C_WidgetKeyReleaseEventCallback -> IO (FunPtr C_WidgetKeyReleaseEventCallback)

genClosure_WidgetKeyReleaseEvent :: WidgetKeyReleaseEventCallback -> IO Closure
genClosure_WidgetKeyReleaseEvent cb = do
    let cb' = wrap_WidgetKeyReleaseEventCallback cb
    mk_WidgetKeyReleaseEventCallback cb' >>= newCClosure


wrap_WidgetKeyReleaseEventCallback ::
    WidgetKeyReleaseEventCallback ->
    Ptr () ->
    Ptr Gdk.EventKey.EventKey ->
    Ptr () ->
    IO CInt
wrap_WidgetKeyReleaseEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventKey.EventKey) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetKeyReleaseEvent :: (GObject a, MonadIO m) => a -> WidgetKeyReleaseEventCallback -> m SignalHandlerId
onWidgetKeyReleaseEvent obj cb = liftIO $ connectWidgetKeyReleaseEvent obj cb SignalConnectBefore
afterWidgetKeyReleaseEvent :: (GObject a, MonadIO m) => a -> WidgetKeyReleaseEventCallback -> m SignalHandlerId
afterWidgetKeyReleaseEvent obj cb = connectWidgetKeyReleaseEvent obj cb SignalConnectAfter

connectWidgetKeyReleaseEvent :: (GObject a, MonadIO m) =>
                                a -> WidgetKeyReleaseEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetKeyReleaseEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetKeyReleaseEventCallback cb
    cb'' <- mk_WidgetKeyReleaseEventCallback cb'
    connectSignalFunPtr obj "key-release-event" cb'' after

-- signal Widget::keynav-failed
type WidgetKeynavFailedCallback =
    Gtk.Enums.DirectionType ->
    IO Bool

noWidgetKeynavFailedCallback :: Maybe WidgetKeynavFailedCallback
noWidgetKeynavFailedCallback = Nothing

type C_WidgetKeynavFailedCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetKeynavFailedCallback :: C_WidgetKeynavFailedCallback -> IO (FunPtr C_WidgetKeynavFailedCallback)

genClosure_WidgetKeynavFailed :: WidgetKeynavFailedCallback -> IO Closure
genClosure_WidgetKeynavFailed cb = do
    let cb' = wrap_WidgetKeynavFailedCallback cb
    mk_WidgetKeynavFailedCallback cb' >>= newCClosure


wrap_WidgetKeynavFailedCallback ::
    WidgetKeynavFailedCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO CInt
wrap_WidgetKeynavFailedCallback _cb _ direction _ = do
    let direction' = (toEnum . fromIntegral) direction
    result <- _cb  direction'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetKeynavFailed :: (GObject a, MonadIO m) => a -> WidgetKeynavFailedCallback -> m SignalHandlerId
onWidgetKeynavFailed obj cb = liftIO $ connectWidgetKeynavFailed obj cb SignalConnectBefore
afterWidgetKeynavFailed :: (GObject a, MonadIO m) => a -> WidgetKeynavFailedCallback -> m SignalHandlerId
afterWidgetKeynavFailed obj cb = connectWidgetKeynavFailed obj cb SignalConnectAfter

connectWidgetKeynavFailed :: (GObject a, MonadIO m) =>
                             a -> WidgetKeynavFailedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetKeynavFailed obj cb after = liftIO $ do
    let cb' = wrap_WidgetKeynavFailedCallback cb
    cb'' <- mk_WidgetKeynavFailedCallback cb'
    connectSignalFunPtr obj "keynav-failed" cb'' after

-- signal Widget::leave-notify-event
type WidgetLeaveNotifyEventCallback =
    Gdk.EventCrossing.EventCrossing ->
    IO Bool

noWidgetLeaveNotifyEventCallback :: Maybe WidgetLeaveNotifyEventCallback
noWidgetLeaveNotifyEventCallback = Nothing

type C_WidgetLeaveNotifyEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventCrossing.EventCrossing ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetLeaveNotifyEventCallback :: C_WidgetLeaveNotifyEventCallback -> IO (FunPtr C_WidgetLeaveNotifyEventCallback)

genClosure_WidgetLeaveNotifyEvent :: WidgetLeaveNotifyEventCallback -> IO Closure
genClosure_WidgetLeaveNotifyEvent cb = do
    let cb' = wrap_WidgetLeaveNotifyEventCallback cb
    mk_WidgetLeaveNotifyEventCallback cb' >>= newCClosure


wrap_WidgetLeaveNotifyEventCallback ::
    WidgetLeaveNotifyEventCallback ->
    Ptr () ->
    Ptr Gdk.EventCrossing.EventCrossing ->
    Ptr () ->
    IO CInt
wrap_WidgetLeaveNotifyEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventCrossing.EventCrossing) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetLeaveNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetLeaveNotifyEventCallback -> m SignalHandlerId
onWidgetLeaveNotifyEvent obj cb = liftIO $ connectWidgetLeaveNotifyEvent obj cb SignalConnectBefore
afterWidgetLeaveNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetLeaveNotifyEventCallback -> m SignalHandlerId
afterWidgetLeaveNotifyEvent obj cb = connectWidgetLeaveNotifyEvent obj cb SignalConnectAfter

connectWidgetLeaveNotifyEvent :: (GObject a, MonadIO m) =>
                                 a -> WidgetLeaveNotifyEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetLeaveNotifyEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetLeaveNotifyEventCallback cb
    cb'' <- mk_WidgetLeaveNotifyEventCallback cb'
    connectSignalFunPtr obj "leave-notify-event" cb'' after

-- signal Widget::map
type WidgetMapCallback =
    IO ()

noWidgetMapCallback :: Maybe WidgetMapCallback
noWidgetMapCallback = Nothing

type C_WidgetMapCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetMapCallback :: C_WidgetMapCallback -> IO (FunPtr C_WidgetMapCallback)

genClosure_WidgetMap :: WidgetMapCallback -> IO Closure
genClosure_WidgetMap cb = do
    let cb' = wrap_WidgetMapCallback cb
    mk_WidgetMapCallback cb' >>= newCClosure


wrap_WidgetMapCallback ::
    WidgetMapCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetMapCallback _cb _ _ = do
    _cb 


onWidgetMap :: (GObject a, MonadIO m) => a -> WidgetMapCallback -> m SignalHandlerId
onWidgetMap obj cb = liftIO $ connectWidgetMap obj cb SignalConnectBefore
afterWidgetMap :: (GObject a, MonadIO m) => a -> WidgetMapCallback -> m SignalHandlerId
afterWidgetMap obj cb = connectWidgetMap obj cb SignalConnectAfter

connectWidgetMap :: (GObject a, MonadIO m) =>
                    a -> WidgetMapCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetMap obj cb after = liftIO $ do
    let cb' = wrap_WidgetMapCallback cb
    cb'' <- mk_WidgetMapCallback cb'
    connectSignalFunPtr obj "map" cb'' after

-- signal Widget::map-event
type WidgetMapEventCallback =
    Gdk.EventAny.EventAny ->
    IO Bool

noWidgetMapEventCallback :: Maybe WidgetMapEventCallback
noWidgetMapEventCallback = Nothing

type C_WidgetMapEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventAny.EventAny ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetMapEventCallback :: C_WidgetMapEventCallback -> IO (FunPtr C_WidgetMapEventCallback)

genClosure_WidgetMapEvent :: WidgetMapEventCallback -> IO Closure
genClosure_WidgetMapEvent cb = do
    let cb' = wrap_WidgetMapEventCallback cb
    mk_WidgetMapEventCallback cb' >>= newCClosure


wrap_WidgetMapEventCallback ::
    WidgetMapEventCallback ->
    Ptr () ->
    Ptr Gdk.EventAny.EventAny ->
    Ptr () ->
    IO CInt
wrap_WidgetMapEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventAny.EventAny) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetMapEvent :: (GObject a, MonadIO m) => a -> WidgetMapEventCallback -> m SignalHandlerId
onWidgetMapEvent obj cb = liftIO $ connectWidgetMapEvent obj cb SignalConnectBefore
afterWidgetMapEvent :: (GObject a, MonadIO m) => a -> WidgetMapEventCallback -> m SignalHandlerId
afterWidgetMapEvent obj cb = connectWidgetMapEvent obj cb SignalConnectAfter

connectWidgetMapEvent :: (GObject a, MonadIO m) =>
                         a -> WidgetMapEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetMapEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetMapEventCallback cb
    cb'' <- mk_WidgetMapEventCallback cb'
    connectSignalFunPtr obj "map-event" cb'' after

-- signal Widget::mnemonic-activate
type WidgetMnemonicActivateCallback =
    Bool ->
    IO Bool

noWidgetMnemonicActivateCallback :: Maybe WidgetMnemonicActivateCallback
noWidgetMnemonicActivateCallback = Nothing

type C_WidgetMnemonicActivateCallback =
    Ptr () ->                               -- object
    CInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetMnemonicActivateCallback :: C_WidgetMnemonicActivateCallback -> IO (FunPtr C_WidgetMnemonicActivateCallback)

genClosure_WidgetMnemonicActivate :: WidgetMnemonicActivateCallback -> IO Closure
genClosure_WidgetMnemonicActivate cb = do
    let cb' = wrap_WidgetMnemonicActivateCallback cb
    mk_WidgetMnemonicActivateCallback cb' >>= newCClosure


wrap_WidgetMnemonicActivateCallback ::
    WidgetMnemonicActivateCallback ->
    Ptr () ->
    CInt ->
    Ptr () ->
    IO CInt
wrap_WidgetMnemonicActivateCallback _cb _ arg1 _ = do
    let arg1' = (/= 0) arg1
    result <- _cb  arg1'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetMnemonicActivate :: (GObject a, MonadIO m) => a -> WidgetMnemonicActivateCallback -> m SignalHandlerId
onWidgetMnemonicActivate obj cb = liftIO $ connectWidgetMnemonicActivate obj cb SignalConnectBefore
afterWidgetMnemonicActivate :: (GObject a, MonadIO m) => a -> WidgetMnemonicActivateCallback -> m SignalHandlerId
afterWidgetMnemonicActivate obj cb = connectWidgetMnemonicActivate obj cb SignalConnectAfter

connectWidgetMnemonicActivate :: (GObject a, MonadIO m) =>
                                 a -> WidgetMnemonicActivateCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetMnemonicActivate obj cb after = liftIO $ do
    let cb' = wrap_WidgetMnemonicActivateCallback cb
    cb'' <- mk_WidgetMnemonicActivateCallback cb'
    connectSignalFunPtr obj "mnemonic-activate" cb'' after

-- signal Widget::motion-notify-event
type WidgetMotionNotifyEventCallback =
    Gdk.EventMotion.EventMotion ->
    IO Bool

noWidgetMotionNotifyEventCallback :: Maybe WidgetMotionNotifyEventCallback
noWidgetMotionNotifyEventCallback = Nothing

type C_WidgetMotionNotifyEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventMotion.EventMotion ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetMotionNotifyEventCallback :: C_WidgetMotionNotifyEventCallback -> IO (FunPtr C_WidgetMotionNotifyEventCallback)

genClosure_WidgetMotionNotifyEvent :: WidgetMotionNotifyEventCallback -> IO Closure
genClosure_WidgetMotionNotifyEvent cb = do
    let cb' = wrap_WidgetMotionNotifyEventCallback cb
    mk_WidgetMotionNotifyEventCallback cb' >>= newCClosure


wrap_WidgetMotionNotifyEventCallback ::
    WidgetMotionNotifyEventCallback ->
    Ptr () ->
    Ptr Gdk.EventMotion.EventMotion ->
    Ptr () ->
    IO CInt
wrap_WidgetMotionNotifyEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventMotion.EventMotion) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetMotionNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetMotionNotifyEventCallback -> m SignalHandlerId
onWidgetMotionNotifyEvent obj cb = liftIO $ connectWidgetMotionNotifyEvent obj cb SignalConnectBefore
afterWidgetMotionNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetMotionNotifyEventCallback -> m SignalHandlerId
afterWidgetMotionNotifyEvent obj cb = connectWidgetMotionNotifyEvent obj cb SignalConnectAfter

connectWidgetMotionNotifyEvent :: (GObject a, MonadIO m) =>
                                  a -> WidgetMotionNotifyEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetMotionNotifyEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetMotionNotifyEventCallback cb
    cb'' <- mk_WidgetMotionNotifyEventCallback cb'
    connectSignalFunPtr obj "motion-notify-event" cb'' after

-- signal Widget::move-focus
type WidgetMoveFocusCallback =
    Gtk.Enums.DirectionType ->
    IO ()

noWidgetMoveFocusCallback :: Maybe WidgetMoveFocusCallback
noWidgetMoveFocusCallback = Nothing

type C_WidgetMoveFocusCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetMoveFocusCallback :: C_WidgetMoveFocusCallback -> IO (FunPtr C_WidgetMoveFocusCallback)

genClosure_WidgetMoveFocus :: WidgetMoveFocusCallback -> IO Closure
genClosure_WidgetMoveFocus cb = do
    let cb' = wrap_WidgetMoveFocusCallback cb
    mk_WidgetMoveFocusCallback cb' >>= newCClosure


wrap_WidgetMoveFocusCallback ::
    WidgetMoveFocusCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_WidgetMoveFocusCallback _cb _ direction _ = do
    let direction' = (toEnum . fromIntegral) direction
    _cb  direction'


onWidgetMoveFocus :: (GObject a, MonadIO m) => a -> WidgetMoveFocusCallback -> m SignalHandlerId
onWidgetMoveFocus obj cb = liftIO $ connectWidgetMoveFocus obj cb SignalConnectBefore
afterWidgetMoveFocus :: (GObject a, MonadIO m) => a -> WidgetMoveFocusCallback -> m SignalHandlerId
afterWidgetMoveFocus obj cb = connectWidgetMoveFocus obj cb SignalConnectAfter

connectWidgetMoveFocus :: (GObject a, MonadIO m) =>
                          a -> WidgetMoveFocusCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetMoveFocus obj cb after = liftIO $ do
    let cb' = wrap_WidgetMoveFocusCallback cb
    cb'' <- mk_WidgetMoveFocusCallback cb'
    connectSignalFunPtr obj "move-focus" cb'' after

-- signal Widget::parent-set
type WidgetParentSetCallback =
    Maybe Widget ->
    IO ()

noWidgetParentSetCallback :: Maybe WidgetParentSetCallback
noWidgetParentSetCallback = Nothing

type C_WidgetParentSetCallback =
    Ptr () ->                               -- object
    Ptr Widget ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetParentSetCallback :: C_WidgetParentSetCallback -> IO (FunPtr C_WidgetParentSetCallback)

genClosure_WidgetParentSet :: WidgetParentSetCallback -> IO Closure
genClosure_WidgetParentSet cb = do
    let cb' = wrap_WidgetParentSetCallback cb
    mk_WidgetParentSetCallback cb' >>= newCClosure


wrap_WidgetParentSetCallback ::
    WidgetParentSetCallback ->
    Ptr () ->
    Ptr Widget ->
    Ptr () ->
    IO ()
wrap_WidgetParentSetCallback _cb _ oldParent _ = do
    maybeOldParent <-
        if oldParent == nullPtr
        then return Nothing
        else do
            oldParent' <- (newObject Widget) oldParent
            return $ Just oldParent'
    _cb  maybeOldParent


onWidgetParentSet :: (GObject a, MonadIO m) => a -> WidgetParentSetCallback -> m SignalHandlerId
onWidgetParentSet obj cb = liftIO $ connectWidgetParentSet obj cb SignalConnectBefore
afterWidgetParentSet :: (GObject a, MonadIO m) => a -> WidgetParentSetCallback -> m SignalHandlerId
afterWidgetParentSet obj cb = connectWidgetParentSet obj cb SignalConnectAfter

connectWidgetParentSet :: (GObject a, MonadIO m) =>
                          a -> WidgetParentSetCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetParentSet obj cb after = liftIO $ do
    let cb' = wrap_WidgetParentSetCallback cb
    cb'' <- mk_WidgetParentSetCallback cb'
    connectSignalFunPtr obj "parent-set" cb'' after

-- signal Widget::popup-menu
type WidgetPopupMenuCallback =
    IO Bool

noWidgetPopupMenuCallback :: Maybe WidgetPopupMenuCallback
noWidgetPopupMenuCallback = Nothing

type C_WidgetPopupMenuCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetPopupMenuCallback :: C_WidgetPopupMenuCallback -> IO (FunPtr C_WidgetPopupMenuCallback)

genClosure_WidgetPopupMenu :: WidgetPopupMenuCallback -> IO Closure
genClosure_WidgetPopupMenu cb = do
    let cb' = wrap_WidgetPopupMenuCallback cb
    mk_WidgetPopupMenuCallback cb' >>= newCClosure


wrap_WidgetPopupMenuCallback ::
    WidgetPopupMenuCallback ->
    Ptr () ->
    Ptr () ->
    IO CInt
wrap_WidgetPopupMenuCallback _cb _ _ = do
    result <- _cb 
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetPopupMenu :: (GObject a, MonadIO m) => a -> WidgetPopupMenuCallback -> m SignalHandlerId
onWidgetPopupMenu obj cb = liftIO $ connectWidgetPopupMenu obj cb SignalConnectBefore
afterWidgetPopupMenu :: (GObject a, MonadIO m) => a -> WidgetPopupMenuCallback -> m SignalHandlerId
afterWidgetPopupMenu obj cb = connectWidgetPopupMenu obj cb SignalConnectAfter

connectWidgetPopupMenu :: (GObject a, MonadIO m) =>
                          a -> WidgetPopupMenuCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetPopupMenu obj cb after = liftIO $ do
    let cb' = wrap_WidgetPopupMenuCallback cb
    cb'' <- mk_WidgetPopupMenuCallback cb'
    connectSignalFunPtr obj "popup-menu" cb'' after

-- signal Widget::property-notify-event
type WidgetPropertyNotifyEventCallback =
    Gdk.EventProperty.EventProperty ->
    IO Bool

noWidgetPropertyNotifyEventCallback :: Maybe WidgetPropertyNotifyEventCallback
noWidgetPropertyNotifyEventCallback = Nothing

type C_WidgetPropertyNotifyEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventProperty.EventProperty ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetPropertyNotifyEventCallback :: C_WidgetPropertyNotifyEventCallback -> IO (FunPtr C_WidgetPropertyNotifyEventCallback)

genClosure_WidgetPropertyNotifyEvent :: WidgetPropertyNotifyEventCallback -> IO Closure
genClosure_WidgetPropertyNotifyEvent cb = do
    let cb' = wrap_WidgetPropertyNotifyEventCallback cb
    mk_WidgetPropertyNotifyEventCallback cb' >>= newCClosure


wrap_WidgetPropertyNotifyEventCallback ::
    WidgetPropertyNotifyEventCallback ->
    Ptr () ->
    Ptr Gdk.EventProperty.EventProperty ->
    Ptr () ->
    IO CInt
wrap_WidgetPropertyNotifyEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventProperty.EventProperty) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetPropertyNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetPropertyNotifyEventCallback -> m SignalHandlerId
onWidgetPropertyNotifyEvent obj cb = liftIO $ connectWidgetPropertyNotifyEvent obj cb SignalConnectBefore
afterWidgetPropertyNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetPropertyNotifyEventCallback -> m SignalHandlerId
afterWidgetPropertyNotifyEvent obj cb = connectWidgetPropertyNotifyEvent obj cb SignalConnectAfter

connectWidgetPropertyNotifyEvent :: (GObject a, MonadIO m) =>
                                    a -> WidgetPropertyNotifyEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetPropertyNotifyEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetPropertyNotifyEventCallback cb
    cb'' <- mk_WidgetPropertyNotifyEventCallback cb'
    connectSignalFunPtr obj "property-notify-event" cb'' after

-- signal Widget::proximity-in-event
type WidgetProximityInEventCallback =
    Gdk.EventProximity.EventProximity ->
    IO Bool

noWidgetProximityInEventCallback :: Maybe WidgetProximityInEventCallback
noWidgetProximityInEventCallback = Nothing

type C_WidgetProximityInEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventProximity.EventProximity ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetProximityInEventCallback :: C_WidgetProximityInEventCallback -> IO (FunPtr C_WidgetProximityInEventCallback)

genClosure_WidgetProximityInEvent :: WidgetProximityInEventCallback -> IO Closure
genClosure_WidgetProximityInEvent cb = do
    let cb' = wrap_WidgetProximityInEventCallback cb
    mk_WidgetProximityInEventCallback cb' >>= newCClosure


wrap_WidgetProximityInEventCallback ::
    WidgetProximityInEventCallback ->
    Ptr () ->
    Ptr Gdk.EventProximity.EventProximity ->
    Ptr () ->
    IO CInt
wrap_WidgetProximityInEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventProximity.EventProximity) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetProximityInEvent :: (GObject a, MonadIO m) => a -> WidgetProximityInEventCallback -> m SignalHandlerId
onWidgetProximityInEvent obj cb = liftIO $ connectWidgetProximityInEvent obj cb SignalConnectBefore
afterWidgetProximityInEvent :: (GObject a, MonadIO m) => a -> WidgetProximityInEventCallback -> m SignalHandlerId
afterWidgetProximityInEvent obj cb = connectWidgetProximityInEvent obj cb SignalConnectAfter

connectWidgetProximityInEvent :: (GObject a, MonadIO m) =>
                                 a -> WidgetProximityInEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetProximityInEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetProximityInEventCallback cb
    cb'' <- mk_WidgetProximityInEventCallback cb'
    connectSignalFunPtr obj "proximity-in-event" cb'' after

-- signal Widget::proximity-out-event
type WidgetProximityOutEventCallback =
    Gdk.EventProximity.EventProximity ->
    IO Bool

noWidgetProximityOutEventCallback :: Maybe WidgetProximityOutEventCallback
noWidgetProximityOutEventCallback = Nothing

type C_WidgetProximityOutEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventProximity.EventProximity ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetProximityOutEventCallback :: C_WidgetProximityOutEventCallback -> IO (FunPtr C_WidgetProximityOutEventCallback)

genClosure_WidgetProximityOutEvent :: WidgetProximityOutEventCallback -> IO Closure
genClosure_WidgetProximityOutEvent cb = do
    let cb' = wrap_WidgetProximityOutEventCallback cb
    mk_WidgetProximityOutEventCallback cb' >>= newCClosure


wrap_WidgetProximityOutEventCallback ::
    WidgetProximityOutEventCallback ->
    Ptr () ->
    Ptr Gdk.EventProximity.EventProximity ->
    Ptr () ->
    IO CInt
wrap_WidgetProximityOutEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventProximity.EventProximity) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetProximityOutEvent :: (GObject a, MonadIO m) => a -> WidgetProximityOutEventCallback -> m SignalHandlerId
onWidgetProximityOutEvent obj cb = liftIO $ connectWidgetProximityOutEvent obj cb SignalConnectBefore
afterWidgetProximityOutEvent :: (GObject a, MonadIO m) => a -> WidgetProximityOutEventCallback -> m SignalHandlerId
afterWidgetProximityOutEvent obj cb = connectWidgetProximityOutEvent obj cb SignalConnectAfter

connectWidgetProximityOutEvent :: (GObject a, MonadIO m) =>
                                  a -> WidgetProximityOutEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetProximityOutEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetProximityOutEventCallback cb
    cb'' <- mk_WidgetProximityOutEventCallback cb'
    connectSignalFunPtr obj "proximity-out-event" cb'' after

-- signal Widget::query-tooltip
type WidgetQueryTooltipCallback =
    Int32 ->
    Int32 ->
    Bool ->
    Gtk.Tooltip.Tooltip ->
    IO Bool

noWidgetQueryTooltipCallback :: Maybe WidgetQueryTooltipCallback
noWidgetQueryTooltipCallback = Nothing

type C_WidgetQueryTooltipCallback =
    Ptr () ->                               -- object
    Int32 ->
    Int32 ->
    CInt ->
    Ptr Gtk.Tooltip.Tooltip ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetQueryTooltipCallback :: C_WidgetQueryTooltipCallback -> IO (FunPtr C_WidgetQueryTooltipCallback)

genClosure_WidgetQueryTooltip :: WidgetQueryTooltipCallback -> IO Closure
genClosure_WidgetQueryTooltip cb = do
    let cb' = wrap_WidgetQueryTooltipCallback cb
    mk_WidgetQueryTooltipCallback cb' >>= newCClosure


wrap_WidgetQueryTooltipCallback ::
    WidgetQueryTooltipCallback ->
    Ptr () ->
    Int32 ->
    Int32 ->
    CInt ->
    Ptr Gtk.Tooltip.Tooltip ->
    Ptr () ->
    IO CInt
wrap_WidgetQueryTooltipCallback _cb _ x y keyboardMode tooltip _ = do
    let keyboardMode' = (/= 0) keyboardMode
    tooltip' <- (newObject Gtk.Tooltip.Tooltip) tooltip
    result <- _cb  x y keyboardMode' tooltip'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetQueryTooltip :: (GObject a, MonadIO m) => a -> WidgetQueryTooltipCallback -> m SignalHandlerId
onWidgetQueryTooltip obj cb = liftIO $ connectWidgetQueryTooltip obj cb SignalConnectBefore
afterWidgetQueryTooltip :: (GObject a, MonadIO m) => a -> WidgetQueryTooltipCallback -> m SignalHandlerId
afterWidgetQueryTooltip obj cb = connectWidgetQueryTooltip obj cb SignalConnectAfter

connectWidgetQueryTooltip :: (GObject a, MonadIO m) =>
                             a -> WidgetQueryTooltipCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetQueryTooltip obj cb after = liftIO $ do
    let cb' = wrap_WidgetQueryTooltipCallback cb
    cb'' <- mk_WidgetQueryTooltipCallback cb'
    connectSignalFunPtr obj "query-tooltip" cb'' after

-- signal Widget::realize
type WidgetRealizeCallback =
    IO ()

noWidgetRealizeCallback :: Maybe WidgetRealizeCallback
noWidgetRealizeCallback = Nothing

type C_WidgetRealizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetRealizeCallback :: C_WidgetRealizeCallback -> IO (FunPtr C_WidgetRealizeCallback)

genClosure_WidgetRealize :: WidgetRealizeCallback -> IO Closure
genClosure_WidgetRealize cb = do
    let cb' = wrap_WidgetRealizeCallback cb
    mk_WidgetRealizeCallback cb' >>= newCClosure


wrap_WidgetRealizeCallback ::
    WidgetRealizeCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetRealizeCallback _cb _ _ = do
    _cb 


onWidgetRealize :: (GObject a, MonadIO m) => a -> WidgetRealizeCallback -> m SignalHandlerId
onWidgetRealize obj cb = liftIO $ connectWidgetRealize obj cb SignalConnectBefore
afterWidgetRealize :: (GObject a, MonadIO m) => a -> WidgetRealizeCallback -> m SignalHandlerId
afterWidgetRealize obj cb = connectWidgetRealize obj cb SignalConnectAfter

connectWidgetRealize :: (GObject a, MonadIO m) =>
                        a -> WidgetRealizeCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetRealize obj cb after = liftIO $ do
    let cb' = wrap_WidgetRealizeCallback cb
    cb'' <- mk_WidgetRealizeCallback cb'
    connectSignalFunPtr obj "realize" cb'' after

-- signal Widget::screen-changed
type WidgetScreenChangedCallback =
    Maybe Gdk.Screen.Screen ->
    IO ()

noWidgetScreenChangedCallback :: Maybe WidgetScreenChangedCallback
noWidgetScreenChangedCallback = Nothing

type C_WidgetScreenChangedCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Screen.Screen ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetScreenChangedCallback :: C_WidgetScreenChangedCallback -> IO (FunPtr C_WidgetScreenChangedCallback)

genClosure_WidgetScreenChanged :: WidgetScreenChangedCallback -> IO Closure
genClosure_WidgetScreenChanged cb = do
    let cb' = wrap_WidgetScreenChangedCallback cb
    mk_WidgetScreenChangedCallback cb' >>= newCClosure


wrap_WidgetScreenChangedCallback ::
    WidgetScreenChangedCallback ->
    Ptr () ->
    Ptr Gdk.Screen.Screen ->
    Ptr () ->
    IO ()
wrap_WidgetScreenChangedCallback _cb _ previousScreen _ = do
    maybePreviousScreen <-
        if previousScreen == nullPtr
        then return Nothing
        else do
            previousScreen' <- (newObject Gdk.Screen.Screen) previousScreen
            return $ Just previousScreen'
    _cb  maybePreviousScreen


onWidgetScreenChanged :: (GObject a, MonadIO m) => a -> WidgetScreenChangedCallback -> m SignalHandlerId
onWidgetScreenChanged obj cb = liftIO $ connectWidgetScreenChanged obj cb SignalConnectBefore
afterWidgetScreenChanged :: (GObject a, MonadIO m) => a -> WidgetScreenChangedCallback -> m SignalHandlerId
afterWidgetScreenChanged obj cb = connectWidgetScreenChanged obj cb SignalConnectAfter

connectWidgetScreenChanged :: (GObject a, MonadIO m) =>
                              a -> WidgetScreenChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetScreenChanged obj cb after = liftIO $ do
    let cb' = wrap_WidgetScreenChangedCallback cb
    cb'' <- mk_WidgetScreenChangedCallback cb'
    connectSignalFunPtr obj "screen-changed" cb'' after

-- signal Widget::scroll-event
type WidgetScrollEventCallback =
    Gdk.EventScroll.EventScroll ->
    IO Bool

noWidgetScrollEventCallback :: Maybe WidgetScrollEventCallback
noWidgetScrollEventCallback = Nothing

type C_WidgetScrollEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventScroll.EventScroll ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetScrollEventCallback :: C_WidgetScrollEventCallback -> IO (FunPtr C_WidgetScrollEventCallback)

genClosure_WidgetScrollEvent :: WidgetScrollEventCallback -> IO Closure
genClosure_WidgetScrollEvent cb = do
    let cb' = wrap_WidgetScrollEventCallback cb
    mk_WidgetScrollEventCallback cb' >>= newCClosure


wrap_WidgetScrollEventCallback ::
    WidgetScrollEventCallback ->
    Ptr () ->
    Ptr Gdk.EventScroll.EventScroll ->
    Ptr () ->
    IO CInt
wrap_WidgetScrollEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventScroll.EventScroll) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetScrollEvent :: (GObject a, MonadIO m) => a -> WidgetScrollEventCallback -> m SignalHandlerId
onWidgetScrollEvent obj cb = liftIO $ connectWidgetScrollEvent obj cb SignalConnectBefore
afterWidgetScrollEvent :: (GObject a, MonadIO m) => a -> WidgetScrollEventCallback -> m SignalHandlerId
afterWidgetScrollEvent obj cb = connectWidgetScrollEvent obj cb SignalConnectAfter

connectWidgetScrollEvent :: (GObject a, MonadIO m) =>
                            a -> WidgetScrollEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetScrollEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetScrollEventCallback cb
    cb'' <- mk_WidgetScrollEventCallback cb'
    connectSignalFunPtr obj "scroll-event" cb'' after

-- signal Widget::selection-clear-event
type WidgetSelectionClearEventCallback =
    Gdk.EventSelection.EventSelection ->
    IO Bool

noWidgetSelectionClearEventCallback :: Maybe WidgetSelectionClearEventCallback
noWidgetSelectionClearEventCallback = Nothing

type C_WidgetSelectionClearEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventSelection.EventSelection ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetSelectionClearEventCallback :: C_WidgetSelectionClearEventCallback -> IO (FunPtr C_WidgetSelectionClearEventCallback)

genClosure_WidgetSelectionClearEvent :: WidgetSelectionClearEventCallback -> IO Closure
genClosure_WidgetSelectionClearEvent cb = do
    let cb' = wrap_WidgetSelectionClearEventCallback cb
    mk_WidgetSelectionClearEventCallback cb' >>= newCClosure


wrap_WidgetSelectionClearEventCallback ::
    WidgetSelectionClearEventCallback ->
    Ptr () ->
    Ptr Gdk.EventSelection.EventSelection ->
    Ptr () ->
    IO CInt
wrap_WidgetSelectionClearEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventSelection.EventSelection) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetSelectionClearEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionClearEventCallback -> m SignalHandlerId
onWidgetSelectionClearEvent obj cb = liftIO $ connectWidgetSelectionClearEvent obj cb SignalConnectBefore
afterWidgetSelectionClearEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionClearEventCallback -> m SignalHandlerId
afterWidgetSelectionClearEvent obj cb = connectWidgetSelectionClearEvent obj cb SignalConnectAfter

connectWidgetSelectionClearEvent :: (GObject a, MonadIO m) =>
                                    a -> WidgetSelectionClearEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetSelectionClearEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetSelectionClearEventCallback cb
    cb'' <- mk_WidgetSelectionClearEventCallback cb'
    connectSignalFunPtr obj "selection-clear-event" cb'' after

-- signal Widget::selection-get
type WidgetSelectionGetCallback =
    Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    IO ()

noWidgetSelectionGetCallback :: Maybe WidgetSelectionGetCallback
noWidgetSelectionGetCallback = Nothing

type C_WidgetSelectionGetCallback =
    Ptr () ->                               -- object
    Ptr Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetSelectionGetCallback :: C_WidgetSelectionGetCallback -> IO (FunPtr C_WidgetSelectionGetCallback)

genClosure_WidgetSelectionGet :: WidgetSelectionGetCallback -> IO Closure
genClosure_WidgetSelectionGet cb = do
    let cb' = wrap_WidgetSelectionGetCallback cb
    mk_WidgetSelectionGetCallback cb' >>= newCClosure


wrap_WidgetSelectionGetCallback ::
    WidgetSelectionGetCallback ->
    Ptr () ->
    Ptr Gtk.SelectionData.SelectionData ->
    Word32 ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_WidgetSelectionGetCallback _cb _ data_ info time _ = do
    data_' <- (newBoxed Gtk.SelectionData.SelectionData) data_
    _cb  data_' info time


onWidgetSelectionGet :: (GObject a, MonadIO m) => a -> WidgetSelectionGetCallback -> m SignalHandlerId
onWidgetSelectionGet obj cb = liftIO $ connectWidgetSelectionGet obj cb SignalConnectBefore
afterWidgetSelectionGet :: (GObject a, MonadIO m) => a -> WidgetSelectionGetCallback -> m SignalHandlerId
afterWidgetSelectionGet obj cb = connectWidgetSelectionGet obj cb SignalConnectAfter

connectWidgetSelectionGet :: (GObject a, MonadIO m) =>
                             a -> WidgetSelectionGetCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetSelectionGet obj cb after = liftIO $ do
    let cb' = wrap_WidgetSelectionGetCallback cb
    cb'' <- mk_WidgetSelectionGetCallback cb'
    connectSignalFunPtr obj "selection-get" cb'' after

-- signal Widget::selection-notify-event
type WidgetSelectionNotifyEventCallback =
    Gdk.EventSelection.EventSelection ->
    IO Bool

noWidgetSelectionNotifyEventCallback :: Maybe WidgetSelectionNotifyEventCallback
noWidgetSelectionNotifyEventCallback = Nothing

type C_WidgetSelectionNotifyEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventSelection.EventSelection ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetSelectionNotifyEventCallback :: C_WidgetSelectionNotifyEventCallback -> IO (FunPtr C_WidgetSelectionNotifyEventCallback)

genClosure_WidgetSelectionNotifyEvent :: WidgetSelectionNotifyEventCallback -> IO Closure
genClosure_WidgetSelectionNotifyEvent cb = do
    let cb' = wrap_WidgetSelectionNotifyEventCallback cb
    mk_WidgetSelectionNotifyEventCallback cb' >>= newCClosure


wrap_WidgetSelectionNotifyEventCallback ::
    WidgetSelectionNotifyEventCallback ->
    Ptr () ->
    Ptr Gdk.EventSelection.EventSelection ->
    Ptr () ->
    IO CInt
wrap_WidgetSelectionNotifyEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventSelection.EventSelection) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetSelectionNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionNotifyEventCallback -> m SignalHandlerId
onWidgetSelectionNotifyEvent obj cb = liftIO $ connectWidgetSelectionNotifyEvent obj cb SignalConnectBefore
afterWidgetSelectionNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionNotifyEventCallback -> m SignalHandlerId
afterWidgetSelectionNotifyEvent obj cb = connectWidgetSelectionNotifyEvent obj cb SignalConnectAfter

connectWidgetSelectionNotifyEvent :: (GObject a, MonadIO m) =>
                                     a -> WidgetSelectionNotifyEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetSelectionNotifyEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetSelectionNotifyEventCallback cb
    cb'' <- mk_WidgetSelectionNotifyEventCallback cb'
    connectSignalFunPtr obj "selection-notify-event" cb'' after

-- signal Widget::selection-received
type WidgetSelectionReceivedCallback =
    Gtk.SelectionData.SelectionData ->
    Word32 ->
    IO ()

noWidgetSelectionReceivedCallback :: Maybe WidgetSelectionReceivedCallback
noWidgetSelectionReceivedCallback = Nothing

type C_WidgetSelectionReceivedCallback =
    Ptr () ->                               -- object
    Ptr Gtk.SelectionData.SelectionData ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetSelectionReceivedCallback :: C_WidgetSelectionReceivedCallback -> IO (FunPtr C_WidgetSelectionReceivedCallback)

genClosure_WidgetSelectionReceived :: WidgetSelectionReceivedCallback -> IO Closure
genClosure_WidgetSelectionReceived cb = do
    let cb' = wrap_WidgetSelectionReceivedCallback cb
    mk_WidgetSelectionReceivedCallback cb' >>= newCClosure


wrap_WidgetSelectionReceivedCallback ::
    WidgetSelectionReceivedCallback ->
    Ptr () ->
    Ptr Gtk.SelectionData.SelectionData ->
    Word32 ->
    Ptr () ->
    IO ()
wrap_WidgetSelectionReceivedCallback _cb _ data_ time _ = do
    data_' <- (newBoxed Gtk.SelectionData.SelectionData) data_
    _cb  data_' time


onWidgetSelectionReceived :: (GObject a, MonadIO m) => a -> WidgetSelectionReceivedCallback -> m SignalHandlerId
onWidgetSelectionReceived obj cb = liftIO $ connectWidgetSelectionReceived obj cb SignalConnectBefore
afterWidgetSelectionReceived :: (GObject a, MonadIO m) => a -> WidgetSelectionReceivedCallback -> m SignalHandlerId
afterWidgetSelectionReceived obj cb = connectWidgetSelectionReceived obj cb SignalConnectAfter

connectWidgetSelectionReceived :: (GObject a, MonadIO m) =>
                                  a -> WidgetSelectionReceivedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetSelectionReceived obj cb after = liftIO $ do
    let cb' = wrap_WidgetSelectionReceivedCallback cb
    cb'' <- mk_WidgetSelectionReceivedCallback cb'
    connectSignalFunPtr obj "selection-received" cb'' after

-- signal Widget::selection-request-event
type WidgetSelectionRequestEventCallback =
    Gdk.EventSelection.EventSelection ->
    IO Bool

noWidgetSelectionRequestEventCallback :: Maybe WidgetSelectionRequestEventCallback
noWidgetSelectionRequestEventCallback = Nothing

type C_WidgetSelectionRequestEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventSelection.EventSelection ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetSelectionRequestEventCallback :: C_WidgetSelectionRequestEventCallback -> IO (FunPtr C_WidgetSelectionRequestEventCallback)

genClosure_WidgetSelectionRequestEvent :: WidgetSelectionRequestEventCallback -> IO Closure
genClosure_WidgetSelectionRequestEvent cb = do
    let cb' = wrap_WidgetSelectionRequestEventCallback cb
    mk_WidgetSelectionRequestEventCallback cb' >>= newCClosure


wrap_WidgetSelectionRequestEventCallback ::
    WidgetSelectionRequestEventCallback ->
    Ptr () ->
    Ptr Gdk.EventSelection.EventSelection ->
    Ptr () ->
    IO CInt
wrap_WidgetSelectionRequestEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventSelection.EventSelection) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetSelectionRequestEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionRequestEventCallback -> m SignalHandlerId
onWidgetSelectionRequestEvent obj cb = liftIO $ connectWidgetSelectionRequestEvent obj cb SignalConnectBefore
afterWidgetSelectionRequestEvent :: (GObject a, MonadIO m) => a -> WidgetSelectionRequestEventCallback -> m SignalHandlerId
afterWidgetSelectionRequestEvent obj cb = connectWidgetSelectionRequestEvent obj cb SignalConnectAfter

connectWidgetSelectionRequestEvent :: (GObject a, MonadIO m) =>
                                      a -> WidgetSelectionRequestEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetSelectionRequestEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetSelectionRequestEventCallback cb
    cb'' <- mk_WidgetSelectionRequestEventCallback cb'
    connectSignalFunPtr obj "selection-request-event" cb'' after

-- signal Widget::show
type WidgetShowCallback =
    IO ()

noWidgetShowCallback :: Maybe WidgetShowCallback
noWidgetShowCallback = Nothing

type C_WidgetShowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetShowCallback :: C_WidgetShowCallback -> IO (FunPtr C_WidgetShowCallback)

genClosure_WidgetShow :: WidgetShowCallback -> IO Closure
genClosure_WidgetShow cb = do
    let cb' = wrap_WidgetShowCallback cb
    mk_WidgetShowCallback cb' >>= newCClosure


wrap_WidgetShowCallback ::
    WidgetShowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetShowCallback _cb _ _ = do
    _cb 


onWidgetShow :: (GObject a, MonadIO m) => a -> WidgetShowCallback -> m SignalHandlerId
onWidgetShow obj cb = liftIO $ connectWidgetShow obj cb SignalConnectBefore
afterWidgetShow :: (GObject a, MonadIO m) => a -> WidgetShowCallback -> m SignalHandlerId
afterWidgetShow obj cb = connectWidgetShow obj cb SignalConnectAfter

connectWidgetShow :: (GObject a, MonadIO m) =>
                     a -> WidgetShowCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetShow obj cb after = liftIO $ do
    let cb' = wrap_WidgetShowCallback cb
    cb'' <- mk_WidgetShowCallback cb'
    connectSignalFunPtr obj "show" cb'' after

-- signal Widget::show-help
type WidgetShowHelpCallback =
    Gtk.Enums.WidgetHelpType ->
    IO Bool

noWidgetShowHelpCallback :: Maybe WidgetShowHelpCallback
noWidgetShowHelpCallback = Nothing

type C_WidgetShowHelpCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetShowHelpCallback :: C_WidgetShowHelpCallback -> IO (FunPtr C_WidgetShowHelpCallback)

genClosure_WidgetShowHelp :: WidgetShowHelpCallback -> IO Closure
genClosure_WidgetShowHelp cb = do
    let cb' = wrap_WidgetShowHelpCallback cb
    mk_WidgetShowHelpCallback cb' >>= newCClosure


wrap_WidgetShowHelpCallback ::
    WidgetShowHelpCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO CInt
wrap_WidgetShowHelpCallback _cb _ helpType _ = do
    let helpType' = (toEnum . fromIntegral) helpType
    result <- _cb  helpType'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetShowHelp :: (GObject a, MonadIO m) => a -> WidgetShowHelpCallback -> m SignalHandlerId
onWidgetShowHelp obj cb = liftIO $ connectWidgetShowHelp obj cb SignalConnectBefore
afterWidgetShowHelp :: (GObject a, MonadIO m) => a -> WidgetShowHelpCallback -> m SignalHandlerId
afterWidgetShowHelp obj cb = connectWidgetShowHelp obj cb SignalConnectAfter

connectWidgetShowHelp :: (GObject a, MonadIO m) =>
                         a -> WidgetShowHelpCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetShowHelp obj cb after = liftIO $ do
    let cb' = wrap_WidgetShowHelpCallback cb
    cb'' <- mk_WidgetShowHelpCallback cb'
    connectSignalFunPtr obj "show-help" cb'' after

-- signal Widget::size-allocate
type WidgetSizeAllocateCallback =
    Gdk.Rectangle.Rectangle ->
    IO ()

noWidgetSizeAllocateCallback :: Maybe WidgetSizeAllocateCallback
noWidgetSizeAllocateCallback = Nothing

type C_WidgetSizeAllocateCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Rectangle.Rectangle ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetSizeAllocateCallback :: C_WidgetSizeAllocateCallback -> IO (FunPtr C_WidgetSizeAllocateCallback)

genClosure_WidgetSizeAllocate :: WidgetSizeAllocateCallback -> IO Closure
genClosure_WidgetSizeAllocate cb = do
    let cb' = wrap_WidgetSizeAllocateCallback cb
    mk_WidgetSizeAllocateCallback cb' >>= newCClosure


wrap_WidgetSizeAllocateCallback ::
    WidgetSizeAllocateCallback ->
    Ptr () ->
    Ptr Gdk.Rectangle.Rectangle ->
    Ptr () ->
    IO ()
wrap_WidgetSizeAllocateCallback _cb _ allocation _ = do
    allocation' <- (newBoxed Gdk.Rectangle.Rectangle) allocation
    _cb  allocation'


onWidgetSizeAllocate :: (GObject a, MonadIO m) => a -> WidgetSizeAllocateCallback -> m SignalHandlerId
onWidgetSizeAllocate obj cb = liftIO $ connectWidgetSizeAllocate obj cb SignalConnectBefore
afterWidgetSizeAllocate :: (GObject a, MonadIO m) => a -> WidgetSizeAllocateCallback -> m SignalHandlerId
afterWidgetSizeAllocate obj cb = connectWidgetSizeAllocate obj cb SignalConnectAfter

connectWidgetSizeAllocate :: (GObject a, MonadIO m) =>
                             a -> WidgetSizeAllocateCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetSizeAllocate obj cb after = liftIO $ do
    let cb' = wrap_WidgetSizeAllocateCallback cb
    cb'' <- mk_WidgetSizeAllocateCallback cb'
    connectSignalFunPtr obj "size-allocate" cb'' after

-- signal Widget::state-changed
{-# DEPRECATED WidgetStateChangedCallback ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.Widget'::@/state-flags-changed/@ instead."] #-}
type WidgetStateChangedCallback =
    Gtk.Enums.StateType ->
    IO ()

noWidgetStateChangedCallback :: Maybe WidgetStateChangedCallback
noWidgetStateChangedCallback = Nothing

type C_WidgetStateChangedCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetStateChangedCallback :: C_WidgetStateChangedCallback -> IO (FunPtr C_WidgetStateChangedCallback)

genClosure_WidgetStateChanged :: WidgetStateChangedCallback -> IO Closure
genClosure_WidgetStateChanged cb = do
    let cb' = wrap_WidgetStateChangedCallback cb
    mk_WidgetStateChangedCallback cb' >>= newCClosure


wrap_WidgetStateChangedCallback ::
    WidgetStateChangedCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_WidgetStateChangedCallback _cb _ state _ = do
    let state' = (toEnum . fromIntegral) state
    _cb  state'


onWidgetStateChanged :: (GObject a, MonadIO m) => a -> WidgetStateChangedCallback -> m SignalHandlerId
onWidgetStateChanged obj cb = liftIO $ connectWidgetStateChanged obj cb SignalConnectBefore
afterWidgetStateChanged :: (GObject a, MonadIO m) => a -> WidgetStateChangedCallback -> m SignalHandlerId
afterWidgetStateChanged obj cb = connectWidgetStateChanged obj cb SignalConnectAfter

connectWidgetStateChanged :: (GObject a, MonadIO m) =>
                             a -> WidgetStateChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetStateChanged obj cb after = liftIO $ do
    let cb' = wrap_WidgetStateChangedCallback cb
    cb'' <- mk_WidgetStateChangedCallback cb'
    connectSignalFunPtr obj "state-changed" cb'' after

-- signal Widget::state-flags-changed
type WidgetStateFlagsChangedCallback =
    [Gtk.Flags.StateFlags] ->
    IO ()

noWidgetStateFlagsChangedCallback :: Maybe WidgetStateFlagsChangedCallback
noWidgetStateFlagsChangedCallback = Nothing

type C_WidgetStateFlagsChangedCallback =
    Ptr () ->                               -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetStateFlagsChangedCallback :: C_WidgetStateFlagsChangedCallback -> IO (FunPtr C_WidgetStateFlagsChangedCallback)

genClosure_WidgetStateFlagsChanged :: WidgetStateFlagsChangedCallback -> IO Closure
genClosure_WidgetStateFlagsChanged cb = do
    let cb' = wrap_WidgetStateFlagsChangedCallback cb
    mk_WidgetStateFlagsChangedCallback cb' >>= newCClosure


wrap_WidgetStateFlagsChangedCallback ::
    WidgetStateFlagsChangedCallback ->
    Ptr () ->
    CUInt ->
    Ptr () ->
    IO ()
wrap_WidgetStateFlagsChangedCallback _cb _ flags _ = do
    let flags' = wordToGFlags flags
    _cb  flags'


onWidgetStateFlagsChanged :: (GObject a, MonadIO m) => a -> WidgetStateFlagsChangedCallback -> m SignalHandlerId
onWidgetStateFlagsChanged obj cb = liftIO $ connectWidgetStateFlagsChanged obj cb SignalConnectBefore
afterWidgetStateFlagsChanged :: (GObject a, MonadIO m) => a -> WidgetStateFlagsChangedCallback -> m SignalHandlerId
afterWidgetStateFlagsChanged obj cb = connectWidgetStateFlagsChanged obj cb SignalConnectAfter

connectWidgetStateFlagsChanged :: (GObject a, MonadIO m) =>
                                  a -> WidgetStateFlagsChangedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetStateFlagsChanged obj cb after = liftIO $ do
    let cb' = wrap_WidgetStateFlagsChangedCallback cb
    cb'' <- mk_WidgetStateFlagsChangedCallback cb'
    connectSignalFunPtr obj "state-flags-changed" cb'' after

-- signal Widget::style-set
{-# DEPRECATED WidgetStyleSetCallback ["(Since version 3.0)","Use the 'GI.Gtk.Objects.Widget.Widget'::@/style-updated/@ signal"] #-}
type WidgetStyleSetCallback =
    Maybe Gtk.Style.Style ->
    IO ()

noWidgetStyleSetCallback :: Maybe WidgetStyleSetCallback
noWidgetStyleSetCallback = Nothing

type C_WidgetStyleSetCallback =
    Ptr () ->                               -- object
    Ptr Gtk.Style.Style ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetStyleSetCallback :: C_WidgetStyleSetCallback -> IO (FunPtr C_WidgetStyleSetCallback)

genClosure_WidgetStyleSet :: WidgetStyleSetCallback -> IO Closure
genClosure_WidgetStyleSet cb = do
    let cb' = wrap_WidgetStyleSetCallback cb
    mk_WidgetStyleSetCallback cb' >>= newCClosure


wrap_WidgetStyleSetCallback ::
    WidgetStyleSetCallback ->
    Ptr () ->
    Ptr Gtk.Style.Style ->
    Ptr () ->
    IO ()
wrap_WidgetStyleSetCallback _cb _ previousStyle _ = do
    maybePreviousStyle <-
        if previousStyle == nullPtr
        then return Nothing
        else do
            previousStyle' <- (newObject Gtk.Style.Style) previousStyle
            return $ Just previousStyle'
    _cb  maybePreviousStyle


onWidgetStyleSet :: (GObject a, MonadIO m) => a -> WidgetStyleSetCallback -> m SignalHandlerId
onWidgetStyleSet obj cb = liftIO $ connectWidgetStyleSet obj cb SignalConnectBefore
afterWidgetStyleSet :: (GObject a, MonadIO m) => a -> WidgetStyleSetCallback -> m SignalHandlerId
afterWidgetStyleSet obj cb = connectWidgetStyleSet obj cb SignalConnectAfter

connectWidgetStyleSet :: (GObject a, MonadIO m) =>
                         a -> WidgetStyleSetCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetStyleSet obj cb after = liftIO $ do
    let cb' = wrap_WidgetStyleSetCallback cb
    cb'' <- mk_WidgetStyleSetCallback cb'
    connectSignalFunPtr obj "style-set" cb'' after

-- signal Widget::style-updated
type WidgetStyleUpdatedCallback =
    IO ()

noWidgetStyleUpdatedCallback :: Maybe WidgetStyleUpdatedCallback
noWidgetStyleUpdatedCallback = Nothing

type C_WidgetStyleUpdatedCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetStyleUpdatedCallback :: C_WidgetStyleUpdatedCallback -> IO (FunPtr C_WidgetStyleUpdatedCallback)

genClosure_WidgetStyleUpdated :: WidgetStyleUpdatedCallback -> IO Closure
genClosure_WidgetStyleUpdated cb = do
    let cb' = wrap_WidgetStyleUpdatedCallback cb
    mk_WidgetStyleUpdatedCallback cb' >>= newCClosure


wrap_WidgetStyleUpdatedCallback ::
    WidgetStyleUpdatedCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetStyleUpdatedCallback _cb _ _ = do
    _cb 


onWidgetStyleUpdated :: (GObject a, MonadIO m) => a -> WidgetStyleUpdatedCallback -> m SignalHandlerId
onWidgetStyleUpdated obj cb = liftIO $ connectWidgetStyleUpdated obj cb SignalConnectBefore
afterWidgetStyleUpdated :: (GObject a, MonadIO m) => a -> WidgetStyleUpdatedCallback -> m SignalHandlerId
afterWidgetStyleUpdated obj cb = connectWidgetStyleUpdated obj cb SignalConnectAfter

connectWidgetStyleUpdated :: (GObject a, MonadIO m) =>
                             a -> WidgetStyleUpdatedCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetStyleUpdated obj cb after = liftIO $ do
    let cb' = wrap_WidgetStyleUpdatedCallback cb
    cb'' <- mk_WidgetStyleUpdatedCallback cb'
    connectSignalFunPtr obj "style-updated" cb'' after

-- signal Widget::touch-event
type WidgetTouchEventCallback =
    Gdk.Event.Event ->
    IO Bool

noWidgetTouchEventCallback :: Maybe WidgetTouchEventCallback
noWidgetTouchEventCallback = Nothing

type C_WidgetTouchEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.Event.Event ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetTouchEventCallback :: C_WidgetTouchEventCallback -> IO (FunPtr C_WidgetTouchEventCallback)

genClosure_WidgetTouchEvent :: WidgetTouchEventCallback -> IO Closure
genClosure_WidgetTouchEvent cb = do
    let cb' = wrap_WidgetTouchEventCallback cb
    mk_WidgetTouchEventCallback cb' >>= newCClosure


wrap_WidgetTouchEventCallback ::
    WidgetTouchEventCallback ->
    Ptr () ->
    Ptr Gdk.Event.Event ->
    Ptr () ->
    IO CInt
wrap_WidgetTouchEventCallback _cb _ object _ = do
    object' <- (newBoxed Gdk.Event.Event) object
    result <- _cb  object'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetTouchEvent :: (GObject a, MonadIO m) => a -> WidgetTouchEventCallback -> m SignalHandlerId
onWidgetTouchEvent obj cb = liftIO $ connectWidgetTouchEvent obj cb SignalConnectBefore
afterWidgetTouchEvent :: (GObject a, MonadIO m) => a -> WidgetTouchEventCallback -> m SignalHandlerId
afterWidgetTouchEvent obj cb = connectWidgetTouchEvent obj cb SignalConnectAfter

connectWidgetTouchEvent :: (GObject a, MonadIO m) =>
                           a -> WidgetTouchEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetTouchEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetTouchEventCallback cb
    cb'' <- mk_WidgetTouchEventCallback cb'
    connectSignalFunPtr obj "touch-event" cb'' after

-- signal Widget::unmap
type WidgetUnmapCallback =
    IO ()

noWidgetUnmapCallback :: Maybe WidgetUnmapCallback
noWidgetUnmapCallback = Nothing

type C_WidgetUnmapCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetUnmapCallback :: C_WidgetUnmapCallback -> IO (FunPtr C_WidgetUnmapCallback)

genClosure_WidgetUnmap :: WidgetUnmapCallback -> IO Closure
genClosure_WidgetUnmap cb = do
    let cb' = wrap_WidgetUnmapCallback cb
    mk_WidgetUnmapCallback cb' >>= newCClosure


wrap_WidgetUnmapCallback ::
    WidgetUnmapCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetUnmapCallback _cb _ _ = do
    _cb 


onWidgetUnmap :: (GObject a, MonadIO m) => a -> WidgetUnmapCallback -> m SignalHandlerId
onWidgetUnmap obj cb = liftIO $ connectWidgetUnmap obj cb SignalConnectBefore
afterWidgetUnmap :: (GObject a, MonadIO m) => a -> WidgetUnmapCallback -> m SignalHandlerId
afterWidgetUnmap obj cb = connectWidgetUnmap obj cb SignalConnectAfter

connectWidgetUnmap :: (GObject a, MonadIO m) =>
                      a -> WidgetUnmapCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetUnmap obj cb after = liftIO $ do
    let cb' = wrap_WidgetUnmapCallback cb
    cb'' <- mk_WidgetUnmapCallback cb'
    connectSignalFunPtr obj "unmap" cb'' after

-- signal Widget::unmap-event
type WidgetUnmapEventCallback =
    Gdk.EventAny.EventAny ->
    IO Bool

noWidgetUnmapEventCallback :: Maybe WidgetUnmapEventCallback
noWidgetUnmapEventCallback = Nothing

type C_WidgetUnmapEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventAny.EventAny ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetUnmapEventCallback :: C_WidgetUnmapEventCallback -> IO (FunPtr C_WidgetUnmapEventCallback)

genClosure_WidgetUnmapEvent :: WidgetUnmapEventCallback -> IO Closure
genClosure_WidgetUnmapEvent cb = do
    let cb' = wrap_WidgetUnmapEventCallback cb
    mk_WidgetUnmapEventCallback cb' >>= newCClosure


wrap_WidgetUnmapEventCallback ::
    WidgetUnmapEventCallback ->
    Ptr () ->
    Ptr Gdk.EventAny.EventAny ->
    Ptr () ->
    IO CInt
wrap_WidgetUnmapEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventAny.EventAny) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetUnmapEvent :: (GObject a, MonadIO m) => a -> WidgetUnmapEventCallback -> m SignalHandlerId
onWidgetUnmapEvent obj cb = liftIO $ connectWidgetUnmapEvent obj cb SignalConnectBefore
afterWidgetUnmapEvent :: (GObject a, MonadIO m) => a -> WidgetUnmapEventCallback -> m SignalHandlerId
afterWidgetUnmapEvent obj cb = connectWidgetUnmapEvent obj cb SignalConnectAfter

connectWidgetUnmapEvent :: (GObject a, MonadIO m) =>
                           a -> WidgetUnmapEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetUnmapEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetUnmapEventCallback cb
    cb'' <- mk_WidgetUnmapEventCallback cb'
    connectSignalFunPtr obj "unmap-event" cb'' after

-- signal Widget::unrealize
type WidgetUnrealizeCallback =
    IO ()

noWidgetUnrealizeCallback :: Maybe WidgetUnrealizeCallback
noWidgetUnrealizeCallback = Nothing

type C_WidgetUnrealizeCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_WidgetUnrealizeCallback :: C_WidgetUnrealizeCallback -> IO (FunPtr C_WidgetUnrealizeCallback)

genClosure_WidgetUnrealize :: WidgetUnrealizeCallback -> IO Closure
genClosure_WidgetUnrealize cb = do
    let cb' = wrap_WidgetUnrealizeCallback cb
    mk_WidgetUnrealizeCallback cb' >>= newCClosure


wrap_WidgetUnrealizeCallback ::
    WidgetUnrealizeCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_WidgetUnrealizeCallback _cb _ _ = do
    _cb 


onWidgetUnrealize :: (GObject a, MonadIO m) => a -> WidgetUnrealizeCallback -> m SignalHandlerId
onWidgetUnrealize obj cb = liftIO $ connectWidgetUnrealize obj cb SignalConnectBefore
afterWidgetUnrealize :: (GObject a, MonadIO m) => a -> WidgetUnrealizeCallback -> m SignalHandlerId
afterWidgetUnrealize obj cb = connectWidgetUnrealize obj cb SignalConnectAfter

connectWidgetUnrealize :: (GObject a, MonadIO m) =>
                          a -> WidgetUnrealizeCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetUnrealize obj cb after = liftIO $ do
    let cb' = wrap_WidgetUnrealizeCallback cb
    cb'' <- mk_WidgetUnrealizeCallback cb'
    connectSignalFunPtr obj "unrealize" cb'' after

-- signal Widget::visibility-notify-event
{-# DEPRECATED WidgetVisibilityNotifyEventCallback ["(Since version 3.12)","Modern composited windowing systems with pervasive","    transparency make it impossible to track the visibility of a window","    reliably, so this signal can not be guaranteed to provide useful","    information."] #-}
type WidgetVisibilityNotifyEventCallback =
    Gdk.EventVisibility.EventVisibility ->
    IO Bool

noWidgetVisibilityNotifyEventCallback :: Maybe WidgetVisibilityNotifyEventCallback
noWidgetVisibilityNotifyEventCallback = Nothing

type C_WidgetVisibilityNotifyEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventVisibility.EventVisibility ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetVisibilityNotifyEventCallback :: C_WidgetVisibilityNotifyEventCallback -> IO (FunPtr C_WidgetVisibilityNotifyEventCallback)

genClosure_WidgetVisibilityNotifyEvent :: WidgetVisibilityNotifyEventCallback -> IO Closure
genClosure_WidgetVisibilityNotifyEvent cb = do
    let cb' = wrap_WidgetVisibilityNotifyEventCallback cb
    mk_WidgetVisibilityNotifyEventCallback cb' >>= newCClosure


wrap_WidgetVisibilityNotifyEventCallback ::
    WidgetVisibilityNotifyEventCallback ->
    Ptr () ->
    Ptr Gdk.EventVisibility.EventVisibility ->
    Ptr () ->
    IO CInt
wrap_WidgetVisibilityNotifyEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventVisibility.EventVisibility) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetVisibilityNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetVisibilityNotifyEventCallback -> m SignalHandlerId
onWidgetVisibilityNotifyEvent obj cb = liftIO $ connectWidgetVisibilityNotifyEvent obj cb SignalConnectBefore
afterWidgetVisibilityNotifyEvent :: (GObject a, MonadIO m) => a -> WidgetVisibilityNotifyEventCallback -> m SignalHandlerId
afterWidgetVisibilityNotifyEvent obj cb = connectWidgetVisibilityNotifyEvent obj cb SignalConnectAfter

connectWidgetVisibilityNotifyEvent :: (GObject a, MonadIO m) =>
                                      a -> WidgetVisibilityNotifyEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetVisibilityNotifyEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetVisibilityNotifyEventCallback cb
    cb'' <- mk_WidgetVisibilityNotifyEventCallback cb'
    connectSignalFunPtr obj "visibility-notify-event" cb'' after

-- signal Widget::window-state-event
type WidgetWindowStateEventCallback =
    Gdk.EventWindowState.EventWindowState ->
    IO Bool

noWidgetWindowStateEventCallback :: Maybe WidgetWindowStateEventCallback
noWidgetWindowStateEventCallback = Nothing

type C_WidgetWindowStateEventCallback =
    Ptr () ->                               -- object
    Ptr Gdk.EventWindowState.EventWindowState ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_WidgetWindowStateEventCallback :: C_WidgetWindowStateEventCallback -> IO (FunPtr C_WidgetWindowStateEventCallback)

genClosure_WidgetWindowStateEvent :: WidgetWindowStateEventCallback -> IO Closure
genClosure_WidgetWindowStateEvent cb = do
    let cb' = wrap_WidgetWindowStateEventCallback cb
    mk_WidgetWindowStateEventCallback cb' >>= newCClosure


wrap_WidgetWindowStateEventCallback ::
    WidgetWindowStateEventCallback ->
    Ptr () ->
    Ptr Gdk.EventWindowState.EventWindowState ->
    Ptr () ->
    IO CInt
wrap_WidgetWindowStateEventCallback _cb _ event _ = do
    event' <- (newPtr Gdk.EventWindowState.EventWindowState) event
    result <- _cb  event'
    let result' = (fromIntegral . fromEnum) result
    return result'


onWidgetWindowStateEvent :: (GObject a, MonadIO m) => a -> WidgetWindowStateEventCallback -> m SignalHandlerId
onWidgetWindowStateEvent obj cb = liftIO $ connectWidgetWindowStateEvent obj cb SignalConnectBefore
afterWidgetWindowStateEvent :: (GObject a, MonadIO m) => a -> WidgetWindowStateEventCallback -> m SignalHandlerId
afterWidgetWindowStateEvent obj cb = connectWidgetWindowStateEvent obj cb SignalConnectAfter

connectWidgetWindowStateEvent :: (GObject a, MonadIO m) =>
                                 a -> WidgetWindowStateEventCallback -> SignalConnectMode -> m SignalHandlerId
connectWidgetWindowStateEvent obj cb after = liftIO $ do
    let cb' = wrap_WidgetWindowStateEventCallback cb
    cb'' <- mk_WidgetWindowStateEventCallback cb'
    connectSignalFunPtr obj "window-state-event" cb'' after

-- VVV Prop "app-paintable"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetAppPaintable :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetAppPaintable obj = liftIO $ getObjectPropertyBool obj "app-paintable"

setWidgetAppPaintable :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetAppPaintable obj val = liftIO $ setObjectPropertyBool obj "app-paintable" val

constructWidgetAppPaintable :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetAppPaintable val = constructObjectPropertyBool "app-paintable" val

data WidgetAppPaintablePropertyInfo
instance AttrInfo WidgetAppPaintablePropertyInfo where
    type AttrAllowedOps WidgetAppPaintablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetAppPaintablePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetAppPaintablePropertyInfo = IsWidget
    type AttrGetType WidgetAppPaintablePropertyInfo = Bool
    type AttrLabel WidgetAppPaintablePropertyInfo = "app-paintable"
    type AttrOrigin WidgetAppPaintablePropertyInfo = Widget
    attrGet _ = getWidgetAppPaintable
    attrSet _ = setWidgetAppPaintable
    attrConstruct _ = constructWidgetAppPaintable
    attrClear _ = undefined

-- VVV Prop "can-default"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetCanDefault :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetCanDefault obj = liftIO $ getObjectPropertyBool obj "can-default"

setWidgetCanDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetCanDefault obj val = liftIO $ setObjectPropertyBool obj "can-default" val

constructWidgetCanDefault :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetCanDefault val = constructObjectPropertyBool "can-default" val

data WidgetCanDefaultPropertyInfo
instance AttrInfo WidgetCanDefaultPropertyInfo where
    type AttrAllowedOps WidgetCanDefaultPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetCanDefaultPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetCanDefaultPropertyInfo = IsWidget
    type AttrGetType WidgetCanDefaultPropertyInfo = Bool
    type AttrLabel WidgetCanDefaultPropertyInfo = "can-default"
    type AttrOrigin WidgetCanDefaultPropertyInfo = Widget
    attrGet _ = getWidgetCanDefault
    attrSet _ = setWidgetCanDefault
    attrConstruct _ = constructWidgetCanDefault
    attrClear _ = undefined

-- VVV Prop "can-focus"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetCanFocus obj = liftIO $ getObjectPropertyBool obj "can-focus"

setWidgetCanFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetCanFocus obj val = liftIO $ setObjectPropertyBool obj "can-focus" val

constructWidgetCanFocus :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetCanFocus val = constructObjectPropertyBool "can-focus" val

data WidgetCanFocusPropertyInfo
instance AttrInfo WidgetCanFocusPropertyInfo where
    type AttrAllowedOps WidgetCanFocusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetCanFocusPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetCanFocusPropertyInfo = IsWidget
    type AttrGetType WidgetCanFocusPropertyInfo = Bool
    type AttrLabel WidgetCanFocusPropertyInfo = "can-focus"
    type AttrOrigin WidgetCanFocusPropertyInfo = Widget
    attrGet _ = getWidgetCanFocus
    attrSet _ = setWidgetCanFocus
    attrConstruct _ = constructWidgetCanFocus
    attrClear _ = undefined

-- VVV Prop "composite-child"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getWidgetCompositeChild :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetCompositeChild obj = liftIO $ getObjectPropertyBool obj "composite-child"

data WidgetCompositeChildPropertyInfo
instance AttrInfo WidgetCompositeChildPropertyInfo where
    type AttrAllowedOps WidgetCompositeChildPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WidgetCompositeChildPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WidgetCompositeChildPropertyInfo = IsWidget
    type AttrGetType WidgetCompositeChildPropertyInfo = Bool
    type AttrLabel WidgetCompositeChildPropertyInfo = "composite-child"
    type AttrOrigin WidgetCompositeChildPropertyInfo = Widget
    attrGet _ = getWidgetCompositeChild
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "double-buffered"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetDoubleBuffered :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetDoubleBuffered obj = liftIO $ getObjectPropertyBool obj "double-buffered"

setWidgetDoubleBuffered :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetDoubleBuffered obj val = liftIO $ setObjectPropertyBool obj "double-buffered" val

constructWidgetDoubleBuffered :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetDoubleBuffered val = constructObjectPropertyBool "double-buffered" val

data WidgetDoubleBufferedPropertyInfo
instance AttrInfo WidgetDoubleBufferedPropertyInfo where
    type AttrAllowedOps WidgetDoubleBufferedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetDoubleBufferedPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetDoubleBufferedPropertyInfo = IsWidget
    type AttrGetType WidgetDoubleBufferedPropertyInfo = Bool
    type AttrLabel WidgetDoubleBufferedPropertyInfo = "double-buffered"
    type AttrOrigin WidgetDoubleBufferedPropertyInfo = Widget
    attrGet _ = getWidgetDoubleBuffered
    attrSet _ = setWidgetDoubleBuffered
    attrConstruct _ = constructWidgetDoubleBuffered
    attrClear _ = undefined

-- VVV Prop "events"
   -- Type: TInterface (Name {namespace = "Gdk", name = "EventMask"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getWidgetEvents :: (MonadIO m, IsWidget o) => o -> m [Gdk.Flags.EventMask]
getWidgetEvents obj = liftIO $ getObjectPropertyFlags obj "events"

setWidgetEvents :: (MonadIO m, IsWidget o) => o -> [Gdk.Flags.EventMask] -> m ()
setWidgetEvents obj val = liftIO $ setObjectPropertyFlags obj "events" val

constructWidgetEvents :: (IsWidget o) => [Gdk.Flags.EventMask] -> IO (GValueConstruct o)
constructWidgetEvents val = constructObjectPropertyFlags "events" val

data WidgetEventsPropertyInfo
instance AttrInfo WidgetEventsPropertyInfo where
    type AttrAllowedOps WidgetEventsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetEventsPropertyInfo = (~) [Gdk.Flags.EventMask]
    type AttrBaseTypeConstraint WidgetEventsPropertyInfo = IsWidget
    type AttrGetType WidgetEventsPropertyInfo = [Gdk.Flags.EventMask]
    type AttrLabel WidgetEventsPropertyInfo = "events"
    type AttrOrigin WidgetEventsPropertyInfo = Widget
    attrGet _ = getWidgetEvents
    attrSet _ = setWidgetEvents
    attrConstruct _ = constructWidgetEvents
    attrClear _ = undefined

-- VVV Prop "expand"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getWidgetExpand :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetExpand obj = liftIO $ getObjectPropertyBool obj "expand"

setWidgetExpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetExpand obj val = liftIO $ setObjectPropertyBool obj "expand" val

constructWidgetExpand :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetExpand val = constructObjectPropertyBool "expand" val

data WidgetExpandPropertyInfo
instance AttrInfo WidgetExpandPropertyInfo where
    type AttrAllowedOps WidgetExpandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetExpandPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetExpandPropertyInfo = IsWidget
    type AttrGetType WidgetExpandPropertyInfo = Bool
    type AttrLabel WidgetExpandPropertyInfo = "expand"
    type AttrOrigin WidgetExpandPropertyInfo = Widget
    attrGet _ = getWidgetExpand
    attrSet _ = setWidgetExpand
    attrConstruct _ = constructWidgetExpand
    attrClear _ = undefined

-- VVV Prop "focus-on-click"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetFocusOnClick obj = liftIO $ getObjectPropertyBool obj "focus-on-click"

setWidgetFocusOnClick :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetFocusOnClick obj val = liftIO $ setObjectPropertyBool obj "focus-on-click" val

constructWidgetFocusOnClick :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetFocusOnClick val = constructObjectPropertyBool "focus-on-click" val

data WidgetFocusOnClickPropertyInfo
instance AttrInfo WidgetFocusOnClickPropertyInfo where
    type AttrAllowedOps WidgetFocusOnClickPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetFocusOnClickPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetFocusOnClickPropertyInfo = IsWidget
    type AttrGetType WidgetFocusOnClickPropertyInfo = Bool
    type AttrLabel WidgetFocusOnClickPropertyInfo = "focus-on-click"
    type AttrOrigin WidgetFocusOnClickPropertyInfo = Widget
    attrGet _ = getWidgetFocusOnClick
    attrSet _ = setWidgetFocusOnClick
    attrConstruct _ = constructWidgetFocusOnClick
    attrClear _ = undefined

-- VVV Prop "halign"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Align"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetHalign :: (MonadIO m, IsWidget o) => o -> m Gtk.Enums.Align
getWidgetHalign obj = liftIO $ getObjectPropertyEnum obj "halign"

setWidgetHalign :: (MonadIO m, IsWidget o) => o -> Gtk.Enums.Align -> m ()
setWidgetHalign obj val = liftIO $ setObjectPropertyEnum obj "halign" val

constructWidgetHalign :: (IsWidget o) => Gtk.Enums.Align -> IO (GValueConstruct o)
constructWidgetHalign val = constructObjectPropertyEnum "halign" val

data WidgetHalignPropertyInfo
instance AttrInfo WidgetHalignPropertyInfo where
    type AttrAllowedOps WidgetHalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetHalignPropertyInfo = (~) Gtk.Enums.Align
    type AttrBaseTypeConstraint WidgetHalignPropertyInfo = IsWidget
    type AttrGetType WidgetHalignPropertyInfo = Gtk.Enums.Align
    type AttrLabel WidgetHalignPropertyInfo = "halign"
    type AttrOrigin WidgetHalignPropertyInfo = Widget
    attrGet _ = getWidgetHalign
    attrSet _ = setWidgetHalign
    attrConstruct _ = constructWidgetHalign
    attrClear _ = undefined

-- VVV Prop "has-default"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetHasDefault obj = liftIO $ getObjectPropertyBool obj "has-default"

setWidgetHasDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetHasDefault obj val = liftIO $ setObjectPropertyBool obj "has-default" val

constructWidgetHasDefault :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetHasDefault val = constructObjectPropertyBool "has-default" val

data WidgetHasDefaultPropertyInfo
instance AttrInfo WidgetHasDefaultPropertyInfo where
    type AttrAllowedOps WidgetHasDefaultPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetHasDefaultPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetHasDefaultPropertyInfo = IsWidget
    type AttrGetType WidgetHasDefaultPropertyInfo = Bool
    type AttrLabel WidgetHasDefaultPropertyInfo = "has-default"
    type AttrOrigin WidgetHasDefaultPropertyInfo = Widget
    attrGet _ = getWidgetHasDefault
    attrSet _ = setWidgetHasDefault
    attrConstruct _ = constructWidgetHasDefault
    attrClear _ = undefined

-- VVV Prop "has-focus"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetHasFocus obj = liftIO $ getObjectPropertyBool obj "has-focus"

setWidgetHasFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetHasFocus obj val = liftIO $ setObjectPropertyBool obj "has-focus" val

constructWidgetHasFocus :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetHasFocus val = constructObjectPropertyBool "has-focus" val

data WidgetHasFocusPropertyInfo
instance AttrInfo WidgetHasFocusPropertyInfo where
    type AttrAllowedOps WidgetHasFocusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetHasFocusPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetHasFocusPropertyInfo = IsWidget
    type AttrGetType WidgetHasFocusPropertyInfo = Bool
    type AttrLabel WidgetHasFocusPropertyInfo = "has-focus"
    type AttrOrigin WidgetHasFocusPropertyInfo = Widget
    attrGet _ = getWidgetHasFocus
    attrSet _ = setWidgetHasFocus
    attrConstruct _ = constructWidgetHasFocus
    attrClear _ = undefined

-- VVV Prop "has-tooltip"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetHasTooltip obj = liftIO $ getObjectPropertyBool obj "has-tooltip"

setWidgetHasTooltip :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetHasTooltip obj val = liftIO $ setObjectPropertyBool obj "has-tooltip" val

constructWidgetHasTooltip :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetHasTooltip val = constructObjectPropertyBool "has-tooltip" val

data WidgetHasTooltipPropertyInfo
instance AttrInfo WidgetHasTooltipPropertyInfo where
    type AttrAllowedOps WidgetHasTooltipPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetHasTooltipPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetHasTooltipPropertyInfo = IsWidget
    type AttrGetType WidgetHasTooltipPropertyInfo = Bool
    type AttrLabel WidgetHasTooltipPropertyInfo = "has-tooltip"
    type AttrOrigin WidgetHasTooltipPropertyInfo = Widget
    attrGet _ = getWidgetHasTooltip
    attrSet _ = setWidgetHasTooltip
    attrConstruct _ = constructWidgetHasTooltip
    attrClear _ = undefined

-- VVV Prop "height-request"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetHeightRequest obj = liftIO $ getObjectPropertyInt32 obj "height-request"

setWidgetHeightRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()
setWidgetHeightRequest obj val = liftIO $ setObjectPropertyInt32 obj "height-request" val

constructWidgetHeightRequest :: (IsWidget o) => Int32 -> IO (GValueConstruct o)
constructWidgetHeightRequest val = constructObjectPropertyInt32 "height-request" val

data WidgetHeightRequestPropertyInfo
instance AttrInfo WidgetHeightRequestPropertyInfo where
    type AttrAllowedOps WidgetHeightRequestPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetHeightRequestPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint WidgetHeightRequestPropertyInfo = IsWidget
    type AttrGetType WidgetHeightRequestPropertyInfo = Int32
    type AttrLabel WidgetHeightRequestPropertyInfo = "height-request"
    type AttrOrigin WidgetHeightRequestPropertyInfo = Widget
    attrGet _ = getWidgetHeightRequest
    attrSet _ = setWidgetHeightRequest
    attrConstruct _ = constructWidgetHeightRequest
    attrClear _ = undefined

-- VVV Prop "hexpand"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetHexpand :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetHexpand obj = liftIO $ getObjectPropertyBool obj "hexpand"

setWidgetHexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetHexpand obj val = liftIO $ setObjectPropertyBool obj "hexpand" val

constructWidgetHexpand :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetHexpand val = constructObjectPropertyBool "hexpand" val

data WidgetHexpandPropertyInfo
instance AttrInfo WidgetHexpandPropertyInfo where
    type AttrAllowedOps WidgetHexpandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetHexpandPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetHexpandPropertyInfo = IsWidget
    type AttrGetType WidgetHexpandPropertyInfo = Bool
    type AttrLabel WidgetHexpandPropertyInfo = "hexpand"
    type AttrOrigin WidgetHexpandPropertyInfo = Widget
    attrGet _ = getWidgetHexpand
    attrSet _ = setWidgetHexpand
    attrConstruct _ = constructWidgetHexpand
    attrClear _ = undefined

-- VVV Prop "hexpand-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetHexpandSet obj = liftIO $ getObjectPropertyBool obj "hexpand-set"

setWidgetHexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetHexpandSet obj val = liftIO $ setObjectPropertyBool obj "hexpand-set" val

constructWidgetHexpandSet :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetHexpandSet val = constructObjectPropertyBool "hexpand-set" val

data WidgetHexpandSetPropertyInfo
instance AttrInfo WidgetHexpandSetPropertyInfo where
    type AttrAllowedOps WidgetHexpandSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetHexpandSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetHexpandSetPropertyInfo = IsWidget
    type AttrGetType WidgetHexpandSetPropertyInfo = Bool
    type AttrLabel WidgetHexpandSetPropertyInfo = "hexpand-set"
    type AttrOrigin WidgetHexpandSetPropertyInfo = Widget
    attrGet _ = getWidgetHexpandSet
    attrSet _ = setWidgetHexpandSet
    attrConstruct _ = constructWidgetHexpandSet
    attrClear _ = undefined

-- VVV Prop "is-focus"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetIsFocus obj = liftIO $ getObjectPropertyBool obj "is-focus"

setWidgetIsFocus :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetIsFocus obj val = liftIO $ setObjectPropertyBool obj "is-focus" val

constructWidgetIsFocus :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetIsFocus val = constructObjectPropertyBool "is-focus" val

data WidgetIsFocusPropertyInfo
instance AttrInfo WidgetIsFocusPropertyInfo where
    type AttrAllowedOps WidgetIsFocusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetIsFocusPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetIsFocusPropertyInfo = IsWidget
    type AttrGetType WidgetIsFocusPropertyInfo = Bool
    type AttrLabel WidgetIsFocusPropertyInfo = "is-focus"
    type AttrOrigin WidgetIsFocusPropertyInfo = Widget
    attrGet _ = getWidgetIsFocus
    attrSet _ = setWidgetIsFocus
    attrConstruct _ = constructWidgetIsFocus
    attrClear _ = undefined

-- VVV Prop "margin"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getWidgetMargin :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetMargin obj = liftIO $ getObjectPropertyInt32 obj "margin"

setWidgetMargin :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()
setWidgetMargin obj val = liftIO $ setObjectPropertyInt32 obj "margin" val

constructWidgetMargin :: (IsWidget o) => Int32 -> IO (GValueConstruct o)
constructWidgetMargin val = constructObjectPropertyInt32 "margin" val

data WidgetMarginPropertyInfo
instance AttrInfo WidgetMarginPropertyInfo where
    type AttrAllowedOps WidgetMarginPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetMarginPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint WidgetMarginPropertyInfo = IsWidget
    type AttrGetType WidgetMarginPropertyInfo = Int32
    type AttrLabel WidgetMarginPropertyInfo = "margin"
    type AttrOrigin WidgetMarginPropertyInfo = Widget
    attrGet _ = getWidgetMargin
    attrSet _ = setWidgetMargin
    attrConstruct _ = constructWidgetMargin
    attrClear _ = undefined

-- VVV Prop "margin-bottom"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetMarginBottom obj = liftIO $ getObjectPropertyInt32 obj "margin-bottom"

setWidgetMarginBottom :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()
setWidgetMarginBottom obj val = liftIO $ setObjectPropertyInt32 obj "margin-bottom" val

constructWidgetMarginBottom :: (IsWidget o) => Int32 -> IO (GValueConstruct o)
constructWidgetMarginBottom val = constructObjectPropertyInt32 "margin-bottom" val

data WidgetMarginBottomPropertyInfo
instance AttrInfo WidgetMarginBottomPropertyInfo where
    type AttrAllowedOps WidgetMarginBottomPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetMarginBottomPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint WidgetMarginBottomPropertyInfo = IsWidget
    type AttrGetType WidgetMarginBottomPropertyInfo = Int32
    type AttrLabel WidgetMarginBottomPropertyInfo = "margin-bottom"
    type AttrOrigin WidgetMarginBottomPropertyInfo = Widget
    attrGet _ = getWidgetMarginBottom
    attrSet _ = setWidgetMarginBottom
    attrConstruct _ = constructWidgetMarginBottom
    attrClear _ = undefined

-- VVV Prop "margin-end"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetMarginEnd obj = liftIO $ getObjectPropertyInt32 obj "margin-end"

setWidgetMarginEnd :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()
setWidgetMarginEnd obj val = liftIO $ setObjectPropertyInt32 obj "margin-end" val

constructWidgetMarginEnd :: (IsWidget o) => Int32 -> IO (GValueConstruct o)
constructWidgetMarginEnd val = constructObjectPropertyInt32 "margin-end" val

data WidgetMarginEndPropertyInfo
instance AttrInfo WidgetMarginEndPropertyInfo where
    type AttrAllowedOps WidgetMarginEndPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetMarginEndPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint WidgetMarginEndPropertyInfo = IsWidget
    type AttrGetType WidgetMarginEndPropertyInfo = Int32
    type AttrLabel WidgetMarginEndPropertyInfo = "margin-end"
    type AttrOrigin WidgetMarginEndPropertyInfo = Widget
    attrGet _ = getWidgetMarginEnd
    attrSet _ = setWidgetMarginEnd
    attrConstruct _ = constructWidgetMarginEnd
    attrClear _ = undefined

-- VVV Prop "margin-left"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetMarginLeft :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetMarginLeft obj = liftIO $ getObjectPropertyInt32 obj "margin-left"

setWidgetMarginLeft :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()
setWidgetMarginLeft obj val = liftIO $ setObjectPropertyInt32 obj "margin-left" val

constructWidgetMarginLeft :: (IsWidget o) => Int32 -> IO (GValueConstruct o)
constructWidgetMarginLeft val = constructObjectPropertyInt32 "margin-left" val

data WidgetMarginLeftPropertyInfo
instance AttrInfo WidgetMarginLeftPropertyInfo where
    type AttrAllowedOps WidgetMarginLeftPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetMarginLeftPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint WidgetMarginLeftPropertyInfo = IsWidget
    type AttrGetType WidgetMarginLeftPropertyInfo = Int32
    type AttrLabel WidgetMarginLeftPropertyInfo = "margin-left"
    type AttrOrigin WidgetMarginLeftPropertyInfo = Widget
    attrGet _ = getWidgetMarginLeft
    attrSet _ = setWidgetMarginLeft
    attrConstruct _ = constructWidgetMarginLeft
    attrClear _ = undefined

-- VVV Prop "margin-right"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetMarginRight :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetMarginRight obj = liftIO $ getObjectPropertyInt32 obj "margin-right"

setWidgetMarginRight :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()
setWidgetMarginRight obj val = liftIO $ setObjectPropertyInt32 obj "margin-right" val

constructWidgetMarginRight :: (IsWidget o) => Int32 -> IO (GValueConstruct o)
constructWidgetMarginRight val = constructObjectPropertyInt32 "margin-right" val

data WidgetMarginRightPropertyInfo
instance AttrInfo WidgetMarginRightPropertyInfo where
    type AttrAllowedOps WidgetMarginRightPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetMarginRightPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint WidgetMarginRightPropertyInfo = IsWidget
    type AttrGetType WidgetMarginRightPropertyInfo = Int32
    type AttrLabel WidgetMarginRightPropertyInfo = "margin-right"
    type AttrOrigin WidgetMarginRightPropertyInfo = Widget
    attrGet _ = getWidgetMarginRight
    attrSet _ = setWidgetMarginRight
    attrConstruct _ = constructWidgetMarginRight
    attrClear _ = undefined

-- VVV Prop "margin-start"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetMarginStart obj = liftIO $ getObjectPropertyInt32 obj "margin-start"

setWidgetMarginStart :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()
setWidgetMarginStart obj val = liftIO $ setObjectPropertyInt32 obj "margin-start" val

constructWidgetMarginStart :: (IsWidget o) => Int32 -> IO (GValueConstruct o)
constructWidgetMarginStart val = constructObjectPropertyInt32 "margin-start" val

data WidgetMarginStartPropertyInfo
instance AttrInfo WidgetMarginStartPropertyInfo where
    type AttrAllowedOps WidgetMarginStartPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetMarginStartPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint WidgetMarginStartPropertyInfo = IsWidget
    type AttrGetType WidgetMarginStartPropertyInfo = Int32
    type AttrLabel WidgetMarginStartPropertyInfo = "margin-start"
    type AttrOrigin WidgetMarginStartPropertyInfo = Widget
    attrGet _ = getWidgetMarginStart
    attrSet _ = setWidgetMarginStart
    attrConstruct _ = constructWidgetMarginStart
    attrClear _ = undefined

-- VVV Prop "margin-top"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetMarginTop obj = liftIO $ getObjectPropertyInt32 obj "margin-top"

setWidgetMarginTop :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()
setWidgetMarginTop obj val = liftIO $ setObjectPropertyInt32 obj "margin-top" val

constructWidgetMarginTop :: (IsWidget o) => Int32 -> IO (GValueConstruct o)
constructWidgetMarginTop val = constructObjectPropertyInt32 "margin-top" val

data WidgetMarginTopPropertyInfo
instance AttrInfo WidgetMarginTopPropertyInfo where
    type AttrAllowedOps WidgetMarginTopPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetMarginTopPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint WidgetMarginTopPropertyInfo = IsWidget
    type AttrGetType WidgetMarginTopPropertyInfo = Int32
    type AttrLabel WidgetMarginTopPropertyInfo = "margin-top"
    type AttrOrigin WidgetMarginTopPropertyInfo = Widget
    attrGet _ = getWidgetMarginTop
    attrSet _ = setWidgetMarginTop
    attrConstruct _ = constructWidgetMarginTop
    attrClear _ = undefined

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetName :: (MonadIO m, IsWidget o) => o -> m T.Text
getWidgetName obj = liftIO $ checkUnexpectedNothing "getWidgetName" $ getObjectPropertyString obj "name"

setWidgetName :: (MonadIO m, IsWidget o) => o -> T.Text -> m ()
setWidgetName obj val = liftIO $ setObjectPropertyString obj "name" (Just val)

constructWidgetName :: (IsWidget o) => T.Text -> IO (GValueConstruct o)
constructWidgetName val = constructObjectPropertyString "name" (Just val)

data WidgetNamePropertyInfo
instance AttrInfo WidgetNamePropertyInfo where
    type AttrAllowedOps WidgetNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint WidgetNamePropertyInfo = IsWidget
    type AttrGetType WidgetNamePropertyInfo = T.Text
    type AttrLabel WidgetNamePropertyInfo = "name"
    type AttrOrigin WidgetNamePropertyInfo = Widget
    attrGet _ = getWidgetName
    attrSet _ = setWidgetName
    attrConstruct _ = constructWidgetName
    attrClear _ = undefined

-- VVV Prop "no-show-all"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetNoShowAll :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetNoShowAll obj = liftIO $ getObjectPropertyBool obj "no-show-all"

setWidgetNoShowAll :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetNoShowAll obj val = liftIO $ setObjectPropertyBool obj "no-show-all" val

constructWidgetNoShowAll :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetNoShowAll val = constructObjectPropertyBool "no-show-all" val

data WidgetNoShowAllPropertyInfo
instance AttrInfo WidgetNoShowAllPropertyInfo where
    type AttrAllowedOps WidgetNoShowAllPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetNoShowAllPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetNoShowAllPropertyInfo = IsWidget
    type AttrGetType WidgetNoShowAllPropertyInfo = Bool
    type AttrLabel WidgetNoShowAllPropertyInfo = "no-show-all"
    type AttrOrigin WidgetNoShowAllPropertyInfo = Widget
    attrGet _ = getWidgetNoShowAll
    attrSet _ = setWidgetNoShowAll
    attrConstruct _ = constructWidgetNoShowAll
    attrClear _ = undefined

-- VVV Prop "opacity"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetOpacity :: (MonadIO m, IsWidget o) => o -> m Double
getWidgetOpacity obj = liftIO $ getObjectPropertyDouble obj "opacity"

setWidgetOpacity :: (MonadIO m, IsWidget o) => o -> Double -> m ()
setWidgetOpacity obj val = liftIO $ setObjectPropertyDouble obj "opacity" val

constructWidgetOpacity :: (IsWidget o) => Double -> IO (GValueConstruct o)
constructWidgetOpacity val = constructObjectPropertyDouble "opacity" val

data WidgetOpacityPropertyInfo
instance AttrInfo WidgetOpacityPropertyInfo where
    type AttrAllowedOps WidgetOpacityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetOpacityPropertyInfo = (~) Double
    type AttrBaseTypeConstraint WidgetOpacityPropertyInfo = IsWidget
    type AttrGetType WidgetOpacityPropertyInfo = Double
    type AttrLabel WidgetOpacityPropertyInfo = "opacity"
    type AttrOrigin WidgetOpacityPropertyInfo = Widget
    attrGet _ = getWidgetOpacity
    attrSet _ = setWidgetOpacity
    attrConstruct _ = constructWidgetOpacity
    attrClear _ = undefined

-- VVV Prop "parent"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Container"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getWidgetParent :: (MonadIO m, IsWidget o) => o -> m (Maybe Gtk.Container.Container)
getWidgetParent obj = liftIO $ getObjectPropertyObject obj "parent" Gtk.Container.Container

setWidgetParent :: (MonadIO m, IsWidget o, Gtk.Container.IsContainer a) => o -> a -> m ()
setWidgetParent obj val = liftIO $ setObjectPropertyObject obj "parent" (Just val)

constructWidgetParent :: (IsWidget o, Gtk.Container.IsContainer a) => a -> IO (GValueConstruct o)
constructWidgetParent val = constructObjectPropertyObject "parent" (Just val)

clearWidgetParent :: (MonadIO m, IsWidget o) => o -> m ()
clearWidgetParent obj = liftIO $ setObjectPropertyObject obj "parent" (Nothing :: Maybe Gtk.Container.Container)

data WidgetParentPropertyInfo
instance AttrInfo WidgetParentPropertyInfo where
    type AttrAllowedOps WidgetParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetParentPropertyInfo = Gtk.Container.IsContainer
    type AttrBaseTypeConstraint WidgetParentPropertyInfo = IsWidget
    type AttrGetType WidgetParentPropertyInfo = (Maybe Gtk.Container.Container)
    type AttrLabel WidgetParentPropertyInfo = "parent"
    type AttrOrigin WidgetParentPropertyInfo = Widget
    attrGet _ = getWidgetParent
    attrSet _ = setWidgetParent
    attrConstruct _ = constructWidgetParent
    attrClear _ = clearWidgetParent

-- VVV Prop "receives-default"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetReceivesDefault obj = liftIO $ getObjectPropertyBool obj "receives-default"

setWidgetReceivesDefault :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetReceivesDefault obj val = liftIO $ setObjectPropertyBool obj "receives-default" val

constructWidgetReceivesDefault :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetReceivesDefault val = constructObjectPropertyBool "receives-default" val

data WidgetReceivesDefaultPropertyInfo
instance AttrInfo WidgetReceivesDefaultPropertyInfo where
    type AttrAllowedOps WidgetReceivesDefaultPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetReceivesDefaultPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetReceivesDefaultPropertyInfo = IsWidget
    type AttrGetType WidgetReceivesDefaultPropertyInfo = Bool
    type AttrLabel WidgetReceivesDefaultPropertyInfo = "receives-default"
    type AttrOrigin WidgetReceivesDefaultPropertyInfo = Widget
    attrGet _ = getWidgetReceivesDefault
    attrSet _ = setWidgetReceivesDefault
    attrConstruct _ = constructWidgetReceivesDefault
    attrClear _ = undefined

-- VVV Prop "scale-factor"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWidgetScaleFactor :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetScaleFactor obj = liftIO $ getObjectPropertyInt32 obj "scale-factor"

data WidgetScaleFactorPropertyInfo
instance AttrInfo WidgetScaleFactorPropertyInfo where
    type AttrAllowedOps WidgetScaleFactorPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WidgetScaleFactorPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WidgetScaleFactorPropertyInfo = IsWidget
    type AttrGetType WidgetScaleFactorPropertyInfo = Int32
    type AttrLabel WidgetScaleFactorPropertyInfo = "scale-factor"
    type AttrOrigin WidgetScaleFactorPropertyInfo = Widget
    attrGet _ = getWidgetScaleFactor
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "sensitive"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetSensitive :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetSensitive obj = liftIO $ getObjectPropertyBool obj "sensitive"

setWidgetSensitive :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetSensitive obj val = liftIO $ setObjectPropertyBool obj "sensitive" val

constructWidgetSensitive :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetSensitive val = constructObjectPropertyBool "sensitive" val

data WidgetSensitivePropertyInfo
instance AttrInfo WidgetSensitivePropertyInfo where
    type AttrAllowedOps WidgetSensitivePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetSensitivePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetSensitivePropertyInfo = IsWidget
    type AttrGetType WidgetSensitivePropertyInfo = Bool
    type AttrLabel WidgetSensitivePropertyInfo = "sensitive"
    type AttrOrigin WidgetSensitivePropertyInfo = Widget
    attrGet _ = getWidgetSensitive
    attrSet _ = setWidgetSensitive
    attrConstruct _ = constructWidgetSensitive
    attrClear _ = undefined

-- VVV Prop "style"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Style"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

getWidgetStyle :: (MonadIO m, IsWidget o) => o -> m Gtk.Style.Style
getWidgetStyle obj = liftIO $ checkUnexpectedNothing "getWidgetStyle" $ getObjectPropertyObject obj "style" Gtk.Style.Style

setWidgetStyle :: (MonadIO m, IsWidget o, Gtk.Style.IsStyle a) => o -> a -> m ()
setWidgetStyle obj val = liftIO $ setObjectPropertyObject obj "style" (Just val)

constructWidgetStyle :: (IsWidget o, Gtk.Style.IsStyle a) => a -> IO (GValueConstruct o)
constructWidgetStyle val = constructObjectPropertyObject "style" (Just val)

clearWidgetStyle :: (MonadIO m, IsWidget o) => o -> m ()
clearWidgetStyle obj = liftIO $ setObjectPropertyObject obj "style" (Nothing :: Maybe Gtk.Style.Style)

data WidgetStylePropertyInfo
instance AttrInfo WidgetStylePropertyInfo where
    type AttrAllowedOps WidgetStylePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetStylePropertyInfo = Gtk.Style.IsStyle
    type AttrBaseTypeConstraint WidgetStylePropertyInfo = IsWidget
    type AttrGetType WidgetStylePropertyInfo = Gtk.Style.Style
    type AttrLabel WidgetStylePropertyInfo = "style"
    type AttrOrigin WidgetStylePropertyInfo = Widget
    attrGet _ = getWidgetStyle
    attrSet _ = setWidgetStyle
    attrConstruct _ = constructWidgetStyle
    attrClear _ = clearWidgetStyle

-- VVV Prop "tooltip-markup"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

getWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m (Maybe T.Text)
getWidgetTooltipMarkup obj = liftIO $ getObjectPropertyString obj "tooltip-markup"

setWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> T.Text -> m ()
setWidgetTooltipMarkup obj val = liftIO $ setObjectPropertyString obj "tooltip-markup" (Just val)

constructWidgetTooltipMarkup :: (IsWidget o) => T.Text -> IO (GValueConstruct o)
constructWidgetTooltipMarkup val = constructObjectPropertyString "tooltip-markup" (Just val)

clearWidgetTooltipMarkup :: (MonadIO m, IsWidget o) => o -> m ()
clearWidgetTooltipMarkup obj = liftIO $ setObjectPropertyString obj "tooltip-markup" (Nothing :: Maybe T.Text)

data WidgetTooltipMarkupPropertyInfo
instance AttrInfo WidgetTooltipMarkupPropertyInfo where
    type AttrAllowedOps WidgetTooltipMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetTooltipMarkupPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint WidgetTooltipMarkupPropertyInfo = IsWidget
    type AttrGetType WidgetTooltipMarkupPropertyInfo = (Maybe T.Text)
    type AttrLabel WidgetTooltipMarkupPropertyInfo = "tooltip-markup"
    type AttrOrigin WidgetTooltipMarkupPropertyInfo = Widget
    attrGet _ = getWidgetTooltipMarkup
    attrSet _ = setWidgetTooltipMarkup
    attrConstruct _ = constructWidgetTooltipMarkup
    attrClear _ = clearWidgetTooltipMarkup

-- VVV Prop "tooltip-text"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just True)

getWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m (Maybe T.Text)
getWidgetTooltipText obj = liftIO $ getObjectPropertyString obj "tooltip-text"

setWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> T.Text -> m ()
setWidgetTooltipText obj val = liftIO $ setObjectPropertyString obj "tooltip-text" (Just val)

constructWidgetTooltipText :: (IsWidget o) => T.Text -> IO (GValueConstruct o)
constructWidgetTooltipText val = constructObjectPropertyString "tooltip-text" (Just val)

clearWidgetTooltipText :: (MonadIO m, IsWidget o) => o -> m ()
clearWidgetTooltipText obj = liftIO $ setObjectPropertyString obj "tooltip-text" (Nothing :: Maybe T.Text)

data WidgetTooltipTextPropertyInfo
instance AttrInfo WidgetTooltipTextPropertyInfo where
    type AttrAllowedOps WidgetTooltipTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetTooltipTextPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint WidgetTooltipTextPropertyInfo = IsWidget
    type AttrGetType WidgetTooltipTextPropertyInfo = (Maybe T.Text)
    type AttrLabel WidgetTooltipTextPropertyInfo = "tooltip-text"
    type AttrOrigin WidgetTooltipTextPropertyInfo = Widget
    attrGet _ = getWidgetTooltipText
    attrSet _ = setWidgetTooltipText
    attrConstruct _ = constructWidgetTooltipText
    attrClear _ = clearWidgetTooltipText

-- VVV Prop "valign"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Align"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetValign :: (MonadIO m, IsWidget o) => o -> m Gtk.Enums.Align
getWidgetValign obj = liftIO $ getObjectPropertyEnum obj "valign"

setWidgetValign :: (MonadIO m, IsWidget o) => o -> Gtk.Enums.Align -> m ()
setWidgetValign obj val = liftIO $ setObjectPropertyEnum obj "valign" val

constructWidgetValign :: (IsWidget o) => Gtk.Enums.Align -> IO (GValueConstruct o)
constructWidgetValign val = constructObjectPropertyEnum "valign" val

data WidgetValignPropertyInfo
instance AttrInfo WidgetValignPropertyInfo where
    type AttrAllowedOps WidgetValignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetValignPropertyInfo = (~) Gtk.Enums.Align
    type AttrBaseTypeConstraint WidgetValignPropertyInfo = IsWidget
    type AttrGetType WidgetValignPropertyInfo = Gtk.Enums.Align
    type AttrLabel WidgetValignPropertyInfo = "valign"
    type AttrOrigin WidgetValignPropertyInfo = Widget
    attrGet _ = getWidgetValign
    attrSet _ = setWidgetValign
    attrConstruct _ = constructWidgetValign
    attrClear _ = undefined

-- VVV Prop "vexpand"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetVexpand :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetVexpand obj = liftIO $ getObjectPropertyBool obj "vexpand"

setWidgetVexpand :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetVexpand obj val = liftIO $ setObjectPropertyBool obj "vexpand" val

constructWidgetVexpand :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetVexpand val = constructObjectPropertyBool "vexpand" val

data WidgetVexpandPropertyInfo
instance AttrInfo WidgetVexpandPropertyInfo where
    type AttrAllowedOps WidgetVexpandPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetVexpandPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetVexpandPropertyInfo = IsWidget
    type AttrGetType WidgetVexpandPropertyInfo = Bool
    type AttrLabel WidgetVexpandPropertyInfo = "vexpand"
    type AttrOrigin WidgetVexpandPropertyInfo = Widget
    attrGet _ = getWidgetVexpand
    attrSet _ = setWidgetVexpand
    attrConstruct _ = constructWidgetVexpand
    attrClear _ = undefined

-- VVV Prop "vexpand-set"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetVexpandSet obj = liftIO $ getObjectPropertyBool obj "vexpand-set"

setWidgetVexpandSet :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetVexpandSet obj val = liftIO $ setObjectPropertyBool obj "vexpand-set" val

constructWidgetVexpandSet :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetVexpandSet val = constructObjectPropertyBool "vexpand-set" val

data WidgetVexpandSetPropertyInfo
instance AttrInfo WidgetVexpandSetPropertyInfo where
    type AttrAllowedOps WidgetVexpandSetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetVexpandSetPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetVexpandSetPropertyInfo = IsWidget
    type AttrGetType WidgetVexpandSetPropertyInfo = Bool
    type AttrLabel WidgetVexpandSetPropertyInfo = "vexpand-set"
    type AttrOrigin WidgetVexpandSetPropertyInfo = Widget
    attrGet _ = getWidgetVexpandSet
    attrSet _ = setWidgetVexpandSet
    attrConstruct _ = constructWidgetVexpandSet
    attrClear _ = undefined

-- VVV Prop "visible"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getWidgetVisible :: (MonadIO m, IsWidget o) => o -> m Bool
getWidgetVisible obj = liftIO $ getObjectPropertyBool obj "visible"

setWidgetVisible :: (MonadIO m, IsWidget o) => o -> Bool -> m ()
setWidgetVisible obj val = liftIO $ setObjectPropertyBool obj "visible" val

constructWidgetVisible :: (IsWidget o) => Bool -> IO (GValueConstruct o)
constructWidgetVisible val = constructObjectPropertyBool "visible" val

data WidgetVisiblePropertyInfo
instance AttrInfo WidgetVisiblePropertyInfo where
    type AttrAllowedOps WidgetVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetVisiblePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint WidgetVisiblePropertyInfo = IsWidget
    type AttrGetType WidgetVisiblePropertyInfo = Bool
    type AttrLabel WidgetVisiblePropertyInfo = "visible"
    type AttrOrigin WidgetVisiblePropertyInfo = Widget
    attrGet _ = getWidgetVisible
    attrSet _ = setWidgetVisible
    attrConstruct _ = constructWidgetVisible
    attrClear _ = undefined

-- VVV Prop "width-request"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> m Int32
getWidgetWidthRequest obj = liftIO $ getObjectPropertyInt32 obj "width-request"

setWidgetWidthRequest :: (MonadIO m, IsWidget o) => o -> Int32 -> m ()
setWidgetWidthRequest obj val = liftIO $ setObjectPropertyInt32 obj "width-request" val

constructWidgetWidthRequest :: (IsWidget o) => Int32 -> IO (GValueConstruct o)
constructWidgetWidthRequest val = constructObjectPropertyInt32 "width-request" val

data WidgetWidthRequestPropertyInfo
instance AttrInfo WidgetWidthRequestPropertyInfo where
    type AttrAllowedOps WidgetWidthRequestPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint WidgetWidthRequestPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint WidgetWidthRequestPropertyInfo = IsWidget
    type AttrGetType WidgetWidthRequestPropertyInfo = Int32
    type AttrLabel WidgetWidthRequestPropertyInfo = "width-request"
    type AttrOrigin WidgetWidthRequestPropertyInfo = Widget
    attrGet _ = getWidgetWidthRequest
    attrSet _ = setWidgetWidthRequest
    attrConstruct _ = constructWidgetWidthRequest
    attrClear _ = undefined

-- VVV Prop "window"
   -- Type: TInterface (Name {namespace = "Gdk", name = "Window"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

getWidgetWindow :: (MonadIO m, IsWidget o) => o -> m (Maybe Gdk.Window.Window)
getWidgetWindow obj = liftIO $ getObjectPropertyObject obj "window" Gdk.Window.Window

data WidgetWindowPropertyInfo
instance AttrInfo WidgetWindowPropertyInfo where
    type AttrAllowedOps WidgetWindowPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetWindowPropertyInfo = (~) ()
    type AttrBaseTypeConstraint WidgetWindowPropertyInfo = IsWidget
    type AttrGetType WidgetWindowPropertyInfo = (Maybe Gdk.Window.Window)
    type AttrLabel WidgetWindowPropertyInfo = "window"
    type AttrOrigin WidgetWindowPropertyInfo = Widget
    attrGet _ = getWidgetWindow
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

instance O.HasAttributeList Widget
type instance O.AttributeList Widget = WidgetAttributeList
type WidgetAttributeList = ('[ '("appPaintable", WidgetAppPaintablePropertyInfo), '("canDefault", WidgetCanDefaultPropertyInfo), '("canFocus", WidgetCanFocusPropertyInfo), '("compositeChild", WidgetCompositeChildPropertyInfo), '("doubleBuffered", WidgetDoubleBufferedPropertyInfo), '("events", WidgetEventsPropertyInfo), '("expand", WidgetExpandPropertyInfo), '("focusOnClick", WidgetFocusOnClickPropertyInfo), '("halign", WidgetHalignPropertyInfo), '("hasDefault", WidgetHasDefaultPropertyInfo), '("hasFocus", WidgetHasFocusPropertyInfo), '("hasTooltip", WidgetHasTooltipPropertyInfo), '("heightRequest", WidgetHeightRequestPropertyInfo), '("hexpand", WidgetHexpandPropertyInfo), '("hexpandSet", WidgetHexpandSetPropertyInfo), '("isFocus", WidgetIsFocusPropertyInfo), '("margin", WidgetMarginPropertyInfo), '("marginBottom", WidgetMarginBottomPropertyInfo), '("marginEnd", WidgetMarginEndPropertyInfo), '("marginLeft", WidgetMarginLeftPropertyInfo), '("marginRight", WidgetMarginRightPropertyInfo), '("marginStart", WidgetMarginStartPropertyInfo), '("marginTop", WidgetMarginTopPropertyInfo), '("name", WidgetNamePropertyInfo), '("noShowAll", WidgetNoShowAllPropertyInfo), '("opacity", WidgetOpacityPropertyInfo), '("parent", WidgetParentPropertyInfo), '("receivesDefault", WidgetReceivesDefaultPropertyInfo), '("scaleFactor", WidgetScaleFactorPropertyInfo), '("sensitive", WidgetSensitivePropertyInfo), '("style", WidgetStylePropertyInfo), '("tooltipMarkup", WidgetTooltipMarkupPropertyInfo), '("tooltipText", WidgetTooltipTextPropertyInfo), '("valign", WidgetValignPropertyInfo), '("vexpand", WidgetVexpandPropertyInfo), '("vexpandSet", WidgetVexpandSetPropertyInfo), '("visible", WidgetVisiblePropertyInfo), '("widthRequest", WidgetWidthRequestPropertyInfo), '("window", WidgetWindowPropertyInfo)] :: [(Symbol, *)])

widgetAppPaintable :: AttrLabelProxy "appPaintable"
widgetAppPaintable = AttrLabelProxy

widgetCanDefault :: AttrLabelProxy "canDefault"
widgetCanDefault = AttrLabelProxy

widgetCanFocus :: AttrLabelProxy "canFocus"
widgetCanFocus = AttrLabelProxy

widgetCompositeChild :: AttrLabelProxy "compositeChild"
widgetCompositeChild = AttrLabelProxy

widgetDoubleBuffered :: AttrLabelProxy "doubleBuffered"
widgetDoubleBuffered = AttrLabelProxy

widgetEvents :: AttrLabelProxy "events"
widgetEvents = AttrLabelProxy

widgetExpand :: AttrLabelProxy "expand"
widgetExpand = AttrLabelProxy

widgetFocusOnClick :: AttrLabelProxy "focusOnClick"
widgetFocusOnClick = AttrLabelProxy

widgetHalign :: AttrLabelProxy "halign"
widgetHalign = AttrLabelProxy

widgetHasTooltip :: AttrLabelProxy "hasTooltip"
widgetHasTooltip = AttrLabelProxy

widgetHeightRequest :: AttrLabelProxy "heightRequest"
widgetHeightRequest = AttrLabelProxy

widgetHexpand :: AttrLabelProxy "hexpand"
widgetHexpand = AttrLabelProxy

widgetHexpandSet :: AttrLabelProxy "hexpandSet"
widgetHexpandSet = AttrLabelProxy

widgetMargin :: AttrLabelProxy "margin"
widgetMargin = AttrLabelProxy

widgetMarginBottom :: AttrLabelProxy "marginBottom"
widgetMarginBottom = AttrLabelProxy

widgetMarginEnd :: AttrLabelProxy "marginEnd"
widgetMarginEnd = AttrLabelProxy

widgetMarginLeft :: AttrLabelProxy "marginLeft"
widgetMarginLeft = AttrLabelProxy

widgetMarginRight :: AttrLabelProxy "marginRight"
widgetMarginRight = AttrLabelProxy

widgetMarginStart :: AttrLabelProxy "marginStart"
widgetMarginStart = AttrLabelProxy

widgetMarginTop :: AttrLabelProxy "marginTop"
widgetMarginTop = AttrLabelProxy

widgetName :: AttrLabelProxy "name"
widgetName = AttrLabelProxy

widgetNoShowAll :: AttrLabelProxy "noShowAll"
widgetNoShowAll = AttrLabelProxy

widgetOpacity :: AttrLabelProxy "opacity"
widgetOpacity = AttrLabelProxy

widgetParent :: AttrLabelProxy "parent"
widgetParent = AttrLabelProxy

widgetReceivesDefault :: AttrLabelProxy "receivesDefault"
widgetReceivesDefault = AttrLabelProxy

widgetScaleFactor :: AttrLabelProxy "scaleFactor"
widgetScaleFactor = AttrLabelProxy

widgetSensitive :: AttrLabelProxy "sensitive"
widgetSensitive = AttrLabelProxy

widgetStyle :: AttrLabelProxy "style"
widgetStyle = AttrLabelProxy

widgetTooltipMarkup :: AttrLabelProxy "tooltipMarkup"
widgetTooltipMarkup = AttrLabelProxy

widgetTooltipText :: AttrLabelProxy "tooltipText"
widgetTooltipText = AttrLabelProxy

widgetValign :: AttrLabelProxy "valign"
widgetValign = AttrLabelProxy

widgetVexpand :: AttrLabelProxy "vexpand"
widgetVexpand = AttrLabelProxy

widgetVexpandSet :: AttrLabelProxy "vexpandSet"
widgetVexpandSet = AttrLabelProxy

widgetVisible :: AttrLabelProxy "visible"
widgetVisible = AttrLabelProxy

widgetWidthRequest :: AttrLabelProxy "widthRequest"
widgetWidthRequest = AttrLabelProxy

widgetWindow :: AttrLabelProxy "window"
widgetWindow = AttrLabelProxy

data WidgetAccelClosuresChangedSignalInfo
instance SignalInfo WidgetAccelClosuresChangedSignalInfo where
    type HaskellCallbackType WidgetAccelClosuresChangedSignalInfo = WidgetAccelClosuresChangedCallback
    connectSignal _ = connectWidgetAccelClosuresChanged

data WidgetButtonPressEventSignalInfo
instance SignalInfo WidgetButtonPressEventSignalInfo where
    type HaskellCallbackType WidgetButtonPressEventSignalInfo = WidgetButtonPressEventCallback
    connectSignal _ = connectWidgetButtonPressEvent

data WidgetButtonReleaseEventSignalInfo
instance SignalInfo WidgetButtonReleaseEventSignalInfo where
    type HaskellCallbackType WidgetButtonReleaseEventSignalInfo = WidgetButtonReleaseEventCallback
    connectSignal _ = connectWidgetButtonReleaseEvent

data WidgetCanActivateAccelSignalInfo
instance SignalInfo WidgetCanActivateAccelSignalInfo where
    type HaskellCallbackType WidgetCanActivateAccelSignalInfo = WidgetCanActivateAccelCallback
    connectSignal _ = connectWidgetCanActivateAccel

data WidgetChildNotifySignalInfo
instance SignalInfo WidgetChildNotifySignalInfo where
    type HaskellCallbackType WidgetChildNotifySignalInfo = WidgetChildNotifyCallback
    connectSignal _ = connectWidgetChildNotify

data WidgetCompositedChangedSignalInfo
instance SignalInfo WidgetCompositedChangedSignalInfo where
    type HaskellCallbackType WidgetCompositedChangedSignalInfo = WidgetCompositedChangedCallback
    connectSignal _ = connectWidgetCompositedChanged

data WidgetConfigureEventSignalInfo
instance SignalInfo WidgetConfigureEventSignalInfo where
    type HaskellCallbackType WidgetConfigureEventSignalInfo = WidgetConfigureEventCallback
    connectSignal _ = connectWidgetConfigureEvent

data WidgetDamageEventSignalInfo
instance SignalInfo WidgetDamageEventSignalInfo where
    type HaskellCallbackType WidgetDamageEventSignalInfo = WidgetDamageEventCallback
    connectSignal _ = connectWidgetDamageEvent

data WidgetDeleteEventSignalInfo
instance SignalInfo WidgetDeleteEventSignalInfo where
    type HaskellCallbackType WidgetDeleteEventSignalInfo = WidgetDeleteEventCallback
    connectSignal _ = connectWidgetDeleteEvent

data WidgetDestroySignalInfo
instance SignalInfo WidgetDestroySignalInfo where
    type HaskellCallbackType WidgetDestroySignalInfo = WidgetDestroyCallback
    connectSignal _ = connectWidgetDestroy

data WidgetDestroyEventSignalInfo
instance SignalInfo WidgetDestroyEventSignalInfo where
    type HaskellCallbackType WidgetDestroyEventSignalInfo = WidgetDestroyEventCallback
    connectSignal _ = connectWidgetDestroyEvent

data WidgetDirectionChangedSignalInfo
instance SignalInfo WidgetDirectionChangedSignalInfo where
    type HaskellCallbackType WidgetDirectionChangedSignalInfo = WidgetDirectionChangedCallback
    connectSignal _ = connectWidgetDirectionChanged

data WidgetDragBeginSignalInfo
instance SignalInfo WidgetDragBeginSignalInfo where
    type HaskellCallbackType WidgetDragBeginSignalInfo = WidgetDragBeginCallback
    connectSignal _ = connectWidgetDragBegin

data WidgetDragDataDeleteSignalInfo
instance SignalInfo WidgetDragDataDeleteSignalInfo where
    type HaskellCallbackType WidgetDragDataDeleteSignalInfo = WidgetDragDataDeleteCallback
    connectSignal _ = connectWidgetDragDataDelete

data WidgetDragDataGetSignalInfo
instance SignalInfo WidgetDragDataGetSignalInfo where
    type HaskellCallbackType WidgetDragDataGetSignalInfo = WidgetDragDataGetCallback
    connectSignal _ = connectWidgetDragDataGet

data WidgetDragDataReceivedSignalInfo
instance SignalInfo WidgetDragDataReceivedSignalInfo where
    type HaskellCallbackType WidgetDragDataReceivedSignalInfo = WidgetDragDataReceivedCallback
    connectSignal _ = connectWidgetDragDataReceived

data WidgetDragDropSignalInfo
instance SignalInfo WidgetDragDropSignalInfo where
    type HaskellCallbackType WidgetDragDropSignalInfo = WidgetDragDropCallback
    connectSignal _ = connectWidgetDragDrop

data WidgetDragEndSignalInfo
instance SignalInfo WidgetDragEndSignalInfo where
    type HaskellCallbackType WidgetDragEndSignalInfo = WidgetDragEndCallback
    connectSignal _ = connectWidgetDragEnd

data WidgetDragFailedSignalInfo
instance SignalInfo WidgetDragFailedSignalInfo where
    type HaskellCallbackType WidgetDragFailedSignalInfo = WidgetDragFailedCallback
    connectSignal _ = connectWidgetDragFailed

data WidgetDragLeaveSignalInfo
instance SignalInfo WidgetDragLeaveSignalInfo where
    type HaskellCallbackType WidgetDragLeaveSignalInfo = WidgetDragLeaveCallback
    connectSignal _ = connectWidgetDragLeave

data WidgetDragMotionSignalInfo
instance SignalInfo WidgetDragMotionSignalInfo where
    type HaskellCallbackType WidgetDragMotionSignalInfo = WidgetDragMotionCallback
    connectSignal _ = connectWidgetDragMotion

data WidgetDrawSignalInfo
instance SignalInfo WidgetDrawSignalInfo where
    type HaskellCallbackType WidgetDrawSignalInfo = WidgetDrawCallback
    connectSignal _ = connectWidgetDraw

data WidgetEnterNotifyEventSignalInfo
instance SignalInfo WidgetEnterNotifyEventSignalInfo where
    type HaskellCallbackType WidgetEnterNotifyEventSignalInfo = WidgetEnterNotifyEventCallback
    connectSignal _ = connectWidgetEnterNotifyEvent

data WidgetEventSignalInfo
instance SignalInfo WidgetEventSignalInfo where
    type HaskellCallbackType WidgetEventSignalInfo = WidgetEventCallback
    connectSignal _ = connectWidgetEvent

data WidgetEventAfterSignalInfo
instance SignalInfo WidgetEventAfterSignalInfo where
    type HaskellCallbackType WidgetEventAfterSignalInfo = WidgetEventAfterCallback
    connectSignal _ = connectWidgetEventAfter

data WidgetFocusSignalInfo
instance SignalInfo WidgetFocusSignalInfo where
    type HaskellCallbackType WidgetFocusSignalInfo = WidgetFocusCallback
    connectSignal _ = connectWidgetFocus

data WidgetFocusInEventSignalInfo
instance SignalInfo WidgetFocusInEventSignalInfo where
    type HaskellCallbackType WidgetFocusInEventSignalInfo = WidgetFocusInEventCallback
    connectSignal _ = connectWidgetFocusInEvent

data WidgetFocusOutEventSignalInfo
instance SignalInfo WidgetFocusOutEventSignalInfo where
    type HaskellCallbackType WidgetFocusOutEventSignalInfo = WidgetFocusOutEventCallback
    connectSignal _ = connectWidgetFocusOutEvent

data WidgetGrabBrokenEventSignalInfo
instance SignalInfo WidgetGrabBrokenEventSignalInfo where
    type HaskellCallbackType WidgetGrabBrokenEventSignalInfo = WidgetGrabBrokenEventCallback
    connectSignal _ = connectWidgetGrabBrokenEvent

data WidgetGrabFocusSignalInfo
instance SignalInfo WidgetGrabFocusSignalInfo where
    type HaskellCallbackType WidgetGrabFocusSignalInfo = WidgetGrabFocusCallback
    connectSignal _ = connectWidgetGrabFocus

data WidgetGrabNotifySignalInfo
instance SignalInfo WidgetGrabNotifySignalInfo where
    type HaskellCallbackType WidgetGrabNotifySignalInfo = WidgetGrabNotifyCallback
    connectSignal _ = connectWidgetGrabNotify

data WidgetHideSignalInfo
instance SignalInfo WidgetHideSignalInfo where
    type HaskellCallbackType WidgetHideSignalInfo = WidgetHideCallback
    connectSignal _ = connectWidgetHide

data WidgetHierarchyChangedSignalInfo
instance SignalInfo WidgetHierarchyChangedSignalInfo where
    type HaskellCallbackType WidgetHierarchyChangedSignalInfo = WidgetHierarchyChangedCallback
    connectSignal _ = connectWidgetHierarchyChanged

data WidgetKeyPressEventSignalInfo
instance SignalInfo WidgetKeyPressEventSignalInfo where
    type HaskellCallbackType WidgetKeyPressEventSignalInfo = WidgetKeyPressEventCallback
    connectSignal _ = connectWidgetKeyPressEvent

data WidgetKeyReleaseEventSignalInfo
instance SignalInfo WidgetKeyReleaseEventSignalInfo where
    type HaskellCallbackType WidgetKeyReleaseEventSignalInfo = WidgetKeyReleaseEventCallback
    connectSignal _ = connectWidgetKeyReleaseEvent

data WidgetKeynavFailedSignalInfo
instance SignalInfo WidgetKeynavFailedSignalInfo where
    type HaskellCallbackType WidgetKeynavFailedSignalInfo = WidgetKeynavFailedCallback
    connectSignal _ = connectWidgetKeynavFailed

data WidgetLeaveNotifyEventSignalInfo
instance SignalInfo WidgetLeaveNotifyEventSignalInfo where
    type HaskellCallbackType WidgetLeaveNotifyEventSignalInfo = WidgetLeaveNotifyEventCallback
    connectSignal _ = connectWidgetLeaveNotifyEvent

data WidgetMapSignalInfo
instance SignalInfo WidgetMapSignalInfo where
    type HaskellCallbackType WidgetMapSignalInfo = WidgetMapCallback
    connectSignal _ = connectWidgetMap

data WidgetMapEventSignalInfo
instance SignalInfo WidgetMapEventSignalInfo where
    type HaskellCallbackType WidgetMapEventSignalInfo = WidgetMapEventCallback
    connectSignal _ = connectWidgetMapEvent

data WidgetMnemonicActivateSignalInfo
instance SignalInfo WidgetMnemonicActivateSignalInfo where
    type HaskellCallbackType WidgetMnemonicActivateSignalInfo = WidgetMnemonicActivateCallback
    connectSignal _ = connectWidgetMnemonicActivate

data WidgetMotionNotifyEventSignalInfo
instance SignalInfo WidgetMotionNotifyEventSignalInfo where
    type HaskellCallbackType WidgetMotionNotifyEventSignalInfo = WidgetMotionNotifyEventCallback
    connectSignal _ = connectWidgetMotionNotifyEvent

data WidgetMoveFocusSignalInfo
instance SignalInfo WidgetMoveFocusSignalInfo where
    type HaskellCallbackType WidgetMoveFocusSignalInfo = WidgetMoveFocusCallback
    connectSignal _ = connectWidgetMoveFocus

data WidgetParentSetSignalInfo
instance SignalInfo WidgetParentSetSignalInfo where
    type HaskellCallbackType WidgetParentSetSignalInfo = WidgetParentSetCallback
    connectSignal _ = connectWidgetParentSet

data WidgetPopupMenuSignalInfo
instance SignalInfo WidgetPopupMenuSignalInfo where
    type HaskellCallbackType WidgetPopupMenuSignalInfo = WidgetPopupMenuCallback
    connectSignal _ = connectWidgetPopupMenu

data WidgetPropertyNotifyEventSignalInfo
instance SignalInfo WidgetPropertyNotifyEventSignalInfo where
    type HaskellCallbackType WidgetPropertyNotifyEventSignalInfo = WidgetPropertyNotifyEventCallback
    connectSignal _ = connectWidgetPropertyNotifyEvent

data WidgetProximityInEventSignalInfo
instance SignalInfo WidgetProximityInEventSignalInfo where
    type HaskellCallbackType WidgetProximityInEventSignalInfo = WidgetProximityInEventCallback
    connectSignal _ = connectWidgetProximityInEvent

data WidgetProximityOutEventSignalInfo
instance SignalInfo WidgetProximityOutEventSignalInfo where
    type HaskellCallbackType WidgetProximityOutEventSignalInfo = WidgetProximityOutEventCallback
    connectSignal _ = connectWidgetProximityOutEvent

data WidgetQueryTooltipSignalInfo
instance SignalInfo WidgetQueryTooltipSignalInfo where
    type HaskellCallbackType WidgetQueryTooltipSignalInfo = WidgetQueryTooltipCallback
    connectSignal _ = connectWidgetQueryTooltip

data WidgetRealizeSignalInfo
instance SignalInfo WidgetRealizeSignalInfo where
    type HaskellCallbackType WidgetRealizeSignalInfo = WidgetRealizeCallback
    connectSignal _ = connectWidgetRealize

data WidgetScreenChangedSignalInfo
instance SignalInfo WidgetScreenChangedSignalInfo where
    type HaskellCallbackType WidgetScreenChangedSignalInfo = WidgetScreenChangedCallback
    connectSignal _ = connectWidgetScreenChanged

data WidgetScrollEventSignalInfo
instance SignalInfo WidgetScrollEventSignalInfo where
    type HaskellCallbackType WidgetScrollEventSignalInfo = WidgetScrollEventCallback
    connectSignal _ = connectWidgetScrollEvent

data WidgetSelectionClearEventSignalInfo
instance SignalInfo WidgetSelectionClearEventSignalInfo where
    type HaskellCallbackType WidgetSelectionClearEventSignalInfo = WidgetSelectionClearEventCallback
    connectSignal _ = connectWidgetSelectionClearEvent

data WidgetSelectionGetSignalInfo
instance SignalInfo WidgetSelectionGetSignalInfo where
    type HaskellCallbackType WidgetSelectionGetSignalInfo = WidgetSelectionGetCallback
    connectSignal _ = connectWidgetSelectionGet

data WidgetSelectionNotifyEventSignalInfo
instance SignalInfo WidgetSelectionNotifyEventSignalInfo where
    type HaskellCallbackType WidgetSelectionNotifyEventSignalInfo = WidgetSelectionNotifyEventCallback
    connectSignal _ = connectWidgetSelectionNotifyEvent

data WidgetSelectionReceivedSignalInfo
instance SignalInfo WidgetSelectionReceivedSignalInfo where
    type HaskellCallbackType WidgetSelectionReceivedSignalInfo = WidgetSelectionReceivedCallback
    connectSignal _ = connectWidgetSelectionReceived

data WidgetSelectionRequestEventSignalInfo
instance SignalInfo WidgetSelectionRequestEventSignalInfo where
    type HaskellCallbackType WidgetSelectionRequestEventSignalInfo = WidgetSelectionRequestEventCallback
    connectSignal _ = connectWidgetSelectionRequestEvent

data WidgetShowSignalInfo
instance SignalInfo WidgetShowSignalInfo where
    type HaskellCallbackType WidgetShowSignalInfo = WidgetShowCallback
    connectSignal _ = connectWidgetShow

data WidgetShowHelpSignalInfo
instance SignalInfo WidgetShowHelpSignalInfo where
    type HaskellCallbackType WidgetShowHelpSignalInfo = WidgetShowHelpCallback
    connectSignal _ = connectWidgetShowHelp

data WidgetSizeAllocateSignalInfo
instance SignalInfo WidgetSizeAllocateSignalInfo where
    type HaskellCallbackType WidgetSizeAllocateSignalInfo = WidgetSizeAllocateCallback
    connectSignal _ = connectWidgetSizeAllocate

data WidgetStateChangedSignalInfo
instance SignalInfo WidgetStateChangedSignalInfo where
    type HaskellCallbackType WidgetStateChangedSignalInfo = WidgetStateChangedCallback
    connectSignal _ = connectWidgetStateChanged

data WidgetStateFlagsChangedSignalInfo
instance SignalInfo WidgetStateFlagsChangedSignalInfo where
    type HaskellCallbackType WidgetStateFlagsChangedSignalInfo = WidgetStateFlagsChangedCallback
    connectSignal _ = connectWidgetStateFlagsChanged

data WidgetStyleSetSignalInfo
instance SignalInfo WidgetStyleSetSignalInfo where
    type HaskellCallbackType WidgetStyleSetSignalInfo = WidgetStyleSetCallback
    connectSignal _ = connectWidgetStyleSet

data WidgetStyleUpdatedSignalInfo
instance SignalInfo WidgetStyleUpdatedSignalInfo where
    type HaskellCallbackType WidgetStyleUpdatedSignalInfo = WidgetStyleUpdatedCallback
    connectSignal _ = connectWidgetStyleUpdated

data WidgetTouchEventSignalInfo
instance SignalInfo WidgetTouchEventSignalInfo where
    type HaskellCallbackType WidgetTouchEventSignalInfo = WidgetTouchEventCallback
    connectSignal _ = connectWidgetTouchEvent

data WidgetUnmapSignalInfo
instance SignalInfo WidgetUnmapSignalInfo where
    type HaskellCallbackType WidgetUnmapSignalInfo = WidgetUnmapCallback
    connectSignal _ = connectWidgetUnmap

data WidgetUnmapEventSignalInfo
instance SignalInfo WidgetUnmapEventSignalInfo where
    type HaskellCallbackType WidgetUnmapEventSignalInfo = WidgetUnmapEventCallback
    connectSignal _ = connectWidgetUnmapEvent

data WidgetUnrealizeSignalInfo
instance SignalInfo WidgetUnrealizeSignalInfo where
    type HaskellCallbackType WidgetUnrealizeSignalInfo = WidgetUnrealizeCallback
    connectSignal _ = connectWidgetUnrealize

data WidgetVisibilityNotifyEventSignalInfo
instance SignalInfo WidgetVisibilityNotifyEventSignalInfo where
    type HaskellCallbackType WidgetVisibilityNotifyEventSignalInfo = WidgetVisibilityNotifyEventCallback
    connectSignal _ = connectWidgetVisibilityNotifyEvent

data WidgetWindowStateEventSignalInfo
instance SignalInfo WidgetWindowStateEventSignalInfo where
    type HaskellCallbackType WidgetWindowStateEventSignalInfo = WidgetWindowStateEventCallback
    connectSignal _ = connectWidgetWindowStateEvent

type instance O.SignalList Widget = WidgetSignalList
type WidgetSignalList = ('[ '("accelClosuresChanged", WidgetAccelClosuresChangedSignalInfo), '("buttonPressEvent", WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", WidgetCanActivateAccelSignalInfo), '("childNotify", WidgetChildNotifySignalInfo), '("compositedChanged", WidgetCompositedChangedSignalInfo), '("configureEvent", WidgetConfigureEventSignalInfo), '("damageEvent", WidgetDamageEventSignalInfo), '("deleteEvent", WidgetDeleteEventSignalInfo), '("destroy", WidgetDestroySignalInfo), '("destroyEvent", WidgetDestroyEventSignalInfo), '("directionChanged", WidgetDirectionChangedSignalInfo), '("dragBegin", WidgetDragBeginSignalInfo), '("dragDataDelete", WidgetDragDataDeleteSignalInfo), '("dragDataGet", WidgetDragDataGetSignalInfo), '("dragDataReceived", WidgetDragDataReceivedSignalInfo), '("dragDrop", WidgetDragDropSignalInfo), '("dragEnd", WidgetDragEndSignalInfo), '("dragFailed", WidgetDragFailedSignalInfo), '("dragLeave", WidgetDragLeaveSignalInfo), '("dragMotion", WidgetDragMotionSignalInfo), '("draw", WidgetDrawSignalInfo), '("enterNotifyEvent", WidgetEnterNotifyEventSignalInfo), '("event", WidgetEventSignalInfo), '("eventAfter", WidgetEventAfterSignalInfo), '("focus", WidgetFocusSignalInfo), '("focusInEvent", WidgetFocusInEventSignalInfo), '("focusOutEvent", WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", WidgetGrabBrokenEventSignalInfo), '("grabFocus", WidgetGrabFocusSignalInfo), '("grabNotify", WidgetGrabNotifySignalInfo), '("hide", WidgetHideSignalInfo), '("hierarchyChanged", WidgetHierarchyChangedSignalInfo), '("keyPressEvent", WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", WidgetKeyReleaseEventSignalInfo), '("keynavFailed", WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", WidgetLeaveNotifyEventSignalInfo), '("map", WidgetMapSignalInfo), '("mapEvent", WidgetMapEventSignalInfo), '("mnemonicActivate", WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", WidgetMotionNotifyEventSignalInfo), '("moveFocus", WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", WidgetParentSetSignalInfo), '("popupMenu", WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", WidgetProximityInEventSignalInfo), '("proximityOutEvent", WidgetProximityOutEventSignalInfo), '("queryTooltip", WidgetQueryTooltipSignalInfo), '("realize", WidgetRealizeSignalInfo), '("screenChanged", WidgetScreenChangedSignalInfo), '("scrollEvent", WidgetScrollEventSignalInfo), '("selectionClearEvent", WidgetSelectionClearEventSignalInfo), '("selectionGet", WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", WidgetSelectionRequestEventSignalInfo), '("show", WidgetShowSignalInfo), '("showHelp", WidgetShowHelpSignalInfo), '("sizeAllocate", WidgetSizeAllocateSignalInfo), '("stateChanged", WidgetStateChangedSignalInfo), '("stateFlagsChanged", WidgetStateFlagsChangedSignalInfo), '("styleSet", WidgetStyleSetSignalInfo), '("styleUpdated", WidgetStyleUpdatedSignalInfo), '("touchEvent", WidgetTouchEventSignalInfo), '("unmap", WidgetUnmapSignalInfo), '("unmapEvent", WidgetUnmapEventSignalInfo), '("unrealize", WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])

-- method Widget::activate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s activatable", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_activate" gtk_widget_activate :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
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'.
-}
widgetActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s activatable -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget was activatable -}
widgetActivate widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_activate widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetActivateMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetActivateMethodInfo a signature where
    overloadedMethod _ = widgetActivate

-- method Widget::add_accelerator
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget to install an accelerator on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_signal", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget signal to emit on accelerator activation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_group", argType = TInterface (Name {namespace = "Gtk", name = "AccelGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "accel group for this widget, added to its toplevel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_key", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GDK keyval of the accelerator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_mods", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "modifier key combination of the accelerator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_flags", argType = TInterface (Name {namespace = "Gtk", name = "AccelFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "flag accelerators, e.g. %GTK_ACCEL_VISIBLE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_add_accelerator" gtk_widget_add_accelerator :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- accel_signal : TBasicType TUTF8
    Ptr Gtk.AccelGroup.AccelGroup ->        -- accel_group : TInterface (Name {namespace = "Gtk", name = "AccelGroup"})
    Word32 ->                               -- accel_key : TBasicType TUInt
    CUInt ->                                -- accel_mods : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    CUInt ->                                -- accel_flags : TInterface (Name {namespace = "Gtk", name = "AccelFlags"})
    IO ()

{- |
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
'GI.Gtk.Objects.Window.windowAddAccelGroup', and the signal must be of type 'GI.GObject.Flags.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 'GI.Gtk.Objects.AccelMap.accelMapAddEntry' and 'GI.Gtk.Objects.Widget.widgetSetAccelPath' or
'GI.Gtk.Objects.MenuItem.menuItemSetAccelPath' instead.
-}
widgetAddAccelerator ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gtk.AccelGroup.IsAccelGroup b) =>
    a
    {- ^ /@widget@/: widget to install an accelerator on -}
    -> T.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 -}
    -> [Gdk.Flags.ModifierType]
    {- ^ /@accelMods@/: modifier key combination of the accelerator -}
    -> [Gtk.Flags.AccelFlags]
    {- ^ /@accelFlags@/: flag accelerators, e.g. 'GI.Gtk.Flags.AccelFlagsVisible' -}
    -> m ()
widgetAddAccelerator widget accelSignal accelGroup accelKey accelMods accelFlags = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    accelSignal' <- textToCString accelSignal
    accelGroup' <- unsafeManagedPtrCastPtr accelGroup
    let accelMods' = gflagsToWord accelMods
    let accelFlags' = gflagsToWord accelFlags
    gtk_widget_add_accelerator widget' accelSignal' accelGroup' accelKey accelMods' accelFlags'
    touchManagedPtr widget
    touchManagedPtr accelGroup
    freeMem accelSignal'
    return ()

data WidgetAddAcceleratorMethodInfo
instance (signature ~ (T.Text -> b -> Word32 -> [Gdk.Flags.ModifierType] -> [Gtk.Flags.AccelFlags] -> m ()), MonadIO m, IsWidget a, Gtk.AccelGroup.IsAccelGroup b) => O.MethodInfo WidgetAddAcceleratorMethodInfo a signature where
    overloadedMethod _ = widgetAddAccelerator

-- method Widget::add_device_events
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "events", argType = TInterface (Name {namespace = "Gdk", name = "EventMask"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an event mask, see #GdkEventMask", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_add_device_events" gtk_widget_add_device_events :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Device.Device ->                -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    CUInt ->                                -- events : TInterface (Name {namespace = "Gdk", name = "EventMask"})
    IO ()

{- |
Adds the device events in the bitfield /@events@/ to the event mask for
/@widget@/. See 'GI.Gtk.Objects.Widget.widgetSetDeviceEvents' for details.

@since 3.0
-}
widgetAddDeviceEvents ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Device.IsDevice b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> [Gdk.Flags.EventMask]
    {- ^ /@events@/: an event mask, see 'GI.Gdk.Flags.EventMask' -}
    -> m ()
widgetAddDeviceEvents widget device events = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    device' <- unsafeManagedPtrCastPtr device
    let events' = gflagsToWord events
    gtk_widget_add_device_events widget' device' events'
    touchManagedPtr widget
    touchManagedPtr device
    return ()

data WidgetAddDeviceEventsMethodInfo
instance (signature ~ (b -> [Gdk.Flags.EventMask] -> m ()), MonadIO m, IsWidget a, Gdk.Device.IsDevice b) => O.MethodInfo WidgetAddDeviceEventsMethodInfo a signature where
    overloadedMethod _ = widgetAddDeviceEvents

-- method Widget::add_events
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "events", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an event mask, see #GdkEventMask", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_add_events" gtk_widget_add_events :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- events : TBasicType TInt
    IO ()

{- |
Adds the events in the bitfield /@events@/ to the event mask for
/@widget@/. See 'GI.Gtk.Objects.Widget.widgetSetEvents' and the
[input handling overview][event-masks] for details.
-}
widgetAddEvents ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@events@/: an event mask, see 'GI.Gdk.Flags.EventMask' -}
    -> m ()
widgetAddEvents widget events = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_add_events widget' events
    touchManagedPtr widget
    return ()

data WidgetAddEventsMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetAddEventsMethodInfo a signature where
    overloadedMethod _ = widgetAddEvents

-- method Widget::add_mnemonic_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that acts as a mnemonic label for @widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_add_mnemonic_label" gtk_widget_add_mnemonic_label :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Widget ->                           -- label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Adds a widget to the list of mnemonic labels for
this widget. (See 'GI.Gtk.Objects.Widget.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 'GI.Gtk.Objects.Widget.Widget'::@/destroy/@ signal or a weak notifier.

@since 2.4
-}
widgetAddMnemonicLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@label@/: a 'GI.Gtk.Objects.Widget.Widget' that acts as a mnemonic label for /@widget@/ -}
    -> m ()
widgetAddMnemonicLabel widget label = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    label' <- unsafeManagedPtrCastPtr label
    gtk_widget_add_mnemonic_label widget' label'
    touchManagedPtr widget
    touchManagedPtr label
    return ()

data WidgetAddMnemonicLabelMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, IsWidget b) => O.MethodInfo WidgetAddMnemonicLabelMethodInfo a signature where
    overloadedMethod _ = widgetAddMnemonicLabel

-- method Widget::add_tick_callback
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gtk", name = "TickCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function to call for updating animations", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data to pass to @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "function to call to free @user_data when the callback is removed.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_add_tick_callback" gtk_widget_add_tick_callback :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    FunPtr Gtk.Callbacks.C_TickCallback ->  -- callback : TInterface (Name {namespace = "Gtk", name = "TickCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO Word32

{- |
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 'GI.Gtk.Objects.Label.Label'),
then you will have to call 'GI.Gtk.Objects.Widget.widgetQueueResize' or
'GI.Gtk.Objects.Widget.widgetQueueDrawArea' yourself.

'GI.Gdk.Objects.FrameClock.frameClockGetFrameTime' should generally be used for timing
continuous animations and
'GI.Gdk.Structs.FrameTimings.frameTimingsGetPredictedPresentationTime' if you are
trying to display isolated frames at particular times.

This is a more convenient alternative to connecting directly to the
'GI.Gdk.Objects.FrameClock.FrameClock'::@/update/@ signal of 'GI.Gdk.Objects.FrameClock.FrameClock', since you don\'t
have to worry about when a 'GI.Gdk.Objects.FrameClock.FrameClock' is assigned to a widget.

@since 3.8
-}
widgetAddTickCallback ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Callbacks.TickCallback
    {- ^ /@callback@/: function to call for updating animations -}
    -> m Word32
    {- ^ __Returns:__ an id for the connection of this callback. Remove the callback
    by passing it to 'GI.Gtk.Objects.Widget.widgetRemoveTickCallback' -}
widgetAddTickCallback widget callback = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    callback' <- Gtk.Callbacks.mk_TickCallback (Gtk.Callbacks.wrap_TickCallback Nothing (Gtk.Callbacks.drop_closures_TickCallback callback))
    let userData = castFunPtrToPtr callback'
    let notify = safeFreeFunPtrPtr
    result <- gtk_widget_add_tick_callback widget' callback' userData notify
    touchManagedPtr widget
    return result

data WidgetAddTickCallbackMethodInfo
instance (signature ~ (Gtk.Callbacks.TickCallback -> m Word32), MonadIO m, IsWidget a) => O.MethodInfo WidgetAddTickCallbackMethodInfo a signature where
    overloadedMethod _ = widgetAddTickCallback

-- method Widget::can_activate_accel
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signal_id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the ID of a signal installed on @widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_can_activate_accel" gtk_widget_can_activate_accel :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Word32 ->                               -- signal_id : TBasicType TUInt
    IO CInt

{- |
Determines whether an accelerator that activates the signal
identified by /@signalId@/ can currently be activated.
This is done by emitting the 'GI.Gtk.Objects.Widget.Widget'::@/can-activate-accel/@
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.

@since 2.4
-}
widgetCanActivateAccel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Word32
    {- ^ /@signalId@/: the ID of a signal installed on /@widget@/ -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the accelerator can be activated. -}
widgetCanActivateAccel widget signalId = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_can_activate_accel widget' signalId
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetCanActivateAccelMethodInfo
instance (signature ~ (Word32 -> m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetCanActivateAccelMethodInfo a signature where
    overloadedMethod _ = widgetCanActivateAccel

-- method Widget::child_focus
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface (Name {namespace = "Gtk", name = "DirectionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "direction of focus movement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_child_focus" gtk_widget_child_focus :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Gtk", name = "DirectionType"})
    IO CInt

{- |
This function is used by custom widget implementations; if you\'re
writing an app, you’d use 'GI.Gtk.Objects.Widget.widgetGrabFocus' to move the focus
to a particular widget, and 'GI.Gtk.Objects.Container.containerSetFocusChain' to
change the focus tab order. So you may want to investigate those
functions instead.

'GI.Gtk.Objects.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). 'GI.Gtk.Objects.Widget.widgetChildFocus' emits the
'GI.Gtk.Objects.Widget.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 'GI.Gtk.Objects.Widget.widgetGrabFocus' to place the focus accordingly;
if returning 'False', they don’t modify the current focus location.
-}
widgetChildFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.DirectionType
    {- ^ /@direction@/: direction of focus movement -}
    -> m Bool
    {- ^ __Returns:__ 'True' if focus ended up inside /@widget@/ -}
widgetChildFocus widget direction = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let direction' = (fromIntegral . fromEnum) direction
    result <- gtk_widget_child_focus widget' direction'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetChildFocusMethodInfo
instance (signature ~ (Gtk.Enums.DirectionType -> m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetChildFocusMethodInfo a signature where
    overloadedMethod _ = widgetChildFocus

-- method Widget::child_notify
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child_property", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a child property installed on the\n                 class of @widget\8217s parent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_child_notify" gtk_widget_child_notify :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- child_property : TBasicType TUTF8
    IO ()

{- |
Emits a 'GI.Gtk.Objects.Widget.Widget'::@/child-notify/@ signal for the
[child property][child-properties] /@childProperty@/
on /@widget@/.

This is the analogue of 'GI.GObject.Objects.Object.objectNotify' for child properties.

Also see 'GI.Gtk.Objects.Container.containerChildNotify'.
-}
widgetChildNotify ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@childProperty@/: the name of a child property installed on the
                 class of /@widget@/’s parent -}
    -> m ()
widgetChildNotify widget childProperty = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    childProperty' <- textToCString childProperty
    gtk_widget_child_notify widget' childProperty'
    touchManagedPtr widget
    freeMem childProperty'
    return ()

data WidgetChildNotifyMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetChildNotifyMethodInfo a signature where
    overloadedMethod _ = widgetChildNotify

-- method Widget::class_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_length", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the length of the\n    class path, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the class path as an\n    allocated string, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "path_reversed", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the reverse\n    class path as an allocated string, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_path" gtk_widget_class_path :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Word32 ->                           -- path_length : TBasicType TUInt
    Ptr CString ->                          -- path : TBasicType TUTF8
    Ptr CString ->                          -- path_reversed : TBasicType TUTF8
    IO ()

{-# DEPRECATED widgetClassPath ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetGetPath' instead"] #-}
{- |
Same as 'GI.Gtk.Objects.Widget.widgetPath', but always uses the name of a widget’s type,
never uses a custom name set with 'GI.Gtk.Objects.Widget.widgetSetName'.
-}
widgetClassPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Word32,T.Text,T.Text)
widgetClassPath widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    pathLength <- allocMem :: IO (Ptr Word32)
    path <- allocMem :: IO (Ptr CString)
    pathReversed <- allocMem :: IO (Ptr CString)
    gtk_widget_class_path widget' pathLength path pathReversed
    pathLength' <- peek pathLength
    path' <- peek path
    path'' <- cstringToText path'
    freeMem path'
    pathReversed' <- peek pathReversed
    pathReversed'' <- cstringToText pathReversed'
    freeMem pathReversed'
    touchManagedPtr widget
    freeMem pathLength
    freeMem path
    freeMem pathReversed
    return (pathLength', path'', pathReversed'')

data WidgetClassPathMethodInfo
instance (signature ~ (m (Word32,T.Text,T.Text)), MonadIO m, IsWidget a) => O.MethodInfo WidgetClassPathMethodInfo a signature where
    overloadedMethod _ = widgetClassPath

-- method Widget::compute_expand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orientation", argType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "expand direction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_compute_expand" gtk_widget_compute_expand :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})
    IO CInt

{- |
Computes whether a container should give this widget extra space
when possible. Containers should check this, rather than
looking at 'GI.Gtk.Objects.Widget.widgetGetHexpand' or 'GI.Gtk.Objects.Widget.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.
-}
widgetComputeExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget -}
    -> Gtk.Enums.Orientation
    {- ^ /@orientation@/: expand direction -}
    -> m Bool
    {- ^ __Returns:__ whether widget tree rooted here should be expanded -}
widgetComputeExpand widget orientation = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let orientation' = (fromIntegral . fromEnum) orientation
    result <- gtk_widget_compute_expand widget' orientation'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetComputeExpandMethodInfo
instance (signature ~ (Gtk.Enums.Orientation -> m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetComputeExpandMethodInfo a signature where
    overloadedMethod _ = widgetComputeExpand

-- method Widget::create_pango_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "Context"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_create_pango_context" gtk_widget_create_pango_context :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Pango.Context.Context)

{- |
Creates a new 'GI.Pango.Objects.Context.Context' with the appropriate font map,
font options, font description, and base direction for drawing
text for this widget. See also 'GI.Gtk.Objects.Widget.widgetGetPangoContext'.
-}
widgetCreatePangoContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Pango.Context.Context
    {- ^ __Returns:__ the new 'GI.Pango.Objects.Context.Context' -}
widgetCreatePangoContext widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_create_pango_context widget'
    checkUnexpectedReturnNULL "widgetCreatePangoContext" result
    result' <- (wrapObject Pango.Context.Context) result
    touchManagedPtr widget
    return result'

data WidgetCreatePangoContextMethodInfo
instance (signature ~ (m Pango.Context.Context), MonadIO m, IsWidget a) => O.MethodInfo WidgetCreatePangoContextMethodInfo a signature where
    overloadedMethod _ = widgetCreatePangoContext

-- method Widget::create_pango_layout
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "text to set on the layout (can be %NULL)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "Layout"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_create_pango_layout" gtk_widget_create_pango_layout :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- text : TBasicType TUTF8
    IO (Ptr Pango.Layout.Layout)

{- |
Creates a new 'GI.Pango.Objects.Layout.Layout' with the appropriate font map,
font description, and base direction for drawing text for
this widget.

If you keep a 'GI.Pango.Objects.Layout.Layout' created in this way around, you need
to re-create it when the widget 'GI.Pango.Objects.Context.Context' is replaced.
This can be tracked by using the 'GI.Gtk.Objects.Widget.Widget'::@/screen-changed/@ signal
on the widget.
-}
widgetCreatePangoLayout ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (T.Text)
    {- ^ /@text@/: text to set on the layout (can be 'Nothing') -}
    -> m Pango.Layout.Layout
    {- ^ __Returns:__ the new 'GI.Pango.Objects.Layout.Layout' -}
widgetCreatePangoLayout widget text = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeText <- case text of
        Nothing -> return nullPtr
        Just jText -> do
            jText' <- textToCString jText
            return jText'
    result <- gtk_widget_create_pango_layout widget' maybeText
    checkUnexpectedReturnNULL "widgetCreatePangoLayout" result
    result' <- (wrapObject Pango.Layout.Layout) result
    touchManagedPtr widget
    freeMem maybeText
    return result'

data WidgetCreatePangoLayoutMethodInfo
instance (signature ~ (Maybe (T.Text) -> m Pango.Layout.Layout), MonadIO m, IsWidget a) => O.MethodInfo WidgetCreatePangoLayoutMethodInfo a signature where
    overloadedMethod _ = widgetCreatePangoLayout

-- method Widget::destroy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_destroy" gtk_widget_destroy :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
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 'GI.Gtk.Objects.Widget.Widget'::@/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 'GI.Gtk.Objects.Container.Container', as you\'ll be able to use the
'GI.Gtk.Structs.ContainerClass.ContainerClass'.@/remove/@() virtual function for that.

It\'s important to notice that 'GI.Gtk.Objects.Widget.widgetDestroy' will only cause
the /@widget@/ to be finalized if no additional references, acquired
using 'GI.GObject.Objects.Object.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: 'GI.Gtk.Objects.Container.containerRemove'
-}
widgetDestroy ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetDestroy widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_destroy widget'
    touchManagedPtr widget
    return ()

data WidgetDestroyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDestroyMethodInfo a signature where
    overloadedMethod _ = widgetDestroy

-- method Widget::destroyed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget_pointer", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionInout, mayBeNull = False, argDoc = Documentation {rawDocText = Just "address of a variable that contains @widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_destroyed" gtk_widget_destroyed :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr (Ptr Widget) ->                     -- widget_pointer : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
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 'GI.Gtk.Objects.Widget.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.
-}
widgetDestroyed ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@widgetPointer@/: address of a variable that contains /@widget@/ -}
    -> m (Widget)
widgetDestroyed widget widgetPointer = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    widgetPointer' <- unsafeManagedPtrCastPtr widgetPointer
    widgetPointer'' <- allocMem :: IO (Ptr (Ptr Widget))
    poke widgetPointer'' widgetPointer'
    gtk_widget_destroyed widget' widgetPointer''
    widgetPointer''' <- peek widgetPointer''
    widgetPointer'''' <- (newObject Widget) widgetPointer'''
    touchManagedPtr widget
    touchManagedPtr widgetPointer
    freeMem widgetPointer''
    return widgetPointer''''

data WidgetDestroyedMethodInfo
instance (signature ~ (b -> m (Widget)), MonadIO m, IsWidget a, IsWidget b) => O.MethodInfo WidgetDestroyedMethodInfo a signature where
    overloadedMethod _ = widgetDestroyed

-- method Widget::device_is_shadowed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_device_is_shadowed" gtk_widget_device_is_shadowed :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Device.Device ->                -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CInt

{- |
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
'GI.Gtk.Objects.Widget.Widget'::@/grab-notify/@ signal to check for specific
devices. See 'GI.Gtk.Functions.deviceGrabAdd'.

@since 3.0
-}
widgetDeviceIsShadowed ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Device.IsDevice b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if there is an ongoing grab on /@device@/
         by another 'GI.Gtk.Objects.Widget.Widget' than /@widget@/. -}
widgetDeviceIsShadowed widget device = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    device' <- unsafeManagedPtrCastPtr device
    result <- gtk_widget_device_is_shadowed widget' device'
    let result' = (/= 0) result
    touchManagedPtr widget
    touchManagedPtr device
    return result'

data WidgetDeviceIsShadowedMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsWidget a, Gdk.Device.IsDevice b) => O.MethodInfo WidgetDeviceIsShadowedMethodInfo a signature where
    overloadedMethod _ = widgetDeviceIsShadowed

-- method Widget::drag_begin
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "targets", argType = TInterface (Name {namespace = "Gtk", name = "TargetList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The targets (data formats) in which the\n   source can provide the data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "actions", argType = TInterface (Name {namespace = "Gdk", name = "DragAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A bitmask of the allowed drag actions for this drag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "button", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The button the user clicked to start the drag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The event that triggered the start of the drag,\n   or %NULL if none can be obtained.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "DragContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_begin" gtk_drag_begin :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.TargetList.TargetList ->        -- targets : TInterface (Name {namespace = "Gtk", name = "TargetList"})
    CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
    Int32 ->                                -- button : TBasicType TInt
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO (Ptr Gdk.DragContext.DragContext)

{-# DEPRECATED widgetDragBegin ["(Since version 3.10)","Use 'GI.Gtk.Objects.Widget.widgetDragBeginWithCoordinates' instead"] #-}
{- |
This function is equivalent to 'GI.Gtk.Objects.Widget.widgetDragBeginWithCoordinates',
passing -1, -1 as coordinates.
-}
widgetDragBegin ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the source widget -}
    -> Gtk.TargetList.TargetList
    {- ^ /@targets@/: The targets (data formats) in which the
   source can provide the data -}
    -> [Gdk.Flags.DragAction]
    {- ^ /@actions@/: A bitmask of the allowed drag actions for this drag -}
    -> Int32
    {- ^ /@button@/: The button the user clicked to start the drag -}
    -> Maybe (Gdk.Event.Event)
    {- ^ /@event@/: The event that triggered the start of the drag,
   or 'Nothing' if none can be obtained. -}
    -> m Gdk.DragContext.DragContext
    {- ^ __Returns:__ the context for this drag -}
widgetDragBegin widget targets actions button event = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    targets' <- unsafeManagedPtrGetPtr targets
    let actions' = gflagsToWord actions
    maybeEvent <- case event of
        Nothing -> return nullPtr
        Just jEvent -> do
            jEvent' <- unsafeManagedPtrGetPtr jEvent
            return jEvent'
    result <- gtk_drag_begin widget' targets' actions' button maybeEvent
    checkUnexpectedReturnNULL "widgetDragBegin" result
    result' <- (newObject Gdk.DragContext.DragContext) result
    touchManagedPtr widget
    touchManagedPtr targets
    whenJust event touchManagedPtr
    return result'

data WidgetDragBeginMethodInfo
instance (signature ~ (Gtk.TargetList.TargetList -> [Gdk.Flags.DragAction] -> Int32 -> Maybe (Gdk.Event.Event) -> m Gdk.DragContext.DragContext), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragBeginMethodInfo a signature where
    overloadedMethod _ = widgetDragBegin

-- method Widget::drag_begin_with_coordinates
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the source widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "targets", argType = TInterface (Name {namespace = "Gtk", name = "TargetList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The targets (data formats) in which the\n   source can provide the data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "actions", argType = TInterface (Name {namespace = "Gdk", name = "DragAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A bitmask of the allowed drag actions for this drag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "button", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The button the user clicked to start the drag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The event that triggered the start of the drag,\n   or %NULL if none can be obtained.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The initial x coordinate to start dragging from, in the coordinate space\n   of @widget. If -1 is passed, the coordinates are retrieved from @event or\n   the current pointer position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The initial y coordinate to start dragging from, in the coordinate space\n   of @widget. If -1 is passed, the coordinates are retrieved from @event or\n   the current pointer position", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "DragContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_begin_with_coordinates" gtk_drag_begin_with_coordinates :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.TargetList.TargetList ->        -- targets : TInterface (Name {namespace = "Gtk", name = "TargetList"})
    CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
    Int32 ->                                -- button : TBasicType TInt
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    IO (Ptr Gdk.DragContext.DragContext)

{- |
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
'GI.Gtk.Objects.Widget.widgetDragSourceSet' is used.

The /@event@/ is used to retrieve the timestamp that will be used internally to
grab the pointer.  If /@event@/ is 'Nothing', then 'GI.Gdk.Constants.CURRENT_TIME' will be used.
However, you should try to pass a real event in all cases, since that can be
used to get information about the drag.

Generally there are three cases when you want to start a drag by hand by
calling this function:

1. During a 'GI.Gtk.Objects.Widget.Widget'::@/button-press-event/@ handler, if you want to start a drag
immediately when the user presses the mouse button.  Pass the /@event@/
that you have in your 'GI.Gtk.Objects.Widget.Widget'::@/button-press-event/@ handler.

2. During a 'GI.Gtk.Objects.Widget.Widget'::@/motion-notify-event/@ handler, if you want to start a drag
when the mouse moves past a certain threshold distance after a button-press.
Pass the /@event@/ that you have in your 'GI.Gtk.Objects.Widget.Widget'::@/motion-notify-event/@ handler.

3. During a timeout handler, if you want to start a drag after the mouse
button is held down for some time.  Try to save the last event that you got
from the mouse, using 'GI.Gdk.Unions.Event.eventCopy', and pass it to this function
(remember to free the event with 'GI.Gdk.Unions.Event.eventFree' when you are done).
If you can really not pass a real event, pass @/NULL/@ instead.

@since 3.10
-}
widgetDragBeginWithCoordinates ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the source widget -}
    -> Gtk.TargetList.TargetList
    {- ^ /@targets@/: The targets (data formats) in which the
   source can provide the data -}
    -> [Gdk.Flags.DragAction]
    {- ^ /@actions@/: A bitmask of the allowed drag actions for this drag -}
    -> Int32
    {- ^ /@button@/: The button the user clicked to start the drag -}
    -> Maybe (Gdk.Event.Event)
    {- ^ /@event@/: The event that triggered the start of the drag,
   or 'Nothing' if none can be obtained. -}
    -> Int32
    {- ^ /@x@/: The initial x coordinate to start dragging from, in the coordinate space
   of /@widget@/. If -1 is passed, the coordinates are retrieved from /@event@/ or
   the current pointer position -}
    -> Int32
    {- ^ /@y@/: The initial y coordinate to start dragging from, in the coordinate space
   of /@widget@/. If -1 is passed, the coordinates are retrieved from /@event@/ or
   the current pointer position -}
    -> m Gdk.DragContext.DragContext
    {- ^ __Returns:__ the context for this drag -}
widgetDragBeginWithCoordinates widget targets actions button event x y = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    targets' <- unsafeManagedPtrGetPtr targets
    let actions' = gflagsToWord actions
    maybeEvent <- case event of
        Nothing -> return nullPtr
        Just jEvent -> do
            jEvent' <- unsafeManagedPtrGetPtr jEvent
            return jEvent'
    result <- gtk_drag_begin_with_coordinates widget' targets' actions' button maybeEvent x y
    checkUnexpectedReturnNULL "widgetDragBeginWithCoordinates" result
    result' <- (newObject Gdk.DragContext.DragContext) result
    touchManagedPtr widget
    touchManagedPtr targets
    whenJust event touchManagedPtr
    return result'

data WidgetDragBeginWithCoordinatesMethodInfo
instance (signature ~ (Gtk.TargetList.TargetList -> [Gdk.Flags.DragAction] -> Int32 -> Maybe (Gdk.Event.Event) -> Int32 -> Int32 -> m Gdk.DragContext.DragContext), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragBeginWithCoordinatesMethodInfo a signature where
    overloadedMethod _ = widgetDragBeginWithCoordinates

-- method Widget::drag_check_threshold
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate of start of drag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate of start of drag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "current_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "current X coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "current_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "current Y coordinate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_check_threshold" gtk_drag_check_threshold :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- start_x : TBasicType TInt
    Int32 ->                                -- start_y : TBasicType TInt
    Int32 ->                                -- current_x : TBasicType TInt
    Int32 ->                                -- current_y : TBasicType TInt
    IO CInt

{- |
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.
-}
widgetDragCheckThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.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. -}
widgetDragCheckThreshold widget startX startY currentX currentY = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_drag_check_threshold widget' startX startY currentX currentY
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetDragCheckThresholdMethodInfo
instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragCheckThresholdMethodInfo a signature where
    overloadedMethod _ = widgetDragCheckThreshold

-- method Widget::drag_dest_add_image_targets
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s a drag destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_add_image_targets" gtk_drag_dest_add_image_targets :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Add the image targets supported by 'GI.Gtk.Structs.SelectionData.SelectionData' to
the target list of the drag destination. The targets
are added with /@info@/ = 0. If you need another value,
use 'GI.Gtk.Structs.TargetList.targetListAddImageTargets' and
'GI.Gtk.Objects.Widget.widgetDragDestSetTargetList'.

@since 2.6
-}
widgetDragDestAddImageTargets ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s a drag destination -}
    -> m ()
widgetDragDestAddImageTargets widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_dest_add_image_targets widget'
    touchManagedPtr widget
    return ()

data WidgetDragDestAddImageTargetsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragDestAddImageTargetsMethodInfo a signature where
    overloadedMethod _ = widgetDragDestAddImageTargets

-- method Widget::drag_dest_add_text_targets
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s a drag destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_add_text_targets" gtk_drag_dest_add_text_targets :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Add the text targets supported by 'GI.Gtk.Structs.SelectionData.SelectionData' to
the target list of the drag destination. The targets
are added with /@info@/ = 0. If you need another value,
use 'GI.Gtk.Structs.TargetList.targetListAddTextTargets' and
'GI.Gtk.Objects.Widget.widgetDragDestSetTargetList'.

@since 2.6
-}
widgetDragDestAddTextTargets ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s a drag destination -}
    -> m ()
widgetDragDestAddTextTargets widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_dest_add_text_targets widget'
    touchManagedPtr widget
    return ()

data WidgetDragDestAddTextTargetsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragDestAddTextTargetsMethodInfo a signature where
    overloadedMethod _ = widgetDragDestAddTextTargets

-- method Widget::drag_dest_add_uri_targets
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s a drag destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_add_uri_targets" gtk_drag_dest_add_uri_targets :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Add the URI targets supported by 'GI.Gtk.Structs.SelectionData.SelectionData' to
the target list of the drag destination. The targets
are added with /@info@/ = 0. If you need another value,
use 'GI.Gtk.Structs.TargetList.targetListAddUriTargets' and
'GI.Gtk.Objects.Widget.widgetDragDestSetTargetList'.

@since 2.6
-}
widgetDragDestAddUriTargets ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s a drag destination -}
    -> m ()
widgetDragDestAddUriTargets widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_dest_add_uri_targets widget'
    touchManagedPtr widget
    return ()

data WidgetDragDestAddUriTargetsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragDestAddUriTargetsMethodInfo a signature where
    overloadedMethod _ = widgetDragDestAddUriTargets

-- method Widget::drag_dest_find_target
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "drag destination widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "Gdk", name = "DragContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "drag context", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_list", argType = TInterface (Name {namespace = "Gtk", name = "TargetList"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "list of droppable targets, or %NULL to use\n   gtk_drag_dest_get_target_list (@widget).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Atom"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_find_target" gtk_drag_dest_find_target :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.DragContext.DragContext ->      -- context : TInterface (Name {namespace = "Gdk", name = "DragContext"})
    Ptr Gtk.TargetList.TargetList ->        -- target_list : TInterface (Name {namespace = "Gtk", name = "TargetList"})
    IO (Ptr Gdk.Atom.Atom)

{- |
Looks for a match between the supported targets of /@context@/ and the
/@destTargetList@/, returning the first matching target, otherwise
returning @/GDK_NONE/@. /@destTargetList@/ should usually be the return
value from 'GI.Gtk.Objects.Widget.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.
-}
widgetDragDestFindTarget ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.DragContext.IsDragContext b) =>
    a
    {- ^ /@widget@/: drag destination widget -}
    -> b
    {- ^ /@context@/: drag context -}
    -> Maybe (Gtk.TargetList.TargetList)
    {- ^ /@targetList@/: list of droppable targets, or 'Nothing' to use
   gtk_drag_dest_get_target_list (/@widget@/). -}
    -> m Gdk.Atom.Atom
    {- ^ __Returns:__ first target that the source offers
    and the dest can accept, or @/GDK_NONE/@ -}
widgetDragDestFindTarget widget context targetList = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    context' <- unsafeManagedPtrCastPtr context
    maybeTargetList <- case targetList of
        Nothing -> return nullPtr
        Just jTargetList -> do
            jTargetList' <- unsafeManagedPtrGetPtr jTargetList
            return jTargetList'
    result <- gtk_drag_dest_find_target widget' context' maybeTargetList
    checkUnexpectedReturnNULL "widgetDragDestFindTarget" result
    result' <- (newPtr Gdk.Atom.Atom) result
    touchManagedPtr widget
    touchManagedPtr context
    whenJust targetList touchManagedPtr
    return result'

data WidgetDragDestFindTargetMethodInfo
instance (signature ~ (b -> Maybe (Gtk.TargetList.TargetList) -> m Gdk.Atom.Atom), MonadIO m, IsWidget a, Gdk.DragContext.IsDragContext b) => O.MethodInfo WidgetDragDestFindTargetMethodInfo a signature where
    overloadedMethod _ = widgetDragDestFindTarget

-- method Widget::drag_dest_get_target_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TargetList"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_get_target_list" gtk_drag_dest_get_target_list :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.TargetList.TargetList)

{- |
Returns the list of targets this widget can accept from
drag-and-drop.
-}
widgetDragDestGetTargetList ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Maybe Gtk.TargetList.TargetList)
    {- ^ __Returns:__ the 'GI.Gtk.Structs.TargetList.TargetList', or 'Nothing' if none -}
widgetDragDestGetTargetList widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_drag_dest_get_target_list widget'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed Gtk.TargetList.TargetList) result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetDragDestGetTargetListMethodInfo
instance (signature ~ (m (Maybe Gtk.TargetList.TargetList)), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragDestGetTargetListMethodInfo a signature where
    overloadedMethod _ = widgetDragDestGetTargetList

-- method Widget::drag_dest_get_track_motion
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s a drag destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_get_track_motion" gtk_drag_dest_get_track_motion :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Returns whether the widget has been configured to always
emit 'GI.Gtk.Objects.Widget.Widget'::@/drag-motion/@ signals.

@since 2.10
-}
widgetDragDestGetTrackMotion ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s a drag destination -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget always emits
  'GI.Gtk.Objects.Widget.Widget'::@/drag-motion/@ events -}
widgetDragDestGetTrackMotion widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_drag_dest_get_track_motion widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetDragDestGetTrackMotionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragDestGetTrackMotionMethodInfo a signature where
    overloadedMethod _ = widgetDragDestGetTrackMotion

-- method Widget::drag_dest_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "DestDefaults"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "which types of default drag behavior to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "targets", argType = TCArray False (-1) 3 (TInterface (Name {namespace = "Gtk", name = "TargetEntry"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a pointer to an array of\n    #GtkTargetEntrys indicating the drop types that this @widget will\n    accept, or %NULL. Later you can access the list with\n    gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of entries in @targets", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "actions", argType = TInterface (Name {namespace = "Gdk", name = "DragAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask of possible actions for a drop onto this @widget.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of entries in @targets", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_set" gtk_drag_dest_set :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "DestDefaults"})
    Ptr Gtk.TargetEntry.TargetEntry ->      -- targets : TCArray False (-1) 3 (TInterface (Name {namespace = "Gtk", name = "TargetEntry"}))
    Int32 ->                                -- n_targets : TBasicType TInt
    CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
    IO ()

{- |
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
('GI.Gtk.Objects.Widget.Widget'::@/drag-motion/@, 'GI.Gtk.Objects.Widget.Widget'::@/drag-drop/@, ...). They all exist
for convenience. When passing @/GTK_DEST_DEFAULT_ALL/@ for instance it is
sufficient to connect to the widget’s 'GI.Gtk.Objects.Widget.Widget'::@/drag-data-received/@
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 'GI.Gtk.Objects.Widget.Widget'::@/drag-motion/@. 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 'GI.Gdk.Functions.dragStatus' in the context of 'GI.Gtk.Objects.Widget.Widget'::@/drag-motion/@,
and invokations of 'GI.Gtk.Functions.dragFinish' in 'GI.Gtk.Objects.Widget.Widget'::@/drag-data-received/@.
Especially the later is dramatic, when your own 'GI.Gtk.Objects.Widget.Widget'::@/drag-motion/@
handler calls 'GI.Gtk.Objects.Widget.widgetDragGetData' to inspect the dragged data.

There’s no way to set a default action here, you can use the
'GI.Gtk.Objects.Widget.Widget'::@/drag-motion/@ 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,
>             GdkDragContext *context,
>             gint x,
>             gint y,
>             guint time)
>{
>  GdkModifierType mask;
>
>  gdk_window_get_pointer (gtk_widget_get_window (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);
>}
-}
widgetDragDestSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> [Gtk.Flags.DestDefaults]
    {- ^ /@flags@/: which types of default drag behavior to use -}
    -> Maybe ([Gtk.TargetEntry.TargetEntry])
    {- ^ /@targets@/: a pointer to an array of
    @/GtkTargetEntrys/@ indicating the drop types that this /@widget@/ will
    accept, or 'Nothing'. Later you can access the list with
    'GI.Gtk.Objects.Widget.widgetDragDestGetTargetList' and 'GI.Gtk.Objects.Widget.widgetDragDestFindTarget'. -}
    -> [Gdk.Flags.DragAction]
    {- ^ /@actions@/: a bitmask of possible actions for a drop onto this /@widget@/. -}
    -> m ()
widgetDragDestSet widget flags targets actions = liftIO $ do
    let nTargets = case targets of
            Nothing -> 0
            Just jTargets -> fromIntegral $ length jTargets
    widget' <- unsafeManagedPtrCastPtr widget
    let flags' = gflagsToWord flags
    maybeTargets <- case targets of
        Nothing -> return nullPtr
        Just jTargets -> do
            jTargets' <- mapM unsafeManagedPtrGetPtr jTargets
            jTargets'' <- packBlockArray 16 jTargets'
            return jTargets''
    let actions' = gflagsToWord actions
    gtk_drag_dest_set widget' flags' maybeTargets nTargets actions'
    touchManagedPtr widget
    whenJust targets (mapM_ touchManagedPtr)
    freeMem maybeTargets
    return ()

data WidgetDragDestSetMethodInfo
instance (signature ~ ([Gtk.Flags.DestDefaults] -> Maybe ([Gtk.TargetEntry.TargetEntry]) -> [Gdk.Flags.DragAction] -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragDestSetMethodInfo a signature where
    overloadedMethod _ = widgetDragDestSet

-- method Widget::drag_dest_set_proxy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proxy_window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the window to which to forward drag events", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TInterface (Name {namespace = "Gdk", name = "DragProtocol"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the drag protocol which the @proxy_window accepts\n  (You can use gdk_drag_get_protocol() to determine this)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use_coordinates", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "If %TRUE, send the same coordinates to the\n  destination, because it is an embedded\n  subwindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_set_proxy" gtk_drag_dest_set_proxy :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Window.Window ->                -- proxy_window : TInterface (Name {namespace = "Gdk", name = "Window"})
    CUInt ->                                -- protocol : TInterface (Name {namespace = "Gdk", name = "DragProtocol"})
    CInt ->                                 -- use_coordinates : TBasicType TBoolean
    IO ()

{-# DEPRECATED widgetDragDestSetProxy ["(Since version 3.22)"] #-}
{- |
Sets this widget as a proxy for drops to another window.
-}
widgetDragDestSetProxy ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Window.IsWindow b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@proxyWindow@/: the window to which to forward drag events -}
    -> Gdk.Enums.DragProtocol
    {- ^ /@protocol@/: the drag protocol which the /@proxyWindow@/ accepts
  (You can use @/gdk_drag_get_protocol()/@ to determine this) -}
    -> Bool
    {- ^ /@useCoordinates@/: If 'True', send the same coordinates to the
  destination, because it is an embedded
  subwindow. -}
    -> m ()
widgetDragDestSetProxy widget proxyWindow protocol useCoordinates = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    proxyWindow' <- unsafeManagedPtrCastPtr proxyWindow
    let protocol' = (fromIntegral . fromEnum) protocol
    let useCoordinates' = (fromIntegral . fromEnum) useCoordinates
    gtk_drag_dest_set_proxy widget' proxyWindow' protocol' useCoordinates'
    touchManagedPtr widget
    touchManagedPtr proxyWindow
    return ()

data WidgetDragDestSetProxyMethodInfo
instance (signature ~ (b -> Gdk.Enums.DragProtocol -> Bool -> m ()), MonadIO m, IsWidget a, Gdk.Window.IsWindow b) => O.MethodInfo WidgetDragDestSetProxyMethodInfo a signature where
    overloadedMethod _ = widgetDragDestSetProxy

-- method Widget::drag_dest_set_target_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s a drag destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_list", argType = TInterface (Name {namespace = "Gtk", name = "TargetList"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "list of droppable targets, or %NULL for none", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_set_target_list" gtk_drag_dest_set_target_list :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.TargetList.TargetList ->        -- target_list : TInterface (Name {namespace = "Gtk", name = "TargetList"})
    IO ()

{- |
Sets the target types that this widget can accept from drag-and-drop.
The widget must first be made into a drag destination with
'GI.Gtk.Objects.Widget.widgetDragDestSet'.
-}
widgetDragDestSetTargetList ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s a drag destination -}
    -> Maybe (Gtk.TargetList.TargetList)
    {- ^ /@targetList@/: list of droppable targets, or 'Nothing' for none -}
    -> m ()
widgetDragDestSetTargetList widget targetList = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeTargetList <- case targetList of
        Nothing -> return nullPtr
        Just jTargetList -> do
            jTargetList' <- unsafeManagedPtrGetPtr jTargetList
            return jTargetList'
    gtk_drag_dest_set_target_list widget' maybeTargetList
    touchManagedPtr widget
    whenJust targetList touchManagedPtr
    return ()

data WidgetDragDestSetTargetListMethodInfo
instance (signature ~ (Maybe (Gtk.TargetList.TargetList) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragDestSetTargetListMethodInfo a signature where
    overloadedMethod _ = widgetDragDestSetTargetList

-- method Widget::drag_dest_set_track_motion
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s a drag destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "track_motion", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to accept all targets", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_set_track_motion" gtk_drag_dest_set_track_motion :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- track_motion : TBasicType TBoolean
    IO ()

{- |
Tells the widget to emit 'GI.Gtk.Objects.Widget.Widget'::@/drag-motion/@ and
'GI.Gtk.Objects.Widget.Widget'::@/drag-leave/@ events regardless of the targets and the
'GI.Gtk.Flags.DestDefaultsMotion' flag.

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

@since 2.10
-}
widgetDragDestSetTrackMotion ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s a drag destination -}
    -> Bool
    {- ^ /@trackMotion@/: whether to accept all targets -}
    -> m ()
widgetDragDestSetTrackMotion widget trackMotion = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let trackMotion' = (fromIntegral . fromEnum) trackMotion
    gtk_drag_dest_set_track_motion widget' trackMotion'
    touchManagedPtr widget
    return ()

data WidgetDragDestSetTrackMotionMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragDestSetTrackMotionMethodInfo a signature where
    overloadedMethod _ = widgetDragDestSetTrackMotion

-- method Widget::drag_dest_unset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_dest_unset" gtk_drag_dest_unset :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Clears information about a drop destination set with
'GI.Gtk.Objects.Widget.widgetDragDestSet'. The widget will no longer receive
notification of drags.
-}
widgetDragDestUnset ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetDragDestUnset widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_dest_unset widget'
    touchManagedPtr widget
    return ()

data WidgetDragDestUnsetMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragDestUnsetMethodInfo a signature where
    overloadedMethod _ = widgetDragDestUnset

-- method Widget::drag_get_data
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget that will receive the\n  #GtkWidget::drag-data-received signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface (Name {namespace = "Gdk", name = "DragContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the drag context", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the target (form of the data) to retrieve", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time_", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a timestamp for retrieving the data. This will\n  generally be the time received in a #GtkWidget::drag-motion\n  or #GtkWidget::drag-drop signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_get_data" gtk_drag_get_data :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.DragContext.DragContext ->      -- context : TInterface (Name {namespace = "Gdk", name = "DragContext"})
    Ptr Gdk.Atom.Atom ->                    -- target : TInterface (Name {namespace = "Gdk", name = "Atom"})
    Word32 ->                               -- time_ : TBasicType TUInt32
    IO ()

{- |
Gets the data associated with a drag. When the data
is received or the retrieval fails, GTK+ will emit a
'GI.Gtk.Objects.Widget.Widget'::@/drag-data-received/@ signal. Failure of the retrieval
is indicated by the length field of the /@selectionData@/
signal parameter being negative. However, when 'GI.Gtk.Objects.Widget.widgetDragGetData'
is called implicitely because the 'GI.Gtk.Flags.DestDefaultsDrop' was set,
then the widget will not receive notification of failed
drops.
-}
widgetDragGetData ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.DragContext.IsDragContext b) =>
    a
    {- ^ /@widget@/: the widget that will receive the
  'GI.Gtk.Objects.Widget.Widget'::@/drag-data-received/@ signal -}
    -> b
    {- ^ /@context@/: the drag context -}
    -> Gdk.Atom.Atom
    {- ^ /@target@/: the target (form of the data) to retrieve -}
    -> Word32
    {- ^ /@time_@/: a timestamp for retrieving the data. This will
  generally be the time received in a 'GI.Gtk.Objects.Widget.Widget'::@/drag-motion/@
  or 'GI.Gtk.Objects.Widget.Widget'::@/drag-drop/@ signal -}
    -> m ()
widgetDragGetData widget context target time_ = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    context' <- unsafeManagedPtrCastPtr context
    target' <- unsafeManagedPtrGetPtr target
    gtk_drag_get_data widget' context' target' time_
    touchManagedPtr widget
    touchManagedPtr context
    touchManagedPtr target
    return ()

data WidgetDragGetDataMethodInfo
instance (signature ~ (b -> Gdk.Atom.Atom -> Word32 -> m ()), MonadIO m, IsWidget a, Gdk.DragContext.IsDragContext b) => O.MethodInfo WidgetDragGetDataMethodInfo a signature where
    overloadedMethod _ = widgetDragGetData

-- method Widget::drag_highlight
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a widget to highlight", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_highlight" gtk_drag_highlight :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Highlights a widget as a currently hovered drop target.
To end the highlight, call 'GI.Gtk.Objects.Widget.widgetDragUnhighlight'.
GTK+ calls this automatically if 'GI.Gtk.Flags.DestDefaultsHighlight' is set.
-}
widgetDragHighlight ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a widget to highlight -}
    -> m ()
widgetDragHighlight widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_highlight widget'
    touchManagedPtr widget
    return ()

data WidgetDragHighlightMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragHighlightMethodInfo a signature where
    overloadedMethod _ = widgetDragHighlight

-- method Widget::drag_source_add_image_targets
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s is a drag source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_add_image_targets" gtk_drag_source_add_image_targets :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Add the writable image targets supported by 'GI.Gtk.Structs.SelectionData.SelectionData' to
the target list of the drag source. The targets
are added with /@info@/ = 0. If you need another value,
use 'GI.Gtk.Structs.TargetList.targetListAddImageTargets' and
'GI.Gtk.Objects.Widget.widgetDragSourceSetTargetList'.

@since 2.6
-}
widgetDragSourceAddImageTargets ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s is a drag source -}
    -> m ()
widgetDragSourceAddImageTargets widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_source_add_image_targets widget'
    touchManagedPtr widget
    return ()

data WidgetDragSourceAddImageTargetsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragSourceAddImageTargetsMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceAddImageTargets

-- method Widget::drag_source_add_text_targets
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s is a drag source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_add_text_targets" gtk_drag_source_add_text_targets :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Add the text targets supported by 'GI.Gtk.Structs.SelectionData.SelectionData' to
the target list of the drag source.  The targets
are added with /@info@/ = 0. If you need another value,
use 'GI.Gtk.Structs.TargetList.targetListAddTextTargets' and
'GI.Gtk.Objects.Widget.widgetDragSourceSetTargetList'.

@since 2.6
-}
widgetDragSourceAddTextTargets ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s is a drag source -}
    -> m ()
widgetDragSourceAddTextTargets widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_source_add_text_targets widget'
    touchManagedPtr widget
    return ()

data WidgetDragSourceAddTextTargetsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragSourceAddTextTargetsMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceAddTextTargets

-- method Widget::drag_source_add_uri_targets
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s is a drag source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_add_uri_targets" gtk_drag_source_add_uri_targets :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Add the URI targets supported by 'GI.Gtk.Structs.SelectionData.SelectionData' to
the target list of the drag source.  The targets
are added with /@info@/ = 0. If you need another value,
use 'GI.Gtk.Structs.TargetList.targetListAddUriTargets' and
'GI.Gtk.Objects.Widget.widgetDragSourceSetTargetList'.

@since 2.6
-}
widgetDragSourceAddUriTargets ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s is a drag source -}
    -> m ()
widgetDragSourceAddUriTargets widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_source_add_uri_targets widget'
    touchManagedPtr widget
    return ()

data WidgetDragSourceAddUriTargetsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragSourceAddUriTargetsMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceAddUriTargets

-- method Widget::drag_source_get_target_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TargetList"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_get_target_list" gtk_drag_source_get_target_list :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.TargetList.TargetList)

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

@since 2.4
-}
widgetDragSourceGetTargetList ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Maybe Gtk.TargetList.TargetList)
    {- ^ __Returns:__ the 'GI.Gtk.Structs.TargetList.TargetList', or 'Nothing' if none -}
widgetDragSourceGetTargetList widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_drag_source_get_target_list widget'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed Gtk.TargetList.TargetList) result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetDragSourceGetTargetListMethodInfo
instance (signature ~ (m (Maybe Gtk.TargetList.TargetList)), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragSourceGetTargetListMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceGetTargetList

-- method Widget::drag_source_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_button_mask", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the bitmask of buttons that can start the drag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "targets", argType = TCArray False (-1) 3 (TInterface (Name {namespace = "Gtk", name = "TargetEntry"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the table of targets\n    that the drag will support, may be %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items in @targets", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "actions", argType = TInterface (Name {namespace = "Gdk", name = "DragAction"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the bitmask of possible actions for a drag from this widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "n_targets", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of items in @targets", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_set" gtk_drag_source_set :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- start_button_mask : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    Ptr Gtk.TargetEntry.TargetEntry ->      -- targets : TCArray False (-1) 3 (TInterface (Name {namespace = "Gtk", name = "TargetEntry"}))
    Int32 ->                                -- n_targets : TBasicType TInt
    CUInt ->                                -- actions : TInterface (Name {namespace = "Gdk", name = "DragAction"})
    IO ()

{- |
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.
-}
widgetDragSourceSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> [Gdk.Flags.ModifierType]
    {- ^ /@startButtonMask@/: the bitmask of buttons that can start the drag -}
    -> Maybe ([Gtk.TargetEntry.TargetEntry])
    {- ^ /@targets@/: the table of targets
    that the drag will support, may be 'Nothing' -}
    -> [Gdk.Flags.DragAction]
    {- ^ /@actions@/: the bitmask of possible actions for a drag from this widget -}
    -> m ()
widgetDragSourceSet widget startButtonMask targets actions = liftIO $ do
    let nTargets = case targets of
            Nothing -> 0
            Just jTargets -> fromIntegral $ length jTargets
    widget' <- unsafeManagedPtrCastPtr widget
    let startButtonMask' = gflagsToWord startButtonMask
    maybeTargets <- case targets of
        Nothing -> return nullPtr
        Just jTargets -> do
            jTargets' <- mapM unsafeManagedPtrGetPtr jTargets
            jTargets'' <- packBlockArray 16 jTargets'
            return jTargets''
    let actions' = gflagsToWord actions
    gtk_drag_source_set widget' startButtonMask' maybeTargets nTargets actions'
    touchManagedPtr widget
    whenJust targets (mapM_ touchManagedPtr)
    freeMem maybeTargets
    return ()

data WidgetDragSourceSetMethodInfo
instance (signature ~ ([Gdk.Flags.ModifierType] -> Maybe ([Gtk.TargetEntry.TargetEntry]) -> [Gdk.Flags.DragAction] -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragSourceSetMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceSet

-- method Widget::drag_source_set_icon_gicon
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon", argType = TInterface (Name {namespace = "Gio", name = "Icon"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIcon", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_set_icon_gicon" gtk_drag_source_set_icon_gicon :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gio.Icon.Icon ->                    -- icon : TInterface (Name {namespace = "Gio", name = "Icon"})
    IO ()

{- |
Sets the icon that will be used for drags from a particular source
to /@icon@/. See the docs for 'GI.Gtk.Objects.IconTheme.IconTheme' for more details.

@since 3.2
-}
widgetDragSourceSetIconGicon ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gio.Icon.IsIcon b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@icon@/: A 'GI.Gio.Interfaces.Icon.Icon' -}
    -> m ()
widgetDragSourceSetIconGicon widget icon = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    icon' <- unsafeManagedPtrCastPtr icon
    gtk_drag_source_set_icon_gicon widget' icon'
    touchManagedPtr widget
    touchManagedPtr icon
    return ()

data WidgetDragSourceSetIconGiconMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, Gio.Icon.IsIcon b) => O.MethodInfo WidgetDragSourceSetIconGiconMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceSetIconGicon

-- method Widget::drag_source_set_icon_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of icon to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_set_icon_name" gtk_drag_source_set_icon_name :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- icon_name : TBasicType TUTF8
    IO ()

{- |
Sets the icon that will be used for drags from a particular source
to a themed icon. See the docs for 'GI.Gtk.Objects.IconTheme.IconTheme' for more details.

@since 2.8
-}
widgetDragSourceSetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@iconName@/: name of icon to use -}
    -> m ()
widgetDragSourceSetIconName widget iconName = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    iconName' <- textToCString iconName
    gtk_drag_source_set_icon_name widget' iconName'
    touchManagedPtr widget
    freeMem iconName'
    return ()

data WidgetDragSourceSetIconNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragSourceSetIconNameMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceSetIconName

-- method Widget::drag_source_set_icon_pixbuf
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkPixbuf for the drag icon", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_set_icon_pixbuf" gtk_drag_source_set_icon_pixbuf :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr GdkPixbuf.Pixbuf.Pixbuf ->          -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})
    IO ()

{- |
Sets the icon that will be used for drags from a particular widget
from a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'. GTK+ retains a reference for /@pixbuf@/ and will
release it when it is no longer needed.
-}
widgetDragSourceSetIconPixbuf ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, GdkPixbuf.Pixbuf.IsPixbuf b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@pixbuf@/: the 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' for the drag icon -}
    -> m ()
widgetDragSourceSetIconPixbuf widget pixbuf = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    pixbuf' <- unsafeManagedPtrCastPtr pixbuf
    gtk_drag_source_set_icon_pixbuf widget' pixbuf'
    touchManagedPtr widget
    touchManagedPtr pixbuf
    return ()

data WidgetDragSourceSetIconPixbufMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, GdkPixbuf.Pixbuf.IsPixbuf b) => O.MethodInfo WidgetDragSourceSetIconPixbufMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceSetIconPixbuf

-- method Widget::drag_source_set_icon_stock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the ID of the stock icon to use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_set_icon_stock" gtk_drag_source_set_icon_stock :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- stock_id : TBasicType TUTF8
    IO ()

{-# DEPRECATED widgetDragSourceSetIconStock ["(Since version 3.10)","Use 'GI.Gtk.Objects.Widget.widgetDragSourceSetIconName' instead."] #-}
{- |
Sets the icon that will be used for drags from a particular source
to a stock icon.
-}
widgetDragSourceSetIconStock ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@stockId@/: the ID of the stock icon to use -}
    -> m ()
widgetDragSourceSetIconStock widget stockId = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    stockId' <- textToCString stockId
    gtk_drag_source_set_icon_stock widget' stockId'
    touchManagedPtr widget
    freeMem stockId'
    return ()

data WidgetDragSourceSetIconStockMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragSourceSetIconStockMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceSetIconStock

-- method Widget::drag_source_set_target_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that\8217s a drag source", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_list", argType = TInterface (Name {namespace = "Gtk", name = "TargetList"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "list of draggable targets, or %NULL for none", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_set_target_list" gtk_drag_source_set_target_list :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.TargetList.TargetList ->        -- target_list : TInterface (Name {namespace = "Gtk", name = "TargetList"})
    IO ()

{- |
Changes the target types that this widget offers for drag-and-drop.
The widget must first be made into a drag source with
'GI.Gtk.Objects.Widget.widgetDragSourceSet'.

@since 2.4
-}
widgetDragSourceSetTargetList ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' that’s a drag source -}
    -> Maybe (Gtk.TargetList.TargetList)
    {- ^ /@targetList@/: list of draggable targets, or 'Nothing' for none -}
    -> m ()
widgetDragSourceSetTargetList widget targetList = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeTargetList <- case targetList of
        Nothing -> return nullPtr
        Just jTargetList -> do
            jTargetList' <- unsafeManagedPtrGetPtr jTargetList
            return jTargetList'
    gtk_drag_source_set_target_list widget' maybeTargetList
    touchManagedPtr widget
    whenJust targetList touchManagedPtr
    return ()

data WidgetDragSourceSetTargetListMethodInfo
instance (signature ~ (Maybe (Gtk.TargetList.TargetList) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragSourceSetTargetListMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceSetTargetList

-- method Widget::drag_source_unset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_source_unset" gtk_drag_source_unset :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Undoes the effects of 'GI.Gtk.Objects.Widget.widgetDragSourceSet'.
-}
widgetDragSourceUnset ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetDragSourceUnset widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_source_unset widget'
    touchManagedPtr widget
    return ()

data WidgetDragSourceUnsetMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragSourceUnsetMethodInfo a signature where
    overloadedMethod _ = widgetDragSourceUnset

-- method Widget::drag_unhighlight
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a widget to remove the highlight from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_drag_unhighlight" gtk_drag_unhighlight :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Removes a highlight set by 'GI.Gtk.Objects.Widget.widgetDragHighlight' from
a widget.
-}
widgetDragUnhighlight ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a widget to remove the highlight from -}
    -> m ()
widgetDragUnhighlight widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_drag_unhighlight widget'
    touchManagedPtr widget
    return ()

data WidgetDragUnhighlightMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDragUnhighlightMethodInfo a signature where
    overloadedMethod _ = widgetDragUnhighlight

-- method Widget::draw
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget to draw. It must be drawable (see\n  gtk_widget_is_drawable()) and a size must have been allocated.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cr", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a cairo context to draw to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_draw" gtk_widget_draw :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Cairo.Context.Context ->            -- cr : TInterface (Name {namespace = "cairo", name = "Context"})
    IO ()

{- |
Draws /@widget@/ to /@cr@/. The top left corner of the widget will be
drawn to the currently set origin point of /@cr@/.

You should pass a cairo context as /@cr@/ argument that is in an
original state. Otherwise the resulting drawing is undefined. For
example changing the operator using @/cairo_set_operator()/@ or the
line width using @/cairo_set_line_width()/@ might have unwanted side
effects.
You may however change the context’s transform matrix - like with
@/cairo_scale()/@, @/cairo_translate()/@ or @/cairo_set_matrix()/@ and clip
region with @/cairo_clip()/@ prior to calling this function. Also, it
is fine to modify the context with @/cairo_save()/@ and
@/cairo_push_group()/@ prior to calling this function.

Note that special-purpose widgets may contain special code for
rendering to the screen and might appear differently on screen
and when rendered using 'GI.Gtk.Objects.Widget.widgetDraw'.

@since 3.0
-}
widgetDraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget to draw. It must be drawable (see
  'GI.Gtk.Objects.Widget.widgetIsDrawable') and a size must have been allocated. -}
    -> Cairo.Context.Context
    {- ^ /@cr@/: a cairo context to draw to -}
    -> m ()
widgetDraw widget cr = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    cr' <- unsafeManagedPtrGetPtr cr
    gtk_widget_draw widget' cr'
    touchManagedPtr widget
    touchManagedPtr cr
    return ()

data WidgetDrawMethodInfo
instance (signature ~ (Cairo.Context.Context -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetDrawMethodInfo a signature where
    overloadedMethod _ = widgetDraw

-- method Widget::ensure_style
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_ensure_style" gtk_widget_ensure_style :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{-# DEPRECATED widgetEnsureStyle ["(Since version 3.0)","Use 'GI.Gtk.Objects.StyleContext.StyleContext' instead"] #-}
{- |
Ensures that /@widget@/ has a style (/@widget@/->style).

Not a very useful function; most of the time, if you
want the style, the widget is realized, and realized
widgets are guaranteed to have a style already.
-}
widgetEnsureStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetEnsureStyle widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_ensure_style widget'
    touchManagedPtr widget
    return ()

data WidgetEnsureStyleMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetEnsureStyleMethodInfo a signature where
    overloadedMethod _ = widgetEnsureStyle

-- method Widget::error_bell
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_error_bell" gtk_widget_error_bell :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Notifies the user about an input-related error on this widget.
If the 'GI.Gtk.Objects.Settings.Settings':@/gtk-error-bell/@ setting is 'True', it calls
'GI.Gdk.Objects.Window.windowBeep', otherwise it does nothing.

Note that the effect of 'GI.Gdk.Objects.Window.windowBeep' can be configured in many
ways, depending on the windowing backend and the desktop environment
or window manager that is used.

@since 2.12
-}
widgetErrorBell ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetErrorBell widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_error_bell widget'
    touchManagedPtr widget
    return ()

data WidgetErrorBellMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetErrorBellMethodInfo a signature where
    overloadedMethod _ = widgetErrorBell

-- method Widget::event
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_event" gtk_widget_event :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO CInt

{- |
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 'GI.Gtk.Functions.mainDoEvent' so the event will behave as if
it were in the event queue. Don’t synthesize expose events; instead,
use 'GI.Gdk.Objects.Window.windowInvalidateRect' to invalidate a region of the
window.
-}
widgetEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event' -}
    -> m Bool
    {- ^ __Returns:__ return from the event signal emission ('True' if
              the event was handled) -}
widgetEvent widget event = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    event' <- unsafeManagedPtrGetPtr event
    result <- gtk_widget_event widget' event'
    let result' = (/= 0) result
    touchManagedPtr widget
    touchManagedPtr event
    return result'

data WidgetEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetEventMethodInfo a signature where
    overloadedMethod _ = widgetEvent

-- method Widget::freeze_child_notify
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_freeze_child_notify" gtk_widget_freeze_child_notify :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Stops emission of 'GI.Gtk.Objects.Widget.Widget'::@/child-notify/@ signals on /@widget@/. The
signals are queued until 'GI.Gtk.Objects.Widget.widgetThawChildNotify' is called
on /@widget@/.

This is the analogue of 'GI.GObject.Objects.Object.objectFreezeNotify' for child properties.
-}
widgetFreezeChildNotify ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetFreezeChildNotify widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_freeze_child_notify widget'
    touchManagedPtr widget
    return ()

data WidgetFreezeChildNotifyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetFreezeChildNotifyMethodInfo a signature where
    overloadedMethod _ = widgetFreezeChildNotify

-- method Widget::get_accessible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Atk", name = "Object"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_accessible" gtk_widget_get_accessible :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Atk.Object.Object)

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

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

The documentation of the
<http://developer.gnome.org/atk/stable/ ATK>
library contains more information about accessible objects and their uses.
-}
widgetGetAccessible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Atk.Object.Object
    {- ^ __Returns:__ the 'GI.Atk.Objects.Object.Object' associated with /@widget@/ -}
widgetGetAccessible widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_accessible widget'
    checkUnexpectedReturnNULL "widgetGetAccessible" result
    result' <- (newObject Atk.Object.Object) result
    touchManagedPtr widget
    return result'

data WidgetGetAccessibleMethodInfo
instance (signature ~ (m Atk.Object.Object), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetAccessibleMethodInfo a signature where
    overloadedMethod _ = widgetGetAccessible

-- method Widget::get_action_group
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "prefix", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The \8220prefix\8221 of the action group.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "ActionGroup"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_action_group" gtk_widget_get_action_group :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- prefix : TBasicType TUTF8
    IO (Ptr Gio.ActionGroup.ActionGroup)

{- |
Retrieves the 'GI.Gio.Interfaces.ActionGroup.ActionGroup' that was registered using /@prefix@/. The resulting
'GI.Gio.Interfaces.ActionGroup.ActionGroup' may have been registered to /@widget@/ or any 'GI.Gtk.Objects.Widget.Widget' in its
ancestry.

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

@since 3.16
-}
widgetGetActionGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: A 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@prefix@/: The “prefix” of the action group. -}
    -> m (Maybe Gio.ActionGroup.ActionGroup)
    {- ^ __Returns:__ A 'GI.Gio.Interfaces.ActionGroup.ActionGroup' or 'Nothing'. -}
widgetGetActionGroup widget prefix = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    prefix' <- textToCString prefix
    result <- gtk_widget_get_action_group widget' prefix'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gio.ActionGroup.ActionGroup) result'
        return result''
    touchManagedPtr widget
    freeMem prefix'
    return maybeResult

data WidgetGetActionGroupMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gio.ActionGroup.ActionGroup)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetActionGroupMethodInfo a signature where
    overloadedMethod _ = widgetGetActionGroup

-- method Widget::get_allocated_baseline
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_allocated_baseline" gtk_widget_get_allocated_baseline :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
Returns the baseline that has currently been allocated to /@widget@/.
This function is intended to be used when implementing handlers
for the 'GI.Gtk.Objects.Widget.Widget'::@/draw/@ function, and when allocating child
widgets in 'GI.Gtk.Objects.Widget.Widget'::@/size_allocate/@.

@since 3.10
-}
widgetGetAllocatedBaseline ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget to query -}
    -> m Int32
    {- ^ __Returns:__ the baseline of the /@widget@/, or -1 if none -}
widgetGetAllocatedBaseline widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_allocated_baseline widget'
    touchManagedPtr widget
    return result

data WidgetGetAllocatedBaselineMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetAllocatedBaselineMethodInfo a signature where
    overloadedMethod _ = widgetGetAllocatedBaseline

-- method Widget::get_allocated_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_allocated_height" gtk_widget_get_allocated_height :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
Returns the height that has currently been allocated to /@widget@/.
This function is intended to be used when implementing handlers
for the 'GI.Gtk.Objects.Widget.Widget'::@/draw/@ function.
-}
widgetGetAllocatedHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget to query -}
    -> m Int32
    {- ^ __Returns:__ the height of the /@widget@/ -}
widgetGetAllocatedHeight widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_allocated_height widget'
    touchManagedPtr widget
    return result

data WidgetGetAllocatedHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetAllocatedHeightMethodInfo a signature where
    overloadedMethod _ = widgetGetAllocatedHeight

-- method Widget::get_allocated_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocation", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GtkAllocation to copy to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "baseline", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to an integer to copy to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_allocated_size" gtk_widget_get_allocated_size :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Rectangle.Rectangle ->          -- allocation : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Int32 ->                            -- baseline : TBasicType TInt
    IO ()

{- |
Retrieves the widget’s allocated size.

This function returns the last values passed to
'GI.Gtk.Objects.Widget.widgetSizeAllocateWithBaseline'. The value differs from
the size returned in 'GI.Gtk.Objects.Widget.widgetGetAllocation' in that functions
like 'GI.Gtk.Objects.Widget.widgetSetHalign' can adjust the allocation, but not
the value returned by this function.

If a widget is not visible, its allocated size is 0.

@since 3.20
-}
widgetGetAllocatedSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Gdk.Rectangle.Rectangle,Int32)
widgetGetAllocatedSize widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    allocation <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    baseline <- allocMem :: IO (Ptr Int32)
    gtk_widget_get_allocated_size widget' allocation baseline
    allocation' <- (wrapBoxed Gdk.Rectangle.Rectangle) allocation
    baseline' <- peek baseline
    touchManagedPtr widget
    freeMem baseline
    return (allocation', baseline')

data WidgetGetAllocatedSizeMethodInfo
instance (signature ~ (m (Gdk.Rectangle.Rectangle,Int32)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetAllocatedSizeMethodInfo a signature where
    overloadedMethod _ = widgetGetAllocatedSize

-- method Widget::get_allocated_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget to query", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_allocated_width" gtk_widget_get_allocated_width :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
Returns the width that has currently been allocated to /@widget@/.
This function is intended to be used when implementing handlers
for the 'GI.Gtk.Objects.Widget.Widget'::@/draw/@ function.
-}
widgetGetAllocatedWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget to query -}
    -> m Int32
    {- ^ __Returns:__ the width of the /@widget@/ -}
widgetGetAllocatedWidth widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_allocated_width widget'
    touchManagedPtr widget
    return result

data WidgetGetAllocatedWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetAllocatedWidthMethodInfo a signature where
    overloadedMethod _ = widgetGetAllocatedWidth

-- method Widget::get_allocation
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocation", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GtkAllocation to copy to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_allocation" gtk_widget_get_allocation :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Rectangle.Rectangle ->          -- allocation : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

{- |
Retrieves the widget’s allocation.

Note, when implementing a 'GI.Gtk.Objects.Container.Container': a widget’s allocation will
be its “adjusted” allocation, that is, the widget’s parent
container typically calls 'GI.Gtk.Objects.Widget.widgetSizeAllocate' with an
allocation, and that allocation is then adjusted (to handle margin
and alignment for example) before assignment to the widget.
'GI.Gtk.Objects.Widget.widgetGetAllocation' returns the adjusted allocation that
was actually assigned to the widget. The adjusted allocation is
guaranteed to be completely contained within the
'GI.Gtk.Objects.Widget.widgetSizeAllocate' allocation, however. So a 'GI.Gtk.Objects.Container.Container'
is guaranteed that its children stay inside the assigned bounds,
but not that they have exactly the bounds the container assigned.
There is no way to get the original allocation assigned by
'GI.Gtk.Objects.Widget.widgetSizeAllocate', since it isn’t stored; if a container
implementation needs that information it will have to track it itself.

@since 2.18
-}
widgetGetAllocation ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Gdk.Rectangle.Rectangle)
widgetGetAllocation widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    allocation <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    gtk_widget_get_allocation widget' allocation
    allocation' <- (wrapBoxed Gdk.Rectangle.Rectangle) allocation
    touchManagedPtr widget
    return allocation'

data WidgetGetAllocationMethodInfo
instance (signature ~ (m (Gdk.Rectangle.Rectangle)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetAllocationMethodInfo a signature where
    overloadedMethod _ = widgetGetAllocation

-- method Widget::get_ancestor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "ancestor type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_ancestor" gtk_widget_get_ancestor :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CGType ->                               -- widget_type : TBasicType TGType
    IO (Ptr Widget)

{- |
Gets the first ancestor of /@widget@/ with type /@widgetType@/. For example,
@gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)@ gets
the first 'GI.Gtk.Objects.Box.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 'GI.Gtk.Objects.Window.Window' in the docs for
'GI.Gtk.Objects.Widget.widgetGetToplevel'.

Note that unlike 'GI.Gtk.Objects.Widget.widgetIsAncestor', 'GI.Gtk.Objects.Widget.widgetGetAncestor'
considers /@widget@/ to be an ancestor of itself.
-}
widgetGetAncestor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> GType
    {- ^ /@widgetType@/: ancestor type -}
    -> m (Maybe Widget)
    {- ^ __Returns:__ the ancestor widget, or 'Nothing' if not found -}
widgetGetAncestor widget widgetType = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let widgetType' = gtypeToCGType widgetType
    result <- gtk_widget_get_ancestor widget' widgetType'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Widget) result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetGetAncestorMethodInfo
instance (signature ~ (GType -> m (Maybe Widget)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetAncestorMethodInfo a signature where
    overloadedMethod _ = widgetGetAncestor

-- method Widget::get_app_paintable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_app_paintable" gtk_widget_get_app_paintable :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether the application intends to draw on the widget in
an 'GI.Gtk.Objects.Widget.Widget'::@/draw/@ handler.

See 'GI.Gtk.Objects.Widget.widgetSetAppPaintable'

@since 2.18
-}
widgetGetAppPaintable ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget is app paintable -}
widgetGetAppPaintable widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_app_paintable widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetAppPaintableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetAppPaintableMethodInfo a signature where
    overloadedMethod _ = widgetGetAppPaintable

-- method Widget::get_can_default
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_can_default" gtk_widget_get_can_default :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether /@widget@/ can be a default widget. See
'GI.Gtk.Objects.Widget.widgetSetCanDefault'.

@since 2.18
-}
widgetGetCanDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ can be a default widget, 'False' otherwise -}
widgetGetCanDefault widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_can_default widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetCanDefaultMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetCanDefaultMethodInfo a signature where
    overloadedMethod _ = widgetGetCanDefault

-- method Widget::get_can_focus
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_can_focus" gtk_widget_get_can_focus :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether /@widget@/ can own the input focus. See
'GI.Gtk.Objects.Widget.widgetSetCanFocus'.

@since 2.18
-}
widgetGetCanFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ can own the input focus, 'False' otherwise -}
widgetGetCanFocus widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_can_focus widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetCanFocusMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetCanFocusMethodInfo a signature where
    overloadedMethod _ = widgetGetCanFocus

-- method Widget::get_child_requisition
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "requisition", argType = TInterface (Name {namespace = "Gtk", name = "Requisition"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkRequisition to be filled in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_child_requisition" gtk_widget_get_child_requisition :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Requisition.Requisition ->      -- requisition : TInterface (Name {namespace = "Gtk", name = "Requisition"})
    IO ()

{-# DEPRECATED widgetGetChildRequisition ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetGetPreferredSize' instead."] #-}
{- |
This function is only for use in widget implementations. Obtains
/@widget@/->requisition, unless someone has forced a particular
geometry on the widget (e.g. with 'GI.Gtk.Objects.Widget.widgetSetSizeRequest'),
in which case it returns that geometry instead of the widget\'s
requisition.

This function differs from 'GI.Gtk.Objects.Widget.widgetSizeRequest' in that
it retrieves the last size request value from /@widget@/->requisition,
while 'GI.Gtk.Objects.Widget.widgetSizeRequest' actually calls the \"size_request\" method
on /@widget@/ to compute the size request and fill in /@widget@/->requisition,
and only then returns /@widget@/->requisition.

Because this function does not call the “size_request” method, it
can only be used when you know that /@widget@/->requisition is
up-to-date, that is, 'GI.Gtk.Objects.Widget.widgetSizeRequest' has been called
since the last time a resize was queued. In general, only container
implementations have this information; applications should use
'GI.Gtk.Objects.Widget.widgetSizeRequest'.
-}
widgetGetChildRequisition ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Gtk.Requisition.Requisition)
widgetGetChildRequisition widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    requisition <- callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition)
    gtk_widget_get_child_requisition widget' requisition
    requisition' <- (wrapBoxed Gtk.Requisition.Requisition) requisition
    touchManagedPtr widget
    return requisition'

data WidgetGetChildRequisitionMethodInfo
instance (signature ~ (m (Gtk.Requisition.Requisition)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetChildRequisitionMethodInfo a signature where
    overloadedMethod _ = widgetGetChildRequisition

-- method Widget::get_child_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_child_visible" gtk_widget_get_child_visible :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Gets the value set with 'GI.Gtk.Objects.Widget.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.
-}
widgetGetChildVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget is mapped with the parent. -}
widgetGetChildVisible widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_child_visible widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetChildVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetChildVisibleMethodInfo a signature where
    overloadedMethod _ = widgetGetChildVisible

-- method Widget::get_clip
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clip", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GtkAllocation to copy to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_clip" gtk_widget_get_clip :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Rectangle.Rectangle ->          -- clip : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

{- |
Retrieves the widget’s clip area.

The clip area is the area in which all of /@widget@/\'s drawing will
happen. Other toolkits call it the bounding box.

Historically, in GTK+ the clip area has been equal to the allocation
retrieved via 'GI.Gtk.Objects.Widget.widgetGetAllocation'.

@since 3.14
-}
widgetGetClip ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Gdk.Rectangle.Rectangle)
widgetGetClip widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    clip <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    gtk_widget_get_clip widget' clip
    clip' <- (wrapBoxed Gdk.Rectangle.Rectangle) clip
    touchManagedPtr widget
    return clip'

data WidgetGetClipMethodInfo
instance (signature ~ (m (Gdk.Rectangle.Rectangle)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetClipMethodInfo a signature where
    overloadedMethod _ = widgetGetClip

-- method Widget::get_clipboard
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selection", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkAtom which identifies the clipboard\n            to use. %GDK_SELECTION_CLIPBOARD gives the\n            default clipboard. Another common value\n            is %GDK_SELECTION_PRIMARY, which gives\n            the primary X selection.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Clipboard"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_clipboard" gtk_widget_get_clipboard :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Atom.Atom ->                    -- selection : TInterface (Name {namespace = "Gdk", name = "Atom"})
    IO (Ptr Gtk.Clipboard.Clipboard)

{- |
Returns the clipboard object for the given selection to
be used with /@widget@/. /@widget@/ must have a 'GI.Gdk.Objects.Display.Display'
associated with it, so must be attached to a toplevel
window.

@since 2.2
-}
widgetGetClipboard ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Atom.Atom
    {- ^ /@selection@/: a 'GI.Gdk.Structs.Atom.Atom' which identifies the clipboard
            to use. @/GDK_SELECTION_CLIPBOARD/@ gives the
            default clipboard. Another common value
            is @/GDK_SELECTION_PRIMARY/@, which gives
            the primary X selection. -}
    -> m Gtk.Clipboard.Clipboard
    {- ^ __Returns:__ the appropriate clipboard object. If no
            clipboard already exists, a new one will
            be created. Once a clipboard object has
            been created, it is persistent for all time. -}
widgetGetClipboard widget selection = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    selection' <- unsafeManagedPtrGetPtr selection
    result <- gtk_widget_get_clipboard widget' selection'
    checkUnexpectedReturnNULL "widgetGetClipboard" result
    result' <- (newObject Gtk.Clipboard.Clipboard) result
    touchManagedPtr widget
    touchManagedPtr selection
    return result'

data WidgetGetClipboardMethodInfo
instance (signature ~ (Gdk.Atom.Atom -> m Gtk.Clipboard.Clipboard), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetClipboardMethodInfo a signature where
    overloadedMethod _ = widgetGetClipboard

-- method Widget::get_composite_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_composite_name" gtk_widget_get_composite_name :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CString

{-# DEPRECATED widgetGetCompositeName ["(Since version 3.10)","Use 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate', or don\8217t use this API at all."] #-}
{- |
Obtains the composite name of a widget.
-}
widgetGetCompositeName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m T.Text
    {- ^ __Returns:__ the composite name of /@widget@/, or 'Nothing' if /@widget@/ is not
  a composite child. The string should be freed when it is no
  longer needed. -}
widgetGetCompositeName widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_composite_name widget'
    checkUnexpectedReturnNULL "widgetGetCompositeName" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr widget
    return result'

data WidgetGetCompositeNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetCompositeNameMethodInfo a signature where
    overloadedMethod _ = widgetGetCompositeName

-- method Widget::get_device_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_device_enabled" gtk_widget_get_device_enabled :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Device.Device ->                -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CInt

{- |
Returns whether /@device@/ can interact with /@widget@/ and its
children. See 'GI.Gtk.Objects.Widget.widgetSetDeviceEnabled'.

@since 3.0
-}
widgetGetDeviceEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Device.IsDevice b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m Bool
    {- ^ __Returns:__ 'True' is /@device@/ is enabled for /@widget@/ -}
widgetGetDeviceEnabled widget device = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    device' <- unsafeManagedPtrCastPtr device
    result <- gtk_widget_get_device_enabled widget' device'
    let result' = (/= 0) result
    touchManagedPtr widget
    touchManagedPtr device
    return result'

data WidgetGetDeviceEnabledMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsWidget a, Gdk.Device.IsDevice b) => O.MethodInfo WidgetGetDeviceEnabledMethodInfo a signature where
    overloadedMethod _ = widgetGetDeviceEnabled

-- method Widget::get_device_events
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "EventMask"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_device_events" gtk_widget_get_device_events :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Device.Device ->                -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    IO CUInt

{- |
Returns the events mask for the widget corresponding to an specific device. These
are the events that the widget will receive when /@device@/ operates on it.

@since 3.0
-}
widgetGetDeviceEvents ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Device.IsDevice b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> m [Gdk.Flags.EventMask]
    {- ^ __Returns:__ device event mask for /@widget@/ -}
widgetGetDeviceEvents widget device = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    device' <- unsafeManagedPtrCastPtr device
    result <- gtk_widget_get_device_events widget' device'
    let result' = wordToGFlags result
    touchManagedPtr widget
    touchManagedPtr device
    return result'

data WidgetGetDeviceEventsMethodInfo
instance (signature ~ (b -> m [Gdk.Flags.EventMask]), MonadIO m, IsWidget a, Gdk.Device.IsDevice b) => O.MethodInfo WidgetGetDeviceEventsMethodInfo a signature where
    overloadedMethod _ = widgetGetDeviceEvents

-- method Widget::get_direction
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextDirection"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_direction" gtk_widget_get_direction :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CUInt

{- |
Gets the reading direction for a particular widget. See
'GI.Gtk.Objects.Widget.widgetSetDirection'.
-}
widgetGetDirection ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.Enums.TextDirection
    {- ^ __Returns:__ the reading direction for the widget. -}
widgetGetDirection widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_direction widget'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr widget
    return result'

data WidgetGetDirectionMethodInfo
instance (signature ~ (m Gtk.Enums.TextDirection), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetDirectionMethodInfo a signature where
    overloadedMethod _ = widgetGetDirection

-- method Widget::get_display
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Display"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_display" gtk_widget_get_display :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gdk.Display.Display)

{- |
Get the 'GI.Gdk.Objects.Display.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 'GI.Gtk.Objects.Window.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.

@since 2.2
-}
widgetGetDisplay ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gdk.Display.Display
    {- ^ __Returns:__ the 'GI.Gdk.Objects.Display.Display' for the toplevel for this widget. -}
widgetGetDisplay widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_display widget'
    checkUnexpectedReturnNULL "widgetGetDisplay" result
    result' <- (newObject Gdk.Display.Display) result
    touchManagedPtr widget
    return result'

data WidgetGetDisplayMethodInfo
instance (signature ~ (m Gdk.Display.Display), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetDisplayMethodInfo a signature where
    overloadedMethod _ = widgetGetDisplay

-- method Widget::get_double_buffered
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_double_buffered" gtk_widget_get_double_buffered :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether the widget is double buffered.

See 'GI.Gtk.Objects.Widget.widgetSetDoubleBuffered'

@since 2.18
-}
widgetGetDoubleBuffered ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget is double buffered -}
widgetGetDoubleBuffered widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_double_buffered widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetDoubleBufferedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetDoubleBufferedMethodInfo a signature where
    overloadedMethod _ = widgetGetDoubleBuffered

-- method Widget::get_events
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_events" gtk_widget_get_events :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
Returns the event mask (see 'GI.Gdk.Flags.EventMask') for the widget. These are the
events that the widget will receive.

Note: Internally, the widget event mask will be the logical OR of the event
mask set through 'GI.Gtk.Objects.Widget.widgetSetEvents' or 'GI.Gtk.Objects.Widget.widgetAddEvents', and the
event mask necessary to cater for every 'GI.Gtk.Objects.EventController.EventController' created for the
widget.
-}
widgetGetEvents ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Int32
    {- ^ __Returns:__ event mask for /@widget@/ -}
widgetGetEvents widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_events widget'
    touchManagedPtr widget
    return result

data WidgetGetEventsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetEventsMethodInfo a signature where
    overloadedMethod _ = widgetGetEvents

-- method Widget::get_focus_on_click
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_focus_on_click" gtk_widget_get_focus_on_click :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Returns whether the widget should grab focus when it is clicked with the mouse.
See 'GI.Gtk.Objects.Widget.widgetSetFocusOnClick'.

@since 3.20
-}
widgetGetFocusOnClick ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget should grab focus when it is clicked with
              the mouse. -}
widgetGetFocusOnClick widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_focus_on_click widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetFocusOnClickMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetFocusOnClickMethodInfo a signature where
    overloadedMethod _ = widgetGetFocusOnClick

-- method Widget::get_font_map
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "FontMap"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_font_map" gtk_widget_get_font_map :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Pango.FontMap.FontMap)

{- |
Gets the font map that has been set with 'GI.Gtk.Objects.Widget.widgetSetFontMap'.

@since 3.18
-}
widgetGetFontMap ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Maybe Pango.FontMap.FontMap)
    {- ^ __Returns:__ A 'GI.Pango.Objects.FontMap.FontMap', or 'Nothing' -}
widgetGetFontMap widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_font_map widget'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Pango.FontMap.FontMap) result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetGetFontMapMethodInfo
instance (signature ~ (m (Maybe Pango.FontMap.FontMap)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetFontMapMethodInfo a signature where
    overloadedMethod _ = widgetGetFontMap

-- method Widget::get_font_options
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "cairo", name = "FontOptions"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_font_options" gtk_widget_get_font_options :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Cairo.FontOptions.FontOptions)

{- |
Returns the 'GI.Cairo.Structs.FontOptions.FontOptions' used for Pango rendering. When not set,
the defaults font options for the 'GI.Gdk.Objects.Screen.Screen' will be used.

@since 3.18
-}
widgetGetFontOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Maybe Cairo.FontOptions.FontOptions)
    {- ^ __Returns:__ the 'GI.Cairo.Structs.FontOptions.FontOptions' or 'Nothing' if not set -}
widgetGetFontOptions widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_font_options widget'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newPtr Cairo.FontOptions.FontOptions) result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetGetFontOptionsMethodInfo
instance (signature ~ (m (Maybe Cairo.FontOptions.FontOptions)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetFontOptionsMethodInfo a signature where
    overloadedMethod _ = widgetGetFontOptions

-- method Widget::get_frame_clock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "FrameClock"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_frame_clock" gtk_widget_get_frame_clock :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gdk.FrameClock.FrameClock)

{- |
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
'GI.Gdk.Objects.FrameClock.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 'GI.Gdk.Objects.FrameClock.frameClockGetFrameTime', and
then update the animation by calling
'GI.Gdk.Objects.FrameClock.frameClockGetFrameTime' again during each repaint.

'GI.Gdk.Objects.FrameClock.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 'GI.Gtk.Objects.Widget.widgetQueueDraw' which invalidates
the widget (thus scheduling it to receive a draw on the next
frame). 'GI.Gtk.Objects.Widget.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.

@since 3.8
-}
widgetGetFrameClock ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Maybe Gdk.FrameClock.FrameClock)
    {- ^ __Returns:__ a 'GI.Gdk.Objects.FrameClock.FrameClock',
or @/NULL/@ if widget is unrealized -}
widgetGetFrameClock widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_frame_clock widget'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.FrameClock.FrameClock) result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetGetFrameClockMethodInfo
instance (signature ~ (m (Maybe Gdk.FrameClock.FrameClock)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetFrameClockMethodInfo a signature where
    overloadedMethod _ = widgetGetFrameClock

-- method Widget::get_halign
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Align"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_halign" gtk_widget_get_halign :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CUInt

{- |
Gets the value of the 'GI.Gtk.Objects.Widget.Widget':@/halign/@ property.

For backwards compatibility reasons this method will never return
'GI.Gtk.Enums.AlignBaseline', but instead it will convert it to
'GI.Gtk.Enums.AlignFill'. Baselines are not supported for horizontal
alignment.
-}
widgetGetHalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.Enums.Align
    {- ^ __Returns:__ the horizontal alignment of /@widget@/ -}
widgetGetHalign widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_halign widget'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr widget
    return result'

data WidgetGetHalignMethodInfo
instance (signature ~ (m Gtk.Enums.Align), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetHalignMethodInfo a signature where
    overloadedMethod _ = widgetGetHalign

-- method Widget::get_has_tooltip
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_has_tooltip" gtk_widget_get_has_tooltip :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Returns the current value of the has-tooltip property.  See
'GI.Gtk.Objects.Widget.Widget':@/has-tooltip/@ for more information.

@since 2.12
-}
widgetGetHasTooltip ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ current value of has-tooltip on /@widget@/. -}
widgetGetHasTooltip widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_has_tooltip widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetHasTooltipMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetHasTooltipMethodInfo a signature where
    overloadedMethod _ = widgetGetHasTooltip

-- method Widget::get_has_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_has_window" gtk_widget_get_has_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether /@widget@/ has a 'GI.Gdk.Objects.Window.Window' of its own. See
'GI.Gtk.Objects.Widget.widgetSetHasWindow'.

@since 2.18
-}
widgetGetHasWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ has a window, 'False' otherwise -}
widgetGetHasWindow widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_has_window widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetHasWindowMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetHasWindowMethodInfo a signature where
    overloadedMethod _ = widgetGetHasWindow

-- method Widget::get_hexpand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_hexpand" gtk_widget_get_hexpand :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Gets whether the widget would like any available extra horizontal
space. When a user resizes a 'GI.Gtk.Objects.Window.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 'GI.Gtk.Objects.Widget.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.
-}
widgetGetHexpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget -}
    -> m Bool
    {- ^ __Returns:__ whether hexpand flag is set -}
widgetGetHexpand widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_hexpand widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetHexpandMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetHexpandMethodInfo a signature where
    overloadedMethod _ = widgetGetHexpand

-- method Widget::get_hexpand_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_hexpand_set" gtk_widget_get_hexpand_set :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Gets whether 'GI.Gtk.Objects.Widget.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.
-}
widgetGetHexpandSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget -}
    -> m Bool
    {- ^ __Returns:__ whether hexpand has been explicitly set -}
widgetGetHexpandSet widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_hexpand_set widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetHexpandSetMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetHexpandSetMethodInfo a signature where
    overloadedMethod _ = widgetGetHexpandSet

-- method Widget::get_mapped
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_mapped" gtk_widget_get_mapped :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Whether the widget is mapped.

@since 2.20
-}
widgetGetMapped ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget is mapped, 'False' otherwise. -}
widgetGetMapped widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_mapped widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetMappedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetMappedMethodInfo a signature where
    overloadedMethod _ = widgetGetMapped

-- method Widget::get_margin_bottom
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_margin_bottom" gtk_widget_get_margin_bottom :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
Gets the value of the 'GI.Gtk.Objects.Widget.Widget':@/margin-bottom/@ property.

@since 3.0
-}
widgetGetMarginBottom ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Int32
    {- ^ __Returns:__ The bottom margin of /@widget@/ -}
widgetGetMarginBottom widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_margin_bottom widget'
    touchManagedPtr widget
    return result

data WidgetGetMarginBottomMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetMarginBottomMethodInfo a signature where
    overloadedMethod _ = widgetGetMarginBottom

-- method Widget::get_margin_end
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_margin_end" gtk_widget_get_margin_end :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
Gets the value of the 'GI.Gtk.Objects.Widget.Widget':@/margin-end/@ property.

@since 3.12
-}
widgetGetMarginEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Int32
    {- ^ __Returns:__ The end margin of /@widget@/ -}
widgetGetMarginEnd widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_margin_end widget'
    touchManagedPtr widget
    return result

data WidgetGetMarginEndMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetMarginEndMethodInfo a signature where
    overloadedMethod _ = widgetGetMarginEnd

-- method Widget::get_margin_left
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_margin_left" gtk_widget_get_margin_left :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{-# DEPRECATED widgetGetMarginLeft ["(Since version 3.12)","Use 'GI.Gtk.Objects.Widget.widgetGetMarginStart' instead."] #-}
{- |
Gets the value of the 'GI.Gtk.Objects.Widget.Widget':@/margin-left/@ property.

@since 3.0
-}
widgetGetMarginLeft ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Int32
    {- ^ __Returns:__ The left margin of /@widget@/ -}
widgetGetMarginLeft widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_margin_left widget'
    touchManagedPtr widget
    return result

data WidgetGetMarginLeftMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetMarginLeftMethodInfo a signature where
    overloadedMethod _ = widgetGetMarginLeft

-- method Widget::get_margin_right
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_margin_right" gtk_widget_get_margin_right :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{-# DEPRECATED widgetGetMarginRight ["(Since version 3.12)","Use 'GI.Gtk.Objects.Widget.widgetGetMarginEnd' instead."] #-}
{- |
Gets the value of the 'GI.Gtk.Objects.Widget.Widget':@/margin-right/@ property.

@since 3.0
-}
widgetGetMarginRight ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Int32
    {- ^ __Returns:__ The right margin of /@widget@/ -}
widgetGetMarginRight widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_margin_right widget'
    touchManagedPtr widget
    return result

data WidgetGetMarginRightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetMarginRightMethodInfo a signature where
    overloadedMethod _ = widgetGetMarginRight

-- method Widget::get_margin_start
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_margin_start" gtk_widget_get_margin_start :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
Gets the value of the 'GI.Gtk.Objects.Widget.Widget':@/margin-start/@ property.

@since 3.12
-}
widgetGetMarginStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Int32
    {- ^ __Returns:__ The start margin of /@widget@/ -}
widgetGetMarginStart widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_margin_start widget'
    touchManagedPtr widget
    return result

data WidgetGetMarginStartMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetMarginStartMethodInfo a signature where
    overloadedMethod _ = widgetGetMarginStart

-- method Widget::get_margin_top
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_margin_top" gtk_widget_get_margin_top :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
Gets the value of the 'GI.Gtk.Objects.Widget.Widget':@/margin-top/@ property.

@since 3.0
-}
widgetGetMarginTop ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Int32
    {- ^ __Returns:__ The top margin of /@widget@/ -}
widgetGetMarginTop widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_margin_top widget'
    touchManagedPtr widget
    return result

data WidgetGetMarginTopMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetMarginTopMethodInfo a signature where
    overloadedMethod _ = widgetGetMarginTop

-- method Widget::get_modifier_mask
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "intent", argType = TInterface (Name {namespace = "Gdk", name = "ModifierIntent"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the use case for the modifier mask", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "ModifierType"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_modifier_mask" gtk_widget_get_modifier_mask :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- intent : TInterface (Name {namespace = "Gdk", name = "ModifierIntent"})
    IO CUInt

{- |
Returns the modifier mask the /@widget@/’s windowing system backend
uses for a particular purpose.

See 'GI.Gdk.Objects.Keymap.keymapGetModifierMask'.

@since 3.4
-}
widgetGetModifierMask ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Enums.ModifierIntent
    {- ^ /@intent@/: the use case for the modifier mask -}
    -> m [Gdk.Flags.ModifierType]
    {- ^ __Returns:__ the modifier mask used for /@intent@/. -}
widgetGetModifierMask widget intent = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let intent' = (fromIntegral . fromEnum) intent
    result <- gtk_widget_get_modifier_mask widget' intent'
    let result' = wordToGFlags result
    touchManagedPtr widget
    return result'

data WidgetGetModifierMaskMethodInfo
instance (signature ~ (Gdk.Enums.ModifierIntent -> m [Gdk.Flags.ModifierType]), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetModifierMaskMethodInfo a signature where
    overloadedMethod _ = widgetGetModifierMask

-- method Widget::get_modifier_style
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "RcStyle"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_modifier_style" gtk_widget_get_modifier_style :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.RcStyle.RcStyle)

{-# DEPRECATED widgetGetModifierStyle ["(Since version 3.0)","Use 'GI.Gtk.Objects.StyleContext.StyleContext' with a custom 'GI.Gtk.Interfaces.StyleProvider.StyleProvider' instead"] #-}
{- |
Returns the current modifier style for the widget. (As set by
'GI.Gtk.Objects.Widget.widgetModifyStyle'.) If no style has previously set, a new
'GI.Gtk.Objects.RcStyle.RcStyle' will be created with all values unset, and set as the
modifier style for the widget. If you make changes to this rc
style, you must call 'GI.Gtk.Objects.Widget.widgetModifyStyle', passing in the
returned rc style, to make sure that your changes take effect.

Caution: passing the style back to 'GI.Gtk.Objects.Widget.widgetModifyStyle' will
normally end up destroying it, because 'GI.Gtk.Objects.Widget.widgetModifyStyle' copies
the passed-in style and sets the copy as the new modifier style,
thus dropping any reference to the old modifier style. Add a reference
to the modifier style if you want to keep it alive.
-}
widgetGetModifierStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.RcStyle.RcStyle
    {- ^ __Returns:__ the modifier style for the widget.
    This rc style is owned by the widget. If you want to keep a
    pointer to value this around, you must add a refcount using
    'GI.GObject.Objects.Object.objectRef'. -}
widgetGetModifierStyle widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_modifier_style widget'
    checkUnexpectedReturnNULL "widgetGetModifierStyle" result
    result' <- (newObject Gtk.RcStyle.RcStyle) result
    touchManagedPtr widget
    return result'

data WidgetGetModifierStyleMethodInfo
instance (signature ~ (m Gtk.RcStyle.RcStyle), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetModifierStyleMethodInfo a signature where
    overloadedMethod _ = widgetGetModifierStyle

-- method Widget::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_name" gtk_widget_get_name :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CString

{- |
Retrieves the name of a widget. See 'GI.Gtk.Objects.Widget.widgetSetName' for the
significance of widget names.
-}
widgetGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m T.Text
    {- ^ __Returns:__ name of the widget. This string is owned by GTK+ and
should not be modified or freed -}
widgetGetName widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_name widget'
    checkUnexpectedReturnNULL "widgetGetName" result
    result' <- cstringToText result
    touchManagedPtr widget
    return result'

data WidgetGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetNameMethodInfo a signature where
    overloadedMethod _ = widgetGetName

-- method Widget::get_no_show_all
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_no_show_all" gtk_widget_get_no_show_all :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Returns the current value of the 'GI.Gtk.Objects.Widget.Widget':@/no-show-all/@ property,
which determines whether calls to 'GI.Gtk.Objects.Widget.widgetShowAll'
will affect this widget.

@since 2.4
-}
widgetGetNoShowAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ the current value of the “no-show-all” property. -}
widgetGetNoShowAll widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_no_show_all widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetNoShowAllMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetNoShowAllMethodInfo a signature where
    overloadedMethod _ = widgetGetNoShowAll

-- method Widget::get_opacity
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TDouble)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_opacity" gtk_widget_get_opacity :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CDouble

{- |
Fetches the requested opacity for this widget.
See 'GI.Gtk.Objects.Widget.widgetSetOpacity'.

@since 3.8
-}
widgetGetOpacity ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Double
    {- ^ __Returns:__ the requested opacity for this widget. -}
widgetGetOpacity widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_opacity widget'
    let result' = realToFrac result
    touchManagedPtr widget
    return result'

data WidgetGetOpacityMethodInfo
instance (signature ~ (m Double), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetOpacityMethodInfo a signature where
    overloadedMethod _ = widgetGetOpacity

-- method Widget::get_pango_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "Context"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_pango_context" gtk_widget_get_pango_context :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Pango.Context.Context)

{- |
Gets a 'GI.Pango.Objects.Context.Context' with the appropriate font map, font description,
and base direction for this widget. Unlike the context returned
by 'GI.Gtk.Objects.Widget.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 'GI.Gtk.Objects.Widget.Widget'::@/screen-changed/@ signal on the widget.
-}
widgetGetPangoContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Pango.Context.Context
    {- ^ __Returns:__ the 'GI.Pango.Objects.Context.Context' for the widget. -}
widgetGetPangoContext widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_pango_context widget'
    checkUnexpectedReturnNULL "widgetGetPangoContext" result
    result' <- (newObject Pango.Context.Context) result
    touchManagedPtr widget
    return result'

data WidgetGetPangoContextMethodInfo
instance (signature ~ (m Pango.Context.Context), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetPangoContextMethodInfo a signature where
    overloadedMethod _ = widgetGetPangoContext

-- method Widget::get_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_parent" gtk_widget_get_parent :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Widget)

{- |
Returns the parent container of /@widget@/.
-}
widgetGetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Maybe Widget)
    {- ^ __Returns:__ the parent container of /@widget@/, or 'Nothing' -}
widgetGetParent widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_parent widget'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Widget) result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetGetParentMethodInfo
instance (signature ~ (m (Maybe Widget)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetParentMethodInfo a signature where
    overloadedMethod _ = widgetGetParent

-- method Widget::get_parent_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_parent_window" gtk_widget_get_parent_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gdk.Window.Window)

{- |
Gets /@widget@/’s parent window.
-}
widgetGetParentWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget'. -}
    -> m Gdk.Window.Window
    {- ^ __Returns:__ the parent window of /@widget@/. -}
widgetGetParentWindow widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_parent_window widget'
    checkUnexpectedReturnNULL "widgetGetParentWindow" result
    result' <- (newObject Gdk.Window.Window) result
    touchManagedPtr widget
    return result'

data WidgetGetParentWindowMethodInfo
instance (signature ~ (m Gdk.Window.Window), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetParentWindowMethodInfo a signature where
    overloadedMethod _ = widgetGetParentWindow

-- method Widget::get_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "WidgetPath"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_path" gtk_widget_get_path :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.WidgetPath.WidgetPath)

{- |
Returns the 'GI.Gtk.Structs.WidgetPath.WidgetPath' representing /@widget@/, if the widget
is not connected to a toplevel widget, a partial path will be
created.
-}
widgetGetPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.WidgetPath.WidgetPath
    {- ^ __Returns:__ The 'GI.Gtk.Structs.WidgetPath.WidgetPath' representing /@widget@/ -}
widgetGetPath widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_path widget'
    checkUnexpectedReturnNULL "widgetGetPath" result
    result' <- (newBoxed Gtk.WidgetPath.WidgetPath) result
    touchManagedPtr widget
    return result'

data WidgetGetPathMethodInfo
instance (signature ~ (m Gtk.WidgetPath.WidgetPath), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetPathMethodInfo a signature where
    overloadedMethod _ = widgetGetPath

-- method Widget::get_pointer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the X coordinate, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the Y coordinate, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_pointer" gtk_widget_get_pointer :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Int32 ->                            -- x : TBasicType TInt
    Ptr Int32 ->                            -- y : TBasicType TInt
    IO ()

{-# DEPRECATED widgetGetPointer ["(Since version 3.4)","Use 'GI.Gdk.Objects.Window.windowGetDevicePosition' instead."] #-}
{- |
Obtains the location of the mouse pointer in widget coordinates.
Widget coordinates are a bit odd; for historical reasons, they are
defined as /@widget@/->window coordinates for widgets that return 'True' for
'GI.Gtk.Objects.Widget.widgetGetHasWindow'; and are relative to /@widget@/->allocation.x,
/@widget@/->allocation.y otherwise.
-}
widgetGetPointer ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Int32,Int32)
widgetGetPointer widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    x <- allocMem :: IO (Ptr Int32)
    y <- allocMem :: IO (Ptr Int32)
    gtk_widget_get_pointer widget' x y
    x' <- peek x
    y' <- peek y
    touchManagedPtr widget
    freeMem x
    freeMem y
    return (x', y')

data WidgetGetPointerMethodInfo
instance (signature ~ (m (Int32,Int32)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetPointerMethodInfo a signature where
    overloadedMethod _ = widgetGetPointer

-- method Widget::get_preferred_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the minimum height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the natural height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_preferred_height" gtk_widget_get_preferred_height :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Int32 ->                            -- minimum_height : TBasicType TInt
    Ptr Int32 ->                            -- natural_height : TBasicType TInt
    IO ()

{- |
Retrieves a widget’s initial minimum and natural height.

This call is specific to width-for-height requests.

The returned request will be modified by the
GtkWidgetClass::adjust_size_request virtual method and by any
@/GtkSizeGroups/@ that have been applied. That is, the returned request
is the one that should be used for layout, not necessarily the one
returned by the widget itself.

@since 3.0
-}
widgetGetPreferredHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' instance -}
    -> m (Int32,Int32)
widgetGetPreferredHeight widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    minimumHeight <- allocMem :: IO (Ptr Int32)
    naturalHeight <- allocMem :: IO (Ptr Int32)
    gtk_widget_get_preferred_height widget' minimumHeight naturalHeight
    minimumHeight' <- peek minimumHeight
    naturalHeight' <- peek naturalHeight
    touchManagedPtr widget
    freeMem minimumHeight
    freeMem naturalHeight
    return (minimumHeight', naturalHeight')

data WidgetGetPreferredHeightMethodInfo
instance (signature ~ (m (Int32,Int32)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetPreferredHeightMethodInfo a signature where
    overloadedMethod _ = widgetGetPreferredHeight

-- method Widget::get_preferred_height_and_baseline_for_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width which is available for allocation, or -1 if none", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the minimum height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the natural height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minimum_baseline", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the baseline for the minimum height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_baseline", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the baseline for the natural height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_preferred_height_and_baseline_for_width" gtk_widget_get_preferred_height_and_baseline_for_width :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- width : TBasicType TInt
    Ptr Int32 ->                            -- minimum_height : TBasicType TInt
    Ptr Int32 ->                            -- natural_height : TBasicType TInt
    Ptr Int32 ->                            -- minimum_baseline : TBasicType TInt
    Ptr Int32 ->                            -- natural_baseline : TBasicType TInt
    IO ()

{- |
Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
the specified /@width@/, or the default height if /@width@/ is -1. The baselines may be -1 which means
that no baseline is requested for this widget.

The returned request will be modified by the
GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
and by any @/GtkSizeGroups/@ that have been applied. That is, the returned request
is the one that should be used for layout, not necessarily the one
returned by the widget itself.

@since 3.10
-}
widgetGetPreferredHeightAndBaselineForWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' instance -}
    -> Int32
    {- ^ /@width@/: the width which is available for allocation, or -1 if none -}
    -> m (Int32,Int32,Int32,Int32)
widgetGetPreferredHeightAndBaselineForWidth widget width = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    minimumHeight <- allocMem :: IO (Ptr Int32)
    naturalHeight <- allocMem :: IO (Ptr Int32)
    minimumBaseline <- allocMem :: IO (Ptr Int32)
    naturalBaseline <- allocMem :: IO (Ptr Int32)
    gtk_widget_get_preferred_height_and_baseline_for_width widget' width minimumHeight naturalHeight minimumBaseline naturalBaseline
    minimumHeight' <- peek minimumHeight
    naturalHeight' <- peek naturalHeight
    minimumBaseline' <- peek minimumBaseline
    naturalBaseline' <- peek naturalBaseline
    touchManagedPtr widget
    freeMem minimumHeight
    freeMem naturalHeight
    freeMem minimumBaseline
    freeMem naturalBaseline
    return (minimumHeight', naturalHeight', minimumBaseline', naturalBaseline')

data WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
instance (signature ~ (Int32 -> m (Int32,Int32,Int32,Int32)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetPreferredHeightAndBaselineForWidthMethodInfo a signature where
    overloadedMethod _ = widgetGetPreferredHeightAndBaselineForWidth

-- method Widget::get_preferred_height_for_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the width which is available for allocation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the minimum height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the natural height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_preferred_height_for_width" gtk_widget_get_preferred_height_for_width :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- width : TBasicType TInt
    Ptr Int32 ->                            -- minimum_height : TBasicType TInt
    Ptr Int32 ->                            -- natural_height : TBasicType TInt
    IO ()

{- |
Retrieves a widget’s minimum and natural height if it would be given
the specified /@width@/.

The returned request will be modified by the
GtkWidgetClass::adjust_size_request virtual method and by any
@/GtkSizeGroups/@ that have been applied. That is, the returned request
is the one that should be used for layout, not necessarily the one
returned by the widget itself.

@since 3.0
-}
widgetGetPreferredHeightForWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' instance -}
    -> Int32
    {- ^ /@width@/: the width which is available for allocation -}
    -> m (Int32,Int32)
widgetGetPreferredHeightForWidth widget width = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    minimumHeight <- allocMem :: IO (Ptr Int32)
    naturalHeight <- allocMem :: IO (Ptr Int32)
    gtk_widget_get_preferred_height_for_width widget' width minimumHeight naturalHeight
    minimumHeight' <- peek minimumHeight
    naturalHeight' <- peek naturalHeight
    touchManagedPtr widget
    freeMem minimumHeight
    freeMem naturalHeight
    return (minimumHeight', naturalHeight')

data WidgetGetPreferredHeightForWidthMethodInfo
instance (signature ~ (Int32 -> m (Int32,Int32)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetPreferredHeightForWidthMethodInfo a signature where
    overloadedMethod _ = widgetGetPreferredHeightForWidth

-- method Widget::get_preferred_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_size", argType = TInterface (Name {namespace = "Gtk", name = "Requisition"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the minimum size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "natural_size", argType = TInterface (Name {namespace = "Gtk", name = "Requisition"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the natural size, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_preferred_size" gtk_widget_get_preferred_size :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Requisition.Requisition ->      -- minimum_size : TInterface (Name {namespace = "Gtk", name = "Requisition"})
    Ptr Gtk.Requisition.Requisition ->      -- natural_size : TInterface (Name {namespace = "Gtk", name = "Requisition"})
    IO ()

{- |
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 'GI.Gtk.Objects.Widget.widgetGetPreferredHeightAndBaselineForWidth' if you want to support
baseline alignment.

@since 3.0
-}
widgetGetPreferredSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' instance -}
    -> m (Gtk.Requisition.Requisition,Gtk.Requisition.Requisition)
widgetGetPreferredSize widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    minimumSize <- callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition)
    naturalSize <- callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition)
    gtk_widget_get_preferred_size widget' minimumSize naturalSize
    minimumSize' <- (wrapBoxed Gtk.Requisition.Requisition) minimumSize
    naturalSize' <- (wrapBoxed Gtk.Requisition.Requisition) naturalSize
    touchManagedPtr widget
    return (minimumSize', naturalSize')

data WidgetGetPreferredSizeMethodInfo
instance (signature ~ (m (Gtk.Requisition.Requisition,Gtk.Requisition.Requisition)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetPreferredSizeMethodInfo a signature where
    overloadedMethod _ = widgetGetPreferredSize

-- method Widget::get_preferred_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the minimum width, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the natural width, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_preferred_width" gtk_widget_get_preferred_width :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Int32 ->                            -- minimum_width : TBasicType TInt
    Ptr Int32 ->                            -- natural_width : TBasicType TInt
    IO ()

{- |
Retrieves a widget’s initial minimum and natural width.

This call is specific to height-for-width requests.

The returned request will be modified by the
GtkWidgetClass::adjust_size_request virtual method and by any
@/GtkSizeGroups/@ that have been applied. That is, the returned request
is the one that should be used for layout, not necessarily the one
returned by the widget itself.

@since 3.0
-}
widgetGetPreferredWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' instance -}
    -> m (Int32,Int32)
widgetGetPreferredWidth widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    minimumWidth <- allocMem :: IO (Ptr Int32)
    naturalWidth <- allocMem :: IO (Ptr Int32)
    gtk_widget_get_preferred_width widget' minimumWidth naturalWidth
    minimumWidth' <- peek minimumWidth
    naturalWidth' <- peek naturalWidth
    touchManagedPtr widget
    freeMem minimumWidth
    freeMem naturalWidth
    return (minimumWidth', naturalWidth')

data WidgetGetPreferredWidthMethodInfo
instance (signature ~ (m (Int32,Int32)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetPreferredWidthMethodInfo a signature where
    overloadedMethod _ = widgetGetPreferredWidth

-- method Widget::get_preferred_width_for_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the height which is available for allocation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minimum_width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the minimum width, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "natural_width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location for storing the natural width, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_preferred_width_for_height" gtk_widget_get_preferred_width_for_height :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- height : TBasicType TInt
    Ptr Int32 ->                            -- minimum_width : TBasicType TInt
    Ptr Int32 ->                            -- natural_width : TBasicType TInt
    IO ()

{- |
Retrieves a widget’s minimum and natural width if it would be given
the specified /@height@/.

The returned request will be modified by the
GtkWidgetClass::adjust_size_request virtual method and by any
@/GtkSizeGroups/@ that have been applied. That is, the returned request
is the one that should be used for layout, not necessarily the one
returned by the widget itself.

@since 3.0
-}
widgetGetPreferredWidthForHeight ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' instance -}
    -> Int32
    {- ^ /@height@/: the height which is available for allocation -}
    -> m (Int32,Int32)
widgetGetPreferredWidthForHeight widget height = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    minimumWidth <- allocMem :: IO (Ptr Int32)
    naturalWidth <- allocMem :: IO (Ptr Int32)
    gtk_widget_get_preferred_width_for_height widget' height minimumWidth naturalWidth
    minimumWidth' <- peek minimumWidth
    naturalWidth' <- peek naturalWidth
    touchManagedPtr widget
    freeMem minimumWidth
    freeMem naturalWidth
    return (minimumWidth', naturalWidth')

data WidgetGetPreferredWidthForHeightMethodInfo
instance (signature ~ (Int32 -> m (Int32,Int32)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetPreferredWidthForHeightMethodInfo a signature where
    overloadedMethod _ = widgetGetPreferredWidthForHeight

-- method Widget::get_realized
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_realized" gtk_widget_get_realized :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether /@widget@/ is realized.

@since 2.20
-}
widgetGetRealized ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ is realized, 'False' otherwise -}
widgetGetRealized widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_realized widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetRealizedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetRealizedMethodInfo a signature where
    overloadedMethod _ = widgetGetRealized

-- method Widget::get_receives_default
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_receives_default" gtk_widget_get_receives_default :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
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 'GI.Gtk.Objects.Widget.widgetSetReceivesDefault'.

@since 2.18
-}
widgetGetReceivesDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ acts as the default widget when focused,
              'False' otherwise -}
widgetGetReceivesDefault widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_receives_default widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetReceivesDefaultMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetReceivesDefaultMethodInfo a signature where
    overloadedMethod _ = widgetGetReceivesDefault

-- method Widget::get_request_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget instance", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "SizeRequestMode"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_request_mode" gtk_widget_get_request_mode :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CUInt

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

'GI.Gtk.Objects.Bin.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.

@since 3.0
-}
widgetGetRequestMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' instance -}
    -> m Gtk.Enums.SizeRequestMode
    {- ^ __Returns:__ The 'GI.Gtk.Enums.SizeRequestMode' preferred by /@widget@/. -}
widgetGetRequestMode widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_request_mode widget'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr widget
    return result'

data WidgetGetRequestModeMethodInfo
instance (signature ~ (m Gtk.Enums.SizeRequestMode), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetRequestModeMethodInfo a signature where
    overloadedMethod _ = widgetGetRequestMode

-- method Widget::get_requisition
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "requisition", argType = TInterface (Name {namespace = "Gtk", name = "Requisition"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GtkRequisition to copy to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_requisition" gtk_widget_get_requisition :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Requisition.Requisition ->      -- requisition : TInterface (Name {namespace = "Gtk", name = "Requisition"})
    IO ()

{-# DEPRECATED widgetGetRequisition ["(Since version 3.0)","The 'GI.Gtk.Structs.Requisition.Requisition' cache on the widget was","removed, If you need to cache sizes across requests and allocations,","add an explicit cache to the widget in question instead."] #-}
{- |
Retrieves the widget’s requisition.

This function should only be used by widget implementations in
order to figure whether the widget’s requisition has actually
changed after some internal state change (so that they can call
'GI.Gtk.Objects.Widget.widgetQueueResize' instead of 'GI.Gtk.Objects.Widget.widgetQueueDraw').

Normally, 'GI.Gtk.Objects.Widget.widgetSizeRequest' should be used.

@since 2.20
-}
widgetGetRequisition ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Gtk.Requisition.Requisition)
widgetGetRequisition widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    requisition <- callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition)
    gtk_widget_get_requisition widget' requisition
    requisition' <- (wrapBoxed Gtk.Requisition.Requisition) requisition
    touchManagedPtr widget
    return requisition'

data WidgetGetRequisitionMethodInfo
instance (signature ~ (m (Gtk.Requisition.Requisition)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetRequisitionMethodInfo a signature where
    overloadedMethod _ = widgetGetRequisition

-- method Widget::get_root_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_root_window" gtk_widget_get_root_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gdk.Window.Window)

{-# DEPRECATED widgetGetRootWindow ["(Since version 3.12)","Use 'GI.Gdk.Objects.Screen.screenGetRootWindow' instead"] #-}
{- |
Get the root window where this widget is located. This function can
only be called after the widget has been added to a widget
hierarchy with 'GI.Gtk.Objects.Window.Window' at the top.

The root window is useful for such purposes as creating a popup
'GI.Gdk.Objects.Window.Window' associated with the window. 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.

@since 2.2
-}
widgetGetRootWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gdk.Window.Window
    {- ^ __Returns:__ the 'GI.Gdk.Objects.Window.Window' root window for the toplevel for this widget. -}
widgetGetRootWindow widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_root_window widget'
    checkUnexpectedReturnNULL "widgetGetRootWindow" result
    result' <- (newObject Gdk.Window.Window) result
    touchManagedPtr widget
    return result'

data WidgetGetRootWindowMethodInfo
instance (signature ~ (m Gdk.Window.Window), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetRootWindowMethodInfo a signature where
    overloadedMethod _ = widgetGetRootWindow

-- method Widget::get_scale_factor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_scale_factor" gtk_widget_get_scale_factor :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO Int32

{- |
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 'GI.Gdk.Objects.Window.windowGetScaleFactor'.

@since 3.10
-}
widgetGetScaleFactor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Int32
    {- ^ __Returns:__ the scale factor for /@widget@/ -}
widgetGetScaleFactor widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_scale_factor widget'
    touchManagedPtr widget
    return result

data WidgetGetScaleFactorMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetScaleFactorMethodInfo a signature where
    overloadedMethod _ = widgetGetScaleFactor

-- method Widget::get_screen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Screen"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_screen" gtk_widget_get_screen :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gdk.Screen.Screen)

{- |
Get the 'GI.Gdk.Objects.Screen.Screen' from 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 'GI.Gtk.Objects.Window.Window'
at the top.

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

@since 2.2
-}
widgetGetScreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gdk.Screen.Screen
    {- ^ __Returns:__ the 'GI.Gdk.Objects.Screen.Screen' for the toplevel for this widget. -}
widgetGetScreen widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_screen widget'
    checkUnexpectedReturnNULL "widgetGetScreen" result
    result' <- (newObject Gdk.Screen.Screen) result
    touchManagedPtr widget
    return result'

data WidgetGetScreenMethodInfo
instance (signature ~ (m Gdk.Screen.Screen), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetScreenMethodInfo a signature where
    overloadedMethod _ = widgetGetScreen

-- method Widget::get_sensitive
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_sensitive" gtk_widget_get_sensitive :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Returns the widget’s sensitivity (in the sense of returning
the value that has been set using 'GI.Gtk.Objects.Widget.widgetSetSensitive').

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

@since 2.18
-}
widgetGetSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget is sensitive -}
widgetGetSensitive widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_sensitive widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetSensitiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetSensitiveMethodInfo a signature where
    overloadedMethod _ = widgetGetSensitive

-- method Widget::get_settings
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Settings"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_settings" gtk_widget_get_settings :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.Settings.Settings)

{- |
Gets the settings object holding the settings used for this widget.

Note that this function can only be called when the 'GI.Gtk.Objects.Widget.Widget'
is attached to a toplevel, since the settings object is specific
to a particular 'GI.Gdk.Objects.Screen.Screen'.
-}
widgetGetSettings ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.Settings.Settings
    {- ^ __Returns:__ the relevant 'GI.Gtk.Objects.Settings.Settings' object -}
widgetGetSettings widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_settings widget'
    checkUnexpectedReturnNULL "widgetGetSettings" result
    result' <- (newObject Gtk.Settings.Settings) result
    touchManagedPtr widget
    return result'

data WidgetGetSettingsMethodInfo
instance (signature ~ (m Gtk.Settings.Settings), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetSettingsMethodInfo a signature where
    overloadedMethod _ = widgetGetSettings

-- method Widget::get_size_request
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for width, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for height, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_size_request" gtk_widget_get_size_request :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Int32 ->                            -- width : TBasicType TInt
    Ptr Int32 ->                            -- height : TBasicType TInt
    IO ()

{- |
Gets the size request that was explicitly set for the widget using
'GI.Gtk.Objects.Widget.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
'GI.Gtk.Objects.Widget.widgetSetSizeRequest'. To get the size a widget will
actually request, call 'GI.Gtk.Objects.Widget.widgetGetPreferredSize' instead of
this function.
-}
widgetGetSizeRequest ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Int32,Int32)
widgetGetSizeRequest widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    width <- allocMem :: IO (Ptr Int32)
    height <- allocMem :: IO (Ptr Int32)
    gtk_widget_get_size_request widget' width height
    width' <- peek width
    height' <- peek height
    touchManagedPtr widget
    freeMem width
    freeMem height
    return (width', height')

data WidgetGetSizeRequestMethodInfo
instance (signature ~ (m (Int32,Int32)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetSizeRequestMethodInfo a signature where
    overloadedMethod _ = widgetGetSizeRequest

-- method Widget::get_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "StateType"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_state" gtk_widget_get_state :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CUInt

{-# DEPRECATED widgetGetState ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetGetStateFlags' instead."] #-}
{- |
Returns the widget’s state. See 'GI.Gtk.Objects.Widget.widgetSetState'.

@since 2.18
-}
widgetGetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.Enums.StateType
    {- ^ __Returns:__ the state of /@widget@/. -}
widgetGetState widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_state widget'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr widget
    return result'

data WidgetGetStateMethodInfo
instance (signature ~ (m Gtk.Enums.StateType), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetStateMethodInfo a signature where
    overloadedMethod _ = widgetGetState

-- method Widget::get_state_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "StateFlags"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_state_flags" gtk_widget_get_state_flags :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CUInt

{- |
Returns the widget state as a flag set. It is worth mentioning
that the effective 'GI.Gtk.Flags.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
'GI.Gtk.Flags.StateFlags' to pass to a 'GI.Gtk.Objects.StyleContext.StyleContext' method, you
should look at 'GI.Gtk.Objects.StyleContext.styleContextGetState'.

@since 3.0
-}
widgetGetStateFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m [Gtk.Flags.StateFlags]
    {- ^ __Returns:__ The state flags for widget -}
widgetGetStateFlags widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_state_flags widget'
    let result' = wordToGFlags result
    touchManagedPtr widget
    return result'

data WidgetGetStateFlagsMethodInfo
instance (signature ~ (m [Gtk.Flags.StateFlags]), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetStateFlagsMethodInfo a signature where
    overloadedMethod _ = widgetGetStateFlags

-- method Widget::get_style
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Style"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_style" gtk_widget_get_style :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.Style.Style)

{-# DEPRECATED widgetGetStyle ["(Since version 3.0)","Use 'GI.Gtk.Objects.StyleContext.StyleContext' instead"] #-}
{- |
Simply an accessor function that returns /@widget@/->style.
-}
widgetGetStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.Style.Style
    {- ^ __Returns:__ the widget’s 'GI.Gtk.Objects.Style.Style' -}
widgetGetStyle widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_style widget'
    checkUnexpectedReturnNULL "widgetGetStyle" result
    result' <- (newObject Gtk.Style.Style) result
    touchManagedPtr widget
    return result'

data WidgetGetStyleMethodInfo
instance (signature ~ (m Gtk.Style.Style), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetStyleMethodInfo a signature where
    overloadedMethod _ = widgetGetStyle

-- method Widget::get_style_context
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "StyleContext"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_style_context" gtk_widget_get_style_context :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.StyleContext.StyleContext)

{- |
Returns the style context associated to /@widget@/. The returned object is
guaranteed to be the same for the lifetime of /@widget@/.
-}
widgetGetStyleContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.StyleContext.StyleContext
    {- ^ __Returns:__ a 'GI.Gtk.Objects.StyleContext.StyleContext'. This memory is owned by /@widget@/ and
         must not be freed. -}
widgetGetStyleContext widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_style_context widget'
    checkUnexpectedReturnNULL "widgetGetStyleContext" result
    result' <- (newObject Gtk.StyleContext.StyleContext) result
    touchManagedPtr widget
    return result'

data WidgetGetStyleContextMethodInfo
instance (signature ~ (m Gtk.StyleContext.StyleContext), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetStyleContextMethodInfo a signature where
    overloadedMethod _ = widgetGetStyleContext

-- method Widget::get_support_multidevice
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_support_multidevice" gtk_widget_get_support_multidevice :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Returns 'True' if /@widget@/ is multiple pointer aware. See
'GI.Gtk.Objects.Widget.widgetSetSupportMultidevice' for more information.
-}
widgetGetSupportMultidevice ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ is multidevice aware. -}
widgetGetSupportMultidevice widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_support_multidevice widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetSupportMultideviceMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetSupportMultideviceMethodInfo a signature where
    overloadedMethod _ = widgetGetSupportMultidevice

-- method Widget::get_template_child
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GType to get a template child for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The \8220id\8221 of the child defined in the template XML", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GObject", name = "Object"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_template_child" gtk_widget_get_template_child :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CGType ->                               -- widget_type : TBasicType TGType
    CString ->                              -- name : TBasicType TUTF8
    IO (Ptr GObject.Object.Object)

{- |
Fetch an object build from the template XML for /@widgetType@/ in this /@widget@/ instance.

This will only report children which were previously declared with
'GI.Gtk.Structs.WidgetClass.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.
-}
widgetGetTemplateChild ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: A 'GI.Gtk.Objects.Widget.Widget' -}
    -> GType
    {- ^ /@widgetType@/: The 'GType' to get a template child for -}
    -> T.Text
    {- ^ /@name@/: The “id” of the child defined in the template XML -}
    -> m GObject.Object.Object
    {- ^ __Returns:__ The object built in the template XML with the id /@name@/ -}
widgetGetTemplateChild widget widgetType name = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let widgetType' = gtypeToCGType widgetType
    name' <- textToCString name
    result <- gtk_widget_get_template_child widget' widgetType' name'
    checkUnexpectedReturnNULL "widgetGetTemplateChild" result
    result' <- (newObject GObject.Object.Object) result
    touchManagedPtr widget
    freeMem name'
    return result'

data WidgetGetTemplateChildMethodInfo
instance (signature ~ (GType -> T.Text -> m GObject.Object.Object), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetTemplateChildMethodInfo a signature where
    overloadedMethod _ = widgetGetTemplateChild

-- method Widget::get_tooltip_markup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_tooltip_markup" gtk_widget_get_tooltip_markup :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CString

{- |
Gets the contents of the tooltip for /@widget@/.

@since 2.12
-}
widgetGetTooltipMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the tooltip text, or 'Nothing'. You should free the
  returned string with 'GI.GLib.Functions.free' when done. -}
widgetGetTooltipMarkup widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_tooltip_markup widget'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        freeMem result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetGetTooltipMarkupMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetTooltipMarkupMethodInfo a signature where
    overloadedMethod _ = widgetGetTooltipMarkup

-- method Widget::get_tooltip_text
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_tooltip_text" gtk_widget_get_tooltip_text :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CString

{- |
Gets the contents of the tooltip for /@widget@/.

@since 2.12
-}
widgetGetTooltipText ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the tooltip text, or 'Nothing'. You should free the
  returned string with 'GI.GLib.Functions.free' when done. -}
widgetGetTooltipText widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_tooltip_text widget'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        freeMem result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetGetTooltipTextMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetTooltipTextMethodInfo a signature where
    overloadedMethod _ = widgetGetTooltipText

-- method Widget::get_tooltip_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_tooltip_window" gtk_widget_get_tooltip_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gtk.Window.Window)

{- |
Returns the 'GI.Gtk.Objects.Window.Window' of the current tooltip. This can be the
GtkWindow created by default, or the custom tooltip window set
using 'GI.Gtk.Objects.Widget.widgetSetTooltipWindow'.

@since 2.12
-}
widgetGetTooltipWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.Window.Window
    {- ^ __Returns:__ The 'GI.Gtk.Objects.Window.Window' of the current tooltip. -}
widgetGetTooltipWindow widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_tooltip_window widget'
    checkUnexpectedReturnNULL "widgetGetTooltipWindow" result
    result' <- (newObject Gtk.Window.Window) result
    touchManagedPtr widget
    return result'

data WidgetGetTooltipWindowMethodInfo
instance (signature ~ (m Gtk.Window.Window), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetTooltipWindowMethodInfo a signature where
    overloadedMethod _ = widgetGetTooltipWindow

-- method Widget::get_toplevel
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_toplevel" gtk_widget_get_toplevel :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Widget)

{- |
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. 'GI.Gtk.Objects.Widget.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 'GI.Gtk.Objects.Window.Window'-derived widget which was in turn
inside the toplevel 'GI.Gtk.Objects.Window.Window'. While the second case may
seem unlikely, it actually happens when a 'GI.Gtk.Objects.Plug.Plug' is embedded
inside a 'GI.Gtk.Objects.Socket.Socket' within the same application.

To reliably find the toplevel 'GI.Gtk.Objects.Window.Window', use
'GI.Gtk.Objects.Widget.widgetGetToplevel' and call 'GI.Gtk.Objects.Widget.widgetIsToplevel'
on the result.

=== /C code/
>
> GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
> if (gtk_widget_is_toplevel (toplevel))
>   {
>     // Perform action on toplevel.
>   }
-}
widgetGetToplevel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Widget
    {- ^ __Returns:__ the topmost ancestor of /@widget@/, or /@widget@/ itself
   if there’s no ancestor. -}
widgetGetToplevel widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_toplevel widget'
    checkUnexpectedReturnNULL "widgetGetToplevel" result
    result' <- (newObject Widget) result
    touchManagedPtr widget
    return result'

data WidgetGetToplevelMethodInfo
instance (signature ~ (m Widget), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetToplevelMethodInfo a signature where
    overloadedMethod _ = widgetGetToplevel

-- method Widget::get_valign
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Align"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_valign" gtk_widget_get_valign :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CUInt

{- |
Gets the value of the 'GI.Gtk.Objects.Widget.Widget':@/valign/@ property.

For backwards compatibility reasons this method will never return
'GI.Gtk.Enums.AlignBaseline', but instead it will convert it to
'GI.Gtk.Enums.AlignFill'. If your widget want to support baseline aligned
children it must use 'GI.Gtk.Objects.Widget.widgetGetValignWithBaseline', or
@g_object_get (widget, \"valign\", &value, NULL)@, which will
also report the true value.
-}
widgetGetValign ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.Enums.Align
    {- ^ __Returns:__ the vertical alignment of /@widget@/, ignoring baseline alignment -}
widgetGetValign widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_valign widget'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr widget
    return result'

data WidgetGetValignMethodInfo
instance (signature ~ (m Gtk.Enums.Align), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetValignMethodInfo a signature where
    overloadedMethod _ = widgetGetValign

-- method Widget::get_valign_with_baseline
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Align"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_valign_with_baseline" gtk_widget_get_valign_with_baseline :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CUInt

{- |
Gets the value of the 'GI.Gtk.Objects.Widget.Widget':@/valign/@ property, including
'GI.Gtk.Enums.AlignBaseline'.

@since 3.10
-}
widgetGetValignWithBaseline ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gtk.Enums.Align
    {- ^ __Returns:__ the vertical alignment of /@widget@/ -}
widgetGetValignWithBaseline widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_valign_with_baseline widget'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr widget
    return result'

data WidgetGetValignWithBaselineMethodInfo
instance (signature ~ (m Gtk.Enums.Align), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetValignWithBaselineMethodInfo a signature where
    overloadedMethod _ = widgetGetValignWithBaseline

-- method Widget::get_vexpand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_vexpand" gtk_widget_get_vexpand :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

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

See 'GI.Gtk.Objects.Widget.widgetGetHexpand' for more detail.
-}
widgetGetVexpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget -}
    -> m Bool
    {- ^ __Returns:__ whether vexpand flag is set -}
widgetGetVexpand widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_vexpand widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetVexpandMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetVexpandMethodInfo a signature where
    overloadedMethod _ = widgetGetVexpand

-- method Widget::get_vexpand_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_vexpand_set" gtk_widget_get_vexpand_set :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Gets whether 'GI.Gtk.Objects.Widget.widgetSetVexpand' has been used to
explicitly set the expand flag on this widget.

See 'GI.Gtk.Objects.Widget.widgetGetHexpandSet' for more detail.
-}
widgetGetVexpandSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget -}
    -> m Bool
    {- ^ __Returns:__ whether vexpand has been explicitly set -}
widgetGetVexpandSet widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_vexpand_set widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetVexpandSetMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetVexpandSetMethodInfo a signature where
    overloadedMethod _ = widgetGetVexpandSet

-- method Widget::get_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_visible" gtk_widget_get_visible :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether the widget is visible. If you want to
take into account whether the widget’s parent is also marked as
visible, use 'GI.Gtk.Objects.Widget.widgetIsVisible' instead.

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

See 'GI.Gtk.Objects.Widget.widgetSetVisible'.

@since 2.18
-}
widgetGetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget is visible -}
widgetGetVisible widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_visible widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetGetVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetVisibleMethodInfo a signature where
    overloadedMethod _ = widgetGetVisible

-- method Widget::get_visual
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Visual"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_visual" gtk_widget_get_visual :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gdk.Visual.Visual)

{- |
Gets the visual that will be used to render /@widget@/.
-}
widgetGetVisual ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Gdk.Visual.Visual
    {- ^ __Returns:__ the visual for /@widget@/ -}
widgetGetVisual widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_visual widget'
    checkUnexpectedReturnNULL "widgetGetVisual" result
    result' <- (newObject Gdk.Visual.Visual) result
    touchManagedPtr widget
    return result'

data WidgetGetVisualMethodInfo
instance (signature ~ (m Gdk.Visual.Visual), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetVisualMethodInfo a signature where
    overloadedMethod _ = widgetGetVisual

-- method Widget::get_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_window" gtk_widget_get_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr Gdk.Window.Window)

{- |
Returns the widget’s window if it is realized, 'Nothing' otherwise

@since 2.14
-}
widgetGetWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Maybe Gdk.Window.Window)
    {- ^ __Returns:__ /@widget@/’s window. -}
widgetGetWindow widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_get_window widget'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gdk.Window.Window) result'
        return result''
    touchManagedPtr widget
    return maybeResult

data WidgetGetWindowMethodInfo
instance (signature ~ (m (Maybe Gdk.Window.Window)), MonadIO m, IsWidget a) => O.MethodInfo WidgetGetWindowMethodInfo a signature where
    overloadedMethod _ = widgetGetWindow

-- method Widget::grab_add
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The widget that grabs keyboard and pointer events", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_grab_add" gtk_grab_add :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
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.
-}
widgetGrabAdd ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: The widget that grabs keyboard and pointer events -}
    -> m ()
widgetGrabAdd widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_grab_add widget'
    touchManagedPtr widget
    return ()

data WidgetGrabAddMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetGrabAddMethodInfo a signature where
    overloadedMethod _ = widgetGrabAdd

-- method Widget::grab_default
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_grab_default" gtk_widget_grab_default :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Causes /@widget@/ to become the default widget. /@widget@/ must be able to be
a default widget; typically you would ensure this yourself
by calling 'GI.Gtk.Objects.Widget.widgetSetCanDefault' with a 'True' value.
The default widget is activated when
the user presses Enter in a window. Default widgets must be
activatable, that is, 'GI.Gtk.Objects.Widget.widgetActivate' should affect them. Note
that 'GI.Gtk.Objects.Entry.Entry' widgets require the “activates-default” property
set to 'True' before they activate the default widget when Enter
is pressed and the 'GI.Gtk.Objects.Entry.Entry' is focused.
-}
widgetGrabDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetGrabDefault widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_grab_default widget'
    touchManagedPtr widget
    return ()

data WidgetGrabDefaultMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetGrabDefaultMethodInfo a signature where
    overloadedMethod _ = widgetGrabDefault

-- method Widget::grab_focus
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_grab_focus" gtk_widget_grab_focus :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Causes /@widget@/ to have the keyboard focus for the 'GI.Gtk.Objects.Window.Window' it\'s
inside. /@widget@/ must be a focusable widget, such as a 'GI.Gtk.Objects.Entry.Entry';
something like 'GI.Gtk.Objects.Frame.Frame' won’t work.

More precisely, it must have the @/GTK_CAN_FOCUS/@ flag set. Use
'GI.Gtk.Objects.Widget.widgetSetCanFocus' to modify that flag.

The widget also needs to be realized and mapped. This is indicated by the
related signals. Grabbing the focus immediately after creating the widget
will likely fail and cause critical warnings.
-}
widgetGrabFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetGrabFocus widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_grab_focus widget'
    touchManagedPtr widget
    return ()

data WidgetGrabFocusMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetGrabFocusMethodInfo a signature where
    overloadedMethod _ = widgetGrabFocus

-- method Widget::grab_remove
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The widget which gives up the grab", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_grab_remove" gtk_grab_remove :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Removes the grab from the given widget.

You have to pair calls to 'GI.Gtk.Objects.Widget.widgetGrabAdd' and 'GI.Gtk.Objects.Widget.widgetGrabRemove'.

If /@widget@/ does not have the grab, this function does nothing.
-}
widgetGrabRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: The widget which gives up the grab -}
    -> m ()
widgetGrabRemove widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_grab_remove widget'
    touchManagedPtr widget
    return ()

data WidgetGrabRemoveMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetGrabRemoveMethodInfo a signature where
    overloadedMethod _ = widgetGrabRemove

-- method Widget::has_default
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_has_default" gtk_widget_has_default :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether /@widget@/ is the current default widget within its
toplevel. See 'GI.Gtk.Objects.Widget.widgetSetCanDefault'.

@since 2.18
-}
widgetHasDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ is the current default widget within
    its toplevel, 'False' otherwise -}
widgetHasDefault widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_has_default widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetHasDefaultMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetHasDefaultMethodInfo a signature where
    overloadedMethod _ = widgetHasDefault

-- method Widget::has_focus
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_has_focus" gtk_widget_has_focus :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines if the widget has the global input focus. See
'GI.Gtk.Objects.Widget.widgetIsFocus' for the difference between having the global
input focus, and only having the focus within a toplevel.

@since 2.18
-}
widgetHasFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget has the global input focus. -}
widgetHasFocus widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_has_focus widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetHasFocusMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetHasFocusMethodInfo a signature where
    overloadedMethod _ = widgetHasFocus

-- method Widget::has_grab
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_has_grab" gtk_widget_has_grab :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

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

See also 'GI.Gtk.Objects.Widget.widgetGrabAdd'.

@since 2.18
-}
widgetHasGrab ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget is in the grab_widgets stack -}
widgetHasGrab widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_has_grab widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetHasGrabMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetHasGrabMethodInfo a signature where
    overloadedMethod _ = widgetHasGrab

-- method Widget::has_rc_style
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_has_rc_style" gtk_widget_has_rc_style :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{-# DEPRECATED widgetHasRcStyle ["(Since version 3.0)","Use 'GI.Gtk.Objects.StyleContext.StyleContext' instead"] #-}
{- |
Determines if the widget style has been looked up through the rc mechanism.

@since 2.20
-}
widgetHasRcStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget has been looked up through the rc
  mechanism, 'False' otherwise. -}
widgetHasRcStyle widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_has_rc_style widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetHasRcStyleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetHasRcStyleMethodInfo a signature where
    overloadedMethod _ = widgetHasRcStyle

-- method Widget::has_screen
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_has_screen" gtk_widget_has_screen :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Checks whether there is a 'GI.Gdk.Objects.Screen.Screen' is associated with
this widget. All toplevel widgets have an associated
screen, and all widgets added into a hierarchy with a toplevel
window at the top.

@since 2.2
-}
widgetHasScreen ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if there is a 'GI.Gdk.Objects.Screen.Screen' associated
  with the widget. -}
widgetHasScreen widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_has_screen widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetHasScreenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetHasScreenMethodInfo a signature where
    overloadedMethod _ = widgetHasScreen

-- method Widget::has_visible_focus
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_has_visible_focus" gtk_widget_has_visible_focus :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
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 'GI.Gtk.Objects.Window.windowGetFocusVisible' for more information
about focus indication.

To find out if the widget has the global input focus, use
'GI.Gtk.Objects.Widget.widgetHasFocus'.

@since 3.2
-}
widgetHasVisibleFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget should display a “focus rectangle” -}
widgetHasVisibleFocus widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_has_visible_focus widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetHasVisibleFocusMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetHasVisibleFocusMethodInfo a signature where
    overloadedMethod _ = widgetHasVisibleFocus

-- method Widget::hide
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_hide" gtk_widget_hide :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Reverses the effects of 'GI.Gtk.Objects.Widget.widgetShow', causing the widget to be
hidden (invisible to the user).
-}
widgetHide ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetHide widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_hide widget'
    touchManagedPtr widget
    return ()

data WidgetHideMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetHideMethodInfo a signature where
    overloadedMethod _ = widgetHide

-- method Widget::hide_on_delete
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_hide_on_delete" gtk_widget_hide_on_delete :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Utility function; intended to be connected to the 'GI.Gtk.Objects.Widget.Widget'::@/delete-event/@
signal on a 'GI.Gtk.Objects.Window.Window'. The function calls 'GI.Gtk.Objects.Widget.widgetHide' on its
argument, then returns 'True'. If connected to ::delete-event, the
result is that clicking the close button for a window (on the
window frame, top right corner usually) will hide but not destroy
the window. By default, GTK+ destroys windows when ::delete-event
is received.
-}
widgetHideOnDelete ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' -}
widgetHideOnDelete widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_hide_on_delete widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetHideOnDeleteMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetHideOnDeleteMethodInfo a signature where
    overloadedMethod _ = widgetHideOnDelete

-- method Widget::in_destruction
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_in_destruction" gtk_widget_in_destruction :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Returns whether the widget is currently being destroyed.
This information can sometimes be used to avoid doing
unnecessary work.
-}
widgetInDestruction ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ is being destroyed -}
widgetInDestruction widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_in_destruction widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetInDestructionMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetInDestructionMethodInfo a signature where
    overloadedMethod _ = widgetInDestruction

-- method Widget::init_template
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_init_template" gtk_widget_init_template :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
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 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'

It is important to call this function in the instance initializer
of a 'GI.Gtk.Objects.Widget.Widget' subclass and not in 'GI.GObject.Objects.Object.Object'.@/constructed/@() or
'GI.GObject.Objects.Object.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.

@since 3.10
-}
widgetInitTemplate ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetInitTemplate widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_init_template widget'
    touchManagedPtr widget
    return ()

data WidgetInitTemplateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetInitTemplateMethodInfo a signature where
    overloadedMethod _ = widgetInitTemplate

-- method Widget::input_shape_combine_region
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "region", argType = TInterface (Name {namespace = "cairo", name = "Region"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "shape to be added, or %NULL to remove an existing shape", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_input_shape_combine_region" gtk_widget_input_shape_combine_region :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Cairo.Region.Region ->              -- region : TInterface (Name {namespace = "cairo", name = "Region"})
    IO ()

{- |
Sets an input shape for this widget’s GDK window. This allows for
windows which react to mouse click in a nonrectangular region, see
'GI.Gdk.Objects.Window.windowInputShapeCombineRegion' for more information.

@since 3.0
-}
widgetInputShapeCombineRegion ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (Cairo.Region.Region)
    {- ^ /@region@/: shape to be added, or 'Nothing' to remove an existing shape -}
    -> m ()
widgetInputShapeCombineRegion widget region = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeRegion <- case region of
        Nothing -> return nullPtr
        Just jRegion -> do
            jRegion' <- unsafeManagedPtrGetPtr jRegion
            return jRegion'
    gtk_widget_input_shape_combine_region widget' maybeRegion
    touchManagedPtr widget
    whenJust region touchManagedPtr
    return ()

data WidgetInputShapeCombineRegionMethodInfo
instance (signature ~ (Maybe (Cairo.Region.Region) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetInputShapeCombineRegionMethodInfo a signature where
    overloadedMethod _ = widgetInputShapeCombineRegion

-- method Widget::insert_action_group
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the prefix for actions in @group", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group", argType = TInterface (Name {namespace = "Gio", name = "ActionGroup"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GActionGroup, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_insert_action_group" gtk_widget_insert_action_group :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr Gio.ActionGroup.ActionGroup ->      -- group : TInterface (Name {namespace = "Gio", name = "ActionGroup"})
    IO ()

{- |
Inserts /@group@/ into /@widget@/. Children of /@widget@/ that implement
'GI.Gtk.Interfaces.Actionable.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@/.

@since 3.6
-}
widgetInsertActionGroup ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gio.ActionGroup.IsActionGroup b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@name@/: the prefix for actions in /@group@/ -}
    -> Maybe (b)
    {- ^ /@group@/: a 'GI.Gio.Interfaces.ActionGroup.ActionGroup', or 'Nothing' -}
    -> m ()
widgetInsertActionGroup widget name group = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    name' <- textToCString name
    maybeGroup <- case group of
        Nothing -> return nullPtr
        Just jGroup -> do
            jGroup' <- unsafeManagedPtrCastPtr jGroup
            return jGroup'
    gtk_widget_insert_action_group widget' name' maybeGroup
    touchManagedPtr widget
    whenJust group touchManagedPtr
    freeMem name'
    return ()

data WidgetInsertActionGroupMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ()), MonadIO m, IsWidget a, Gio.ActionGroup.IsActionGroup b) => O.MethodInfo WidgetInsertActionGroupMethodInfo a signature where
    overloadedMethod _ = widgetInsertActionGroup

-- method Widget::intersect
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "area", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a rectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "intersection", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle to store intersection of @widget and @area", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_intersect" gtk_widget_intersect :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Rectangle.Rectangle ->          -- area : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Ptr Gdk.Rectangle.Rectangle ->          -- intersection : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO CInt

{- |
Computes the intersection of a /@widget@/’s area and /@area@/, storing
the intersection in /@intersection@/, and returns 'True' if there was
an intersection.  /@intersection@/ may be 'Nothing' if you’re only
interested in whether there was an intersection.
-}
widgetIntersect ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@area@/: a rectangle -}
    -> m (Bool,Gdk.Rectangle.Rectangle)
    {- ^ __Returns:__ 'True' if there was an intersection -}
widgetIntersect widget area = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    area' <- unsafeManagedPtrGetPtr area
    intersection <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
    result <- gtk_widget_intersect widget' area' intersection
    let result' = (/= 0) result
    intersection' <- (wrapBoxed Gdk.Rectangle.Rectangle) intersection
    touchManagedPtr widget
    touchManagedPtr area
    return (result', intersection')

data WidgetIntersectMethodInfo
instance (signature ~ (Gdk.Rectangle.Rectangle -> m (Bool,Gdk.Rectangle.Rectangle)), MonadIO m, IsWidget a) => O.MethodInfo WidgetIntersectMethodInfo a signature where
    overloadedMethod _ = widgetIntersect

-- method Widget::is_ancestor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ancestor", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "another #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_is_ancestor" gtk_widget_is_ancestor :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Widget ->                           -- ancestor : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether /@widget@/ is somewhere inside /@ancestor@/, possibly with
intermediate containers.
-}
widgetIsAncestor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@ancestor@/: another 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@ancestor@/ contains /@widget@/ as a child,
   grandchild, great grandchild, etc. -}
widgetIsAncestor widget ancestor = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    ancestor' <- unsafeManagedPtrCastPtr ancestor
    result <- gtk_widget_is_ancestor widget' ancestor'
    let result' = (/= 0) result
    touchManagedPtr widget
    touchManagedPtr ancestor
    return result'

data WidgetIsAncestorMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsWidget a, IsWidget b) => O.MethodInfo WidgetIsAncestorMethodInfo a signature where
    overloadedMethod _ = widgetIsAncestor

-- method Widget::is_composited
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_is_composited" gtk_widget_is_composited :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{-# DEPRECATED widgetIsComposited ["(Since version 3.22)","Use 'GI.Gdk.Objects.Screen.screenIsComposited' instead."] #-}
{- |
Whether /@widget@/ can rely on having its alpha channel
drawn correctly. On X11 this function returns whether a
compositing manager is running for /@widget@/’s screen.

Please note that the semantics of this call will change
in the future if used on a widget that has a composited
window in its hierarchy (as set by 'GI.Gdk.Objects.Window.windowSetComposited').

@since 2.10
-}
widgetIsComposited ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget can rely on its alpha
channel being drawn correctly. -}
widgetIsComposited widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_is_composited widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetIsCompositedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetIsCompositedMethodInfo a signature where
    overloadedMethod _ = widgetIsComposited

-- method Widget::is_drawable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_is_drawable" gtk_widget_is_drawable :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether /@widget@/ can be drawn to. A widget can be drawn
to if it is mapped and visible.

@since 2.18
-}
widgetIsDrawable ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ is drawable, 'False' otherwise -}
widgetIsDrawable widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_is_drawable widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetIsDrawableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetIsDrawableMethodInfo a signature where
    overloadedMethod _ = widgetIsDrawable

-- method Widget::is_focus
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_is_focus" gtk_widget_is_focus :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines if the widget is the focus widget within its
toplevel. (This does not mean that the 'GI.Gtk.Objects.Widget.Widget':@/has-focus/@ property is
necessarily set; 'GI.Gtk.Objects.Widget.Widget':@/has-focus/@ will only be set if the
toplevel widget additionally has the global input focus.)
-}
widgetIsFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget is the focus widget. -}
widgetIsFocus widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_is_focus widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetIsFocusMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetIsFocusMethodInfo a signature where
    overloadedMethod _ = widgetIsFocus

-- method Widget::is_sensitive
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_is_sensitive" gtk_widget_is_sensitive :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

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

@since 2.18
-}
widgetIsSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget is effectively sensitive -}
widgetIsSensitive widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_is_sensitive widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetIsSensitiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetIsSensitiveMethodInfo a signature where
    overloadedMethod _ = widgetIsSensitive

-- method Widget::is_toplevel
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_is_toplevel" gtk_widget_is_toplevel :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
Determines whether /@widget@/ is a toplevel widget.

Currently only 'GI.Gtk.Objects.Window.Window' and 'GI.Gtk.Objects.Invisible.Invisible' (and out-of-process
@/GtkPlugs/@) are toplevel widgets. Toplevel widgets have no parent
widget.

@since 2.18
-}
widgetIsToplevel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@widget@/ is a toplevel, 'False' otherwise -}
widgetIsToplevel widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_is_toplevel widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetIsToplevelMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetIsToplevelMethodInfo a signature where
    overloadedMethod _ = widgetIsToplevel

-- method Widget::is_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_is_visible" gtk_widget_is_visible :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO CInt

{- |
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 'GI.Gtk.Objects.Widget.widgetGetVisible' and 'GI.Gtk.Objects.Widget.widgetSetVisible'

@since 3.8
-}
widgetIsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the widget and all its parents are visible -}
widgetIsVisible widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_is_visible widget'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetIsVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetIsVisibleMethodInfo a signature where
    overloadedMethod _ = widgetIsVisible

-- method Widget::keynav_failed
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface (Name {namespace = "Gtk", name = "DirectionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "direction of focus movement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_keynav_failed" gtk_widget_keynav_failed :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- direction : TInterface (Name {namespace = "Gtk", name = "DirectionType"})
    IO CInt

{- |
This function should be called whenever keyboard navigation within
a single widget hits a boundary. The function emits the
'GI.Gtk.Objects.Widget.Widget'::@/keynav-failed/@ signal on the widget and its return
value should be interpreted in a way similar to the return value of
'GI.Gtk.Objects.Widget.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
'GI.Gtk.Objects.Widget.widgetChildFocus' on the widget’s toplevel.

The default ::keynav-failed handler returns 'True' for
'GI.Gtk.Enums.DirectionTypeTabForward' and 'GI.Gtk.Enums.DirectionTypeTabBackward'. For the other
values of 'GI.Gtk.Enums.DirectionType' it returns 'False'.

Whenever the default handler returns 'True', it also calls
'GI.Gtk.Objects.Widget.widgetErrorBell' to notify the user of the failed keyboard
navigation.

A use case for providing an own implementation of ::keynav-failed
(either by connecting to it or by overriding it) would be a row of
'GI.Gtk.Objects.Entry.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.

@since 2.12
-}
widgetKeynavFailed ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.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). -}
widgetKeynavFailed widget direction = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let direction' = (fromIntegral . fromEnum) direction
    result <- gtk_widget_keynav_failed widget' direction'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetKeynavFailedMethodInfo
instance (signature ~ (Gtk.Enums.DirectionType -> m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetKeynavFailedMethodInfo a signature where
    overloadedMethod _ = widgetKeynavFailed

-- method Widget::list_accel_closures
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget to list accelerator closures for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GObject", name = "Closure"})))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_list_accel_closures" gtk_widget_list_accel_closures :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr (GList (Ptr Closure)))

{- |
Lists the closures used by /@widget@/ for accelerator group connections
with 'GI.Gtk.Objects.AccelGroup.accelGroupConnectByPath' or 'GI.Gtk.Objects.AccelGroup.accelGroupConnect'.
The closures can be used to monitor accelerator changes on /@widget@/,
by connecting to the /@gtkAccelGroup@/::accel-changed signal of the
'GI.Gtk.Objects.AccelGroup.AccelGroup' of a closure which can be found out with
'GI.Gtk.Objects.AccelGroup.accelGroupFromAccelClosure'.
-}
widgetListAccelClosures ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: widget to list accelerator closures for -}
    -> m [Closure]
    {- ^ __Returns:__ 
    a newly allocated 'GI.GLib.Structs.List.List' of closures -}
widgetListAccelClosures widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_list_accel_closures widget'
    result' <- unpackGList result
    result'' <- mapM (newBoxed Closure) result'
    g_list_free result
    touchManagedPtr widget
    return result''

data WidgetListAccelClosuresMethodInfo
instance (signature ~ (m [Closure]), MonadIO m, IsWidget a) => O.MethodInfo WidgetListAccelClosuresMethodInfo a signature where
    overloadedMethod _ = widgetListAccelClosures

-- method Widget::list_action_prefixes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_list_action_prefixes" gtk_widget_list_action_prefixes :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr CString)

{- |
Retrieves a 'Nothing'-terminated array of strings containing the prefixes of
'GI.Gio.Interfaces.ActionGroup.ActionGroup'\'s available to /@widget@/.

@since 3.16
-}
widgetListActionPrefixes ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: A 'GI.Gtk.Objects.Widget.Widget' -}
    -> m [T.Text]
    {- ^ __Returns:__ a 'Nothing'-terminated array of strings. -}
widgetListActionPrefixes widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_list_action_prefixes widget'
    checkUnexpectedReturnNULL "widgetListActionPrefixes" result
    result' <- unpackZeroTerminatedUTF8CArray result
    freeMem result
    touchManagedPtr widget
    return result'

data WidgetListActionPrefixesMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsWidget a) => O.MethodInfo WidgetListActionPrefixesMethodInfo a signature where
    overloadedMethod _ = widgetListActionPrefixes

-- method Widget::list_mnemonic_labels
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gtk", name = "Widget"})))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_list_mnemonic_labels" gtk_widget_list_mnemonic_labels :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO (Ptr (GList (Ptr Widget)))

{- |
Returns a newly allocated list of the widgets, normally labels, for
which this widget is the target of a mnemonic (see for example,
'GI.Gtk.Objects.Label.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.

@since 2.4
-}
widgetListMnemonicLabels ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m [Widget]
    {- ^ __Returns:__ the list of
 mnemonic labels; free this list
 with @/g_list_free()/@ when you are done with it. -}
widgetListMnemonicLabels widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    result <- gtk_widget_list_mnemonic_labels widget'
    result' <- unpackGList result
    result'' <- mapM (newObject Widget) result'
    g_list_free result
    touchManagedPtr widget
    return result''

data WidgetListMnemonicLabelsMethodInfo
instance (signature ~ (m [Widget]), MonadIO m, IsWidget a) => O.MethodInfo WidgetListMnemonicLabelsMethodInfo a signature where
    overloadedMethod _ = widgetListMnemonicLabels

-- method Widget::map
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_map" gtk_widget_map :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
This function is only for use in widget implementations. Causes
a widget to be mapped if it isn’t already.
-}
widgetMap ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetMap widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_map widget'
    touchManagedPtr widget
    return ()

data WidgetMapMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetMapMethodInfo a signature where
    overloadedMethod _ = widgetMap

-- method Widget::mnemonic_activate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_cycling", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if there are other widgets with the same mnemonic", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_mnemonic_activate" gtk_widget_mnemonic_activate :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- group_cycling : TBasicType TBoolean
    IO CInt

{- |
Emits the 'GI.Gtk.Objects.Widget.Widget'::@/mnemonic-activate/@ signal.

The default handler for this signal activates the /@widget@/ if
/@groupCycling@/ is 'False', and just grabs the focus if /@groupCycling@/
is 'True'.
-}
widgetMnemonicActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@groupCycling@/: 'True' if there are other widgets with the same mnemonic -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the signal has been handled -}
widgetMnemonicActivate widget groupCycling = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let groupCycling' = (fromIntegral . fromEnum) groupCycling
    result <- gtk_widget_mnemonic_activate widget' groupCycling'
    let result' = (/= 0) result
    touchManagedPtr widget
    return result'

data WidgetMnemonicActivateMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetMnemonicActivateMethodInfo a signature where
    overloadedMethod _ = widgetMnemonicActivate

-- method Widget::modify_base
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the state for which to set the base color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to assign (does not need to\n    be allocated), or %NULL to undo the effect of previous\n    calls to of gtk_widget_modify_base().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_modify_base" gtk_widget_modify_base :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateType"})
    Ptr Gdk.Color.Color ->                  -- color : TInterface (Name {namespace = "Gdk", name = "Color"})
    IO ()

{-# DEPRECATED widgetModifyBase ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetOverrideBackgroundColor' instead"] #-}
{- |
Sets the base color for a widget in a particular state.
All other style values are left untouched. The base color
is the background color used along with the text color
(see 'GI.Gtk.Objects.Widget.widgetModifyText') for widgets such as 'GI.Gtk.Objects.Entry.Entry'
and 'GI.Gtk.Objects.TextView.TextView'. See also 'GI.Gtk.Objects.Widget.widgetModifyStyle'.

> Note that “no window” widgets (which have the @/GTK_NO_WINDOW/@
> flag set) draw on their parent container’s window and thus may
> not draw any background themselves. This is the case for e.g.
> 'GI.Gtk.Objects.Label.Label'.
>
> To modify the background of such widgets, you have to set the
> base color on their parent; if you want to set the background
> of a rectangular area around a label, try placing the label in
> a 'GI.Gtk.Objects.EventBox.EventBox' widget and setting the base color on that.
-}
widgetModifyBase ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.StateType
    {- ^ /@state@/: the state for which to set the base color -}
    -> Maybe (Gdk.Color.Color)
    {- ^ /@color@/: the color to assign (does not need to
    be allocated), or 'Nothing' to undo the effect of previous
    calls to of 'GI.Gtk.Objects.Widget.widgetModifyBase'. -}
    -> m ()
widgetModifyBase widget state color = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let state' = (fromIntegral . fromEnum) state
    maybeColor <- case color of
        Nothing -> return nullPtr
        Just jColor -> do
            jColor' <- unsafeManagedPtrGetPtr jColor
            return jColor'
    gtk_widget_modify_base widget' state' maybeColor
    touchManagedPtr widget
    whenJust color touchManagedPtr
    return ()

data WidgetModifyBaseMethodInfo
instance (signature ~ (Gtk.Enums.StateType -> Maybe (Gdk.Color.Color) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetModifyBaseMethodInfo a signature where
    overloadedMethod _ = widgetModifyBase

-- method Widget::modify_bg
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the state for which to set the background color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to assign (does not need\n    to be allocated), or %NULL to undo the effect of previous\n    calls to of gtk_widget_modify_bg().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_modify_bg" gtk_widget_modify_bg :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateType"})
    Ptr Gdk.Color.Color ->                  -- color : TInterface (Name {namespace = "Gdk", name = "Color"})
    IO ()

{-# DEPRECATED widgetModifyBg ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetOverrideBackgroundColor' instead"] #-}
{- |
Sets the background color for a widget in a particular state.

All other style values are left untouched.
See also 'GI.Gtk.Objects.Widget.widgetModifyStyle'.

> Note that “no window” widgets (which have the @/GTK_NO_WINDOW/@
> flag set) draw on their parent container’s window and thus may
> not draw any background themselves. This is the case for e.g.
> 'GI.Gtk.Objects.Label.Label'.
>
> To modify the background of such widgets, you have to set the
> background color on their parent; if you want to set the background
> of a rectangular area around a label, try placing the label in
> a 'GI.Gtk.Objects.EventBox.EventBox' widget and setting the background color on that.
-}
widgetModifyBg ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.StateType
    {- ^ /@state@/: the state for which to set the background color -}
    -> Maybe (Gdk.Color.Color)
    {- ^ /@color@/: the color to assign (does not need
    to be allocated), or 'Nothing' to undo the effect of previous
    calls to of 'GI.Gtk.Objects.Widget.widgetModifyBg'. -}
    -> m ()
widgetModifyBg widget state color = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let state' = (fromIntegral . fromEnum) state
    maybeColor <- case color of
        Nothing -> return nullPtr
        Just jColor -> do
            jColor' <- unsafeManagedPtrGetPtr jColor
            return jColor'
    gtk_widget_modify_bg widget' state' maybeColor
    touchManagedPtr widget
    whenJust color touchManagedPtr
    return ()

data WidgetModifyBgMethodInfo
instance (signature ~ (Gtk.Enums.StateType -> Maybe (Gdk.Color.Color) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetModifyBgMethodInfo a signature where
    overloadedMethod _ = widgetModifyBg

-- method Widget::modify_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "primary", argType = TInterface (Name {namespace = "Gdk", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to use for primary cursor (does not\n    need to be allocated), or %NULL to undo the effect of previous\n    calls to of gtk_widget_modify_cursor().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "secondary", argType = TInterface (Name {namespace = "Gdk", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to use for secondary cursor (does\n    not need to be allocated), or %NULL to undo the effect of\n    previous calls to of gtk_widget_modify_cursor().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_modify_cursor" gtk_widget_modify_cursor :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Color.Color ->                  -- primary : TInterface (Name {namespace = "Gdk", name = "Color"})
    Ptr Gdk.Color.Color ->                  -- secondary : TInterface (Name {namespace = "Gdk", name = "Color"})
    IO ()

{-# DEPRECATED widgetModifyCursor ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetOverrideCursor' instead."] #-}
{- |
Sets the cursor color to use in a widget, overriding the 'GI.Gtk.Objects.Widget.Widget'
cursor-color and secondary-cursor-color
style properties.

All other style values are left untouched.
See also 'GI.Gtk.Objects.Widget.widgetModifyStyle'.

@since 2.12
-}
widgetModifyCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (Gdk.Color.Color)
    {- ^ /@primary@/: the color to use for primary cursor (does not
    need to be allocated), or 'Nothing' to undo the effect of previous
    calls to of 'GI.Gtk.Objects.Widget.widgetModifyCursor'. -}
    -> Maybe (Gdk.Color.Color)
    {- ^ /@secondary@/: the color to use for secondary cursor (does
    not need to be allocated), or 'Nothing' to undo the effect of
    previous calls to of 'GI.Gtk.Objects.Widget.widgetModifyCursor'. -}
    -> m ()
widgetModifyCursor widget primary secondary = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybePrimary <- case primary of
        Nothing -> return nullPtr
        Just jPrimary -> do
            jPrimary' <- unsafeManagedPtrGetPtr jPrimary
            return jPrimary'
    maybeSecondary <- case secondary of
        Nothing -> return nullPtr
        Just jSecondary -> do
            jSecondary' <- unsafeManagedPtrGetPtr jSecondary
            return jSecondary'
    gtk_widget_modify_cursor widget' maybePrimary maybeSecondary
    touchManagedPtr widget
    whenJust primary touchManagedPtr
    whenJust secondary touchManagedPtr
    return ()

data WidgetModifyCursorMethodInfo
instance (signature ~ (Maybe (Gdk.Color.Color) -> Maybe (Gdk.Color.Color) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetModifyCursorMethodInfo a signature where
    overloadedMethod _ = widgetModifyCursor

-- method Widget::modify_fg
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the state for which to set the foreground color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to assign (does not need to be allocated),\n    or %NULL to undo the effect of previous calls to\n    of gtk_widget_modify_fg().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_modify_fg" gtk_widget_modify_fg :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateType"})
    Ptr Gdk.Color.Color ->                  -- color : TInterface (Name {namespace = "Gdk", name = "Color"})
    IO ()

{-# DEPRECATED widgetModifyFg ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetOverrideColor' instead"] #-}
{- |
Sets the foreground color for a widget in a particular state.

All other style values are left untouched.
See also 'GI.Gtk.Objects.Widget.widgetModifyStyle'.
-}
widgetModifyFg ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.StateType
    {- ^ /@state@/: the state for which to set the foreground color -}
    -> Maybe (Gdk.Color.Color)
    {- ^ /@color@/: the color to assign (does not need to be allocated),
    or 'Nothing' to undo the effect of previous calls to
    of 'GI.Gtk.Objects.Widget.widgetModifyFg'. -}
    -> m ()
widgetModifyFg widget state color = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let state' = (fromIntegral . fromEnum) state
    maybeColor <- case color of
        Nothing -> return nullPtr
        Just jColor -> do
            jColor' <- unsafeManagedPtrGetPtr jColor
            return jColor'
    gtk_widget_modify_fg widget' state' maybeColor
    touchManagedPtr widget
    whenJust color touchManagedPtr
    return ()

data WidgetModifyFgMethodInfo
instance (signature ~ (Gtk.Enums.StateType -> Maybe (Gdk.Color.Color) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetModifyFgMethodInfo a signature where
    overloadedMethod _ = widgetModifyFg

-- method Widget::modify_font
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_desc", argType = TInterface (Name {namespace = "Pango", name = "FontDescription"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the font description to use, or %NULL\n    to undo the effect of previous calls to gtk_widget_modify_font()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_modify_font" gtk_widget_modify_font :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Pango.FontDescription.FontDescription -> -- font_desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
    IO ()

{-# DEPRECATED widgetModifyFont ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetOverrideFont' instead"] #-}
{- |
Sets the font to use for a widget.

All other style values are left untouched.
See also 'GI.Gtk.Objects.Widget.widgetModifyStyle'.
-}
widgetModifyFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (Pango.FontDescription.FontDescription)
    {- ^ /@fontDesc@/: the font description to use, or 'Nothing'
    to undo the effect of previous calls to 'GI.Gtk.Objects.Widget.widgetModifyFont' -}
    -> m ()
widgetModifyFont widget fontDesc = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeFontDesc <- case fontDesc of
        Nothing -> return nullPtr
        Just jFontDesc -> do
            jFontDesc' <- unsafeManagedPtrGetPtr jFontDesc
            return jFontDesc'
    gtk_widget_modify_font widget' maybeFontDesc
    touchManagedPtr widget
    whenJust fontDesc touchManagedPtr
    return ()

data WidgetModifyFontMethodInfo
instance (signature ~ (Maybe (Pango.FontDescription.FontDescription) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetModifyFontMethodInfo a signature where
    overloadedMethod _ = widgetModifyFont

-- method Widget::modify_style
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "style", argType = TInterface (Name {namespace = "Gtk", name = "RcStyle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GtkRcStyle-struct holding the style modifications", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_modify_style" gtk_widget_modify_style :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.RcStyle.RcStyle ->              -- style : TInterface (Name {namespace = "Gtk", name = "RcStyle"})
    IO ()

{-# DEPRECATED widgetModifyStyle ["(Since version 3.0)","Use 'GI.Gtk.Objects.StyleContext.StyleContext' with a custom 'GI.Gtk.Interfaces.StyleProvider.StyleProvider' instead"] #-}
{- |
Modifies style values on the widget.

Modifications made using this technique take precedence over
style values set via an RC file, however, they will be overridden
if a style is explicitly set on the widget using 'GI.Gtk.Objects.Widget.widgetSetStyle'.
The 'GI.Gtk.Objects.RcStyle.RcStyle'-struct is designed so each field can either be
set or unset, so it is possible, using this function, to modify some
style values and leave the others unchanged.

Note that modifications made with this function are not cumulative
with previous calls to 'GI.Gtk.Objects.Widget.widgetModifyStyle' or with such
functions as 'GI.Gtk.Objects.Widget.widgetModifyFg'. If you wish to retain
previous values, you must first call 'GI.Gtk.Objects.Widget.widgetGetModifierStyle',
make your modifications to the returned style, then call
'GI.Gtk.Objects.Widget.widgetModifyStyle' with that style. On the other hand,
if you first call 'GI.Gtk.Objects.Widget.widgetModifyStyle', subsequent calls
to such functions 'GI.Gtk.Objects.Widget.widgetModifyFg' will have a cumulative
effect with the initial modifications.
-}
widgetModifyStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gtk.RcStyle.IsRcStyle b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@style@/: the 'GI.Gtk.Objects.RcStyle.RcStyle'-struct holding the style modifications -}
    -> m ()
widgetModifyStyle widget style = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    style' <- unsafeManagedPtrCastPtr style
    gtk_widget_modify_style widget' style'
    touchManagedPtr widget
    touchManagedPtr style
    return ()

data WidgetModifyStyleMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, Gtk.RcStyle.IsRcStyle b) => O.MethodInfo WidgetModifyStyleMethodInfo a signature where
    overloadedMethod _ = widgetModifyStyle

-- method Widget::modify_text
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the state for which to set the text color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to assign (does not need to\n    be allocated), or %NULL to undo the effect of previous\n    calls to of gtk_widget_modify_text().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_modify_text" gtk_widget_modify_text :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateType"})
    Ptr Gdk.Color.Color ->                  -- color : TInterface (Name {namespace = "Gdk", name = "Color"})
    IO ()

{-# DEPRECATED widgetModifyText ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetOverrideColor' instead"] #-}
{- |
Sets the text color for a widget in a particular state.

All other style values are left untouched.
The text color is the foreground color used along with the
base color (see 'GI.Gtk.Objects.Widget.widgetModifyBase') for widgets such
as 'GI.Gtk.Objects.Entry.Entry' and 'GI.Gtk.Objects.TextView.TextView'.
See also 'GI.Gtk.Objects.Widget.widgetModifyStyle'.
-}
widgetModifyText ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.StateType
    {- ^ /@state@/: the state for which to set the text color -}
    -> Maybe (Gdk.Color.Color)
    {- ^ /@color@/: the color to assign (does not need to
    be allocated), or 'Nothing' to undo the effect of previous
    calls to of 'GI.Gtk.Objects.Widget.widgetModifyText'. -}
    -> m ()
widgetModifyText widget state color = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let state' = (fromIntegral . fromEnum) state
    maybeColor <- case color of
        Nothing -> return nullPtr
        Just jColor -> do
            jColor' <- unsafeManagedPtrGetPtr jColor
            return jColor'
    gtk_widget_modify_text widget' state' maybeColor
    touchManagedPtr widget
    whenJust color touchManagedPtr
    return ()

data WidgetModifyTextMethodInfo
instance (signature ~ (Gtk.Enums.StateType -> Maybe (Gdk.Color.Color) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetModifyTextMethodInfo a signature where
    overloadedMethod _ = widgetModifyText

-- method Widget::override_background_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the state for which to set the background color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to assign, or %NULL to undo the effect\n    of previous calls to gtk_widget_override_background_color()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_override_background_color" gtk_widget_override_background_color :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{-# DEPRECATED widgetOverrideBackgroundColor ["(Since version 3.16)","This function is not useful in the context of CSS-based","  rendering. If you wish to change the way a widget renders its background","  you should use a custom CSS style, through an application-specific","  'GI.Gtk.Interfaces.StyleProvider.StyleProvider' and a CSS style class. You can also override the default","  drawing of a widget through the 'GI.Gtk.Objects.Widget.Widget'::@/draw/@ signal, and use Cairo to","  draw a specific color, regardless of the CSS style."] #-}
{- |
Sets the background color to use for a widget.

All other style values are left untouched.
See 'GI.Gtk.Objects.Widget.widgetOverrideColor'.

@since 3.0
-}
widgetOverrideBackgroundColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: the state for which to set the background color -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@color@/: the color to assign, or 'Nothing' to undo the effect
    of previous calls to 'GI.Gtk.Objects.Widget.widgetOverrideBackgroundColor' -}
    -> m ()
widgetOverrideBackgroundColor widget state color = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let state' = gflagsToWord state
    maybeColor <- case color of
        Nothing -> return nullPtr
        Just jColor -> do
            jColor' <- unsafeManagedPtrGetPtr jColor
            return jColor'
    gtk_widget_override_background_color widget' state' maybeColor
    touchManagedPtr widget
    whenJust color touchManagedPtr
    return ()

data WidgetOverrideBackgroundColorMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetOverrideBackgroundColorMethodInfo a signature where
    overloadedMethod _ = widgetOverrideBackgroundColor

-- method Widget::override_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the state for which to set the color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to assign, or %NULL to undo the effect\n    of previous calls to gtk_widget_override_color()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_override_color" gtk_widget_override_color :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{-# DEPRECATED widgetOverrideColor ["(Since version 3.16)","Use a custom style provider and style classes instead"] #-}
{- |
Sets the color to use for a widget.

All other style values are left untouched.

This function does not act recursively. Setting the color of a
container does not affect its children. Note that some widgets that
you may not think of as containers, for instance @/GtkButtons/@,
are actually containers.

This API is mostly meant as a quick way for applications to
change a widget appearance. If you are developing a widgets
library and intend this change to be themeable, it is better
done by setting meaningful CSS classes in your
widget\/container implementation through 'GI.Gtk.Objects.StyleContext.styleContextAddClass'.

This way, your widget library can install a 'GI.Gtk.Objects.CssProvider.CssProvider'
with the 'GI.Gtk.Constants.STYLE_PROVIDER_PRIORITY_FALLBACK' priority in order
to provide a default styling for those widgets that need so, and
this theming may fully overridden by the user’s theme.

Note that for complex widgets this may bring in undesired
results (such as uniform background color everywhere), in
these cases it is better to fully style such widgets through a
'GI.Gtk.Objects.CssProvider.CssProvider' with the 'GI.Gtk.Constants.STYLE_PROVIDER_PRIORITY_APPLICATION'
priority.

@since 3.0
-}
widgetOverrideColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@state@/: the state for which to set the color -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@color@/: the color to assign, or 'Nothing' to undo the effect
    of previous calls to 'GI.Gtk.Objects.Widget.widgetOverrideColor' -}
    -> m ()
widgetOverrideColor widget state color = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let state' = gflagsToWord state
    maybeColor <- case color of
        Nothing -> return nullPtr
        Just jColor -> do
            jColor' <- unsafeManagedPtrGetPtr jColor
            return jColor'
    gtk_widget_override_color widget' state' maybeColor
    touchManagedPtr widget
    whenJust color touchManagedPtr
    return ()

data WidgetOverrideColorMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetOverrideColorMethodInfo a signature where
    overloadedMethod _ = widgetOverrideColor

-- method Widget::override_cursor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cursor", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to use for primary cursor (does not need to be\n    allocated), or %NULL to undo the effect of previous calls to\n    of gtk_widget_override_cursor().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "secondary_cursor", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to use for secondary cursor (does not\n    need to be allocated), or %NULL to undo the effect of previous\n    calls to of gtk_widget_override_cursor().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_override_cursor" gtk_widget_override_cursor :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.RGBA.RGBA ->                    -- cursor : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    Ptr Gdk.RGBA.RGBA ->                    -- secondary_cursor : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{-# DEPRECATED widgetOverrideCursor ["(Since version 3.16)","This function is not useful in the context of CSS-based","  rendering. If you wish to change the color used to render the primary","  and secondary cursors you should use a custom CSS style, through an","  application-specific 'GI.Gtk.Interfaces.StyleProvider.StyleProvider' and a CSS style class."] #-}
{- |
Sets the cursor color to use in a widget, overriding the
cursor-color and secondary-cursor-color
style properties. All other style values are left untouched.
See also 'GI.Gtk.Objects.Widget.widgetModifyStyle'.

Note that the underlying properties have the 'GI.Gdk.Structs.Color.Color' type,
so the alpha value in /@primary@/ and /@secondary@/ will be ignored.

@since 3.0
-}
widgetOverrideCursor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@cursor@/: the color to use for primary cursor (does not need to be
    allocated), or 'Nothing' to undo the effect of previous calls to
    of 'GI.Gtk.Objects.Widget.widgetOverrideCursor'. -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@secondaryCursor@/: the color to use for secondary cursor (does not
    need to be allocated), or 'Nothing' to undo the effect of previous
    calls to of 'GI.Gtk.Objects.Widget.widgetOverrideCursor'. -}
    -> m ()
widgetOverrideCursor widget cursor secondaryCursor = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeCursor <- case cursor of
        Nothing -> return nullPtr
        Just jCursor -> do
            jCursor' <- unsafeManagedPtrGetPtr jCursor
            return jCursor'
    maybeSecondaryCursor <- case secondaryCursor of
        Nothing -> return nullPtr
        Just jSecondaryCursor -> do
            jSecondaryCursor' <- unsafeManagedPtrGetPtr jSecondaryCursor
            return jSecondaryCursor'
    gtk_widget_override_cursor widget' maybeCursor maybeSecondaryCursor
    touchManagedPtr widget
    whenJust cursor touchManagedPtr
    whenJust secondaryCursor touchManagedPtr
    return ()

data WidgetOverrideCursorMethodInfo
instance (signature ~ (Maybe (Gdk.RGBA.RGBA) -> Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetOverrideCursorMethodInfo a signature where
    overloadedMethod _ = widgetOverrideCursor

-- method Widget::override_font
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_desc", argType = TInterface (Name {namespace = "Pango", name = "FontDescription"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the font description to use, or %NULL to undo\n    the effect of previous calls to gtk_widget_override_font()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_override_font" gtk_widget_override_font :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Pango.FontDescription.FontDescription -> -- font_desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
    IO ()

{-# DEPRECATED widgetOverrideFont ["(Since version 3.16)","This function is not useful in the context of CSS-based","  rendering. If you wish to change the font a widget uses to render its text","  you should use a custom CSS style, through an application-specific","  'GI.Gtk.Interfaces.StyleProvider.StyleProvider' and a CSS style class."] #-}
{- |
Sets the font to use for a widget. All other style values are
left untouched. See 'GI.Gtk.Objects.Widget.widgetOverrideColor'.

@since 3.0
-}
widgetOverrideFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (Pango.FontDescription.FontDescription)
    {- ^ /@fontDesc@/: the font description to use, or 'Nothing' to undo
    the effect of previous calls to 'GI.Gtk.Objects.Widget.widgetOverrideFont' -}
    -> m ()
widgetOverrideFont widget fontDesc = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeFontDesc <- case fontDesc of
        Nothing -> return nullPtr
        Just jFontDesc -> do
            jFontDesc' <- unsafeManagedPtrGetPtr jFontDesc
            return jFontDesc'
    gtk_widget_override_font widget' maybeFontDesc
    touchManagedPtr widget
    whenJust fontDesc touchManagedPtr
    return ()

data WidgetOverrideFontMethodInfo
instance (signature ~ (Maybe (Pango.FontDescription.FontDescription) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetOverrideFontMethodInfo a signature where
    overloadedMethod _ = widgetOverrideFont

-- method Widget::override_symbolic_color
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the symbolic color to modify", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Gdk", name = "RGBA"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the color to assign (does not need\n    to be allocated), or %NULL to undo the effect of previous\n    calls to gtk_widget_override_symbolic_color()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_override_symbolic_color" gtk_widget_override_symbolic_color :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- name : TBasicType TUTF8
    Ptr Gdk.RGBA.RGBA ->                    -- color : TInterface (Name {namespace = "Gdk", name = "RGBA"})
    IO ()

{-# DEPRECATED widgetOverrideSymbolicColor ["(Since version 3.16)","This function is not useful in the context of CSS-based","  rendering. If you wish to change the color used to render symbolic icons","  you should use a custom CSS style, through an application-specific","  'GI.Gtk.Interfaces.StyleProvider.StyleProvider' and a CSS style class."] #-}
{- |
Sets a symbolic color for a widget.

All other style values are left untouched.
See 'GI.Gtk.Objects.Widget.widgetOverrideColor' for overriding the foreground
or background color.

@since 3.0
-}
widgetOverrideSymbolicColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@name@/: the name of the symbolic color to modify -}
    -> Maybe (Gdk.RGBA.RGBA)
    {- ^ /@color@/: the color to assign (does not need
    to be allocated), or 'Nothing' to undo the effect of previous
    calls to 'GI.Gtk.Objects.Widget.widgetOverrideSymbolicColor' -}
    -> m ()
widgetOverrideSymbolicColor widget name color = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    name' <- textToCString name
    maybeColor <- case color of
        Nothing -> return nullPtr
        Just jColor -> do
            jColor' <- unsafeManagedPtrGetPtr jColor
            return jColor'
    gtk_widget_override_symbolic_color widget' name' maybeColor
    touchManagedPtr widget
    whenJust color touchManagedPtr
    freeMem name'
    return ()

data WidgetOverrideSymbolicColorMethodInfo
instance (signature ~ (T.Text -> Maybe (Gdk.RGBA.RGBA) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetOverrideSymbolicColorMethodInfo a signature where
    overloadedMethod _ = widgetOverrideSymbolicColor

-- method Widget::path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_length", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store length of the path,\n    or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store allocated path string,\n    or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "path_reversed", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store allocated reverse\n    path string, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_path" gtk_widget_path :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Word32 ->                           -- path_length : TBasicType TUInt
    Ptr CString ->                          -- path : TBasicType TUTF8
    Ptr CString ->                          -- path_reversed : TBasicType TUTF8
    IO ()

{-# DEPRECATED widgetPath ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetGetPath' instead"] #-}
{- |
Obtains the full path to /@widget@/. The path is simply the name of a
widget and all its parents in the container hierarchy, separated by
periods. The name of a widget comes from
'GI.Gtk.Objects.Widget.widgetGetName'. Paths are used to apply styles to a widget
in gtkrc configuration files. Widget names are the type of the
widget by default (e.g. “GtkButton”) or can be set to an
application-specific value with 'GI.Gtk.Objects.Widget.widgetSetName'. By setting
the name of a widget, you allow users or theme authors to apply
styles to that specific widget in their gtkrc
file. /@pathReversedP@/ fills in the path in reverse order,
i.e. starting with /@widget@/’s name instead of starting with the name
of /@widget@/’s outermost ancestor.
-}
widgetPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Word32,T.Text,T.Text)
widgetPath widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    pathLength <- allocMem :: IO (Ptr Word32)
    path <- allocMem :: IO (Ptr CString)
    pathReversed <- allocMem :: IO (Ptr CString)
    gtk_widget_path widget' pathLength path pathReversed
    pathLength' <- peek pathLength
    path' <- peek path
    path'' <- cstringToText path'
    freeMem path'
    pathReversed' <- peek pathReversed
    pathReversed'' <- cstringToText pathReversed'
    freeMem pathReversed'
    touchManagedPtr widget
    freeMem pathLength
    freeMem path
    freeMem pathReversed
    return (pathLength', path'', pathReversed'')

data WidgetPathMethodInfo
instance (signature ~ (m (Word32,T.Text,T.Text)), MonadIO m, IsWidget a) => O.MethodInfo WidgetPathMethodInfo a signature where
    overloadedMethod _ = widgetPath

-- method Widget::queue_allocate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_queue_allocate" gtk_widget_queue_allocate :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
This function is only for use in widget implementations.

Flags the widget for a rerun of the GtkWidgetClass::size_allocate
function. Use this function instead of 'GI.Gtk.Objects.Widget.widgetQueueResize'
when the /@widget@/\'s size request didn\'t change but it wants to
reposition its contents.

An example user of this function is 'GI.Gtk.Objects.Widget.widgetSetHalign'.

@since 3.20
-}
widgetQueueAllocate ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetQueueAllocate widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_queue_allocate widget'
    touchManagedPtr widget
    return ()

data WidgetQueueAllocateMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetQueueAllocateMethodInfo a signature where
    overloadedMethod _ = widgetQueueAllocate

-- method Widget::queue_compute_expand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_queue_compute_expand" gtk_widget_queue_compute_expand :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
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 'GI.Gtk.Objects.Widget.widgetComputeExpand'.
-}
widgetQueueComputeExpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetQueueComputeExpand widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_queue_compute_expand widget'
    touchManagedPtr widget
    return ()

data WidgetQueueComputeExpandMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetQueueComputeExpandMethodInfo a signature where
    overloadedMethod _ = widgetQueueComputeExpand

-- method Widget::queue_draw
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_queue_draw" gtk_widget_queue_draw :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Equivalent to calling 'GI.Gtk.Objects.Widget.widgetQueueDrawArea' for the
entire area of a widget.
-}
widgetQueueDraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetQueueDraw widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_queue_draw widget'
    touchManagedPtr widget
    return ()

data WidgetQueueDrawMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetQueueDrawMethodInfo a signature where
    overloadedMethod _ = widgetQueueDraw

-- method Widget::queue_draw_area
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "x coordinate of upper-left corner of rectangle to redraw", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "y coordinate of upper-left corner of rectangle to redraw", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width of region to draw", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height of region to draw", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_queue_draw_area" gtk_widget_queue_draw_area :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- x : TBasicType TInt
    Int32 ->                                -- y : TBasicType TInt
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    IO ()

{- |
Convenience function that calls 'GI.Gtk.Objects.Widget.widgetQueueDrawRegion' on
the region created from the given coordinates.

The region here is specified in widget coordinates.
Widget coordinates are a bit odd; for historical reasons, they are
defined as /@widget@/->window coordinates for widgets that return 'True' for
'GI.Gtk.Objects.Widget.widgetGetHasWindow', and are relative to /@widget@/->allocation.x,
/@widget@/->allocation.y otherwise.

/@width@/ or /@height@/ may be 0, in this case this function does
nothing. Negative values for /@width@/ and /@height@/ are not allowed.
-}
widgetQueueDrawArea ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@x@/: x coordinate of upper-left corner of rectangle to redraw -}
    -> Int32
    {- ^ /@y@/: y coordinate of upper-left corner of rectangle to redraw -}
    -> Int32
    {- ^ /@width@/: width of region to draw -}
    -> Int32
    {- ^ /@height@/: height of region to draw -}
    -> m ()
widgetQueueDrawArea widget x y width height = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_queue_draw_area widget' x y width height
    touchManagedPtr widget
    return ()

data WidgetQueueDrawAreaMethodInfo
instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetQueueDrawAreaMethodInfo a signature where
    overloadedMethod _ = widgetQueueDrawArea

-- method Widget::queue_draw_region
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "region", argType = TInterface (Name {namespace = "cairo", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "region to draw", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_queue_draw_region" gtk_widget_queue_draw_region :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Cairo.Region.Region ->              -- region : TInterface (Name {namespace = "cairo", name = "Region"})
    IO ()

{- |
Invalidates the area of /@widget@/ defined by /@region@/ by calling
'GI.Gdk.Objects.Window.windowInvalidateRegion' on the widget’s window and all its
child windows. Once the main loop becomes idle (after the current
batch of events has been processed, roughly), the window will
receive expose events for the union of all regions that have been
invalidated.

Normally you would only use this function in widget
implementations. You might also use it to schedule a redraw of a
'GI.Gtk.Objects.DrawingArea.DrawingArea' or some portion thereof.

@since 3.0
-}
widgetQueueDrawRegion ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Cairo.Region.Region
    {- ^ /@region@/: region to draw -}
    -> m ()
widgetQueueDrawRegion widget region = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    region' <- unsafeManagedPtrGetPtr region
    gtk_widget_queue_draw_region widget' region'
    touchManagedPtr widget
    touchManagedPtr region
    return ()

data WidgetQueueDrawRegionMethodInfo
instance (signature ~ (Cairo.Region.Region -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetQueueDrawRegionMethodInfo a signature where
    overloadedMethod _ = widgetQueueDrawRegion

-- method Widget::queue_resize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_queue_resize" gtk_widget_queue_resize :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
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 'GI.Gtk.Objects.Label.Label', 'GI.Gtk.Objects.Label.Label'
queues a resize to ensure there’s enough space for the new text.

Note that you cannot call 'GI.Gtk.Objects.Widget.widgetQueueResize' on a widget
from inside its implementation of the GtkWidgetClass::size_allocate
virtual method. Calls to 'GI.Gtk.Objects.Widget.widgetQueueResize' from inside
GtkWidgetClass::size_allocate will be silently ignored.
-}
widgetQueueResize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetQueueResize widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_queue_resize widget'
    touchManagedPtr widget
    return ()

data WidgetQueueResizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetQueueResizeMethodInfo a signature where
    overloadedMethod _ = widgetQueueResize

-- method Widget::queue_resize_no_redraw
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_queue_resize_no_redraw" gtk_widget_queue_resize_no_redraw :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
This function works like 'GI.Gtk.Objects.Widget.widgetQueueResize',
except that the widget is not invalidated.

@since 2.4
-}
widgetQueueResizeNoRedraw ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetQueueResizeNoRedraw widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_queue_resize_no_redraw widget'
    touchManagedPtr widget
    return ()

data WidgetQueueResizeNoRedrawMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetQueueResizeNoRedrawMethodInfo a signature where
    overloadedMethod _ = widgetQueueResizeNoRedraw

-- method Widget::realize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_realize" gtk_widget_realize :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Creates the GDK (windowing system) resources associated with a
widget.  For example, /@widget@/->window 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
'GI.Gtk.Objects.Widget.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
'GI.Gtk.Objects.Widget.Widget'::@/draw/@. Or simply g_signal_connect () to the
'GI.Gtk.Objects.Widget.Widget'::@/realize/@ signal.
-}
widgetRealize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetRealize widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_realize widget'
    touchManagedPtr widget
    return ()

data WidgetRealizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetRealizeMethodInfo a signature where
    overloadedMethod _ = widgetRealize

-- method Widget::region_intersect
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "region", argType = TInterface (Name {namespace = "cairo", name = "Region"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #cairo_region_t, in the same coordinate system as\n         @widget->allocation. That is, relative to @widget->window\n         for widgets which return %FALSE from gtk_widget_get_has_window();\n         relative to the parent window of @widget->window otherwise.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "cairo", name = "Region"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_region_intersect" gtk_widget_region_intersect :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Cairo.Region.Region ->              -- region : TInterface (Name {namespace = "cairo", name = "Region"})
    IO (Ptr Cairo.Region.Region)

{-# DEPRECATED widgetRegionIntersect ["(Since version 3.14)","Use 'GI.Gtk.Objects.Widget.widgetGetAllocation' and","    @/cairo_region_intersect_rectangle()/@ to get the same behavior."] #-}
{- |
Computes the intersection of a /@widget@/’s area and /@region@/, returning
the intersection. The result may be empty, use @/cairo_region_is_empty()/@ to
check.
-}
widgetRegionIntersect ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Cairo.Region.Region
    {- ^ /@region@/: a 'GI.Cairo.Structs.Region.Region', in the same coordinate system as
         /@widget@/->allocation. That is, relative to /@widget@/->window
         for widgets which return 'False' from 'GI.Gtk.Objects.Widget.widgetGetHasWindow';
         relative to the parent window of /@widget@/->window otherwise. -}
    -> m Cairo.Region.Region
    {- ^ __Returns:__ A newly allocated region holding the intersection of /@widget@/
    and /@region@/. -}
widgetRegionIntersect widget region = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    region' <- unsafeManagedPtrGetPtr region
    result <- gtk_widget_region_intersect widget' region'
    checkUnexpectedReturnNULL "widgetRegionIntersect" result
    result' <- (wrapBoxed Cairo.Region.Region) result
    touchManagedPtr widget
    touchManagedPtr region
    return result'

data WidgetRegionIntersectMethodInfo
instance (signature ~ (Cairo.Region.Region -> m Cairo.Region.Region), MonadIO m, IsWidget a) => O.MethodInfo WidgetRegionIntersectMethodInfo a signature where
    overloadedMethod _ = widgetRegionIntersect

-- method Widget::register_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_register_window" gtk_widget_register_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Window.Window ->                -- window : TInterface (Name {namespace = "Gdk", name = "Window"})
    IO ()

{- |
Registers a 'GI.Gdk.Objects.Window.Window' with the widget and sets it up so that
the widget receives events for it. Call 'GI.Gtk.Objects.Widget.widgetUnregisterWindow'
when destroying the window.

Before 3.8 you needed to call 'GI.Gdk.Objects.Window.windowSetUserData' directly to set
this up. This is now deprecated and you should use 'GI.Gtk.Objects.Widget.widgetRegisterWindow'
instead. Old code will keep working as is, although some new features like
transparency might not work perfectly.

@since 3.8
-}
widgetRegisterWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Window.IsWindow b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -}
    -> m ()
widgetRegisterWindow widget window = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    window' <- unsafeManagedPtrCastPtr window
    gtk_widget_register_window widget' window'
    touchManagedPtr widget
    touchManagedPtr window
    return ()

data WidgetRegisterWindowMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, Gdk.Window.IsWindow b) => O.MethodInfo WidgetRegisterWindowMethodInfo a signature where
    overloadedMethod _ = widgetRegisterWindow

-- method Widget::remove_accelerator
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "widget to install an accelerator on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_group", argType = TInterface (Name {namespace = "Gtk", name = "AccelGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "accel group for this widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_key", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "GDK keyval of the accelerator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_mods", argType = TInterface (Name {namespace = "Gdk", name = "ModifierType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "modifier key combination of the accelerator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_remove_accelerator" gtk_widget_remove_accelerator :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.AccelGroup.AccelGroup ->        -- accel_group : TInterface (Name {namespace = "Gtk", name = "AccelGroup"})
    Word32 ->                               -- accel_key : TBasicType TUInt
    CUInt ->                                -- accel_mods : TInterface (Name {namespace = "Gdk", name = "ModifierType"})
    IO CInt

{- |
Removes an accelerator from /@widget@/, previously installed with
'GI.Gtk.Objects.Widget.widgetAddAccelerator'.
-}
widgetRemoveAccelerator ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gtk.AccelGroup.IsAccelGroup b) =>
    a
    {- ^ /@widget@/: widget to install an accelerator on -}
    -> b
    {- ^ /@accelGroup@/: accel group for this widget -}
    -> Word32
    {- ^ /@accelKey@/: GDK keyval of the accelerator -}
    -> [Gdk.Flags.ModifierType]
    {- ^ /@accelMods@/: modifier key combination of the accelerator -}
    -> m Bool
    {- ^ __Returns:__ whether an accelerator was installed and could be removed -}
widgetRemoveAccelerator widget accelGroup accelKey accelMods = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    accelGroup' <- unsafeManagedPtrCastPtr accelGroup
    let accelMods' = gflagsToWord accelMods
    result <- gtk_widget_remove_accelerator widget' accelGroup' accelKey accelMods'
    let result' = (/= 0) result
    touchManagedPtr widget
    touchManagedPtr accelGroup
    return result'

data WidgetRemoveAcceleratorMethodInfo
instance (signature ~ (b -> Word32 -> [Gdk.Flags.ModifierType] -> m Bool), MonadIO m, IsWidget a, Gtk.AccelGroup.IsAccelGroup b) => O.MethodInfo WidgetRemoveAcceleratorMethodInfo a signature where
    overloadedMethod _ = widgetRemoveAccelerator

-- method Widget::remove_mnemonic_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget that was previously set as a mnemonic label for\n        @widget with gtk_widget_add_mnemonic_label().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_remove_mnemonic_label" gtk_widget_remove_mnemonic_label :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Widget ->                           -- label : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Removes a widget from the list of mnemonic labels for
this widget. (See 'GI.Gtk.Objects.Widget.widgetListMnemonicLabels'). The widget
must have previously been added to the list with
'GI.Gtk.Objects.Widget.widgetAddMnemonicLabel'.

@since 2.4
-}
widgetRemoveMnemonicLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@label@/: a 'GI.Gtk.Objects.Widget.Widget' that was previously set as a mnemonic label for
        /@widget@/ with 'GI.Gtk.Objects.Widget.widgetAddMnemonicLabel'. -}
    -> m ()
widgetRemoveMnemonicLabel widget label = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    label' <- unsafeManagedPtrCastPtr label
    gtk_widget_remove_mnemonic_label widget' label'
    touchManagedPtr widget
    touchManagedPtr label
    return ()

data WidgetRemoveMnemonicLabelMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, IsWidget b) => O.MethodInfo WidgetRemoveMnemonicLabelMethodInfo a signature where
    overloadedMethod _ = widgetRemoveMnemonicLabel

-- method Widget::remove_tick_callback
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an id returned by gtk_widget_add_tick_callback()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_remove_tick_callback" gtk_widget_remove_tick_callback :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Word32 ->                               -- id : TBasicType TUInt
    IO ()

{- |
Removes a tick callback previously registered with
'GI.Gtk.Objects.Widget.widgetAddTickCallback'.

@since 3.8
-}
widgetRemoveTickCallback ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Word32
    {- ^ /@id@/: an id returned by 'GI.Gtk.Objects.Widget.widgetAddTickCallback' -}
    -> m ()
widgetRemoveTickCallback widget id = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_remove_tick_callback widget' id
    touchManagedPtr widget
    return ()

data WidgetRemoveTickCallbackMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetRemoveTickCallbackMethodInfo a signature where
    overloadedMethod _ = widgetRemoveTickCallback

-- method Widget::render_icon
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a stock ID", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`\n    means render at the size of the source and don\8217t scale (if there are\n    multiple source sizes, GTK+ picks one of the available sizes).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "detail", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "render detail to pass to theme engine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_render_icon" gtk_widget_render_icon :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- stock_id : TBasicType TUTF8
    Int32 ->                                -- size : TBasicType TInt
    CString ->                              -- detail : TBasicType TUTF8
    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)

{-# DEPRECATED widgetRenderIcon ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetRenderIconPixbuf' instead."] #-}
{- |
A convenience function that uses the theme settings for /@widget@/
to look up /@stockId@/ and render it to a pixbuf. /@stockId@/ should
be a stock icon ID such as 'GI.Gtk.Constants.STOCK_OPEN' or 'GI.Gtk.Constants.STOCK_OK'. /@size@/
should be a size such as @/GTK_ICON_SIZE_MENU/@. /@detail@/ should be a
string that identifies the widget or code doing the rendering, so
that theme engines can special-case rendering for that widget or
code.

The pixels in the returned 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' are shared with the rest of
the application and should not be modified. The pixbuf should be
freed after use with 'GI.GObject.Objects.Object.objectUnref'.
-}
widgetRenderIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@stockId@/: a stock ID -}
    -> Int32
    {- ^ /@size@/: a stock size ('GI.Gtk.Enums.IconSize'). A size of @(GtkIconSize)-1@
    means render at the size of the source and don’t scale (if there are
    multiple source sizes, GTK+ picks one of the available sizes). -}
    -> Maybe (T.Text)
    {- ^ /@detail@/: render detail to pass to theme engine -}
    -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)
    {- ^ __Returns:__ a new pixbuf, or 'Nothing' if the
    stock ID wasn’t known -}
widgetRenderIcon widget stockId size detail = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    stockId' <- textToCString stockId
    maybeDetail <- case detail of
        Nothing -> return nullPtr
        Just jDetail -> do
            jDetail' <- textToCString jDetail
            return jDetail'
    result <- gtk_widget_render_icon widget' stockId' size maybeDetail
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject GdkPixbuf.Pixbuf.Pixbuf) result'
        return result''
    touchManagedPtr widget
    freeMem stockId'
    freeMem maybeDetail
    return maybeResult

data WidgetRenderIconMethodInfo
instance (signature ~ (T.Text -> Int32 -> Maybe (T.Text) -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)), MonadIO m, IsWidget a) => O.MethodInfo WidgetRenderIconMethodInfo a signature where
    overloadedMethod _ = widgetRenderIcon

-- method Widget::render_icon_pixbuf
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stock_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a stock ID", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`\n    means render at the size of the source and don\8217t scale (if there are\n    multiple source sizes, GTK+ picks one of the available sizes).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_render_icon_pixbuf" gtk_widget_render_icon_pixbuf :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- stock_id : TBasicType TUTF8
    Int32 ->                                -- size : TBasicType TInt
    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)

{-# DEPRECATED widgetRenderIconPixbuf ["(Since version 3.10)","Use 'GI.Gtk.Objects.IconTheme.iconThemeLoadIcon' instead."] #-}
{- |
A convenience function that uses the theme engine and style
settings for /@widget@/ to look up /@stockId@/ and render it to
a pixbuf. /@stockId@/ should be a stock icon ID such as
'GI.Gtk.Constants.STOCK_OPEN' or 'GI.Gtk.Constants.STOCK_OK'. /@size@/ should be a size
such as @/GTK_ICON_SIZE_MENU/@.

The pixels in the returned 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' are shared with the rest of
the application and should not be modified. The pixbuf should be freed
after use with 'GI.GObject.Objects.Object.objectUnref'.

@since 3.0
-}
widgetRenderIconPixbuf ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@stockId@/: a stock ID -}
    -> Int32
    {- ^ /@size@/: a stock size ('GI.Gtk.Enums.IconSize'). A size of @(GtkIconSize)-1@
    means render at the size of the source and don’t scale (if there are
    multiple source sizes, GTK+ picks one of the available sizes). -}
    -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)
    {- ^ __Returns:__ a new pixbuf, or 'Nothing' if the
    stock ID wasn’t known -}
widgetRenderIconPixbuf widget stockId size = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    stockId' <- textToCString stockId
    result <- gtk_widget_render_icon_pixbuf widget' stockId' size
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapObject GdkPixbuf.Pixbuf.Pixbuf) result'
        return result''
    touchManagedPtr widget
    freeMem stockId'
    return maybeResult

data WidgetRenderIconPixbufMethodInfo
instance (signature ~ (T.Text -> Int32 -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)), MonadIO m, IsWidget a) => O.MethodInfo WidgetRenderIconPixbufMethodInfo a signature where
    overloadedMethod _ = widgetRenderIconPixbuf

-- method Widget::reparent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_parent", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkContainer to move the widget into", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_reparent" gtk_widget_reparent :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Widget ->                           -- new_parent : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{-# DEPRECATED widgetReparent ["(Since version 3.14)","Use 'GI.Gtk.Objects.Container.containerRemove' and 'GI.Gtk.Objects.Container.containerAdd'."] #-}
{- |
Moves a widget from one 'GI.Gtk.Objects.Container.Container' to another, handling reference
count issues to avoid destroying the widget.
-}
widgetReparent ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@newParent@/: a 'GI.Gtk.Objects.Container.Container' to move the widget into -}
    -> m ()
widgetReparent widget newParent = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    newParent' <- unsafeManagedPtrCastPtr newParent
    gtk_widget_reparent widget' newParent'
    touchManagedPtr widget
    touchManagedPtr newParent
    return ()

data WidgetReparentMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, IsWidget b) => O.MethodInfo WidgetReparentMethodInfo a signature where
    overloadedMethod _ = widgetReparent

-- method Widget::reset_rc_styles
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_reset_rc_styles" gtk_widget_reset_rc_styles :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{-# DEPRECATED widgetResetRcStyles ["(Since version 3.0)","Use 'GI.Gtk.Objects.StyleContext.StyleContext' instead, and 'GI.Gtk.Objects.Widget.widgetResetStyle'"] #-}
{- |
Reset the styles of /@widget@/ and all descendents, so when
they are looked up again, they get the correct values
for the currently loaded RC file settings.

This function is not useful for applications.
-}
widgetResetRcStyles ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget'. -}
    -> m ()
widgetResetRcStyles widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_reset_rc_styles widget'
    touchManagedPtr widget
    return ()

data WidgetResetRcStylesMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetResetRcStylesMethodInfo a signature where
    overloadedMethod _ = widgetResetRcStyles

-- method Widget::reset_style
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_reset_style" gtk_widget_reset_style :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
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 'GI.Gtk.Objects.Container.containerGetPathForChild'.

@since 3.0
-}
widgetResetStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetResetStyle widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_reset_style widget'
    touchManagedPtr widget
    return ()

data WidgetResetStyleMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetResetStyleMethodInfo a signature where
    overloadedMethod _ = widgetResetStyle

-- method Widget::send_expose
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a expose #GdkEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_send_expose" gtk_widget_send_expose :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO Int32

{-# DEPRECATED widgetSendExpose ["(Since version 3.22)","Application and widget code should not handle","  expose events directly; invalidation should use the 'GI.Gtk.Objects.Widget.Widget'","  API, and drawing should only happen inside 'GI.Gtk.Objects.Widget.Widget'::@/draw/@","  implementations"] #-}
{- |
Very rarely-used function. This function is used to emit
an expose event on a widget. This function is not normally used
directly. The only time it is used is when propagating an expose
event to a windowless child widget ('GI.Gtk.Objects.Widget.widgetGetHasWindow' is 'False'),
and that is normally done using 'GI.Gtk.Objects.Container.containerPropagateDraw'.

If you want to force an area of a window to be redrawn,
use 'GI.Gdk.Objects.Window.windowInvalidateRect' or 'GI.Gdk.Objects.Window.windowInvalidateRegion'.
To cause the redraw to be done immediately, follow that call
with a call to 'GI.Gdk.Objects.Window.windowProcessUpdates'.
-}
widgetSendExpose ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: a expose 'GI.Gdk.Unions.Event.Event' -}
    -> m Int32
    {- ^ __Returns:__ return from the event signal emission ('True' if
  the event was handled) -}
widgetSendExpose widget event = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    event' <- unsafeManagedPtrGetPtr event
    result <- gtk_widget_send_expose widget' event'
    touchManagedPtr widget
    touchManagedPtr event
    return result

data WidgetSendExposeMethodInfo
instance (signature ~ (Gdk.Event.Event -> m Int32), MonadIO m, IsWidget a) => O.MethodInfo WidgetSendExposeMethodInfo a signature where
    overloadedMethod _ = widgetSendExpose

-- method Widget::send_focus_change
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkEvent of type GDK_FOCUS_CHANGE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_send_focus_change" gtk_widget_send_focus_change :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO CInt

{- |
Sends the focus change /@event@/ to /@widget@/

This function is not meant to be used by applications. The only time it
should be used is when it is necessary for a 'GI.Gtk.Objects.Widget.Widget' to assign focus
to a widget that is semantically owned by the first widget even though
it’s not a direct child - for instance, a search entry in a floating
window similar to the quick search in 'GI.Gtk.Objects.TreeView.TreeView'.

An example of its usage is:


=== /C code/
>
>  GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
>
>  fevent->focus_change.type = GDK_FOCUS_CHANGE;
>  fevent->focus_change.in = TRUE;
>  fevent->focus_change.window = _gtk_widget_get_window (widget);
>  if (fevent->focus_change.window != NULL)
>    g_object_ref (fevent->focus_change.window);
>
>  gtk_widget_send_focus_change (widget, fevent);
>
>  gdk_event_free (event);

@since 2.20
-}
widgetSendFocusChange ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event' of type GDK_FOCUS_CHANGE -}
    -> m Bool
    {- ^ __Returns:__ the return value from the event signal emission: 'True'
  if the event was handled, and 'False' otherwise -}
widgetSendFocusChange widget event = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    event' <- unsafeManagedPtrGetPtr event
    result <- gtk_widget_send_focus_change widget' event'
    let result' = (/= 0) result
    touchManagedPtr widget
    touchManagedPtr event
    return result'

data WidgetSendFocusChangeMethodInfo
instance (signature ~ (Gdk.Event.Event -> m Bool), MonadIO m, IsWidget a) => O.MethodInfo WidgetSendFocusChangeMethodInfo a signature where
    overloadedMethod _ = widgetSendFocusChange

-- method Widget::set_accel_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "path used to look up the accelerator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accel_group", argType = TInterface (Name {namespace = "Gtk", name = "AccelGroup"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkAccelGroup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_accel_path" gtk_widget_set_accel_path :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- accel_path : TBasicType TUTF8
    Ptr Gtk.AccelGroup.AccelGroup ->        -- accel_group : TInterface (Name {namespace = "Gtk", name = "AccelGroup"})
    IO ()

{- |
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
'GI.Gtk.Objects.Widget.widgetSetAccelPath'. Associating accelerators with
paths allows them to be modified by the user and the modifications
to be saved for future use. (See 'GI.Gtk.Objects.AccelMap.accelMapSave'.)

This function is a low level function that would most likely
be used by a menu creation system like 'GI.Gtk.Objects.UIManager.UIManager'. If you
use 'GI.Gtk.Objects.UIManager.UIManager', setting up accelerator paths will be done
automatically.

Even when you you aren’t using 'GI.Gtk.Objects.UIManager.UIManager', if you only want to
set up accelerators on menu items 'GI.Gtk.Objects.MenuItem.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
'GI.GLib.Functions.internStaticString'.
-}
widgetSetAccelPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gtk.AccelGroup.IsAccelGroup b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (T.Text)
    {- ^ /@accelPath@/: path used to look up the accelerator -}
    -> Maybe (b)
    {- ^ /@accelGroup@/: a 'GI.Gtk.Objects.AccelGroup.AccelGroup'. -}
    -> m ()
widgetSetAccelPath widget accelPath accelGroup = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeAccelPath <- case accelPath of
        Nothing -> return nullPtr
        Just jAccelPath -> do
            jAccelPath' <- textToCString jAccelPath
            return jAccelPath'
    maybeAccelGroup <- case accelGroup of
        Nothing -> return nullPtr
        Just jAccelGroup -> do
            jAccelGroup' <- unsafeManagedPtrCastPtr jAccelGroup
            return jAccelGroup'
    gtk_widget_set_accel_path widget' maybeAccelPath maybeAccelGroup
    touchManagedPtr widget
    whenJust accelGroup touchManagedPtr
    freeMem maybeAccelPath
    return ()

data WidgetSetAccelPathMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (b) -> m ()), MonadIO m, IsWidget a, Gtk.AccelGroup.IsAccelGroup b) => O.MethodInfo WidgetSetAccelPathMethodInfo a signature where
    overloadedMethod _ = widgetSetAccelPath

-- method Widget::set_allocation
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocation", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GtkAllocation to copy from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_allocation" gtk_widget_set_allocation :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Rectangle.Rectangle ->          -- allocation : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

{- |
Sets the widget’s allocation.  This should not be used
directly, but from within a widget’s size_allocate method.

The allocation set should be the “adjusted” or actual
allocation. If you’re implementing a 'GI.Gtk.Objects.Container.Container', you want to use
'GI.Gtk.Objects.Widget.widgetSizeAllocate' instead of 'GI.Gtk.Objects.Widget.widgetSetAllocation'.
The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
allocation inside 'GI.Gtk.Objects.Widget.widgetSizeAllocate' to create an adjusted
allocation.

@since 2.18
-}
widgetSetAllocation ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@allocation@/: a pointer to a @/GtkAllocation/@ to copy from -}
    -> m ()
widgetSetAllocation widget allocation = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    allocation' <- unsafeManagedPtrGetPtr allocation
    gtk_widget_set_allocation widget' allocation'
    touchManagedPtr widget
    touchManagedPtr allocation
    return ()

data WidgetSetAllocationMethodInfo
instance (signature ~ (Gdk.Rectangle.Rectangle -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetAllocationMethodInfo a signature where
    overloadedMethod _ = widgetSetAllocation

-- method Widget::set_app_paintable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "app_paintable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the application will paint on the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_app_paintable" gtk_widget_set_app_paintable :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- app_paintable : TBasicType TBoolean
    IO ()

{- |
Sets whether the application intends to draw on the widget in
an 'GI.Gtk.Objects.Widget.Widget'::@/draw/@ handler.

This is a hint to the widget and does not affect the behavior of
the GTK+ core; many widgets ignore this flag entirely. For widgets
that do pay attention to the flag, such as 'GI.Gtk.Objects.EventBox.EventBox' and 'GI.Gtk.Objects.Window.Window',
the effect is to suppress default themed drawing of the widget\'s
background. (Children of the widget will still be drawn.) The application
is then entirely responsible for drawing the widget background.

Note that the background is still drawn when the widget is mapped.
-}
widgetSetAppPaintable ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@appPaintable@/: 'True' if the application will paint on the widget -}
    -> m ()
widgetSetAppPaintable widget appPaintable = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let appPaintable' = (fromIntegral . fromEnum) appPaintable
    gtk_widget_set_app_paintable widget' appPaintable'
    touchManagedPtr widget
    return ()

data WidgetSetAppPaintableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetAppPaintableMethodInfo a signature where
    overloadedMethod _ = widgetSetAppPaintable

-- method Widget::set_can_default
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "can_default", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not @widget can be a default widget.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_can_default" gtk_widget_set_can_default :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- can_default : TBasicType TBoolean
    IO ()

{- |
Specifies whether /@widget@/ can be a default widget. See
'GI.Gtk.Objects.Widget.widgetGrabDefault' for details about the meaning of
“default”.

@since 2.18
-}
widgetSetCanDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@canDefault@/: whether or not /@widget@/ can be a default widget. -}
    -> m ()
widgetSetCanDefault widget canDefault = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let canDefault' = (fromIntegral . fromEnum) canDefault
    gtk_widget_set_can_default widget' canDefault'
    touchManagedPtr widget
    return ()

data WidgetSetCanDefaultMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetCanDefaultMethodInfo a signature where
    overloadedMethod _ = widgetSetCanDefault

-- method Widget::set_can_focus
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "can_focus", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not @widget can own the input focus.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_can_focus" gtk_widget_set_can_focus :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- can_focus : TBasicType TBoolean
    IO ()

{- |
Specifies whether /@widget@/ can own the input focus. See
'GI.Gtk.Objects.Widget.widgetGrabFocus' for actually setting the input focus on a
widget.

@since 2.18
-}
widgetSetCanFocus ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@canFocus@/: whether or not /@widget@/ can own the input focus. -}
    -> m ()
widgetSetCanFocus widget canFocus = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let canFocus' = (fromIntegral . fromEnum) canFocus
    gtk_widget_set_can_focus widget' canFocus'
    touchManagedPtr widget
    return ()

data WidgetSetCanFocusMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetCanFocusMethodInfo a signature where
    overloadedMethod _ = widgetSetCanFocus

-- method Widget::set_child_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %TRUE, @widget should be mapped along with its parent.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_child_visible" gtk_widget_set_child_visible :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- is_visible : TBasicType TBoolean
    IO ()

{- |
Sets whether /@widget@/ should be mapped along with its when its parent
is mapped and /@widget@/ has been shown with 'GI.Gtk.Objects.Widget.widgetShow'.

The child visibility can be set for widget before it is added to
a container with 'GI.Gtk.Objects.Widget.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.
-}
widgetSetChildVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@isVisible@/: if 'True', /@widget@/ should be mapped along with its parent. -}
    -> m ()
widgetSetChildVisible widget isVisible = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let isVisible' = (fromIntegral . fromEnum) isVisible
    gtk_widget_set_child_visible widget' isVisible'
    touchManagedPtr widget
    return ()

data WidgetSetChildVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetChildVisibleMethodInfo a signature where
    overloadedMethod _ = widgetSetChildVisible

-- method Widget::set_clip
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clip", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GtkAllocation to copy from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_clip" gtk_widget_set_clip :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Rectangle.Rectangle ->          -- clip : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

{- |
Sets the widget’s clip.  This must not be used directly,
but from within a widget’s size_allocate method.
It must be called after 'GI.Gtk.Objects.Widget.widgetSetAllocation' (or after chaining up
to the parent class), because that function resets the clip.

The clip set should be the area that /@widget@/ draws on. If /@widget@/ is a
'GI.Gtk.Objects.Container.Container', the area must contain all children\'s clips.

If this function is not called by /@widget@/ during a ::size-allocate handler,
the clip will be set to /@widget@/\'s allocation.

@since 3.14
-}
widgetSetClip ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@clip@/: a pointer to a @/GtkAllocation/@ to copy from -}
    -> m ()
widgetSetClip widget clip = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    clip' <- unsafeManagedPtrGetPtr clip
    gtk_widget_set_clip widget' clip'
    touchManagedPtr widget
    touchManagedPtr clip
    return ()

data WidgetSetClipMethodInfo
instance (signature ~ (Gdk.Rectangle.Rectangle -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetClipMethodInfo a signature where
    overloadedMethod _ = widgetSetClip

-- method Widget::set_composite_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_composite_name" gtk_widget_set_composite_name :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{-# DEPRECATED widgetSetCompositeName ["(Since version 3.10)","Use 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate', or don\8217t use this API at all."] #-}
{- |
Sets a widgets composite name. The widget must be
a composite child of its parent; see 'GI.Gtk.Objects.Widget.widgetPushCompositeChild'.
-}
widgetSetCompositeName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget'. -}
    -> T.Text
    {- ^ /@name@/: the name to set -}
    -> m ()
widgetSetCompositeName widget name = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    name' <- textToCString name
    gtk_widget_set_composite_name widget' name'
    touchManagedPtr widget
    freeMem name'
    return ()

data WidgetSetCompositeNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetCompositeNameMethodInfo a signature where
    overloadedMethod _ = widgetSetCompositeName

-- method Widget::set_device_enabled
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to enable the device", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_device_enabled" gtk_widget_set_device_enabled :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Device.Device ->                -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    CInt ->                                 -- enabled : TBasicType TBoolean
    IO ()

{- |
Enables or disables a 'GI.Gdk.Objects.Device.Device' to interact with /@widget@/
and all its children.

It does so by descending through the 'GI.Gdk.Objects.Window.Window' hierarchy
and enabling the same mask that is has for core events
(i.e. the one that 'GI.Gdk.Objects.Window.windowGetEvents' returns).

@since 3.0
-}
widgetSetDeviceEnabled ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Device.IsDevice b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> Bool
    {- ^ /@enabled@/: whether to enable the device -}
    -> m ()
widgetSetDeviceEnabled widget device enabled = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    device' <- unsafeManagedPtrCastPtr device
    let enabled' = (fromIntegral . fromEnum) enabled
    gtk_widget_set_device_enabled widget' device' enabled'
    touchManagedPtr widget
    touchManagedPtr device
    return ()

data WidgetSetDeviceEnabledMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsWidget a, Gdk.Device.IsDevice b) => O.MethodInfo WidgetSetDeviceEnabledMethodInfo a signature where
    overloadedMethod _ = widgetSetDeviceEnabled

-- method Widget::set_device_events
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface (Name {namespace = "Gdk", name = "Device"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "events", argType = TInterface (Name {namespace = "Gdk", name = "EventMask"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "event mask", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_device_events" gtk_widget_set_device_events :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Device.Device ->                -- device : TInterface (Name {namespace = "Gdk", name = "Device"})
    CUInt ->                                -- events : TInterface (Name {namespace = "Gdk", name = "EventMask"})
    IO ()

{- |
Sets the device event mask (see 'GI.Gdk.Flags.EventMask') for a widget. The event
mask determines which events a widget will receive from /@device@/. Keep
in mind that different widgets have different default event masks, and by
changing the event mask you may disrupt a widget’s functionality,
so be careful. This function must be called while a widget is
unrealized. Consider 'GI.Gtk.Objects.Widget.widgetAddDeviceEvents' for widgets that are
already realized, or if you want to preserve the existing event
mask. This function can’t be used with windowless widgets (which return
'False' from 'GI.Gtk.Objects.Widget.widgetGetHasWindow');
to get events on those widgets, place them inside a 'GI.Gtk.Objects.EventBox.EventBox'
and receive events on the event box.

@since 3.0
-}
widgetSetDeviceEvents ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Device.IsDevice b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -}
    -> [Gdk.Flags.EventMask]
    {- ^ /@events@/: event mask -}
    -> m ()
widgetSetDeviceEvents widget device events = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    device' <- unsafeManagedPtrCastPtr device
    let events' = gflagsToWord events
    gtk_widget_set_device_events widget' device' events'
    touchManagedPtr widget
    touchManagedPtr device
    return ()

data WidgetSetDeviceEventsMethodInfo
instance (signature ~ (b -> [Gdk.Flags.EventMask] -> m ()), MonadIO m, IsWidget a, Gdk.Device.IsDevice b) => O.MethodInfo WidgetSetDeviceEventsMethodInfo a signature where
    overloadedMethod _ = widgetSetDeviceEvents

-- method Widget::set_direction
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dir", argType = TInterface (Name {namespace = "Gtk", name = "TextDirection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new direction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_direction" gtk_widget_set_direction :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- dir : TInterface (Name {namespace = "Gtk", name = "TextDirection"})
    IO ()

{- |
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 'GI.Gtk.Enums.TextDirectionNone', then the value
set by 'GI.Gtk.Objects.Widget.widgetSetDefaultDirection' will be used.
-}
widgetSetDirection ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.TextDirection
    {- ^ /@dir@/: the new direction -}
    -> m ()
widgetSetDirection widget dir = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let dir' = (fromIntegral . fromEnum) dir
    gtk_widget_set_direction widget' dir'
    touchManagedPtr widget
    return ()

data WidgetSetDirectionMethodInfo
instance (signature ~ (Gtk.Enums.TextDirection -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetDirectionMethodInfo a signature where
    overloadedMethod _ = widgetSetDirection

-- method Widget::set_double_buffered
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "double_buffered", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to double-buffer a widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_double_buffered" gtk_widget_set_double_buffered :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- double_buffered : TBasicType TBoolean
    IO ()

{-# DEPRECATED widgetSetDoubleBuffered ["(Since version 3.14)","This function does not work under non-X11 backends or with","non-native windows.","It should not be used in newly written code."] #-}
{- |
Widgets are double buffered by default; you can use this function
to turn off the buffering. “Double buffered” simply means that
'GI.Gdk.Objects.Window.windowBeginDrawFrame' and 'GI.Gdk.Objects.Window.windowEndDrawFrame' are called
automatically around expose events sent to the
widget. 'GI.Gdk.Objects.Window.windowBeginDrawFrame' diverts all drawing to a widget\'s
window to an offscreen buffer, and 'GI.Gdk.Objects.Window.windowEndDrawFrame' draws the
buffer to the screen. The result is that users see the window
update in one smooth step, and don’t see individual graphics
primitives being rendered.

In very simple terms, double buffered widgets don’t flicker,
so you would only use this function to turn off double buffering
if you had special needs and really knew what you were doing.

Note: if you turn off double-buffering, you have to handle
expose events, since even the clearing to the background color or
pixmap will not happen automatically (as it is done in
'GI.Gdk.Objects.Window.windowBeginDrawFrame').

In 3.10 GTK and GDK have been restructured for translucent drawing. Since
then expose events for double-buffered widgets are culled into a single
event to the toplevel GDK window. If you now unset double buffering, you
will cause a separate rendering pass for every widget. This will likely
cause rendering problems - in particular related to stacking - and usually
increases rendering times significantly.
-}
widgetSetDoubleBuffered ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@doubleBuffered@/: 'True' to double-buffer a widget -}
    -> m ()
widgetSetDoubleBuffered widget doubleBuffered = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let doubleBuffered' = (fromIntegral . fromEnum) doubleBuffered
    gtk_widget_set_double_buffered widget' doubleBuffered'
    touchManagedPtr widget
    return ()

data WidgetSetDoubleBufferedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetDoubleBufferedMethodInfo a signature where
    overloadedMethod _ = widgetSetDoubleBuffered

-- method Widget::set_events
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "events", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "event mask", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_events" gtk_widget_set_events :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- events : TBasicType TInt
    IO ()

{- |
Sets the event mask (see 'GI.Gdk.Flags.EventMask') for a widget. The event
mask determines which events a widget will receive. Keep in mind
that different widgets have different default event masks, and by
changing the event mask you may disrupt a widget’s functionality,
so be careful. This function must be called while a widget is
unrealized. Consider 'GI.Gtk.Objects.Widget.widgetAddEvents' for widgets that are
already realized, or if you want to preserve the existing event
mask. This function can’t be used with widgets that have no window.
(See 'GI.Gtk.Objects.Widget.widgetGetHasWindow').  To get events on those widgets,
place them inside a 'GI.Gtk.Objects.EventBox.EventBox' and receive events on the event
box.
-}
widgetSetEvents ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@events@/: event mask -}
    -> m ()
widgetSetEvents widget events = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_set_events widget' events
    touchManagedPtr widget
    return ()

data WidgetSetEventsMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetEventsMethodInfo a signature where
    overloadedMethod _ = widgetSetEvents

-- method Widget::set_focus_on_click
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "focus_on_click", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the widget should grab focus when clicked with the mouse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_focus_on_click" gtk_widget_set_focus_on_click :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- focus_on_click : TBasicType TBoolean
    IO ()

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

@since 3.20
-}
widgetSetFocusOnClick ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@focusOnClick@/: whether the widget should grab focus when clicked with the mouse -}
    -> m ()
widgetSetFocusOnClick widget focusOnClick = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let focusOnClick' = (fromIntegral . fromEnum) focusOnClick
    gtk_widget_set_focus_on_click widget' focusOnClick'
    touchManagedPtr widget
    return ()

data WidgetSetFocusOnClickMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetFocusOnClickMethodInfo a signature where
    overloadedMethod _ = widgetSetFocusOnClick

-- method Widget::set_font_map
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font_map", argType = TInterface (Name {namespace = "Pango", name = "FontMap"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #PangoFontMap, or %NULL to unset any previously\n    set font map", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_font_map" gtk_widget_set_font_map :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Pango.FontMap.FontMap ->            -- font_map : TInterface (Name {namespace = "Pango", name = "FontMap"})
    IO ()

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

@since 3.18
-}
widgetSetFontMap ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Pango.FontMap.IsFontMap b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (b)
    {- ^ /@fontMap@/: a 'GI.Pango.Objects.FontMap.FontMap', or 'Nothing' to unset any previously
    set font map -}
    -> m ()
widgetSetFontMap widget fontMap = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeFontMap <- case fontMap of
        Nothing -> return nullPtr
        Just jFontMap -> do
            jFontMap' <- unsafeManagedPtrCastPtr jFontMap
            return jFontMap'
    gtk_widget_set_font_map widget' maybeFontMap
    touchManagedPtr widget
    whenJust fontMap touchManagedPtr
    return ()

data WidgetSetFontMapMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsWidget a, Pango.FontMap.IsFontMap b) => O.MethodInfo WidgetSetFontMapMethodInfo a signature where
    overloadedMethod _ = widgetSetFontMap

-- method Widget::set_font_options
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "cairo", name = "FontOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #cairo_font_options_t, or %NULL to unset any\n  previously set default font options.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_font_options" gtk_widget_set_font_options :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Cairo.FontOptions.FontOptions ->    -- options : TInterface (Name {namespace = "cairo", name = "FontOptions"})
    IO ()

{- |
Sets the 'GI.Cairo.Structs.FontOptions.FontOptions' used for Pango rendering in this widget.
When not set, the default font options for the 'GI.Gdk.Objects.Screen.Screen' will be used.

@since 3.18
-}
widgetSetFontOptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (Cairo.FontOptions.FontOptions)
    {- ^ /@options@/: a 'GI.Cairo.Structs.FontOptions.FontOptions', or 'Nothing' to unset any
  previously set default font options. -}
    -> m ()
widgetSetFontOptions widget options = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeOptions <- case options of
        Nothing -> return nullPtr
        Just jOptions -> do
            jOptions' <- unsafeManagedPtrGetPtr jOptions
            return jOptions'
    gtk_widget_set_font_options widget' maybeOptions
    touchManagedPtr widget
    whenJust options touchManagedPtr
    return ()

data WidgetSetFontOptionsMethodInfo
instance (signature ~ (Maybe (Cairo.FontOptions.FontOptions) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetFontOptionsMethodInfo a signature where
    overloadedMethod _ = widgetSetFontOptions

-- method Widget::set_halign
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface (Name {namespace = "Gtk", name = "Align"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the horizontal alignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_halign" gtk_widget_set_halign :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- align : TInterface (Name {namespace = "Gtk", name = "Align"})
    IO ()

{- |
Sets the horizontal alignment of /@widget@/.
See the 'GI.Gtk.Objects.Widget.Widget':@/halign/@ property.
-}
widgetSetHalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.Align
    {- ^ /@align@/: the horizontal alignment -}
    -> m ()
widgetSetHalign widget align = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let align' = (fromIntegral . fromEnum) align
    gtk_widget_set_halign widget' align'
    touchManagedPtr widget
    return ()

data WidgetSetHalignMethodInfo
instance (signature ~ (Gtk.Enums.Align -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetHalignMethodInfo a signature where
    overloadedMethod _ = widgetSetHalign

-- method Widget::set_has_tooltip
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "has_tooltip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not @widget has a tooltip.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_has_tooltip" gtk_widget_set_has_tooltip :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- has_tooltip : TBasicType TBoolean
    IO ()

{- |
Sets the has-tooltip property on /@widget@/ to /@hasTooltip@/.  See
'GI.Gtk.Objects.Widget.Widget':@/has-tooltip/@ for more information.

@since 2.12
-}
widgetSetHasTooltip ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@hasTooltip@/: whether or not /@widget@/ has a tooltip. -}
    -> m ()
widgetSetHasTooltip widget hasTooltip = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let hasTooltip' = (fromIntegral . fromEnum) hasTooltip
    gtk_widget_set_has_tooltip widget' hasTooltip'
    touchManagedPtr widget
    return ()

data WidgetSetHasTooltipMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetHasTooltipMethodInfo a signature where
    overloadedMethod _ = widgetSetHasTooltip

-- method Widget::set_has_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "has_window", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not @widget has a window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_has_window" gtk_widget_set_has_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- has_window : TBasicType TBoolean
    IO ()

{- |
Specifies whether /@widget@/ has a 'GI.Gdk.Objects.Window.Window' of its own. Note that
all realized widgets have a non-'Nothing' “window” pointer
('GI.Gtk.Objects.Widget.widgetGetWindow' never returns a 'Nothing' window when a widget
is realized), but for many of them it’s actually the 'GI.Gdk.Objects.Window.Window' of
one of its parent widgets. Widgets that do not create a @/window/@ for
themselves in 'GI.Gtk.Objects.Widget.Widget'::@/realize/@ must announce this by
calling this function with /@hasWindow@/ = 'False'.

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

@since 2.18
-}
widgetSetHasWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@hasWindow@/: whether or not /@widget@/ has a window. -}
    -> m ()
widgetSetHasWindow widget hasWindow = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let hasWindow' = (fromIntegral . fromEnum) hasWindow
    gtk_widget_set_has_window widget' hasWindow'
    touchManagedPtr widget
    return ()

data WidgetSetHasWindowMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetHasWindowMethodInfo a signature where
    overloadedMethod _ = widgetSetHasWindow

-- method Widget::set_hexpand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to expand", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_hexpand" gtk_widget_set_hexpand :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- expand : TBasicType TBoolean
    IO ()

{- |
Sets whether the widget would like any available extra horizontal
space. When a user resizes a 'GI.Gtk.Objects.Window.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 'GI.Gtk.Objects.Widget.widgetComputeExpand'. A
container can decide how the expandability of children affects the
expansion of the container by overriding the compute_expand virtual
method on 'GI.Gtk.Objects.Widget.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
'GI.Gtk.Objects.Widget.widgetSetHexpand' sets the hexpand-set property (see
'GI.Gtk.Objects.Widget.widgetSetHexpandSet') which causes the widget’s hexpand
value to be used, rather than looking at children and widget state.
-}
widgetSetHexpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget -}
    -> Bool
    {- ^ /@expand@/: whether to expand -}
    -> m ()
widgetSetHexpand widget expand = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let expand' = (fromIntegral . fromEnum) expand
    gtk_widget_set_hexpand widget' expand'
    touchManagedPtr widget
    return ()

data WidgetSetHexpandMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetHexpandMethodInfo a signature where
    overloadedMethod _ = widgetSetHexpand

-- method Widget::set_hexpand_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "set", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "value for hexpand-set property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_hexpand_set" gtk_widget_set_hexpand_set :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- set : TBasicType TBoolean
    IO ()

{- |
Sets whether the hexpand flag (see 'GI.Gtk.Objects.Widget.widgetGetHexpand') will
be used.

The hexpand-set property will be set automatically when you call
'GI.Gtk.Objects.Widget.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.
-}
widgetSetHexpandSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget -}
    -> Bool
    {- ^ /@set@/: value for hexpand-set property -}
    -> m ()
widgetSetHexpandSet widget set = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let set' = (fromIntegral . fromEnum) set
    gtk_widget_set_hexpand_set widget' set'
    touchManagedPtr widget
    return ()

data WidgetSetHexpandSetMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetHexpandSetMethodInfo a signature where
    overloadedMethod _ = widgetSetHexpandSet

-- method Widget::set_mapped
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mapped", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to mark the widget as mapped", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_mapped" gtk_widget_set_mapped :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- mapped : TBasicType TBoolean
    IO ()

{- |
Marks the widget as being realized.

This function should only ever be called in a derived widget\'s
“map” or “unmap” implementation.

@since 2.20
-}
widgetSetMapped ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@mapped@/: 'True' to mark the widget as mapped -}
    -> m ()
widgetSetMapped widget mapped = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let mapped' = (fromIntegral . fromEnum) mapped
    gtk_widget_set_mapped widget' mapped'
    touchManagedPtr widget
    return ()

data WidgetSetMappedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetMappedMethodInfo a signature where
    overloadedMethod _ = widgetSetMapped

-- method Widget::set_margin_bottom
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the bottom margin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_margin_bottom" gtk_widget_set_margin_bottom :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- margin : TBasicType TInt
    IO ()

{- |
Sets the bottom margin of /@widget@/.
See the 'GI.Gtk.Objects.Widget.Widget':@/margin-bottom/@ property.

@since 3.0
-}
widgetSetMarginBottom ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@margin@/: the bottom margin -}
    -> m ()
widgetSetMarginBottom widget margin = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_set_margin_bottom widget' margin
    touchManagedPtr widget
    return ()

data WidgetSetMarginBottomMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetMarginBottomMethodInfo a signature where
    overloadedMethod _ = widgetSetMarginBottom

-- method Widget::set_margin_end
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the end margin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_margin_end" gtk_widget_set_margin_end :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- margin : TBasicType TInt
    IO ()

{- |
Sets the end margin of /@widget@/.
See the 'GI.Gtk.Objects.Widget.Widget':@/margin-end/@ property.

@since 3.12
-}
widgetSetMarginEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@margin@/: the end margin -}
    -> m ()
widgetSetMarginEnd widget margin = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_set_margin_end widget' margin
    touchManagedPtr widget
    return ()

data WidgetSetMarginEndMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetMarginEndMethodInfo a signature where
    overloadedMethod _ = widgetSetMarginEnd

-- method Widget::set_margin_left
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the left margin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_margin_left" gtk_widget_set_margin_left :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- margin : TBasicType TInt
    IO ()

{-# DEPRECATED widgetSetMarginLeft ["(Since version 3.12)","Use 'GI.Gtk.Objects.Widget.widgetSetMarginStart' instead."] #-}
{- |
Sets the left margin of /@widget@/.
See the 'GI.Gtk.Objects.Widget.Widget':@/margin-left/@ property.

@since 3.0
-}
widgetSetMarginLeft ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@margin@/: the left margin -}
    -> m ()
widgetSetMarginLeft widget margin = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_set_margin_left widget' margin
    touchManagedPtr widget
    return ()

data WidgetSetMarginLeftMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetMarginLeftMethodInfo a signature where
    overloadedMethod _ = widgetSetMarginLeft

-- method Widget::set_margin_right
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the right margin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_margin_right" gtk_widget_set_margin_right :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- margin : TBasicType TInt
    IO ()

{-# DEPRECATED widgetSetMarginRight ["(Since version 3.12)","Use 'GI.Gtk.Objects.Widget.widgetSetMarginEnd' instead."] #-}
{- |
Sets the right margin of /@widget@/.
See the 'GI.Gtk.Objects.Widget.Widget':@/margin-right/@ property.

@since 3.0
-}
widgetSetMarginRight ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@margin@/: the right margin -}
    -> m ()
widgetSetMarginRight widget margin = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_set_margin_right widget' margin
    touchManagedPtr widget
    return ()

data WidgetSetMarginRightMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetMarginRightMethodInfo a signature where
    overloadedMethod _ = widgetSetMarginRight

-- method Widget::set_margin_start
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the start margin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_margin_start" gtk_widget_set_margin_start :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- margin : TBasicType TInt
    IO ()

{- |
Sets the start margin of /@widget@/.
See the 'GI.Gtk.Objects.Widget.Widget':@/margin-start/@ property.

@since 3.12
-}
widgetSetMarginStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@margin@/: the start margin -}
    -> m ()
widgetSetMarginStart widget margin = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_set_margin_start widget' margin
    touchManagedPtr widget
    return ()

data WidgetSetMarginStartMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetMarginStartMethodInfo a signature where
    overloadedMethod _ = widgetSetMarginStart

-- method Widget::set_margin_top
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "margin", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the top margin", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_margin_top" gtk_widget_set_margin_top :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- margin : TBasicType TInt
    IO ()

{- |
Sets the top margin of /@widget@/.
See the 'GI.Gtk.Objects.Widget.Widget':@/margin-top/@ property.

@since 3.0
-}
widgetSetMarginTop ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@margin@/: the top margin -}
    -> m ()
widgetSetMarginTop widget margin = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_set_margin_top widget' margin
    touchManagedPtr widget
    return ()

data WidgetSetMarginTopMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetMarginTopMethodInfo a signature where
    overloadedMethod _ = widgetSetMarginTop

-- method Widget::set_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name for the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_name" gtk_widget_set_name :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

{- |
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 'GI.Gtk.Objects.StyleContext.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.
-}
widgetSetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@name@/: name for the widget -}
    -> m ()
widgetSetName widget name = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    name' <- textToCString name
    gtk_widget_set_name widget' name'
    touchManagedPtr widget
    freeMem name'
    return ()

data WidgetSetNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetNameMethodInfo a signature where
    overloadedMethod _ = widgetSetName

-- method Widget::set_no_show_all
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "no_show_all", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value for the \8220no-show-all\8221 property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_no_show_all" gtk_widget_set_no_show_all :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- no_show_all : TBasicType TBoolean
    IO ()

{- |
Sets the 'GI.Gtk.Objects.Widget.Widget':@/no-show-all/@ property, which determines whether
calls to 'GI.Gtk.Objects.Widget.widgetShowAll' will affect this widget.

This is mostly for use in constructing widget hierarchies with externally
controlled visibility, see 'GI.Gtk.Objects.UIManager.UIManager'.

@since 2.4
-}
widgetSetNoShowAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@noShowAll@/: the new value for the “no-show-all” property -}
    -> m ()
widgetSetNoShowAll widget noShowAll = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let noShowAll' = (fromIntegral . fromEnum) noShowAll
    gtk_widget_set_no_show_all widget' noShowAll'
    touchManagedPtr widget
    return ()

data WidgetSetNoShowAllMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetNoShowAllMethodInfo a signature where
    overloadedMethod _ = widgetSetNoShowAll

-- method Widget::set_opacity
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "opacity", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "desired opacity, between 0 and 1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_opacity" gtk_widget_set_opacity :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CDouble ->                              -- opacity : TBasicType TDouble
    IO ()

{- |
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 screens with a compositing manager
running. See 'GI.Gtk.Objects.Widget.widgetIsComposited'. 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, or
disables double buffering.

@since 3.8
-}
widgetSetOpacity ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Double
    {- ^ /@opacity@/: desired opacity, between 0 and 1 -}
    -> m ()
widgetSetOpacity widget opacity = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let opacity' = realToFrac opacity
    gtk_widget_set_opacity widget' opacity'
    touchManagedPtr widget
    return ()

data WidgetSetOpacityMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetOpacityMethodInfo a signature where
    overloadedMethod _ = widgetSetOpacity

-- method Widget::set_parent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "parent container", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_parent" gtk_widget_set_parent :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Widget ->                           -- parent : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
This function is useful only when implementing subclasses of
'GI.Gtk.Objects.Container.Container'.
Sets the container as the parent of /@widget@/, and takes care of
some details such as updating the state and style of the child
to reflect its new location. The opposite function is
'GI.Gtk.Objects.Widget.widgetUnparent'.
-}
widgetSetParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@parent@/: parent container -}
    -> m ()
widgetSetParent widget parent = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    parent' <- unsafeManagedPtrCastPtr parent
    gtk_widget_set_parent widget' parent'
    touchManagedPtr widget
    touchManagedPtr parent
    return ()

data WidgetSetParentMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, IsWidget b) => O.MethodInfo WidgetSetParentMethodInfo a signature where
    overloadedMethod _ = widgetSetParent

-- method Widget::set_parent_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent_window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new parent window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_parent_window" gtk_widget_set_parent_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Window.Window ->                -- parent_window : TInterface (Name {namespace = "Gdk", name = "Window"})
    IO ()

{- |
Sets a non default parent window for /@widget@/.

For 'GI.Gtk.Objects.Window.Window' classes, setting a /@parentWindow@/ effects whether
the window is a toplevel window or can be embedded into other
widgets.

For 'GI.Gtk.Objects.Window.Window' classes, this needs to be called before the
window is realized.
-}
widgetSetParentWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Window.IsWindow b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget'. -}
    -> b
    {- ^ /@parentWindow@/: the new parent window. -}
    -> m ()
widgetSetParentWindow widget parentWindow = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    parentWindow' <- unsafeManagedPtrCastPtr parentWindow
    gtk_widget_set_parent_window widget' parentWindow'
    touchManagedPtr widget
    touchManagedPtr parentWindow
    return ()

data WidgetSetParentWindowMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, Gdk.Window.IsWindow b) => O.MethodInfo WidgetSetParentWindowMethodInfo a signature where
    overloadedMethod _ = widgetSetParentWindow

-- method Widget::set_realized
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "realized", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to mark the widget as realized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_realized" gtk_widget_set_realized :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- realized : TBasicType TBoolean
    IO ()

{- |
Marks the widget as being realized. This function must only be
called after all @/GdkWindows/@ for the /@widget@/ have been created
and registered.

This function should only ever be called in a derived widget\'s
“realize” or “unrealize” implementation.

@since 2.20
-}
widgetSetRealized ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@realized@/: 'True' to mark the widget as realized -}
    -> m ()
widgetSetRealized widget realized = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let realized' = (fromIntegral . fromEnum) realized
    gtk_widget_set_realized widget' realized'
    touchManagedPtr widget
    return ()

data WidgetSetRealizedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetRealizedMethodInfo a signature where
    overloadedMethod _ = widgetSetRealized

-- method Widget::set_receives_default
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "receives_default", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not @widget can be a default widget.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_receives_default" gtk_widget_set_receives_default :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- receives_default : TBasicType TBoolean
    IO ()

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

See 'GI.Gtk.Objects.Widget.widgetGrabDefault' for details about the meaning of
“default”.

@since 2.18
-}
widgetSetReceivesDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@receivesDefault@/: whether or not /@widget@/ can be a default widget. -}
    -> m ()
widgetSetReceivesDefault widget receivesDefault = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let receivesDefault' = (fromIntegral . fromEnum) receivesDefault
    gtk_widget_set_receives_default widget' receivesDefault'
    touchManagedPtr widget
    return ()

data WidgetSetReceivesDefaultMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetReceivesDefaultMethodInfo a signature where
    overloadedMethod _ = widgetSetReceivesDefault

-- method Widget::set_redraw_on_allocate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "redraw_on_allocate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %TRUE, the entire widget will be redrawn\n  when it is allocated to a new size. Otherwise, only the\n  new portion of the widget will be redrawn.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_redraw_on_allocate" gtk_widget_set_redraw_on_allocate :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- redraw_on_allocate : TBasicType TBoolean
    IO ()

{- |
Sets whether the entire widget is queued for drawing when its size
allocation changes. By default, this setting is 'True' and
the entire widget is redrawn on every size change. If your widget
leaves the upper left unchanged when made bigger, turning this
setting off will improve performance.

Note that for widgets where 'GI.Gtk.Objects.Widget.widgetGetHasWindow' is 'False'
setting this flag to 'False' turns off all allocation on resizing:
the widget will not even redraw if its position changes; this is to
allow containers that don’t draw anything to avoid excess
invalidations. If you set this flag on a widget with no window that
does draw on /@widget@/->window, you are
responsible for invalidating both the old and new allocation of the
widget when the widget is moved and responsible for invalidating
regions newly when the widget increases size.
-}
widgetSetRedrawOnAllocate ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@redrawOnAllocate@/: if 'True', the entire widget will be redrawn
  when it is allocated to a new size. Otherwise, only the
  new portion of the widget will be redrawn. -}
    -> m ()
widgetSetRedrawOnAllocate widget redrawOnAllocate = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let redrawOnAllocate' = (fromIntegral . fromEnum) redrawOnAllocate
    gtk_widget_set_redraw_on_allocate widget' redrawOnAllocate'
    touchManagedPtr widget
    return ()

data WidgetSetRedrawOnAllocateMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetRedrawOnAllocateMethodInfo a signature where
    overloadedMethod _ = widgetSetRedrawOnAllocate

-- method Widget::set_sensitive
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sensitive", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to make the widget sensitive", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_sensitive" gtk_widget_set_sensitive :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- sensitive : TBasicType TBoolean
    IO ()

{- |
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.
-}
widgetSetSensitive ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@sensitive@/: 'True' to make the widget sensitive -}
    -> m ()
widgetSetSensitive widget sensitive = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let sensitive' = (fromIntegral . fromEnum) sensitive
    gtk_widget_set_sensitive widget' sensitive'
    touchManagedPtr widget
    return ()

data WidgetSetSensitiveMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetSensitiveMethodInfo a signature where
    overloadedMethod _ = widgetSetSensitive

-- method Widget::set_size_request
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width @widget should request, or -1 to unset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height @widget should request, or -1 to unset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_size_request" gtk_widget_set_size_request :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    IO ()

{- |
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, 'GI.Gtk.Objects.Window.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,
'GI.Gtk.Objects.Window.windowSetGeometryHints' 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
'GI.Gtk.Objects.Widget.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 'GI.Gtk.Objects.Widget.Widget'.
-}
widgetSetSizeRequest ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@width@/: width /@widget@/ should request, or -1 to unset -}
    -> Int32
    {- ^ /@height@/: height /@widget@/ should request, or -1 to unset -}
    -> m ()
widgetSetSizeRequest widget width height = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_set_size_request widget' width height
    touchManagedPtr widget
    return ()

data WidgetSetSizeRequestMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetSizeRequestMethodInfo a signature where
    overloadedMethod _ = widgetSetSizeRequest

-- method Widget::set_state
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface (Name {namespace = "Gtk", name = "StateType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new state for @widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_state" gtk_widget_set_state :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- state : TInterface (Name {namespace = "Gtk", name = "StateType"})
    IO ()

{-# DEPRECATED widgetSetState ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetSetStateFlags' instead."] #-}
{- |
This function is for use in widget implementations. Sets the state
of a widget (insensitive, prelighted, etc.) Usually you should set
the state using wrapper functions such as 'GI.Gtk.Objects.Widget.widgetSetSensitive'.
-}
widgetSetState ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.StateType
    {- ^ /@state@/: new state for /@widget@/ -}
    -> m ()
widgetSetState widget state = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let state' = (fromIntegral . fromEnum) state
    gtk_widget_set_state widget' state'
    touchManagedPtr widget
    return ()

data WidgetSetStateMethodInfo
instance (signature ~ (Gtk.Enums.StateType -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetStateMethodInfo a signature where
    overloadedMethod _ = widgetSetState

-- method Widget::set_state_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "State flags to turn on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clear", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether to clear state before turning on @flags", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_state_flags" gtk_widget_set_state_flags :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    CInt ->                                 -- clear : TBasicType TBoolean
    IO ()

{- |
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 'GI.Gtk.Flags.StateFlagsDirLtr' and
'GI.Gtk.Flags.StateFlagsDirRtl' but ignores them. If you want to set the widget\'s
direction, use 'GI.Gtk.Objects.Widget.widgetSetDirection'.

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

@since 3.0
-}
widgetSetStateFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@flags@/: State flags to turn on -}
    -> Bool
    {- ^ /@clear@/: Whether to clear state before turning on /@flags@/ -}
    -> m ()
widgetSetStateFlags widget flags clear = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let flags' = gflagsToWord flags
    let clear' = (fromIntegral . fromEnum) clear
    gtk_widget_set_state_flags widget' flags' clear'
    touchManagedPtr widget
    return ()

data WidgetSetStateFlagsMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetStateFlagsMethodInfo a signature where
    overloadedMethod _ = widgetSetStateFlags

-- method Widget::set_style
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "style", argType = TInterface (Name {namespace = "Gtk", name = "Style"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkStyle, or %NULL to remove the effect\n    of a previous call to gtk_widget_set_style() and go back to\n    the default style", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_style" gtk_widget_set_style :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Style.Style ->                  -- style : TInterface (Name {namespace = "Gtk", name = "Style"})
    IO ()

{-# DEPRECATED widgetSetStyle ["(Since version 3.0)","Use 'GI.Gtk.Objects.StyleContext.StyleContext' instead"] #-}
{- |
Used to set the 'GI.Gtk.Objects.Style.Style' for a widget (/@widget@/->style). Since
GTK 3, this function does nothing, the passed in style is ignored.
-}
widgetSetStyle ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gtk.Style.IsStyle b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (b)
    {- ^ /@style@/: a 'GI.Gtk.Objects.Style.Style', or 'Nothing' to remove the effect
    of a previous call to 'GI.Gtk.Objects.Widget.widgetSetStyle' and go back to
    the default style -}
    -> m ()
widgetSetStyle widget style = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeStyle <- case style of
        Nothing -> return nullPtr
        Just jStyle -> do
            jStyle' <- unsafeManagedPtrCastPtr jStyle
            return jStyle'
    gtk_widget_set_style widget' maybeStyle
    touchManagedPtr widget
    whenJust style touchManagedPtr
    return ()

data WidgetSetStyleMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsWidget a, Gtk.Style.IsStyle b) => O.MethodInfo WidgetSetStyleMethodInfo a signature where
    overloadedMethod _ = widgetSetStyle

-- method Widget::set_support_multidevice
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "support_multidevice", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to support input from multiple devices.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_support_multidevice" gtk_widget_set_support_multidevice :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- support_multidevice : TBasicType TBoolean
    IO ()

{- |
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 @/GdkWindows/@ are created in 'GI.Gtk.Objects.Widget.Widget'::@/realize/@,
'GI.Gdk.Objects.Window.windowSetSupportMultidevice' will have to be called manually on them.

@since 3.0
-}
widgetSetSupportMultidevice ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@supportMultidevice@/: 'True' to support input from multiple devices. -}
    -> m ()
widgetSetSupportMultidevice widget supportMultidevice = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let supportMultidevice' = (fromIntegral . fromEnum) supportMultidevice
    gtk_widget_set_support_multidevice widget' supportMultidevice'
    touchManagedPtr widget
    return ()

data WidgetSetSupportMultideviceMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetSupportMultideviceMethodInfo a signature where
    overloadedMethod _ = widgetSetSupportMultidevice

-- method Widget::set_tooltip_markup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the contents of the tooltip for @widget, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_tooltip_markup" gtk_widget_set_tooltip_markup :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- markup : TBasicType TUTF8
    IO ()

{- |
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 'GI.Gtk.Objects.Widget.Widget':@/has-tooltip/@ to 'True'
and of the default handler for the 'GI.Gtk.Objects.Widget.Widget'::@/query-tooltip/@ signal.

See also the 'GI.Gtk.Objects.Widget.Widget':@/tooltip-markup/@ property and
'GI.Gtk.Objects.Tooltip.tooltipSetMarkup'.

@since 2.12
-}
widgetSetTooltipMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (T.Text)
    {- ^ /@markup@/: the contents of the tooltip for /@widget@/, or 'Nothing' -}
    -> m ()
widgetSetTooltipMarkup widget markup = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeMarkup <- case markup of
        Nothing -> return nullPtr
        Just jMarkup -> do
            jMarkup' <- textToCString jMarkup
            return jMarkup'
    gtk_widget_set_tooltip_markup widget' maybeMarkup
    touchManagedPtr widget
    freeMem maybeMarkup
    return ()

data WidgetSetTooltipMarkupMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetTooltipMarkupMethodInfo a signature where
    overloadedMethod _ = widgetSetTooltipMarkup

-- method Widget::set_tooltip_text
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the contents of the tooltip for @widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_tooltip_text" gtk_widget_set_tooltip_text :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- text : TBasicType TUTF8
    IO ()

{- |
Sets /@text@/ as the contents of the tooltip. This function will take
care of setting 'GI.Gtk.Objects.Widget.Widget':@/has-tooltip/@ to 'True' and of the default
handler for the 'GI.Gtk.Objects.Widget.Widget'::@/query-tooltip/@ signal.

See also the 'GI.Gtk.Objects.Widget.Widget':@/tooltip-text/@ property and 'GI.Gtk.Objects.Tooltip.tooltipSetText'.

@since 2.12
-}
widgetSetTooltipText ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (T.Text)
    {- ^ /@text@/: the contents of the tooltip for /@widget@/ -}
    -> m ()
widgetSetTooltipText widget text = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeText <- case text of
        Nothing -> return nullPtr
        Just jText -> do
            jText' <- textToCString jText
            return jText'
    gtk_widget_set_tooltip_text widget' maybeText
    touchManagedPtr widget
    freeMem maybeText
    return ()

data WidgetSetTooltipTextMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetTooltipTextMethodInfo a signature where
    overloadedMethod _ = widgetSetTooltipText

-- method Widget::set_tooltip_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "custom_window", argType = TInterface (Name {namespace = "Gtk", name = "Window"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GtkWindow, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_tooltip_window" gtk_widget_set_tooltip_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Window.Window ->                -- custom_window : TInterface (Name {namespace = "Gtk", name = "Window"})
    IO ()

{- |
Replaces the default, usually yellow, 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.

If the custom window should have the default theming it needs to
have the name “gtk-tooltip”, see 'GI.Gtk.Objects.Widget.widgetSetName'.

@since 2.12
-}
widgetSetTooltipWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gtk.Window.IsWindow b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (b)
    {- ^ /@customWindow@/: a 'GI.Gtk.Objects.Window.Window', or 'Nothing' -}
    -> m ()
widgetSetTooltipWindow widget customWindow = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeCustomWindow <- case customWindow of
        Nothing -> return nullPtr
        Just jCustomWindow -> do
            jCustomWindow' <- unsafeManagedPtrCastPtr jCustomWindow
            return jCustomWindow'
    gtk_widget_set_tooltip_window widget' maybeCustomWindow
    touchManagedPtr widget
    whenJust customWindow touchManagedPtr
    return ()

data WidgetSetTooltipWindowMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsWidget a, Gtk.Window.IsWindow b) => O.MethodInfo WidgetSetTooltipWindowMethodInfo a signature where
    overloadedMethod _ = widgetSetTooltipWindow

-- method Widget::set_valign
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TInterface (Name {namespace = "Gtk", name = "Align"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the vertical alignment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_valign" gtk_widget_set_valign :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- align : TInterface (Name {namespace = "Gtk", name = "Align"})
    IO ()

{- |
Sets the vertical alignment of /@widget@/.
See the 'GI.Gtk.Objects.Widget.Widget':@/valign/@ property.
-}
widgetSetValign ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gtk.Enums.Align
    {- ^ /@align@/: the vertical alignment -}
    -> m ()
widgetSetValign widget align = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let align' = (fromIntegral . fromEnum) align
    gtk_widget_set_valign widget' align'
    touchManagedPtr widget
    return ()

data WidgetSetValignMethodInfo
instance (signature ~ (Gtk.Enums.Align -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetValignMethodInfo a signature where
    overloadedMethod _ = widgetSetValign

-- method Widget::set_vexpand
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "expand", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to expand", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_vexpand" gtk_widget_set_vexpand :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- expand : TBasicType TBoolean
    IO ()

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

See 'GI.Gtk.Objects.Widget.widgetSetHexpand' for more detail.
-}
widgetSetVexpand ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget -}
    -> Bool
    {- ^ /@expand@/: whether to expand -}
    -> m ()
widgetSetVexpand widget expand = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let expand' = (fromIntegral . fromEnum) expand
    gtk_widget_set_vexpand widget' expand'
    touchManagedPtr widget
    return ()

data WidgetSetVexpandMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetVexpandMethodInfo a signature where
    overloadedMethod _ = widgetSetVexpand

-- method Widget::set_vexpand_set
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "set", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "value for vexpand-set property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_vexpand_set" gtk_widget_set_vexpand_set :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- set : TBasicType TBoolean
    IO ()

{- |
Sets whether the vexpand flag (see 'GI.Gtk.Objects.Widget.widgetGetVexpand') will
be used.

See 'GI.Gtk.Objects.Widget.widgetSetHexpandSet' for more detail.
-}
widgetSetVexpandSet ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: the widget -}
    -> Bool
    {- ^ /@set@/: value for vexpand-set property -}
    -> m ()
widgetSetVexpandSet widget set = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let set' = (fromIntegral . fromEnum) set
    gtk_widget_set_vexpand_set widget' set'
    touchManagedPtr widget
    return ()

data WidgetSetVexpandSetMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetVexpandSetMethodInfo a signature where
    overloadedMethod _ = widgetSetVexpandSet

-- method Widget::set_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visible", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether the widget should be shown or not", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_visible" gtk_widget_set_visible :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

{- |
Sets the visibility state of /@widget@/. Note that setting this to
'True' doesn’t mean the widget is actually viewable, see
'GI.Gtk.Objects.Widget.widgetGetVisible'.

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

@since 2.18
-}
widgetSetVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Bool
    {- ^ /@visible@/: whether the widget should be shown or not -}
    -> m ()
widgetSetVisible widget visible = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let visible' = (fromIntegral . fromEnum) visible
    gtk_widget_set_visible widget' visible'
    touchManagedPtr widget
    return ()

data WidgetSetVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSetVisibleMethodInfo a signature where
    overloadedMethod _ = widgetSetVisible

-- method Widget::set_visual
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "visual", argType = TInterface (Name {namespace = "Gdk", name = "Visual"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "visual to be used or %NULL to unset a previous one", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_visual" gtk_widget_set_visual :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Visual.Visual ->                -- visual : TInterface (Name {namespace = "Gdk", name = "Visual"})
    IO ()

{- |
Sets the visual that should be used for by widget and its children for
creating @/GdkWindows/@. The visual must be on the same 'GI.Gdk.Objects.Screen.Screen' as
returned by 'GI.Gtk.Objects.Widget.widgetGetScreen', so handling the
'GI.Gtk.Objects.Widget.Widget'::@/screen-changed/@ signal is necessary.

Setting a new /@visual@/ will not cause /@widget@/ to recreate its windows,
so you should call this function before /@widget@/ is realized.
-}
widgetSetVisual ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Visual.IsVisual b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (b)
    {- ^ /@visual@/: visual to be used or 'Nothing' to unset a previous one -}
    -> m ()
widgetSetVisual widget visual = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeVisual <- case visual of
        Nothing -> return nullPtr
        Just jVisual -> do
            jVisual' <- unsafeManagedPtrCastPtr jVisual
            return jVisual'
    gtk_widget_set_visual widget' maybeVisual
    touchManagedPtr widget
    whenJust visual touchManagedPtr
    return ()

data WidgetSetVisualMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsWidget a, Gdk.Visual.IsVisual b) => O.MethodInfo WidgetSetVisualMethodInfo a signature where
    overloadedMethod _ = widgetSetVisual

-- method Widget::set_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_window" gtk_widget_set_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Window.Window ->                -- window : TInterface (Name {namespace = "Gdk", name = "Window"})
    IO ()

{- |
Sets a widget’s window. This function should only be used in a
widget’s 'GI.Gtk.Objects.Widget.Widget'::@/realize/@ implementation. The @/window/@ passed is
usually either new window created with 'GI.Gdk.Objects.Window.windowNew', or the
window of its parent widget as returned by
'GI.Gtk.Objects.Widget.widgetGetParentWindow'.

Widgets must indicate whether they will create their own 'GI.Gdk.Objects.Window.Window'
by calling 'GI.Gtk.Objects.Widget.widgetSetHasWindow'. This is usually done in the
widget’s @/init()/@ function.

Note that this function does not add any reference to /@window@/.

@since 2.18
-}
widgetSetWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Window.IsWindow b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -}
    -> m ()
widgetSetWindow widget window = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    window' <- B.ManagedPtr.disownObject window
    gtk_widget_set_window widget' window'
    touchManagedPtr widget
    touchManagedPtr window
    return ()

data WidgetSetWindowMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, Gdk.Window.IsWindow b) => O.MethodInfo WidgetSetWindowMethodInfo a signature where
    overloadedMethod _ = widgetSetWindow

-- method Widget::shape_combine_region
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "region", argType = TInterface (Name {namespace = "cairo", name = "Region"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "shape to be added, or %NULL to remove an existing shape", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_shape_combine_region" gtk_widget_shape_combine_region :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Cairo.Region.Region ->              -- region : TInterface (Name {namespace = "cairo", name = "Region"})
    IO ()

{- |
Sets a shape for this widget’s GDK window. This allows for
transparent windows etc., see 'GI.Gdk.Objects.Window.windowShapeCombineRegion'
for more information.

@since 3.0
-}
widgetShapeCombineRegion ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Maybe (Cairo.Region.Region)
    {- ^ /@region@/: shape to be added, or 'Nothing' to remove an existing shape -}
    -> m ()
widgetShapeCombineRegion widget region = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    maybeRegion <- case region of
        Nothing -> return nullPtr
        Just jRegion -> do
            jRegion' <- unsafeManagedPtrGetPtr jRegion
            return jRegion'
    gtk_widget_shape_combine_region widget' maybeRegion
    touchManagedPtr widget
    whenJust region touchManagedPtr
    return ()

data WidgetShapeCombineRegionMethodInfo
instance (signature ~ (Maybe (Cairo.Region.Region) -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetShapeCombineRegionMethodInfo a signature where
    overloadedMethod _ = widgetShapeCombineRegion

-- method Widget::show
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_show" gtk_widget_show :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Flags a widget to be displayed. Any widget that isn’t shown will
not appear on the screen. If you want to show all the widgets in a
container, it’s easier to call 'GI.Gtk.Objects.Widget.widgetShowAll' on the
container, instead of individually showing the widgets.

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.
-}
widgetShow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetShow widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_show widget'
    touchManagedPtr widget
    return ()

data WidgetShowMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetShowMethodInfo a signature where
    overloadedMethod _ = widgetShow

-- method Widget::show_all
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_show_all" gtk_widget_show_all :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Recursively shows a widget, and any child widgets (if the widget is
a container).
-}
widgetShowAll ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetShowAll widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_show_all widget'
    touchManagedPtr widget
    return ()

data WidgetShowAllMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetShowAllMethodInfo a signature where
    overloadedMethod _ = widgetShowAll

-- method Widget::show_now
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_show_now" gtk_widget_show_now :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Shows a widget. If the widget is an unmapped toplevel widget
(i.e. a 'GI.Gtk.Objects.Window.Window' that has not yet been shown), enter the main
loop and wait for the window to actually be mapped. Be careful;
because the main loop is running, anything can happen during
this function.
-}
widgetShowNow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetShowNow widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_show_now widget'
    touchManagedPtr widget
    return ()

data WidgetShowNowMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetShowNowMethodInfo a signature where
    overloadedMethod _ = widgetShowNow

-- method Widget::size_allocate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocation", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position and size to be allocated to @widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_size_allocate" gtk_widget_size_allocate :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Rectangle.Rectangle ->          -- allocation : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    IO ()

{- |
This function is only used by 'GI.Gtk.Objects.Container.Container' subclasses, to assign a size
and position to their child widgets.

In this function, the allocation may be adjusted. It will be forced
to a 1x1 minimum size, and the adjust_size_allocation virtual
method on the child will be used to adjust the allocation. Standard
adjustments include removing the widget’s margins, and applying the
widget’s 'GI.Gtk.Objects.Widget.Widget':@/halign/@ and 'GI.Gtk.Objects.Widget.Widget':@/valign/@ properties.

For baseline support in containers you need to use 'GI.Gtk.Objects.Widget.widgetSizeAllocateWithBaseline'
instead.
-}
widgetSizeAllocate ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@allocation@/: position and size to be allocated to /@widget@/ -}
    -> m ()
widgetSizeAllocate widget allocation = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    allocation' <- unsafeManagedPtrGetPtr allocation
    gtk_widget_size_allocate widget' allocation'
    touchManagedPtr widget
    touchManagedPtr allocation
    return ()

data WidgetSizeAllocateMethodInfo
instance (signature ~ (Gdk.Rectangle.Rectangle -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSizeAllocateMethodInfo a signature where
    overloadedMethod _ = widgetSizeAllocate

-- method Widget::size_allocate_with_baseline
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocation", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "position and size to be allocated to @widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "baseline", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The baseline of the child, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_size_allocate_with_baseline" gtk_widget_size_allocate_with_baseline :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Rectangle.Rectangle ->          -- allocation : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
    Int32 ->                                -- baseline : TBasicType TInt
    IO ()

{- |
This function is only used by 'GI.Gtk.Objects.Container.Container' subclasses, to assign a size,
position and (optionally) baseline to their child widgets.

In this function, the allocation and baseline may be adjusted. It
will be forced to a 1x1 minimum size, and the
adjust_size_allocation virtual and adjust_baseline_allocation
methods on the child will be used to adjust the allocation and
baseline. Standard adjustments include removing the widget\'s
margins, and applying the widget’s 'GI.Gtk.Objects.Widget.Widget':@/halign/@ and
'GI.Gtk.Objects.Widget.Widget':@/valign/@ properties.

If the child widget does not have a valign of 'GI.Gtk.Enums.AlignBaseline' the
baseline argument is ignored and -1 is used instead.

@since 3.10
-}
widgetSizeAllocateWithBaseline ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Gdk.Rectangle.Rectangle
    {- ^ /@allocation@/: position and size to be allocated to /@widget@/ -}
    -> Int32
    {- ^ /@baseline@/: The baseline of the child, or -1 -}
    -> m ()
widgetSizeAllocateWithBaseline widget allocation baseline = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    allocation' <- unsafeManagedPtrGetPtr allocation
    gtk_widget_size_allocate_with_baseline widget' allocation' baseline
    touchManagedPtr widget
    touchManagedPtr allocation
    return ()

data WidgetSizeAllocateWithBaselineMethodInfo
instance (signature ~ (Gdk.Rectangle.Rectangle -> Int32 -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetSizeAllocateWithBaselineMethodInfo a signature where
    overloadedMethod _ = widgetSizeAllocateWithBaseline

-- method Widget::size_request
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "requisition", argType = TInterface (Name {namespace = "Gtk", name = "Requisition"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkRequisition to be filled in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_size_request" gtk_widget_size_request :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gtk.Requisition.Requisition ->      -- requisition : TInterface (Name {namespace = "Gtk", name = "Requisition"})
    IO ()

{-# DEPRECATED widgetSizeRequest ["(Since version 3.0)","Use 'GI.Gtk.Objects.Widget.widgetGetPreferredSize' instead."] #-}
{- |
This function is typically used when implementing a 'GI.Gtk.Objects.Container.Container'
subclass.  Obtains the preferred size of a widget. The container
uses this information to arrange its child widgets and decide what
size allocations to give them with 'GI.Gtk.Objects.Widget.widgetSizeAllocate'.

You can also call this function from an application, with some
caveats. Most notably, getting a size request requires the widget
to be associated with a screen, because font information may be
needed. Multihead-aware applications should keep this in mind.

Also remember that the size request is not necessarily the size
a widget will actually be allocated.
-}
widgetSizeRequest ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m (Gtk.Requisition.Requisition)
widgetSizeRequest widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    requisition <- callocBoxedBytes 8 :: IO (Ptr Gtk.Requisition.Requisition)
    gtk_widget_size_request widget' requisition
    requisition' <- (wrapBoxed Gtk.Requisition.Requisition) requisition
    touchManagedPtr widget
    return requisition'

data WidgetSizeRequestMethodInfo
instance (signature ~ (m (Gtk.Requisition.Requisition)), MonadIO m, IsWidget a) => O.MethodInfo WidgetSizeRequestMethodInfo a signature where
    overloadedMethod _ = widgetSizeRequest

-- method Widget::style_attach
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_style_attach" gtk_widget_style_attach :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{-# DEPRECATED widgetStyleAttach ["(Since version 3.0)","This step is unnecessary with 'GI.Gtk.Objects.StyleContext.StyleContext'."] #-}
{- |
This function attaches the widget’s 'GI.Gtk.Objects.Style.Style' to the widget\'s
'GI.Gdk.Objects.Window.Window'. It is a replacement for

>
>widget->style = gtk_style_attach (widget->style, widget->window);


and should only ever be called in a derived widget’s “realize”
implementation which does not chain up to its parent class\'
“realize” implementation, because one of the parent classes
(finally 'GI.Gtk.Objects.Widget.Widget') would attach the style itself.

@since 2.20
-}
widgetStyleAttach ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetStyleAttach widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_style_attach widget'
    touchManagedPtr widget
    return ()

data WidgetStyleAttachMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetStyleAttachMethodInfo a signature where
    overloadedMethod _ = widgetStyleAttach

-- method Widget::style_get_property
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a style property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to return the property value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_style_get_property" gtk_widget_style_get_property :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CString ->                              -- property_name : TBasicType TUTF8
    Ptr GValue ->                           -- value : TInterface (Name {namespace = "GObject", name = "Value"})
    IO ()

{- |
Gets the value of a style property of /@widget@/.
-}
widgetStyleGetProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> T.Text
    {- ^ /@propertyName@/: the name of a style property -}
    -> GValue
    {- ^ /@value@/: location to return the property value -}
    -> m ()
widgetStyleGetProperty widget propertyName value = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    propertyName' <- textToCString propertyName
    value' <- unsafeManagedPtrGetPtr value
    gtk_widget_style_get_property widget' propertyName' value'
    touchManagedPtr widget
    touchManagedPtr value
    freeMem propertyName'
    return ()

data WidgetStyleGetPropertyMethodInfo
instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetStyleGetPropertyMethodInfo a signature where
    overloadedMethod _ = widgetStyleGetProperty

-- method Widget::thaw_child_notify
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_thaw_child_notify" gtk_widget_thaw_child_notify :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Reverts the effect of a previous call to 'GI.Gtk.Objects.Widget.widgetFreezeChildNotify'.
This causes all queued 'GI.Gtk.Objects.Widget.Widget'::@/child-notify/@ signals on /@widget@/ to be
emitted.
-}
widgetThawChildNotify ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetThawChildNotify widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_thaw_child_notify widget'
    touchManagedPtr widget
    return ()

data WidgetThawChildNotifyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetThawChildNotifyMethodInfo a signature where
    overloadedMethod _ = widgetThawChildNotify

-- method Widget::translate_coordinates
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "src_widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position relative to @src_widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position relative to @src_widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_x", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store X position relative to @dest_widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_y", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store Y position relative to @dest_widget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_translate_coordinates" gtk_widget_translate_coordinates :: 
    Ptr Widget ->                           -- src_widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Widget ->                           -- dest_widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Int32 ->                                -- src_x : TBasicType TInt
    Int32 ->                                -- src_y : TBasicType TInt
    Ptr Int32 ->                            -- dest_x : TBasicType TInt
    Ptr Int32 ->                            -- dest_y : TBasicType TInt
    IO CInt

{- |
Translate coordinates relative to /@srcWidget@/’s allocation to coordinates
relative to /@destWidget@/’s allocations. In order to perform this
operation, both widgets must be realized, and must share a common
toplevel.
-}
widgetTranslateCoordinates ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
    a
    {- ^ /@srcWidget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@destWidget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> Int32
    {- ^ /@srcX@/: X position relative to /@srcWidget@/ -}
    -> Int32
    {- ^ /@srcY@/: Y position relative to /@srcWidget@/ -}
    -> m (Bool,Int32,Int32)
    {- ^ __Returns:__ 'False' if either widget was not realized, or there
  was no common ancestor. In this case, nothing is stored in
  */@destX@/ and */@destY@/. Otherwise 'True'. -}
widgetTranslateCoordinates srcWidget destWidget srcX srcY = liftIO $ do
    srcWidget' <- unsafeManagedPtrCastPtr srcWidget
    destWidget' <- unsafeManagedPtrCastPtr destWidget
    destX <- allocMem :: IO (Ptr Int32)
    destY <- allocMem :: IO (Ptr Int32)
    result <- gtk_widget_translate_coordinates srcWidget' destWidget' srcX srcY destX destY
    let result' = (/= 0) result
    destX' <- peek destX
    destY' <- peek destY
    touchManagedPtr srcWidget
    touchManagedPtr destWidget
    freeMem destX
    freeMem destY
    return (result', destX', destY')

data WidgetTranslateCoordinatesMethodInfo
instance (signature ~ (b -> Int32 -> Int32 -> m (Bool,Int32,Int32)), MonadIO m, IsWidget a, IsWidget b) => O.MethodInfo WidgetTranslateCoordinatesMethodInfo a signature where
    overloadedMethod _ = widgetTranslateCoordinates

-- method Widget::trigger_tooltip_query
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_trigger_tooltip_query" gtk_widget_trigger_tooltip_query :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
Triggers a tooltip query on the display where the toplevel of /@widget@/
is located. See 'GI.Gtk.Objects.Tooltip.tooltipTriggerTooltipQuery' for more
information.

@since 2.12
-}
widgetTriggerTooltipQuery ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetTriggerTooltipQuery widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_trigger_tooltip_query widget'
    touchManagedPtr widget
    return ()

data WidgetTriggerTooltipQueryMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetTriggerTooltipQueryMethodInfo a signature where
    overloadedMethod _ = widgetTriggerTooltipQuery

-- method Widget::unmap
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_unmap" gtk_widget_unmap :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
This function is only for use in widget implementations. Causes
a widget to be unmapped if it’s currently mapped.
-}
widgetUnmap ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetUnmap widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_unmap widget'
    touchManagedPtr widget
    return ()

data WidgetUnmapMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetUnmapMethodInfo a signature where
    overloadedMethod _ = widgetUnmap

-- method Widget::unparent
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_unparent" gtk_widget_unparent :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
This function is only for use in widget implementations.
Should be called by implementations of the remove method
on 'GI.Gtk.Objects.Container.Container', to dissociate a child from the container.
-}
widgetUnparent ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetUnparent widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_unparent widget'
    touchManagedPtr widget
    return ()

data WidgetUnparentMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetUnparentMethodInfo a signature where
    overloadedMethod _ = widgetUnparent

-- method Widget::unrealize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_unrealize" gtk_widget_unrealize :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
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@/->window).
-}
widgetUnrealize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
widgetUnrealize widget = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    gtk_widget_unrealize widget'
    touchManagedPtr widget
    return ()

data WidgetUnrealizeMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetUnrealizeMethodInfo a signature where
    overloadedMethod _ = widgetUnrealize

-- method Widget::unregister_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_unregister_window" gtk_widget_unregister_window :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    Ptr Gdk.Window.Window ->                -- window : TInterface (Name {namespace = "Gdk", name = "Window"})
    IO ()

{- |
Unregisters a 'GI.Gdk.Objects.Window.Window' from the widget that was previously set up with
'GI.Gtk.Objects.Widget.widgetRegisterWindow'. You need to call this when the window is
no longer used by the widget, such as when you destroy it.

@since 3.8
-}
widgetUnregisterWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a, Gdk.Window.IsWindow b) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> b
    {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -}
    -> m ()
widgetUnregisterWindow widget window = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    window' <- unsafeManagedPtrCastPtr window
    gtk_widget_unregister_window widget' window'
    touchManagedPtr widget
    touchManagedPtr window
    return ()

data WidgetUnregisterWindowMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsWidget a, Gdk.Window.IsWindow b) => O.MethodInfo WidgetUnregisterWindowMethodInfo a signature where
    overloadedMethod _ = widgetUnregisterWindow

-- method Widget::unset_state_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkWidget", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gtk", name = "StateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "State flags to turn off", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_unset_state_flags" gtk_widget_unset_state_flags :: 
    Ptr Widget ->                           -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gtk", name = "StateFlags"})
    IO ()

{- |
This function is for use in widget implementations. Turns off flag
values for the current widget state (insensitive, prelighted, etc.).
See 'GI.Gtk.Objects.Widget.widgetSetStateFlags'.

@since 3.0
-}
widgetUnsetStateFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsWidget a) =>
    a
    {- ^ /@widget@/: a 'GI.Gtk.Objects.Widget.Widget' -}
    -> [Gtk.Flags.StateFlags]
    {- ^ /@flags@/: State flags to turn off -}
    -> m ()
widgetUnsetStateFlags widget flags = liftIO $ do
    widget' <- unsafeManagedPtrCastPtr widget
    let flags' = gflagsToWord flags
    gtk_widget_unset_state_flags widget' flags'
    touchManagedPtr widget
    return ()

data WidgetUnsetStateFlagsMethodInfo
instance (signature ~ ([Gtk.Flags.StateFlags] -> m ()), MonadIO m, IsWidget a) => O.MethodInfo WidgetUnsetStateFlagsMethodInfo a signature where
    overloadedMethod _ = widgetUnsetStateFlags

-- method Widget::get_default_direction
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "TextDirection"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_default_direction" gtk_widget_get_default_direction :: 
    IO CUInt

{- |
Obtains the current default reading direction. See
'GI.Gtk.Objects.Widget.widgetSetDefaultDirection'.
-}
widgetGetDefaultDirection ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gtk.Enums.TextDirection
    {- ^ __Returns:__ the current default direction. -}
widgetGetDefaultDirection  = liftIO $ do
    result <- gtk_widget_get_default_direction
    let result' = (toEnum . fromIntegral) result
    return result'

-- method Widget::get_default_style
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Style"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_get_default_style" gtk_widget_get_default_style :: 
    IO (Ptr Gtk.Style.Style)

{-# DEPRECATED widgetGetDefaultStyle ["(Since version 3.0)","Use 'GI.Gtk.Objects.StyleContext.StyleContext' instead, and","    'GI.Gtk.Objects.CssProvider.cssProviderGetDefault' to obtain a 'GI.Gtk.Interfaces.StyleProvider.StyleProvider'","    with the default widget style information."] #-}
{- |
Returns the default style used by all widgets initially.
-}
widgetGetDefaultStyle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gtk.Style.Style
    {- ^ __Returns:__ the default style. This 'GI.Gtk.Objects.Style.Style'
    object is owned by GTK+ and should not be modified or freed. -}
widgetGetDefaultStyle  = liftIO $ do
    result <- gtk_widget_get_default_style
    checkUnexpectedReturnNULL "widgetGetDefaultStyle" result
    result' <- (newObject Gtk.Style.Style) result
    return result'

-- method Widget::pop_composite_child
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_pop_composite_child" gtk_widget_pop_composite_child :: 
    IO ()

{-# DEPRECATED widgetPopCompositeChild ["(Since version 3.10)","Use 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate', or don\8217t use this API at all."] #-}
{- |
Cancels the effect of a previous call to 'GI.Gtk.Objects.Widget.widgetPushCompositeChild'.
-}
widgetPopCompositeChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ()
widgetPopCompositeChild  = liftIO $ do
    gtk_widget_pop_composite_child
    return ()

-- method Widget::push_composite_child
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_push_composite_child" gtk_widget_push_composite_child :: 
    IO ()

{-# DEPRECATED widgetPushCompositeChild ["(Since version 3.10)","This API never really worked well and was mostly unused, now","we have a more complete mechanism for composite children, see 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'."] #-}
{- |
Makes all newly-created widgets as composite children until
the corresponding 'GI.Gtk.Objects.Widget.widgetPopCompositeChild' call.

A composite child is a child that’s an implementation detail of the
container it’s inside and should not be visible to people using the
container. Composite children aren’t treated differently by GTK+ (but
see 'GI.Gtk.Objects.Container.containerForeach' vs. 'GI.Gtk.Objects.Container.containerForall'), but e.g. GUI
builders might want to treat them in a different way.
-}
widgetPushCompositeChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ()
widgetPushCompositeChild  = liftIO $ do
    gtk_widget_push_composite_child
    return ()

-- method Widget::set_default_direction
-- method type : MemberFunction
-- Args : [Arg {argCName = "dir", argType = TInterface (Name {namespace = "Gtk", name = "TextDirection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new default direction. This cannot be\n       %GTK_TEXT_DIR_NONE.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_set_default_direction" gtk_widget_set_default_direction :: 
    CUInt ->                                -- dir : TInterface (Name {namespace = "Gtk", name = "TextDirection"})
    IO ()

{- |
Sets the default reading direction for widgets where the
direction has not been explicitly set by 'GI.Gtk.Objects.Widget.widgetSetDirection'.
-}
widgetSetDefaultDirection ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Gtk.Enums.TextDirection
    {- ^ /@dir@/: the new default direction. This cannot be
       'GI.Gtk.Enums.TextDirectionNone'. -}
    -> m ()
widgetSetDefaultDirection dir = liftIO $ do
    let dir' = (fromIntegral . fromEnum) dir
    gtk_widget_set_default_direction dir'
    return ()