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

The 'GI.Gtk.Objects.Label.Label' widget displays a small amount of text. As the name
implies, most labels are used to label another widget such as a
'GI.Gtk.Objects.Button.Button', a 'GI.Gtk.Objects.MenuItem.MenuItem', or a 'GI.Gtk.Objects.ComboBox.ComboBox'.

= CSS nodes


=== /plain code/
>
>label
>├── [selection]
>├── [link]
>┊
>╰── [link]


GtkLabel has a single CSS node with the name label. A wide variety
of style classes may be applied to labels, such as .title, .subtitle,
.dim-label, etc. In the 'GI.Gtk.Objects.ShortcutsWindow.ShortcutsWindow', labels are used wth the
.keycap style class.

If the label has a selection, it gets a subnode with name selection.

If the label has links, there is one subnode per link. These subnodes
carry the link or visited state depending on whether they have been
visited.

= GtkLabel as GtkBuildable

The GtkLabel implementation of the GtkBuildable interface supports a
custom \<attributes> element, which supports any number of \<attribute>
elements. The \<attribute> element has attributes named “name“, “value“,
“start“ and “end“ and allows you to specify 'GI.Pango.Structs.Attribute.Attribute' values for
this label.

An example of a UI definition fragment specifying Pango attributes:
>
><object class="GtkLabel">
>  <attributes>
>    <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
>    <attribute name="background" value="red" start="5" end="10"/>"
>  </attributes>
></object>


The start and end attributes specify the range of characters to which the
Pango attribute applies. If start and end are not specified, the attribute is
applied to the whole text. Note that specifying ranges does not make much
sense with translatable attributes. Use markup embedded in the translatable
content instead.

= Mnemonics

Labels may contain “mnemonics”. Mnemonics are
underlined characters in the label, used for keyboard navigation.
Mnemonics are created by providing a string with an underscore before
the mnemonic character, such as @\"_File\"@, to the
functions 'GI.Gtk.Objects.Label.labelNewWithMnemonic' or
'GI.Gtk.Objects.Label.labelSetTextWithMnemonic'.

Mnemonics automatically activate any activatable widget the label is
inside, such as a 'GI.Gtk.Objects.Button.Button'; if the label is not inside the
mnemonic’s target widget, you have to tell the label about the target
using 'GI.Gtk.Objects.Label.labelSetMnemonicWidget'. Here’s a simple example where
the label is inside a button:


=== /C code/
>
>  // Pressing Alt+H will activate this button
>  button = gtk_button_new ();
>  label = gtk_label_new_with_mnemonic ("_Hello");
>  gtk_container_add (GTK_CONTAINER (button), label);


There’s a convenience function to create buttons with a mnemonic label
already inside:


=== /C code/
>
>  // Pressing Alt+H will activate this button
>  button = gtk_button_new_with_mnemonic ("_Hello");


To create a mnemonic for a widget alongside the label, such as a
'GI.Gtk.Objects.Entry.Entry', you have to point the label at the entry with
'GI.Gtk.Objects.Label.labelSetMnemonicWidget':


=== /C code/
>
>  // Pressing Alt+H will focus the entry
>  entry = gtk_entry_new ();
>  label = gtk_label_new_with_mnemonic ("_Hello");
>  gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);


= Markup (styled text)

To make it easy to format text in a label (changing colors,
fonts, etc.), label text can be provided in a simple
[markup format][PangoMarkupFormat].

Here’s how to create a label with a small font:

=== /C code/
>
>  label = gtk_label_new (NULL);
>  gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>");


(See [complete documentation][PangoMarkupFormat] of available
tags in the Pango manual.)

The markup passed to 'GI.Gtk.Objects.Label.labelSetMarkup' must be valid; for example,
literal \<, > and & characters must be escaped as &lt;, &gt;, and &amp;.
If you pass text obtained from the user, file, or a network to
'GI.Gtk.Objects.Label.labelSetMarkup', you’ll want to escape it with
'GI.GLib.Functions.markupEscapeText' or @/g_markup_printf_escaped()/@.

Markup strings are just a convenient way to set the 'GI.Pango.Structs.AttrList.AttrList' on
a label; 'GI.Gtk.Objects.Label.labelSetAttributes' may be a simpler way to set
attributes in some cases. Be careful though; 'GI.Pango.Structs.AttrList.AttrList' tends to
cause internationalization problems, unless you’re applying attributes
to the entire string (i.e. unless you set the range of each attribute
to [0, @/G_MAXINT/@)). The reason is that specifying the start_index and
end_index for a 'GI.Pango.Structs.Attribute.Attribute' requires knowledge of the exact string
being displayed, so translations will cause problems.

= Selectable labels

Labels can be made selectable with 'GI.Gtk.Objects.Label.labelSetSelectable'.
Selectable labels allow the user to copy the label contents to
the clipboard. Only labels that contain useful-to-copy information
— such as error messages — should be made selectable.

# Text layout # {@/label/@-text-layout}

A label can contain any number of paragraphs, but will have
performance problems if it contains more than a small number.
Paragraphs are separated by newlines or other paragraph separators
understood by Pango.

Labels can automatically wrap text if you call
'GI.Gtk.Objects.Label.labelSetLineWrap'.

'GI.Gtk.Objects.Label.labelSetJustify' sets how the lines in a label align
with one another. If you want to set how the label as a whole
aligns in its available space, see the 'GI.Gtk.Objects.Widget.Widget':@/halign/@ and
'GI.Gtk.Objects.Widget.Widget':@/valign/@ properties.

The 'GI.Gtk.Objects.Label.Label':@/width-chars/@ and 'GI.Gtk.Objects.Label.Label':@/max-width-chars/@ properties
can be used to control the size allocation of ellipsized or wrapped
labels. For ellipsizing labels, if either is specified (and less
than the actual text size), it is used as the minimum width, and the actual
text size is used as the natural width of the label. For wrapping labels,
width-chars is used as the minimum width, if specified, and max-width-chars
is used as the natural width. Even if max-width-chars specified, wrapping
labels will be rewrapped to use all of the available width.

Note that the interpretation of 'GI.Gtk.Objects.Label.Label':@/width-chars/@ and
'GI.Gtk.Objects.Label.Label':@/max-width-chars/@ has changed a bit with the introduction of
[width-for-height geometry management.][geometry-management]

= Links

Since 2.18, GTK+ supports markup for clickable hyperlinks in addition
to regular Pango markup. The markup for links is borrowed from HTML,
using the @\<a>@ with “href“ and “title“ attributes. GTK+ renders links
similar to the way they appear in web browsers, with colored, underlined
text. The “title“ attribute is displayed as a tooltip on the link.

An example looks like this:


=== /C code/
>
>const gchar *text =
>"Go to the"
>"<a href=\"http://www.gtk.org title="&lt;i&gt;Our&lt;/i&gt; website\">"
>"GTK+ website</a> for more...";
>gtk_label_set_markup (label, text);


It is possible to implement custom handling for links and their tooltips with
the 'GI.Gtk.Objects.Label.Label'::@/activate-link/@ signal and the 'GI.Gtk.Objects.Label.labelGetCurrentUri' function.
-}

module GI.Gtk.Objects.Label
    ( 

-- * Exported types
    Label(..)                               ,
    IsLabel                                 ,
    toLabel                                 ,
    noLabel                                 ,


 -- * Methods
-- ** getAngle #method:getAngle#
    LabelGetAngleMethodInfo                 ,
    labelGetAngle                           ,


-- ** getAttributes #method:getAttributes#
    LabelGetAttributesMethodInfo            ,
    labelGetAttributes                      ,


-- ** getCurrentUri #method:getCurrentUri#
    LabelGetCurrentUriMethodInfo            ,
    labelGetCurrentUri                      ,


-- ** getEllipsize #method:getEllipsize#
    LabelGetEllipsizeMethodInfo             ,
    labelGetEllipsize                       ,


-- ** getJustify #method:getJustify#
    LabelGetJustifyMethodInfo               ,
    labelGetJustify                         ,


-- ** getLabel #method:getLabel#
    LabelGetLabelMethodInfo                 ,
    labelGetLabel                           ,


-- ** getLayout #method:getLayout#
    LabelGetLayoutMethodInfo                ,
    labelGetLayout                          ,


-- ** getLayoutOffsets #method:getLayoutOffsets#
    LabelGetLayoutOffsetsMethodInfo         ,
    labelGetLayoutOffsets                   ,


-- ** getLineWrap #method:getLineWrap#
    LabelGetLineWrapMethodInfo              ,
    labelGetLineWrap                        ,


-- ** getLineWrapMode #method:getLineWrapMode#
    LabelGetLineWrapModeMethodInfo          ,
    labelGetLineWrapMode                    ,


-- ** getLines #method:getLines#
    LabelGetLinesMethodInfo                 ,
    labelGetLines                           ,


-- ** getMaxWidthChars #method:getMaxWidthChars#
    LabelGetMaxWidthCharsMethodInfo         ,
    labelGetMaxWidthChars                   ,


-- ** getMnemonicKeyval #method:getMnemonicKeyval#
    LabelGetMnemonicKeyvalMethodInfo        ,
    labelGetMnemonicKeyval                  ,


-- ** getMnemonicWidget #method:getMnemonicWidget#
    LabelGetMnemonicWidgetMethodInfo        ,
    labelGetMnemonicWidget                  ,


-- ** getSelectable #method:getSelectable#
    LabelGetSelectableMethodInfo            ,
    labelGetSelectable                      ,


-- ** getSelectionBounds #method:getSelectionBounds#
    LabelGetSelectionBoundsMethodInfo       ,
    labelGetSelectionBounds                 ,


-- ** getSingleLineMode #method:getSingleLineMode#
    LabelGetSingleLineModeMethodInfo        ,
    labelGetSingleLineMode                  ,


-- ** getText #method:getText#
    LabelGetTextMethodInfo                  ,
    labelGetText                            ,


-- ** getTrackVisitedLinks #method:getTrackVisitedLinks#
    LabelGetTrackVisitedLinksMethodInfo     ,
    labelGetTrackVisitedLinks               ,


-- ** getUseMarkup #method:getUseMarkup#
    LabelGetUseMarkupMethodInfo             ,
    labelGetUseMarkup                       ,


-- ** getUseUnderline #method:getUseUnderline#
    LabelGetUseUnderlineMethodInfo          ,
    labelGetUseUnderline                    ,


-- ** getWidthChars #method:getWidthChars#
    LabelGetWidthCharsMethodInfo            ,
    labelGetWidthChars                      ,


-- ** getXalign #method:getXalign#
    LabelGetXalignMethodInfo                ,
    labelGetXalign                          ,


-- ** getYalign #method:getYalign#
    LabelGetYalignMethodInfo                ,
    labelGetYalign                          ,


-- ** new #method:new#
    labelNew                                ,


-- ** newWithMnemonic #method:newWithMnemonic#
    labelNewWithMnemonic                    ,


-- ** selectRegion #method:selectRegion#
    LabelSelectRegionMethodInfo             ,
    labelSelectRegion                       ,


-- ** setAngle #method:setAngle#
    LabelSetAngleMethodInfo                 ,
    labelSetAngle                           ,


-- ** setAttributes #method:setAttributes#
    LabelSetAttributesMethodInfo            ,
    labelSetAttributes                      ,


-- ** setEllipsize #method:setEllipsize#
    LabelSetEllipsizeMethodInfo             ,
    labelSetEllipsize                       ,


-- ** setJustify #method:setJustify#
    LabelSetJustifyMethodInfo               ,
    labelSetJustify                         ,


-- ** setLabel #method:setLabel#
    LabelSetLabelMethodInfo                 ,
    labelSetLabel                           ,


-- ** setLineWrap #method:setLineWrap#
    LabelSetLineWrapMethodInfo              ,
    labelSetLineWrap                        ,


-- ** setLineWrapMode #method:setLineWrapMode#
    LabelSetLineWrapModeMethodInfo          ,
    labelSetLineWrapMode                    ,


-- ** setLines #method:setLines#
    LabelSetLinesMethodInfo                 ,
    labelSetLines                           ,


-- ** setMarkup #method:setMarkup#
    LabelSetMarkupMethodInfo                ,
    labelSetMarkup                          ,


-- ** setMarkupWithMnemonic #method:setMarkupWithMnemonic#
    LabelSetMarkupWithMnemonicMethodInfo    ,
    labelSetMarkupWithMnemonic              ,


-- ** setMaxWidthChars #method:setMaxWidthChars#
    LabelSetMaxWidthCharsMethodInfo         ,
    labelSetMaxWidthChars                   ,


-- ** setMnemonicWidget #method:setMnemonicWidget#
    LabelSetMnemonicWidgetMethodInfo        ,
    labelSetMnemonicWidget                  ,


-- ** setPattern #method:setPattern#
    LabelSetPatternMethodInfo               ,
    labelSetPattern                         ,


-- ** setSelectable #method:setSelectable#
    LabelSetSelectableMethodInfo            ,
    labelSetSelectable                      ,


-- ** setSingleLineMode #method:setSingleLineMode#
    LabelSetSingleLineModeMethodInfo        ,
    labelSetSingleLineMode                  ,


-- ** setText #method:setText#
    LabelSetTextMethodInfo                  ,
    labelSetText                            ,


-- ** setTextWithMnemonic #method:setTextWithMnemonic#
    LabelSetTextWithMnemonicMethodInfo      ,
    labelSetTextWithMnemonic                ,


-- ** setTrackVisitedLinks #method:setTrackVisitedLinks#
    LabelSetTrackVisitedLinksMethodInfo     ,
    labelSetTrackVisitedLinks               ,


-- ** setUseMarkup #method:setUseMarkup#
    LabelSetUseMarkupMethodInfo             ,
    labelSetUseMarkup                       ,


-- ** setUseUnderline #method:setUseUnderline#
    LabelSetUseUnderlineMethodInfo          ,
    labelSetUseUnderline                    ,


-- ** setWidthChars #method:setWidthChars#
    LabelSetWidthCharsMethodInfo            ,
    labelSetWidthChars                      ,


-- ** setXalign #method:setXalign#
    LabelSetXalignMethodInfo                ,
    labelSetXalign                          ,


-- ** setYalign #method:setYalign#
    LabelSetYalignMethodInfo                ,
    labelSetYalign                          ,




 -- * Properties
-- ** angle #attr:angle#
    LabelAnglePropertyInfo                  ,
    constructLabelAngle                     ,
    getLabelAngle                           ,
    labelAngle                              ,
    setLabelAngle                           ,


-- ** attributes #attr:attributes#
    LabelAttributesPropertyInfo             ,
    clearLabelAttributes                    ,
    constructLabelAttributes                ,
    getLabelAttributes                      ,
    labelAttributes                         ,
    setLabelAttributes                      ,


-- ** cursorPosition #attr:cursorPosition#
    LabelCursorPositionPropertyInfo         ,
    getLabelCursorPosition                  ,
    labelCursorPosition                     ,


-- ** ellipsize #attr:ellipsize#
    LabelEllipsizePropertyInfo              ,
    constructLabelEllipsize                 ,
    getLabelEllipsize                       ,
    labelEllipsize                          ,
    setLabelEllipsize                       ,


-- ** justify #attr:justify#
    LabelJustifyPropertyInfo                ,
    constructLabelJustify                   ,
    getLabelJustify                         ,
    labelJustify                            ,
    setLabelJustify                         ,


-- ** label #attr:label#
    LabelLabelPropertyInfo                  ,
    constructLabelLabel                     ,
    getLabelLabel                           ,
    labelLabel                              ,
    setLabelLabel                           ,


-- ** lines #attr:lines#
    LabelLinesPropertyInfo                  ,
    constructLabelLines                     ,
    getLabelLines                           ,
    labelLines                              ,
    setLabelLines                           ,


-- ** maxWidthChars #attr:maxWidthChars#
    LabelMaxWidthCharsPropertyInfo          ,
    constructLabelMaxWidthChars             ,
    getLabelMaxWidthChars                   ,
    labelMaxWidthChars                      ,
    setLabelMaxWidthChars                   ,


-- ** mnemonicKeyval #attr:mnemonicKeyval#
    LabelMnemonicKeyvalPropertyInfo         ,
    getLabelMnemonicKeyval                  ,
    labelMnemonicKeyval                     ,


-- ** mnemonicWidget #attr:mnemonicWidget#
    LabelMnemonicWidgetPropertyInfo         ,
    clearLabelMnemonicWidget                ,
    constructLabelMnemonicWidget            ,
    getLabelMnemonicWidget                  ,
    labelMnemonicWidget                     ,
    setLabelMnemonicWidget                  ,


-- ** pattern #attr:pattern#
    LabelPatternPropertyInfo                ,
    constructLabelPattern                   ,
    labelPattern                            ,
    setLabelPattern                         ,


-- ** selectable #attr:selectable#
    LabelSelectablePropertyInfo             ,
    constructLabelSelectable                ,
    getLabelSelectable                      ,
    labelSelectable                         ,
    setLabelSelectable                      ,


-- ** selectionBound #attr:selectionBound#
    LabelSelectionBoundPropertyInfo         ,
    getLabelSelectionBound                  ,
    labelSelectionBound                     ,


-- ** singleLineMode #attr:singleLineMode#
    LabelSingleLineModePropertyInfo         ,
    constructLabelSingleLineMode            ,
    getLabelSingleLineMode                  ,
    labelSingleLineMode                     ,
    setLabelSingleLineMode                  ,


-- ** trackVisitedLinks #attr:trackVisitedLinks#
    LabelTrackVisitedLinksPropertyInfo      ,
    constructLabelTrackVisitedLinks         ,
    getLabelTrackVisitedLinks               ,
    labelTrackVisitedLinks                  ,
    setLabelTrackVisitedLinks               ,


-- ** useMarkup #attr:useMarkup#
    LabelUseMarkupPropertyInfo              ,
    constructLabelUseMarkup                 ,
    getLabelUseMarkup                       ,
    labelUseMarkup                          ,
    setLabelUseMarkup                       ,


-- ** useUnderline #attr:useUnderline#
    LabelUseUnderlinePropertyInfo           ,
    constructLabelUseUnderline              ,
    getLabelUseUnderline                    ,
    labelUseUnderline                       ,
    setLabelUseUnderline                    ,


-- ** widthChars #attr:widthChars#
    LabelWidthCharsPropertyInfo             ,
    constructLabelWidthChars                ,
    getLabelWidthChars                      ,
    labelWidthChars                         ,
    setLabelWidthChars                      ,


-- ** wrap #attr:wrap#
    LabelWrapPropertyInfo                   ,
    constructLabelWrap                      ,
    getLabelWrap                            ,
    labelWrap                               ,
    setLabelWrap                            ,


-- ** wrapMode #attr:wrapMode#
    LabelWrapModePropertyInfo               ,
    constructLabelWrapMode                  ,
    getLabelWrapMode                        ,
    labelWrapMode                           ,
    setLabelWrapMode                        ,


-- ** xalign #attr:xalign#
    LabelXalignPropertyInfo                 ,
    constructLabelXalign                    ,
    getLabelXalign                          ,
    labelXalign                             ,
    setLabelXalign                          ,


-- ** yalign #attr:yalign#
    LabelYalignPropertyInfo                 ,
    constructLabelYalign                    ,
    getLabelYalign                          ,
    labelYalign                             ,
    setLabelYalign                          ,




 -- * Signals
-- ** activateCurrentLink #signal:activateCurrentLink#
    C_LabelActivateCurrentLinkCallback      ,
    LabelActivateCurrentLinkCallback        ,
    LabelActivateCurrentLinkSignalInfo      ,
    afterLabelActivateCurrentLink           ,
    genClosure_LabelActivateCurrentLink     ,
    mk_LabelActivateCurrentLinkCallback     ,
    noLabelActivateCurrentLinkCallback      ,
    onLabelActivateCurrentLink              ,
    wrap_LabelActivateCurrentLinkCallback   ,


-- ** activateLink #signal:activateLink#
    C_LabelActivateLinkCallback             ,
    LabelActivateLinkCallback               ,
    LabelActivateLinkSignalInfo             ,
    afterLabelActivateLink                  ,
    genClosure_LabelActivateLink            ,
    mk_LabelActivateLinkCallback            ,
    noLabelActivateLinkCallback             ,
    onLabelActivateLink                     ,
    wrap_LabelActivateLinkCallback          ,


-- ** copyClipboard #signal:copyClipboard#
    C_LabelCopyClipboardCallback            ,
    LabelCopyClipboardCallback              ,
    LabelCopyClipboardSignalInfo            ,
    afterLabelCopyClipboard                 ,
    genClosure_LabelCopyClipboard           ,
    mk_LabelCopyClipboardCallback           ,
    noLabelCopyClipboardCallback            ,
    onLabelCopyClipboard                    ,
    wrap_LabelCopyClipboardCallback         ,


-- ** moveCursor #signal:moveCursor#
    C_LabelMoveCursorCallback               ,
    LabelMoveCursorCallback                 ,
    LabelMoveCursorSignalInfo               ,
    afterLabelMoveCursor                    ,
    genClosure_LabelMoveCursor              ,
    mk_LabelMoveCursorCallback              ,
    noLabelMoveCursorCallback               ,
    onLabelMoveCursor                       ,
    wrap_LabelMoveCursorCallback            ,


-- ** populatePopup #signal:populatePopup#
    C_LabelPopulatePopupCallback            ,
    LabelPopulatePopupCallback              ,
    LabelPopulatePopupSignalInfo            ,
    afterLabelPopulatePopup                 ,
    genClosure_LabelPopulatePopup           ,
    mk_LabelPopulatePopupCallback           ,
    noLabelPopulatePopupCallback            ,
    onLabelPopulatePopup                    ,
    wrap_LabelPopulatePopupCallback         ,




    ) 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.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Objects.Menu as Gtk.Menu
import {-# SOURCE #-} qualified GI.Gtk.Objects.Misc as Gtk.Misc
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Pango.Enums as Pango.Enums
import qualified GI.Pango.Objects.Layout as Pango.Layout
import qualified GI.Pango.Structs.AttrList as Pango.AttrList

newtype Label = Label (ManagedPtr Label)
foreign import ccall "gtk_label_get_type"
    c_gtk_label_get_type :: IO GType

instance GObject Label where
    gobjectType _ = c_gtk_label_get_type
    

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

toLabel :: IsLabel o => o -> IO Label
toLabel = unsafeCastTo Label

noLabel :: Maybe Label
noLabel = Nothing

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

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

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

-- signal Label::activate-current-link
type LabelActivateCurrentLinkCallback =
    IO ()

noLabelActivateCurrentLinkCallback :: Maybe LabelActivateCurrentLinkCallback
noLabelActivateCurrentLinkCallback = Nothing

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

foreign import ccall "wrapper"
    mk_LabelActivateCurrentLinkCallback :: C_LabelActivateCurrentLinkCallback -> IO (FunPtr C_LabelActivateCurrentLinkCallback)

genClosure_LabelActivateCurrentLink :: LabelActivateCurrentLinkCallback -> IO Closure
genClosure_LabelActivateCurrentLink cb = do
    let cb' = wrap_LabelActivateCurrentLinkCallback cb
    mk_LabelActivateCurrentLinkCallback cb' >>= newCClosure


wrap_LabelActivateCurrentLinkCallback ::
    LabelActivateCurrentLinkCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_LabelActivateCurrentLinkCallback _cb _ _ = do
    _cb 


onLabelActivateCurrentLink :: (GObject a, MonadIO m) => a -> LabelActivateCurrentLinkCallback -> m SignalHandlerId
onLabelActivateCurrentLink obj cb = liftIO $ connectLabelActivateCurrentLink obj cb SignalConnectBefore
afterLabelActivateCurrentLink :: (GObject a, MonadIO m) => a -> LabelActivateCurrentLinkCallback -> m SignalHandlerId
afterLabelActivateCurrentLink obj cb = connectLabelActivateCurrentLink obj cb SignalConnectAfter

connectLabelActivateCurrentLink :: (GObject a, MonadIO m) =>
                                   a -> LabelActivateCurrentLinkCallback -> SignalConnectMode -> m SignalHandlerId
connectLabelActivateCurrentLink obj cb after = liftIO $ do
    let cb' = wrap_LabelActivateCurrentLinkCallback cb
    cb'' <- mk_LabelActivateCurrentLinkCallback cb'
    connectSignalFunPtr obj "activate-current-link" cb'' after

-- signal Label::activate-link
type LabelActivateLinkCallback =
    T.Text ->
    IO Bool

noLabelActivateLinkCallback :: Maybe LabelActivateLinkCallback
noLabelActivateLinkCallback = Nothing

type C_LabelActivateLinkCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO CInt

foreign import ccall "wrapper"
    mk_LabelActivateLinkCallback :: C_LabelActivateLinkCallback -> IO (FunPtr C_LabelActivateLinkCallback)

genClosure_LabelActivateLink :: LabelActivateLinkCallback -> IO Closure
genClosure_LabelActivateLink cb = do
    let cb' = wrap_LabelActivateLinkCallback cb
    mk_LabelActivateLinkCallback cb' >>= newCClosure


wrap_LabelActivateLinkCallback ::
    LabelActivateLinkCallback ->
    Ptr () ->
    CString ->
    Ptr () ->
    IO CInt
wrap_LabelActivateLinkCallback _cb _ uri _ = do
    uri' <- cstringToText uri
    result <- _cb  uri'
    let result' = (fromIntegral . fromEnum) result
    return result'


onLabelActivateLink :: (GObject a, MonadIO m) => a -> LabelActivateLinkCallback -> m SignalHandlerId
onLabelActivateLink obj cb = liftIO $ connectLabelActivateLink obj cb SignalConnectBefore
afterLabelActivateLink :: (GObject a, MonadIO m) => a -> LabelActivateLinkCallback -> m SignalHandlerId
afterLabelActivateLink obj cb = connectLabelActivateLink obj cb SignalConnectAfter

connectLabelActivateLink :: (GObject a, MonadIO m) =>
                            a -> LabelActivateLinkCallback -> SignalConnectMode -> m SignalHandlerId
connectLabelActivateLink obj cb after = liftIO $ do
    let cb' = wrap_LabelActivateLinkCallback cb
    cb'' <- mk_LabelActivateLinkCallback cb'
    connectSignalFunPtr obj "activate-link" cb'' after

-- signal Label::copy-clipboard
type LabelCopyClipboardCallback =
    IO ()

noLabelCopyClipboardCallback :: Maybe LabelCopyClipboardCallback
noLabelCopyClipboardCallback = Nothing

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

foreign import ccall "wrapper"
    mk_LabelCopyClipboardCallback :: C_LabelCopyClipboardCallback -> IO (FunPtr C_LabelCopyClipboardCallback)

genClosure_LabelCopyClipboard :: LabelCopyClipboardCallback -> IO Closure
genClosure_LabelCopyClipboard cb = do
    let cb' = wrap_LabelCopyClipboardCallback cb
    mk_LabelCopyClipboardCallback cb' >>= newCClosure


wrap_LabelCopyClipboardCallback ::
    LabelCopyClipboardCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_LabelCopyClipboardCallback _cb _ _ = do
    _cb 


onLabelCopyClipboard :: (GObject a, MonadIO m) => a -> LabelCopyClipboardCallback -> m SignalHandlerId
onLabelCopyClipboard obj cb = liftIO $ connectLabelCopyClipboard obj cb SignalConnectBefore
afterLabelCopyClipboard :: (GObject a, MonadIO m) => a -> LabelCopyClipboardCallback -> m SignalHandlerId
afterLabelCopyClipboard obj cb = connectLabelCopyClipboard obj cb SignalConnectAfter

connectLabelCopyClipboard :: (GObject a, MonadIO m) =>
                             a -> LabelCopyClipboardCallback -> SignalConnectMode -> m SignalHandlerId
connectLabelCopyClipboard obj cb after = liftIO $ do
    let cb' = wrap_LabelCopyClipboardCallback cb
    cb'' <- mk_LabelCopyClipboardCallback cb'
    connectSignalFunPtr obj "copy-clipboard" cb'' after

-- signal Label::move-cursor
type LabelMoveCursorCallback =
    Gtk.Enums.MovementStep ->
    Int32 ->
    Bool ->
    IO ()

noLabelMoveCursorCallback :: Maybe LabelMoveCursorCallback
noLabelMoveCursorCallback = Nothing

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

foreign import ccall "wrapper"
    mk_LabelMoveCursorCallback :: C_LabelMoveCursorCallback -> IO (FunPtr C_LabelMoveCursorCallback)

genClosure_LabelMoveCursor :: LabelMoveCursorCallback -> IO Closure
genClosure_LabelMoveCursor cb = do
    let cb' = wrap_LabelMoveCursorCallback cb
    mk_LabelMoveCursorCallback cb' >>= newCClosure


wrap_LabelMoveCursorCallback ::
    LabelMoveCursorCallback ->
    Ptr () ->
    CUInt ->
    Int32 ->
    CInt ->
    Ptr () ->
    IO ()
wrap_LabelMoveCursorCallback _cb _ step count extendSelection _ = do
    let step' = (toEnum . fromIntegral) step
    let extendSelection' = (/= 0) extendSelection
    _cb  step' count extendSelection'


onLabelMoveCursor :: (GObject a, MonadIO m) => a -> LabelMoveCursorCallback -> m SignalHandlerId
onLabelMoveCursor obj cb = liftIO $ connectLabelMoveCursor obj cb SignalConnectBefore
afterLabelMoveCursor :: (GObject a, MonadIO m) => a -> LabelMoveCursorCallback -> m SignalHandlerId
afterLabelMoveCursor obj cb = connectLabelMoveCursor obj cb SignalConnectAfter

connectLabelMoveCursor :: (GObject a, MonadIO m) =>
                          a -> LabelMoveCursorCallback -> SignalConnectMode -> m SignalHandlerId
connectLabelMoveCursor obj cb after = liftIO $ do
    let cb' = wrap_LabelMoveCursorCallback cb
    cb'' <- mk_LabelMoveCursorCallback cb'
    connectSignalFunPtr obj "move-cursor" cb'' after

-- signal Label::populate-popup
type LabelPopulatePopupCallback =
    Gtk.Menu.Menu ->
    IO ()

noLabelPopulatePopupCallback :: Maybe LabelPopulatePopupCallback
noLabelPopulatePopupCallback = Nothing

type C_LabelPopulatePopupCallback =
    Ptr () ->                               -- object
    Ptr Gtk.Menu.Menu ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_LabelPopulatePopupCallback :: C_LabelPopulatePopupCallback -> IO (FunPtr C_LabelPopulatePopupCallback)

genClosure_LabelPopulatePopup :: LabelPopulatePopupCallback -> IO Closure
genClosure_LabelPopulatePopup cb = do
    let cb' = wrap_LabelPopulatePopupCallback cb
    mk_LabelPopulatePopupCallback cb' >>= newCClosure


wrap_LabelPopulatePopupCallback ::
    LabelPopulatePopupCallback ->
    Ptr () ->
    Ptr Gtk.Menu.Menu ->
    Ptr () ->
    IO ()
wrap_LabelPopulatePopupCallback _cb _ menu _ = do
    menu' <- (newObject Gtk.Menu.Menu) menu
    _cb  menu'


onLabelPopulatePopup :: (GObject a, MonadIO m) => a -> LabelPopulatePopupCallback -> m SignalHandlerId
onLabelPopulatePopup obj cb = liftIO $ connectLabelPopulatePopup obj cb SignalConnectBefore
afterLabelPopulatePopup :: (GObject a, MonadIO m) => a -> LabelPopulatePopupCallback -> m SignalHandlerId
afterLabelPopulatePopup obj cb = connectLabelPopulatePopup obj cb SignalConnectAfter

connectLabelPopulatePopup :: (GObject a, MonadIO m) =>
                             a -> LabelPopulatePopupCallback -> SignalConnectMode -> m SignalHandlerId
connectLabelPopulatePopup obj cb after = liftIO $ do
    let cb' = wrap_LabelPopulatePopupCallback cb
    cb'' <- mk_LabelPopulatePopupCallback cb'
    connectSignalFunPtr obj "populate-popup" cb'' after

--- XXX Duplicated object with different types:
  --- Name {namespace = "Gtk", name = "Label"} -> Property {propName = "xalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDeprecated = Nothing}
  --- Name {namespace = "Gtk", name = "Misc"} -> Property {propName = "xalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Just "3.14", deprecationMessage = Just "Use gtk_widget_set_halign() instead. If you are using\n  #GtkLabel, use #GtkLabel:xalign instead."})}
--- XXX Duplicated object with different types:
  --- Name {namespace = "Gtk", name = "Label"} -> Property {propName = "yalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDeprecated = Nothing}
  --- Name {namespace = "Gtk", name = "Misc"} -> Property {propName = "yalign", propType = TBasicType TFloat, propFlags = [PropertyReadable,PropertyWritable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDeprecated = Just (DeprecationInfo {deprecatedSinceVersion = Just "3.14", deprecationMessage = Just "Use gtk_widget_set_valign() instead. If you are using\n  #GtkLabel, use #GtkLabel:yalign instead."})}
-- VVV Prop "angle"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelAngle :: (MonadIO m, IsLabel o) => o -> m Double
getLabelAngle obj = liftIO $ getObjectPropertyDouble obj "angle"

setLabelAngle :: (MonadIO m, IsLabel o) => o -> Double -> m ()
setLabelAngle obj val = liftIO $ setObjectPropertyDouble obj "angle" val

constructLabelAngle :: (IsLabel o) => Double -> IO (GValueConstruct o)
constructLabelAngle val = constructObjectPropertyDouble "angle" val

data LabelAnglePropertyInfo
instance AttrInfo LabelAnglePropertyInfo where
    type AttrAllowedOps LabelAnglePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelAnglePropertyInfo = (~) Double
    type AttrBaseTypeConstraint LabelAnglePropertyInfo = IsLabel
    type AttrGetType LabelAnglePropertyInfo = Double
    type AttrLabel LabelAnglePropertyInfo = "angle"
    type AttrOrigin LabelAnglePropertyInfo = Label
    attrGet _ = getLabelAngle
    attrSet _ = setLabelAngle
    attrConstruct _ = constructLabelAngle
    attrClear _ = undefined

-- VVV Prop "attributes"
   -- Type: TInterface (Name {namespace = "Pango", name = "AttrList"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

getLabelAttributes :: (MonadIO m, IsLabel o) => o -> m (Maybe Pango.AttrList.AttrList)
getLabelAttributes obj = liftIO $ getObjectPropertyBoxed obj "attributes" Pango.AttrList.AttrList

setLabelAttributes :: (MonadIO m, IsLabel o) => o -> Pango.AttrList.AttrList -> m ()
setLabelAttributes obj val = liftIO $ setObjectPropertyBoxed obj "attributes" (Just val)

constructLabelAttributes :: (IsLabel o) => Pango.AttrList.AttrList -> IO (GValueConstruct o)
constructLabelAttributes val = constructObjectPropertyBoxed "attributes" (Just val)

clearLabelAttributes :: (MonadIO m, IsLabel o) => o -> m ()
clearLabelAttributes obj = liftIO $ setObjectPropertyBoxed obj "attributes" (Nothing :: Maybe Pango.AttrList.AttrList)

data LabelAttributesPropertyInfo
instance AttrInfo LabelAttributesPropertyInfo where
    type AttrAllowedOps LabelAttributesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint LabelAttributesPropertyInfo = (~) Pango.AttrList.AttrList
    type AttrBaseTypeConstraint LabelAttributesPropertyInfo = IsLabel
    type AttrGetType LabelAttributesPropertyInfo = (Maybe Pango.AttrList.AttrList)
    type AttrLabel LabelAttributesPropertyInfo = "attributes"
    type AttrOrigin LabelAttributesPropertyInfo = Label
    attrGet _ = getLabelAttributes
    attrSet _ = setLabelAttributes
    attrConstruct _ = constructLabelAttributes
    attrClear _ = clearLabelAttributes

-- VVV Prop "cursor-position"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getLabelCursorPosition :: (MonadIO m, IsLabel o) => o -> m Int32
getLabelCursorPosition obj = liftIO $ getObjectPropertyInt32 obj "cursor-position"

data LabelCursorPositionPropertyInfo
instance AttrInfo LabelCursorPositionPropertyInfo where
    type AttrAllowedOps LabelCursorPositionPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint LabelCursorPositionPropertyInfo = (~) ()
    type AttrBaseTypeConstraint LabelCursorPositionPropertyInfo = IsLabel
    type AttrGetType LabelCursorPositionPropertyInfo = Int32
    type AttrLabel LabelCursorPositionPropertyInfo = "cursor-position"
    type AttrOrigin LabelCursorPositionPropertyInfo = Label
    attrGet _ = getLabelCursorPosition
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "ellipsize"
   -- Type: TInterface (Name {namespace = "Pango", name = "EllipsizeMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelEllipsize :: (MonadIO m, IsLabel o) => o -> m Pango.Enums.EllipsizeMode
getLabelEllipsize obj = liftIO $ getObjectPropertyEnum obj "ellipsize"

setLabelEllipsize :: (MonadIO m, IsLabel o) => o -> Pango.Enums.EllipsizeMode -> m ()
setLabelEllipsize obj val = liftIO $ setObjectPropertyEnum obj "ellipsize" val

constructLabelEllipsize :: (IsLabel o) => Pango.Enums.EllipsizeMode -> IO (GValueConstruct o)
constructLabelEllipsize val = constructObjectPropertyEnum "ellipsize" val

data LabelEllipsizePropertyInfo
instance AttrInfo LabelEllipsizePropertyInfo where
    type AttrAllowedOps LabelEllipsizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelEllipsizePropertyInfo = (~) Pango.Enums.EllipsizeMode
    type AttrBaseTypeConstraint LabelEllipsizePropertyInfo = IsLabel
    type AttrGetType LabelEllipsizePropertyInfo = Pango.Enums.EllipsizeMode
    type AttrLabel LabelEllipsizePropertyInfo = "ellipsize"
    type AttrOrigin LabelEllipsizePropertyInfo = Label
    attrGet _ = getLabelEllipsize
    attrSet _ = setLabelEllipsize
    attrConstruct _ = constructLabelEllipsize
    attrClear _ = undefined

-- VVV Prop "justify"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Justification"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelJustify :: (MonadIO m, IsLabel o) => o -> m Gtk.Enums.Justification
getLabelJustify obj = liftIO $ getObjectPropertyEnum obj "justify"

setLabelJustify :: (MonadIO m, IsLabel o) => o -> Gtk.Enums.Justification -> m ()
setLabelJustify obj val = liftIO $ setObjectPropertyEnum obj "justify" val

constructLabelJustify :: (IsLabel o) => Gtk.Enums.Justification -> IO (GValueConstruct o)
constructLabelJustify val = constructObjectPropertyEnum "justify" val

data LabelJustifyPropertyInfo
instance AttrInfo LabelJustifyPropertyInfo where
    type AttrAllowedOps LabelJustifyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelJustifyPropertyInfo = (~) Gtk.Enums.Justification
    type AttrBaseTypeConstraint LabelJustifyPropertyInfo = IsLabel
    type AttrGetType LabelJustifyPropertyInfo = Gtk.Enums.Justification
    type AttrLabel LabelJustifyPropertyInfo = "justify"
    type AttrOrigin LabelJustifyPropertyInfo = Label
    attrGet _ = getLabelJustify
    attrSet _ = setLabelJustify
    attrConstruct _ = constructLabelJustify
    attrClear _ = undefined

-- VVV Prop "label"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelLabel :: (MonadIO m, IsLabel o) => o -> m T.Text
getLabelLabel obj = liftIO $ checkUnexpectedNothing "getLabelLabel" $ getObjectPropertyString obj "label"

setLabelLabel :: (MonadIO m, IsLabel o) => o -> T.Text -> m ()
setLabelLabel obj val = liftIO $ setObjectPropertyString obj "label" (Just val)

constructLabelLabel :: (IsLabel o) => T.Text -> IO (GValueConstruct o)
constructLabelLabel val = constructObjectPropertyString "label" (Just val)

data LabelLabelPropertyInfo
instance AttrInfo LabelLabelPropertyInfo where
    type AttrAllowedOps LabelLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint LabelLabelPropertyInfo = IsLabel
    type AttrGetType LabelLabelPropertyInfo = T.Text
    type AttrLabel LabelLabelPropertyInfo = "label"
    type AttrOrigin LabelLabelPropertyInfo = Label
    attrGet _ = getLabelLabel
    attrSet _ = setLabelLabel
    attrConstruct _ = constructLabelLabel
    attrClear _ = undefined

-- VVV Prop "lines"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelLines :: (MonadIO m, IsLabel o) => o -> m Int32
getLabelLines obj = liftIO $ getObjectPropertyInt32 obj "lines"

setLabelLines :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()
setLabelLines obj val = liftIO $ setObjectPropertyInt32 obj "lines" val

constructLabelLines :: (IsLabel o) => Int32 -> IO (GValueConstruct o)
constructLabelLines val = constructObjectPropertyInt32 "lines" val

data LabelLinesPropertyInfo
instance AttrInfo LabelLinesPropertyInfo where
    type AttrAllowedOps LabelLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelLinesPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint LabelLinesPropertyInfo = IsLabel
    type AttrGetType LabelLinesPropertyInfo = Int32
    type AttrLabel LabelLinesPropertyInfo = "lines"
    type AttrOrigin LabelLinesPropertyInfo = Label
    attrGet _ = getLabelLines
    attrSet _ = setLabelLines
    attrConstruct _ = constructLabelLines
    attrClear _ = undefined

-- VVV Prop "max-width-chars"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelMaxWidthChars :: (MonadIO m, IsLabel o) => o -> m Int32
getLabelMaxWidthChars obj = liftIO $ getObjectPropertyInt32 obj "max-width-chars"

setLabelMaxWidthChars :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()
setLabelMaxWidthChars obj val = liftIO $ setObjectPropertyInt32 obj "max-width-chars" val

constructLabelMaxWidthChars :: (IsLabel o) => Int32 -> IO (GValueConstruct o)
constructLabelMaxWidthChars val = constructObjectPropertyInt32 "max-width-chars" val

data LabelMaxWidthCharsPropertyInfo
instance AttrInfo LabelMaxWidthCharsPropertyInfo where
    type AttrAllowedOps LabelMaxWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelMaxWidthCharsPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint LabelMaxWidthCharsPropertyInfo = IsLabel
    type AttrGetType LabelMaxWidthCharsPropertyInfo = Int32
    type AttrLabel LabelMaxWidthCharsPropertyInfo = "max-width-chars"
    type AttrOrigin LabelMaxWidthCharsPropertyInfo = Label
    attrGet _ = getLabelMaxWidthChars
    attrSet _ = setLabelMaxWidthChars
    attrConstruct _ = constructLabelMaxWidthChars
    attrClear _ = undefined

-- VVV Prop "mnemonic-keyval"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getLabelMnemonicKeyval :: (MonadIO m, IsLabel o) => o -> m Word32
getLabelMnemonicKeyval obj = liftIO $ getObjectPropertyUInt32 obj "mnemonic-keyval"

data LabelMnemonicKeyvalPropertyInfo
instance AttrInfo LabelMnemonicKeyvalPropertyInfo where
    type AttrAllowedOps LabelMnemonicKeyvalPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint LabelMnemonicKeyvalPropertyInfo = (~) ()
    type AttrBaseTypeConstraint LabelMnemonicKeyvalPropertyInfo = IsLabel
    type AttrGetType LabelMnemonicKeyvalPropertyInfo = Word32
    type AttrLabel LabelMnemonicKeyvalPropertyInfo = "mnemonic-keyval"
    type AttrOrigin LabelMnemonicKeyvalPropertyInfo = Label
    attrGet _ = getLabelMnemonicKeyval
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "mnemonic-widget"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

getLabelMnemonicWidget :: (MonadIO m, IsLabel o) => o -> m (Maybe Gtk.Widget.Widget)
getLabelMnemonicWidget obj = liftIO $ getObjectPropertyObject obj "mnemonic-widget" Gtk.Widget.Widget

setLabelMnemonicWidget :: (MonadIO m, IsLabel o, Gtk.Widget.IsWidget a) => o -> a -> m ()
setLabelMnemonicWidget obj val = liftIO $ setObjectPropertyObject obj "mnemonic-widget" (Just val)

constructLabelMnemonicWidget :: (IsLabel o, Gtk.Widget.IsWidget a) => a -> IO (GValueConstruct o)
constructLabelMnemonicWidget val = constructObjectPropertyObject "mnemonic-widget" (Just val)

clearLabelMnemonicWidget :: (MonadIO m, IsLabel o) => o -> m ()
clearLabelMnemonicWidget obj = liftIO $ setObjectPropertyObject obj "mnemonic-widget" (Nothing :: Maybe Gtk.Widget.Widget)

data LabelMnemonicWidgetPropertyInfo
instance AttrInfo LabelMnemonicWidgetPropertyInfo where
    type AttrAllowedOps LabelMnemonicWidgetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint LabelMnemonicWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrBaseTypeConstraint LabelMnemonicWidgetPropertyInfo = IsLabel
    type AttrGetType LabelMnemonicWidgetPropertyInfo = (Maybe Gtk.Widget.Widget)
    type AttrLabel LabelMnemonicWidgetPropertyInfo = "mnemonic-widget"
    type AttrOrigin LabelMnemonicWidgetPropertyInfo = Label
    attrGet _ = getLabelMnemonicWidget
    attrSet _ = setLabelMnemonicWidget
    attrConstruct _ = constructLabelMnemonicWidget
    attrClear _ = clearLabelMnemonicWidget

-- VVV Prop "pattern"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyWritable]
   -- Nullable: (Nothing,Just False)

setLabelPattern :: (MonadIO m, IsLabel o) => o -> T.Text -> m ()
setLabelPattern obj val = liftIO $ setObjectPropertyString obj "pattern" (Just val)

constructLabelPattern :: (IsLabel o) => T.Text -> IO (GValueConstruct o)
constructLabelPattern val = constructObjectPropertyString "pattern" (Just val)

data LabelPatternPropertyInfo
instance AttrInfo LabelPatternPropertyInfo where
    type AttrAllowedOps LabelPatternPropertyInfo = '[ 'AttrSet, 'AttrConstruct]
    type AttrSetTypeConstraint LabelPatternPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint LabelPatternPropertyInfo = IsLabel
    type AttrGetType LabelPatternPropertyInfo = ()
    type AttrLabel LabelPatternPropertyInfo = "pattern"
    type AttrOrigin LabelPatternPropertyInfo = Label
    attrGet _ = undefined
    attrSet _ = setLabelPattern
    attrConstruct _ = constructLabelPattern
    attrClear _ = undefined

-- VVV Prop "selectable"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelSelectable :: (MonadIO m, IsLabel o) => o -> m Bool
getLabelSelectable obj = liftIO $ getObjectPropertyBool obj "selectable"

setLabelSelectable :: (MonadIO m, IsLabel o) => o -> Bool -> m ()
setLabelSelectable obj val = liftIO $ setObjectPropertyBool obj "selectable" val

constructLabelSelectable :: (IsLabel o) => Bool -> IO (GValueConstruct o)
constructLabelSelectable val = constructObjectPropertyBool "selectable" val

data LabelSelectablePropertyInfo
instance AttrInfo LabelSelectablePropertyInfo where
    type AttrAllowedOps LabelSelectablePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelSelectablePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint LabelSelectablePropertyInfo = IsLabel
    type AttrGetType LabelSelectablePropertyInfo = Bool
    type AttrLabel LabelSelectablePropertyInfo = "selectable"
    type AttrOrigin LabelSelectablePropertyInfo = Label
    attrGet _ = getLabelSelectable
    attrSet _ = setLabelSelectable
    attrConstruct _ = constructLabelSelectable
    attrClear _ = undefined

-- VVV Prop "selection-bound"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getLabelSelectionBound :: (MonadIO m, IsLabel o) => o -> m Int32
getLabelSelectionBound obj = liftIO $ getObjectPropertyInt32 obj "selection-bound"

data LabelSelectionBoundPropertyInfo
instance AttrInfo LabelSelectionBoundPropertyInfo where
    type AttrAllowedOps LabelSelectionBoundPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint LabelSelectionBoundPropertyInfo = (~) ()
    type AttrBaseTypeConstraint LabelSelectionBoundPropertyInfo = IsLabel
    type AttrGetType LabelSelectionBoundPropertyInfo = Int32
    type AttrLabel LabelSelectionBoundPropertyInfo = "selection-bound"
    type AttrOrigin LabelSelectionBoundPropertyInfo = Label
    attrGet _ = getLabelSelectionBound
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "single-line-mode"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelSingleLineMode :: (MonadIO m, IsLabel o) => o -> m Bool
getLabelSingleLineMode obj = liftIO $ getObjectPropertyBool obj "single-line-mode"

setLabelSingleLineMode :: (MonadIO m, IsLabel o) => o -> Bool -> m ()
setLabelSingleLineMode obj val = liftIO $ setObjectPropertyBool obj "single-line-mode" val

constructLabelSingleLineMode :: (IsLabel o) => Bool -> IO (GValueConstruct o)
constructLabelSingleLineMode val = constructObjectPropertyBool "single-line-mode" val

data LabelSingleLineModePropertyInfo
instance AttrInfo LabelSingleLineModePropertyInfo where
    type AttrAllowedOps LabelSingleLineModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelSingleLineModePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint LabelSingleLineModePropertyInfo = IsLabel
    type AttrGetType LabelSingleLineModePropertyInfo = Bool
    type AttrLabel LabelSingleLineModePropertyInfo = "single-line-mode"
    type AttrOrigin LabelSingleLineModePropertyInfo = Label
    attrGet _ = getLabelSingleLineMode
    attrSet _ = setLabelSingleLineMode
    attrConstruct _ = constructLabelSingleLineMode
    attrClear _ = undefined

-- VVV Prop "track-visited-links"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelTrackVisitedLinks :: (MonadIO m, IsLabel o) => o -> m Bool
getLabelTrackVisitedLinks obj = liftIO $ getObjectPropertyBool obj "track-visited-links"

setLabelTrackVisitedLinks :: (MonadIO m, IsLabel o) => o -> Bool -> m ()
setLabelTrackVisitedLinks obj val = liftIO $ setObjectPropertyBool obj "track-visited-links" val

constructLabelTrackVisitedLinks :: (IsLabel o) => Bool -> IO (GValueConstruct o)
constructLabelTrackVisitedLinks val = constructObjectPropertyBool "track-visited-links" val

data LabelTrackVisitedLinksPropertyInfo
instance AttrInfo LabelTrackVisitedLinksPropertyInfo where
    type AttrAllowedOps LabelTrackVisitedLinksPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelTrackVisitedLinksPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint LabelTrackVisitedLinksPropertyInfo = IsLabel
    type AttrGetType LabelTrackVisitedLinksPropertyInfo = Bool
    type AttrLabel LabelTrackVisitedLinksPropertyInfo = "track-visited-links"
    type AttrOrigin LabelTrackVisitedLinksPropertyInfo = Label
    attrGet _ = getLabelTrackVisitedLinks
    attrSet _ = setLabelTrackVisitedLinks
    attrConstruct _ = constructLabelTrackVisitedLinks
    attrClear _ = undefined

-- VVV Prop "use-markup"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelUseMarkup :: (MonadIO m, IsLabel o) => o -> m Bool
getLabelUseMarkup obj = liftIO $ getObjectPropertyBool obj "use-markup"

setLabelUseMarkup :: (MonadIO m, IsLabel o) => o -> Bool -> m ()
setLabelUseMarkup obj val = liftIO $ setObjectPropertyBool obj "use-markup" val

constructLabelUseMarkup :: (IsLabel o) => Bool -> IO (GValueConstruct o)
constructLabelUseMarkup val = constructObjectPropertyBool "use-markup" val

data LabelUseMarkupPropertyInfo
instance AttrInfo LabelUseMarkupPropertyInfo where
    type AttrAllowedOps LabelUseMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelUseMarkupPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint LabelUseMarkupPropertyInfo = IsLabel
    type AttrGetType LabelUseMarkupPropertyInfo = Bool
    type AttrLabel LabelUseMarkupPropertyInfo = "use-markup"
    type AttrOrigin LabelUseMarkupPropertyInfo = Label
    attrGet _ = getLabelUseMarkup
    attrSet _ = setLabelUseMarkup
    attrConstruct _ = constructLabelUseMarkup
    attrClear _ = undefined

-- VVV Prop "use-underline"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelUseUnderline :: (MonadIO m, IsLabel o) => o -> m Bool
getLabelUseUnderline obj = liftIO $ getObjectPropertyBool obj "use-underline"

setLabelUseUnderline :: (MonadIO m, IsLabel o) => o -> Bool -> m ()
setLabelUseUnderline obj val = liftIO $ setObjectPropertyBool obj "use-underline" val

constructLabelUseUnderline :: (IsLabel o) => Bool -> IO (GValueConstruct o)
constructLabelUseUnderline val = constructObjectPropertyBool "use-underline" val

data LabelUseUnderlinePropertyInfo
instance AttrInfo LabelUseUnderlinePropertyInfo where
    type AttrAllowedOps LabelUseUnderlinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelUseUnderlinePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint LabelUseUnderlinePropertyInfo = IsLabel
    type AttrGetType LabelUseUnderlinePropertyInfo = Bool
    type AttrLabel LabelUseUnderlinePropertyInfo = "use-underline"
    type AttrOrigin LabelUseUnderlinePropertyInfo = Label
    attrGet _ = getLabelUseUnderline
    attrSet _ = setLabelUseUnderline
    attrConstruct _ = constructLabelUseUnderline
    attrClear _ = undefined

-- VVV Prop "width-chars"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelWidthChars :: (MonadIO m, IsLabel o) => o -> m Int32
getLabelWidthChars obj = liftIO $ getObjectPropertyInt32 obj "width-chars"

setLabelWidthChars :: (MonadIO m, IsLabel o) => o -> Int32 -> m ()
setLabelWidthChars obj val = liftIO $ setObjectPropertyInt32 obj "width-chars" val

constructLabelWidthChars :: (IsLabel o) => Int32 -> IO (GValueConstruct o)
constructLabelWidthChars val = constructObjectPropertyInt32 "width-chars" val

data LabelWidthCharsPropertyInfo
instance AttrInfo LabelWidthCharsPropertyInfo where
    type AttrAllowedOps LabelWidthCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelWidthCharsPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint LabelWidthCharsPropertyInfo = IsLabel
    type AttrGetType LabelWidthCharsPropertyInfo = Int32
    type AttrLabel LabelWidthCharsPropertyInfo = "width-chars"
    type AttrOrigin LabelWidthCharsPropertyInfo = Label
    attrGet _ = getLabelWidthChars
    attrSet _ = setLabelWidthChars
    attrConstruct _ = constructLabelWidthChars
    attrClear _ = undefined

-- VVV Prop "wrap"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getLabelWrap :: (MonadIO m, IsLabel o) => o -> m Bool
getLabelWrap obj = liftIO $ getObjectPropertyBool obj "wrap"

setLabelWrap :: (MonadIO m, IsLabel o) => o -> Bool -> m ()
setLabelWrap obj val = liftIO $ setObjectPropertyBool obj "wrap" val

constructLabelWrap :: (IsLabel o) => Bool -> IO (GValueConstruct o)
constructLabelWrap val = constructObjectPropertyBool "wrap" val

data LabelWrapPropertyInfo
instance AttrInfo LabelWrapPropertyInfo where
    type AttrAllowedOps LabelWrapPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelWrapPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint LabelWrapPropertyInfo = IsLabel
    type AttrGetType LabelWrapPropertyInfo = Bool
    type AttrLabel LabelWrapPropertyInfo = "wrap"
    type AttrOrigin LabelWrapPropertyInfo = Label
    attrGet _ = getLabelWrap
    attrSet _ = setLabelWrap
    attrConstruct _ = constructLabelWrap
    attrClear _ = undefined

-- VVV Prop "wrap-mode"
   -- Type: TInterface (Name {namespace = "Pango", name = "WrapMode"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getLabelWrapMode :: (MonadIO m, IsLabel o) => o -> m Pango.Enums.WrapMode
getLabelWrapMode obj = liftIO $ getObjectPropertyEnum obj "wrap-mode"

setLabelWrapMode :: (MonadIO m, IsLabel o) => o -> Pango.Enums.WrapMode -> m ()
setLabelWrapMode obj val = liftIO $ setObjectPropertyEnum obj "wrap-mode" val

constructLabelWrapMode :: (IsLabel o) => Pango.Enums.WrapMode -> IO (GValueConstruct o)
constructLabelWrapMode val = constructObjectPropertyEnum "wrap-mode" val

data LabelWrapModePropertyInfo
instance AttrInfo LabelWrapModePropertyInfo where
    type AttrAllowedOps LabelWrapModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelWrapModePropertyInfo = (~) Pango.Enums.WrapMode
    type AttrBaseTypeConstraint LabelWrapModePropertyInfo = IsLabel
    type AttrGetType LabelWrapModePropertyInfo = Pango.Enums.WrapMode
    type AttrLabel LabelWrapModePropertyInfo = "wrap-mode"
    type AttrOrigin LabelWrapModePropertyInfo = Label
    attrGet _ = getLabelWrapMode
    attrSet _ = setLabelWrapMode
    attrConstruct _ = constructLabelWrapMode
    attrClear _ = undefined

-- VVV Prop "xalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelXalign :: (MonadIO m, IsLabel o) => o -> m Float
getLabelXalign obj = liftIO $ getObjectPropertyFloat obj "xalign"

setLabelXalign :: (MonadIO m, IsLabel o) => o -> Float -> m ()
setLabelXalign obj val = liftIO $ setObjectPropertyFloat obj "xalign" val

constructLabelXalign :: (IsLabel o) => Float -> IO (GValueConstruct o)
constructLabelXalign val = constructObjectPropertyFloat "xalign" val

data LabelXalignPropertyInfo
instance AttrInfo LabelXalignPropertyInfo where
    type AttrAllowedOps LabelXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelXalignPropertyInfo = (~) Float
    type AttrBaseTypeConstraint LabelXalignPropertyInfo = IsLabel
    type AttrGetType LabelXalignPropertyInfo = Float
    type AttrLabel LabelXalignPropertyInfo = "xalign"
    type AttrOrigin LabelXalignPropertyInfo = Label
    attrGet _ = getLabelXalign
    attrSet _ = setLabelXalign
    attrConstruct _ = constructLabelXalign
    attrClear _ = undefined

-- VVV Prop "yalign"
   -- Type: TBasicType TFloat
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getLabelYalign :: (MonadIO m, IsLabel o) => o -> m Float
getLabelYalign obj = liftIO $ getObjectPropertyFloat obj "yalign"

setLabelYalign :: (MonadIO m, IsLabel o) => o -> Float -> m ()
setLabelYalign obj val = liftIO $ setObjectPropertyFloat obj "yalign" val

constructLabelYalign :: (IsLabel o) => Float -> IO (GValueConstruct o)
constructLabelYalign val = constructObjectPropertyFloat "yalign" val

data LabelYalignPropertyInfo
instance AttrInfo LabelYalignPropertyInfo where
    type AttrAllowedOps LabelYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint LabelYalignPropertyInfo = (~) Float
    type AttrBaseTypeConstraint LabelYalignPropertyInfo = IsLabel
    type AttrGetType LabelYalignPropertyInfo = Float
    type AttrLabel LabelYalignPropertyInfo = "yalign"
    type AttrOrigin LabelYalignPropertyInfo = Label
    attrGet _ = getLabelYalign
    attrSet _ = setLabelYalign
    attrConstruct _ = constructLabelYalign
    attrClear _ = undefined

instance O.HasAttributeList Label
type instance O.AttributeList Label = LabelAttributeList
type LabelAttributeList = ('[ '("angle", LabelAnglePropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("attributes", LabelAttributesPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("cursorPosition", LabelCursorPositionPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("ellipsize", LabelEllipsizePropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("justify", LabelJustifyPropertyInfo), '("label", LabelLabelPropertyInfo), '("lines", LabelLinesPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("maxWidthChars", LabelMaxWidthCharsPropertyInfo), '("mnemonicKeyval", LabelMnemonicKeyvalPropertyInfo), '("mnemonicWidget", LabelMnemonicWidgetPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("pattern", LabelPatternPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("selectable", LabelSelectablePropertyInfo), '("selectionBound", LabelSelectionBoundPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("singleLineMode", LabelSingleLineModePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("trackVisitedLinks", LabelTrackVisitedLinksPropertyInfo), '("useMarkup", LabelUseMarkupPropertyInfo), '("useUnderline", LabelUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthChars", LabelWidthCharsPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo), '("wrap", LabelWrapPropertyInfo), '("wrapMode", LabelWrapModePropertyInfo), '("xalign", LabelXalignPropertyInfo), '("xpad", Gtk.Misc.MiscXpadPropertyInfo), '("yalign", LabelYalignPropertyInfo), '("ypad", Gtk.Misc.MiscYpadPropertyInfo)] :: [(Symbol, *)])

labelAngle :: AttrLabelProxy "angle"
labelAngle = AttrLabelProxy

labelAttributes :: AttrLabelProxy "attributes"
labelAttributes = AttrLabelProxy

labelCursorPosition :: AttrLabelProxy "cursorPosition"
labelCursorPosition = AttrLabelProxy

labelEllipsize :: AttrLabelProxy "ellipsize"
labelEllipsize = AttrLabelProxy

labelJustify :: AttrLabelProxy "justify"
labelJustify = AttrLabelProxy

labelLabel :: AttrLabelProxy "label"
labelLabel = AttrLabelProxy

labelLines :: AttrLabelProxy "lines"
labelLines = AttrLabelProxy

labelMaxWidthChars :: AttrLabelProxy "maxWidthChars"
labelMaxWidthChars = AttrLabelProxy

labelMnemonicKeyval :: AttrLabelProxy "mnemonicKeyval"
labelMnemonicKeyval = AttrLabelProxy

labelMnemonicWidget :: AttrLabelProxy "mnemonicWidget"
labelMnemonicWidget = AttrLabelProxy

labelPattern :: AttrLabelProxy "pattern"
labelPattern = AttrLabelProxy

labelSelectable :: AttrLabelProxy "selectable"
labelSelectable = AttrLabelProxy

labelSelectionBound :: AttrLabelProxy "selectionBound"
labelSelectionBound = AttrLabelProxy

labelSingleLineMode :: AttrLabelProxy "singleLineMode"
labelSingleLineMode = AttrLabelProxy

labelTrackVisitedLinks :: AttrLabelProxy "trackVisitedLinks"
labelTrackVisitedLinks = AttrLabelProxy

labelUseMarkup :: AttrLabelProxy "useMarkup"
labelUseMarkup = AttrLabelProxy

labelUseUnderline :: AttrLabelProxy "useUnderline"
labelUseUnderline = AttrLabelProxy

labelWidthChars :: AttrLabelProxy "widthChars"
labelWidthChars = AttrLabelProxy

labelWrap :: AttrLabelProxy "wrap"
labelWrap = AttrLabelProxy

labelWrapMode :: AttrLabelProxy "wrapMode"
labelWrapMode = AttrLabelProxy

labelXalign :: AttrLabelProxy "xalign"
labelXalign = AttrLabelProxy

labelYalign :: AttrLabelProxy "yalign"
labelYalign = AttrLabelProxy

data LabelActivateCurrentLinkSignalInfo
instance SignalInfo LabelActivateCurrentLinkSignalInfo where
    type HaskellCallbackType LabelActivateCurrentLinkSignalInfo = LabelActivateCurrentLinkCallback
    connectSignal _ = connectLabelActivateCurrentLink

data LabelActivateLinkSignalInfo
instance SignalInfo LabelActivateLinkSignalInfo where
    type HaskellCallbackType LabelActivateLinkSignalInfo = LabelActivateLinkCallback
    connectSignal _ = connectLabelActivateLink

data LabelCopyClipboardSignalInfo
instance SignalInfo LabelCopyClipboardSignalInfo where
    type HaskellCallbackType LabelCopyClipboardSignalInfo = LabelCopyClipboardCallback
    connectSignal _ = connectLabelCopyClipboard

data LabelMoveCursorSignalInfo
instance SignalInfo LabelMoveCursorSignalInfo where
    type HaskellCallbackType LabelMoveCursorSignalInfo = LabelMoveCursorCallback
    connectSignal _ = connectLabelMoveCursor

data LabelPopulatePopupSignalInfo
instance SignalInfo LabelPopulatePopupSignalInfo where
    type HaskellCallbackType LabelPopulatePopupSignalInfo = LabelPopulatePopupCallback
    connectSignal _ = connectLabelPopulatePopup

type instance O.SignalList Label = LabelSignalList
type LabelSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activateCurrentLink", LabelActivateCurrentLinkSignalInfo), '("activateLink", LabelActivateLinkSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("copyClipboard", LabelCopyClipboardSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveCursor", LabelMoveCursorSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("populatePopup", LabelPopulatePopupSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])

-- method Label::new
-- method type : Constructor
-- Args : [Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The text of the label", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Label"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_new" gtk_label_new :: 
    CString ->                              -- str : TBasicType TUTF8
    IO (Ptr Label)

{- |
Creates a new label with the given text inside it. You can
pass 'Nothing' to get an empty label widget.
-}
labelNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    {- ^ /@str@/: The text of the label -}
    -> m Label
    {- ^ __Returns:__ the new 'GI.Gtk.Objects.Label.Label' -}
labelNew str = liftIO $ do
    maybeStr <- case str of
        Nothing -> return nullPtr
        Just jStr -> do
            jStr' <- textToCString jStr
            return jStr'
    result <- gtk_label_new maybeStr
    checkUnexpectedReturnNULL "labelNew" result
    result' <- (newObject Label) result
    freeMem maybeStr
    return result'

-- method Label::new_with_mnemonic
-- method type : Constructor
-- Args : [Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The text of the label, with an underscore in front of the\n      mnemonic character", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Label"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_new_with_mnemonic" gtk_label_new_with_mnemonic :: 
    CString ->                              -- str : TBasicType TUTF8
    IO (Ptr Label)

{- |
Creates a new 'GI.Gtk.Objects.Label.Label', containing the text in /@str@/.

If characters in /@str@/ are preceded by an underscore, they are
underlined. If you need a literal underscore character in a label, use
\'__\' (two underscores). The first underlined character represents a
keyboard accelerator called a mnemonic. The mnemonic key can be used
to activate another widget, chosen automatically, or explicitly using
'GI.Gtk.Objects.Label.labelSetMnemonicWidget'.

If 'GI.Gtk.Objects.Label.labelSetMnemonicWidget' is not called, then the first
activatable ancestor of the 'GI.Gtk.Objects.Label.Label' will be chosen as the mnemonic
widget. For instance, if the label is inside a button or menu item,
the button or menu item will automatically become the mnemonic widget
and be activated by the mnemonic.
-}
labelNewWithMnemonic ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    {- ^ /@str@/: The text of the label, with an underscore in front of the
      mnemonic character -}
    -> m Label
    {- ^ __Returns:__ the new 'GI.Gtk.Objects.Label.Label' -}
labelNewWithMnemonic str = liftIO $ do
    maybeStr <- case str of
        Nothing -> return nullPtr
        Just jStr -> do
            jStr' <- textToCString jStr
            return jStr'
    result <- gtk_label_new_with_mnemonic maybeStr
    checkUnexpectedReturnNULL "labelNewWithMnemonic" result
    result' <- (newObject Label) result
    freeMem maybeStr
    return result'

-- method Label::get_angle
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_angle" gtk_label_get_angle :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CDouble

{- |
Gets the angle of rotation for the label. See
'GI.Gtk.Objects.Label.labelSetAngle'.

@since 2.6
-}
labelGetAngle ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Double
    {- ^ __Returns:__ the angle of rotation for the label -}
labelGetAngle label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_angle label'
    let result' = realToFrac result
    touchManagedPtr label
    return result'

data LabelGetAngleMethodInfo
instance (signature ~ (m Double), MonadIO m, IsLabel a) => O.MethodInfo LabelGetAngleMethodInfo a signature where
    overloadedMethod _ = labelGetAngle

-- method Label::get_attributes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "AttrList"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_get_attributes" gtk_label_get_attributes :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO (Ptr Pango.AttrList.AttrList)

{- |
Gets the attribute list that was set on the label using
'GI.Gtk.Objects.Label.labelSetAttributes', if any. This function does
not reflect attributes that come from the labels markup
(see 'GI.Gtk.Objects.Label.labelSetMarkup'). If you want to get the
effective attributes for the label, use
pango_layout_get_attribute (gtk_label_get_layout (label)).
-}
labelGetAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m (Maybe Pango.AttrList.AttrList)
    {- ^ __Returns:__ the attribute list, or 'Nothing'
    if none was set. -}
labelGetAttributes label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_attributes label'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newBoxed Pango.AttrList.AttrList) result'
        return result''
    touchManagedPtr label
    return maybeResult

data LabelGetAttributesMethodInfo
instance (signature ~ (m (Maybe Pango.AttrList.AttrList)), MonadIO m, IsLabel a) => O.MethodInfo LabelGetAttributesMethodInfo a signature where
    overloadedMethod _ = labelGetAttributes

-- method Label::get_current_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_current_uri" gtk_label_get_current_uri :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CString

{- |
Returns the URI for the currently active link in the label.
The active link is the one under the mouse pointer or, in a
selectable label, the link in which the text cursor is currently
positioned.

This function is intended for use in a 'GI.Gtk.Objects.Label.Label'::@/activate-link/@ handler
or for use in a 'GI.Gtk.Objects.Widget.Widget'::@/query-tooltip/@ handler.

@since 2.18
-}
labelGetCurrentUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m T.Text
    {- ^ __Returns:__ the currently active URI. The string is owned by GTK+ and must
  not be freed or modified. -}
labelGetCurrentUri label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_current_uri label'
    checkUnexpectedReturnNULL "labelGetCurrentUri" result
    result' <- cstringToText result
    touchManagedPtr label
    return result'

data LabelGetCurrentUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsLabel a) => O.MethodInfo LabelGetCurrentUriMethodInfo a signature where
    overloadedMethod _ = labelGetCurrentUri

-- method Label::get_ellipsize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "EllipsizeMode"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_get_ellipsize" gtk_label_get_ellipsize :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CUInt

{- |
Returns the ellipsizing position of the label. See 'GI.Gtk.Objects.Label.labelSetEllipsize'.

@since 2.6
-}
labelGetEllipsize ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Pango.Enums.EllipsizeMode
    {- ^ __Returns:__ 'GI.Pango.Enums.EllipsizeMode' -}
labelGetEllipsize label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_ellipsize label'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr label
    return result'

data LabelGetEllipsizeMethodInfo
instance (signature ~ (m Pango.Enums.EllipsizeMode), MonadIO m, IsLabel a) => O.MethodInfo LabelGetEllipsizeMethodInfo a signature where
    overloadedMethod _ = labelGetEllipsize

-- method Label::get_justify
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Justification"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_get_justify" gtk_label_get_justify :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CUInt

{- |
Returns the justification of the label. See 'GI.Gtk.Objects.Label.labelSetJustify'.
-}
labelGetJustify ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Gtk.Enums.Justification
    {- ^ __Returns:__ 'GI.Gtk.Enums.Justification' -}
labelGetJustify label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_justify label'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr label
    return result'

data LabelGetJustifyMethodInfo
instance (signature ~ (m Gtk.Enums.Justification), MonadIO m, IsLabel a) => O.MethodInfo LabelGetJustifyMethodInfo a signature where
    overloadedMethod _ = labelGetJustify

-- method Label::get_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_label" gtk_label_get_label :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CString

{- |
Fetches the text from a label widget including any embedded
underlines indicating mnemonics and Pango markup. (See
'GI.Gtk.Objects.Label.labelGetText').
-}
labelGetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m T.Text
    {- ^ __Returns:__ the text of the label widget. This string is
  owned by the widget and must not be modified or freed. -}
labelGetLabel label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_label label'
    checkUnexpectedReturnNULL "labelGetLabel" result
    result' <- cstringToText result
    touchManagedPtr label
    return result'

data LabelGetLabelMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsLabel a) => O.MethodInfo LabelGetLabelMethodInfo a signature where
    overloadedMethod _ = labelGetLabel

-- method Label::get_layout
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_layout" gtk_label_get_layout :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO (Ptr Pango.Layout.Layout)

{- |
Gets the 'GI.Pango.Objects.Layout.Layout' used to display the label.
The layout is useful to e.g. convert text positions to
pixel positions, in combination with 'GI.Gtk.Objects.Label.labelGetLayoutOffsets'.
The returned layout is owned by the /@label@/ so need not be
freed by the caller. The /@label@/ is free to recreate its layout at
any time, so it should be considered read-only.
-}
labelGetLayout ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Pango.Layout.Layout
    {- ^ __Returns:__ the 'GI.Pango.Objects.Layout.Layout' for this label -}
labelGetLayout label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_layout label'
    checkUnexpectedReturnNULL "labelGetLayout" result
    result' <- (newObject Pango.Layout.Layout) result
    touchManagedPtr label
    return result'

data LabelGetLayoutMethodInfo
instance (signature ~ (m Pango.Layout.Layout), MonadIO m, IsLabel a) => O.MethodInfo LabelGetLayoutMethodInfo a signature where
    overloadedMethod _ = labelGetLayout

-- method Label::get_layout_offsets
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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 "location to store X offset of layout, 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 "location to store Y offset of layout, 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_label_get_layout_offsets" gtk_label_get_layout_offsets :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    Ptr Int32 ->                            -- x : TBasicType TInt
    Ptr Int32 ->                            -- y : TBasicType TInt
    IO ()

{- |
Obtains the coordinates where the label will draw the 'GI.Pango.Objects.Layout.Layout'
representing the text in the label; useful to convert mouse events
into coordinates inside the 'GI.Pango.Objects.Layout.Layout', e.g. to take some action
if some part of the label is clicked. Of course you will need to
create a 'GI.Gtk.Objects.EventBox.EventBox' to receive the events, and pack the label
inside it, since labels are windowless (they return 'False' from
'GI.Gtk.Objects.Widget.widgetGetHasWindow'). Remember
when using the 'GI.Pango.Objects.Layout.Layout' functions you need to convert to
and from pixels using @/PANGO_PIXELS()/@ or 'GI.Pango.Constants.SCALE'.
-}
labelGetLayoutOffsets ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m (Int32,Int32)
labelGetLayoutOffsets label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    x <- allocMem :: IO (Ptr Int32)
    y <- allocMem :: IO (Ptr Int32)
    gtk_label_get_layout_offsets label' x y
    x' <- peek x
    y' <- peek y
    touchManagedPtr label
    freeMem x
    freeMem y
    return (x', y')

data LabelGetLayoutOffsetsMethodInfo
instance (signature ~ (m (Int32,Int32)), MonadIO m, IsLabel a) => O.MethodInfo LabelGetLayoutOffsetsMethodInfo a signature where
    overloadedMethod _ = labelGetLayoutOffsets

-- method Label::get_line_wrap
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_line_wrap" gtk_label_get_line_wrap :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CInt

{- |
Returns whether lines in the label are automatically wrapped.
See 'GI.Gtk.Objects.Label.labelSetLineWrap'.
-}
labelGetLineWrap ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the lines of the label are automatically wrapped. -}
labelGetLineWrap label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_line_wrap label'
    let result' = (/= 0) result
    touchManagedPtr label
    return result'

data LabelGetLineWrapMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLabel a) => O.MethodInfo LabelGetLineWrapMethodInfo a signature where
    overloadedMethod _ = labelGetLineWrap

-- method Label::get_line_wrap_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "WrapMode"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_get_line_wrap_mode" gtk_label_get_line_wrap_mode :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CUInt

{- |
Returns line wrap mode used by the label. See 'GI.Gtk.Objects.Label.labelSetLineWrapMode'.

@since 2.10
-}
labelGetLineWrapMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Pango.Enums.WrapMode
    {- ^ __Returns:__ 'True' if the lines of the label are automatically wrapped. -}
labelGetLineWrapMode label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_line_wrap_mode label'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr label
    return result'

data LabelGetLineWrapModeMethodInfo
instance (signature ~ (m Pango.Enums.WrapMode), MonadIO m, IsLabel a) => O.MethodInfo LabelGetLineWrapModeMethodInfo a signature where
    overloadedMethod _ = labelGetLineWrapMode

-- method Label::get_lines
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_lines" gtk_label_get_lines :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO Int32

{- |
Gets the number of lines to which an ellipsized, wrapping
label should be limited. See 'GI.Gtk.Objects.Label.labelSetLines'.

@since 3.10
-}
labelGetLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Int32
    {- ^ __Returns:__ The number of lines -}
labelGetLines label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_lines label'
    touchManagedPtr label
    return result

data LabelGetLinesMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsLabel a) => O.MethodInfo LabelGetLinesMethodInfo a signature where
    overloadedMethod _ = labelGetLines

-- method Label::get_max_width_chars
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_max_width_chars" gtk_label_get_max_width_chars :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO Int32

{- |
Retrieves the desired maximum width of /@label@/, in characters. See
'GI.Gtk.Objects.Label.labelSetWidthChars'.

@since 2.6
-}
labelGetMaxWidthChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Int32
    {- ^ __Returns:__ the maximum width of the label in characters. -}
labelGetMaxWidthChars label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_max_width_chars label'
    touchManagedPtr label
    return result

data LabelGetMaxWidthCharsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsLabel a) => O.MethodInfo LabelGetMaxWidthCharsMethodInfo a signature where
    overloadedMethod _ = labelGetMaxWidthChars

-- method Label::get_mnemonic_keyval
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_get_mnemonic_keyval" gtk_label_get_mnemonic_keyval :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO Word32

{- |
If the label has been set so that it has an mnemonic key this function
returns the keyval used for the mnemonic accelerator. If there is no
mnemonic set up it returns 'GI.Gdk.Constants.KEY_VoidSymbol'.
-}
labelGetMnemonicKeyval ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Word32
    {- ^ __Returns:__ GDK keyval usable for accelerators, or 'GI.Gdk.Constants.KEY_VoidSymbol' -}
labelGetMnemonicKeyval label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_mnemonic_keyval label'
    touchManagedPtr label
    return result

data LabelGetMnemonicKeyvalMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsLabel a) => O.MethodInfo LabelGetMnemonicKeyvalMethodInfo a signature where
    overloadedMethod _ = labelGetMnemonicKeyval

-- method Label::get_mnemonic_widget
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_mnemonic_widget" gtk_label_get_mnemonic_widget :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO (Ptr Gtk.Widget.Widget)

{- |
Retrieves the target of the mnemonic (keyboard shortcut) of this
label. See 'GI.Gtk.Objects.Label.labelSetMnemonicWidget'.
-}
labelGetMnemonicWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m (Maybe Gtk.Widget.Widget)
    {- ^ __Returns:__ the target of the label’s mnemonic,
    or 'Nothing' if none has been set and the default algorithm will be used. -}
labelGetMnemonicWidget label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_mnemonic_widget label'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject Gtk.Widget.Widget) result'
        return result''
    touchManagedPtr label
    return maybeResult

data LabelGetMnemonicWidgetMethodInfo
instance (signature ~ (m (Maybe Gtk.Widget.Widget)), MonadIO m, IsLabel a) => O.MethodInfo LabelGetMnemonicWidgetMethodInfo a signature where
    overloadedMethod _ = labelGetMnemonicWidget

-- method Label::get_selectable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_selectable" gtk_label_get_selectable :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CInt

{- |
Gets the value set by 'GI.Gtk.Objects.Label.labelSetSelectable'.
-}
labelGetSelectable ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the user can copy text from the label -}
labelGetSelectable label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_selectable label'
    let result' = (/= 0) result
    touchManagedPtr label
    return result'

data LabelGetSelectableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLabel a) => O.MethodInfo LabelGetSelectableMethodInfo a signature where
    overloadedMethod _ = labelGetSelectable

-- method Label::get_selection_bounds
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for start of selection, as a character offset", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "end", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for end of selection, as a character offset", 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_label_get_selection_bounds" gtk_label_get_selection_bounds :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    Ptr Int32 ->                            -- start : TBasicType TInt
    Ptr Int32 ->                            -- end : TBasicType TInt
    IO CInt

{- |
Gets the selected range of characters in the label, returning 'True'
if there’s a selection.
-}
labelGetSelectionBounds ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m (Bool,Int32,Int32)
    {- ^ __Returns:__ 'True' if selection is non-empty -}
labelGetSelectionBounds label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    start <- allocMem :: IO (Ptr Int32)
    end <- allocMem :: IO (Ptr Int32)
    result <- gtk_label_get_selection_bounds label' start end
    let result' = (/= 0) result
    start' <- peek start
    end' <- peek end
    touchManagedPtr label
    freeMem start
    freeMem end
    return (result', start', end')

data LabelGetSelectionBoundsMethodInfo
instance (signature ~ (m (Bool,Int32,Int32)), MonadIO m, IsLabel a) => O.MethodInfo LabelGetSelectionBoundsMethodInfo a signature where
    overloadedMethod _ = labelGetSelectionBounds

-- method Label::get_single_line_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_single_line_mode" gtk_label_get_single_line_mode :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CInt

{- |
Returns whether the label is in single line mode.

@since 2.6
-}
labelGetSingleLineMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Bool
    {- ^ __Returns:__ 'True' when the label is in single line mode. -}
labelGetSingleLineMode label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_single_line_mode label'
    let result' = (/= 0) result
    touchManagedPtr label
    return result'

data LabelGetSingleLineModeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLabel a) => O.MethodInfo LabelGetSingleLineModeMethodInfo a signature where
    overloadedMethod _ = labelGetSingleLineMode

-- method Label::get_text
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_text" gtk_label_get_text :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CString

{- |
Fetches the text from a label widget, as displayed on the
screen. This does not include any embedded underlines
indicating mnemonics or Pango markup. (See 'GI.Gtk.Objects.Label.labelGetLabel')
-}
labelGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m T.Text
    {- ^ __Returns:__ the text in the label widget. This is the internal
  string used by the label, and must not be modified. -}
labelGetText label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_text label'
    checkUnexpectedReturnNULL "labelGetText" result
    result' <- cstringToText result
    touchManagedPtr label
    return result'

data LabelGetTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsLabel a) => O.MethodInfo LabelGetTextMethodInfo a signature where
    overloadedMethod _ = labelGetText

-- method Label::get_track_visited_links
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_track_visited_links" gtk_label_get_track_visited_links :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CInt

{- |
Returns whether the label is currently keeping track
of clicked links.

@since 2.18
-}
labelGetTrackVisitedLinks ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if clicked links are remembered -}
labelGetTrackVisitedLinks label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_track_visited_links label'
    let result' = (/= 0) result
    touchManagedPtr label
    return result'

data LabelGetTrackVisitedLinksMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLabel a) => O.MethodInfo LabelGetTrackVisitedLinksMethodInfo a signature where
    overloadedMethod _ = labelGetTrackVisitedLinks

-- method Label::get_use_markup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_use_markup" gtk_label_get_use_markup :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CInt

{- |
Returns whether the label’s text is interpreted as marked up with
the [Pango text markup language][PangoMarkupFormat].
See gtk_label_set_use_markup ().
-}
labelGetUseMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the label’s text will be parsed for markup. -}
labelGetUseMarkup label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_use_markup label'
    let result' = (/= 0) result
    touchManagedPtr label
    return result'

data LabelGetUseMarkupMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLabel a) => O.MethodInfo LabelGetUseMarkupMethodInfo a signature where
    overloadedMethod _ = labelGetUseMarkup

-- method Label::get_use_underline
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_use_underline" gtk_label_get_use_underline :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CInt

{- |
Returns whether an embedded underline in the label indicates a
mnemonic. See 'GI.Gtk.Objects.Label.labelSetUseUnderline'.
-}
labelGetUseUnderline ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Bool
    {- ^ __Returns:__ 'True' whether an embedded underline in the label indicates
              the mnemonic accelerator keys. -}
labelGetUseUnderline label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_use_underline label'
    let result' = (/= 0) result
    touchManagedPtr label
    return result'

data LabelGetUseUnderlineMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLabel a) => O.MethodInfo LabelGetUseUnderlineMethodInfo a signature where
    overloadedMethod _ = labelGetUseUnderline

-- method Label::get_width_chars
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", 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_label_get_width_chars" gtk_label_get_width_chars :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO Int32

{- |
Retrieves the desired width of /@label@/, in characters. See
'GI.Gtk.Objects.Label.labelSetWidthChars'.

@since 2.6
-}
labelGetWidthChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Int32
    {- ^ __Returns:__ the width of the label in characters. -}
labelGetWidthChars label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_width_chars label'
    touchManagedPtr label
    return result

data LabelGetWidthCharsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsLabel a) => O.MethodInfo LabelGetWidthCharsMethodInfo a signature where
    overloadedMethod _ = labelGetWidthChars

-- method Label::get_xalign
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_get_xalign" gtk_label_get_xalign :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CFloat

{- |
Gets the 'GI.Gtk.Objects.Label.Label':@/xalign/@ property for /@label@/.

@since 3.16
-}
labelGetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Float
    {- ^ __Returns:__ the xalign property -}
labelGetXalign label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_xalign label'
    let result' = realToFrac result
    touchManagedPtr label
    return result'

data LabelGetXalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsLabel a) => O.MethodInfo LabelGetXalignMethodInfo a signature where
    overloadedMethod _ = labelGetXalign

-- method Label::get_yalign
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TFloat)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_get_yalign" gtk_label_get_yalign :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    IO CFloat

{- |
Gets the 'GI.Gtk.Objects.Label.Label':@/yalign/@ property for /@label@/.

@since 3.16
-}
labelGetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> m Float
    {- ^ __Returns:__ the yalign property -}
labelGetYalign label = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    result <- gtk_label_get_yalign label'
    let result' = realToFrac result
    touchManagedPtr label
    return result'

data LabelGetYalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsLabel a) => O.MethodInfo LabelGetYalignMethodInfo a signature where
    overloadedMethod _ = labelGetYalign

-- method Label::select_region
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_offset", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start offset (in characters not bytes)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_offset", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "end offset (in characters not bytes)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_select_region" gtk_label_select_region :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    Int32 ->                                -- start_offset : TBasicType TInt
    Int32 ->                                -- end_offset : TBasicType TInt
    IO ()

{- |
Selects a range of characters in the label, if the label is selectable.
See 'GI.Gtk.Objects.Label.labelSetSelectable'. If the label is not selectable,
this function has no effect. If /@startOffset@/ or
/@endOffset@/ are -1, then the end of the label will be substituted.
-}
labelSelectRegion ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Int32
    {- ^ /@startOffset@/: start offset (in characters not bytes) -}
    -> Int32
    {- ^ /@endOffset@/: end offset (in characters not bytes) -}
    -> m ()
labelSelectRegion label startOffset endOffset = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    gtk_label_select_region label' startOffset endOffset
    touchManagedPtr label
    return ()

data LabelSelectRegionMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSelectRegionMethodInfo a signature where
    overloadedMethod _ = labelSelectRegion

-- method Label::set_angle
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "angle", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the angle that the baseline of the label makes with\n  the horizontal, in degrees, measured counterclockwise", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_angle" gtk_label_set_angle :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CDouble ->                              -- angle : TBasicType TDouble
    IO ()

{- |
Sets the angle of rotation for the label. An angle of 90 reads from
from bottom to top, an angle of 270, from top to bottom. The angle
setting for the label is ignored if the label is selectable,
wrapped, or ellipsized.

@since 2.6
-}
labelSetAngle ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Double
    {- ^ /@angle@/: the angle that the baseline of the label makes with
  the horizontal, in degrees, measured counterclockwise -}
    -> m ()
labelSetAngle label angle = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let angle' = realToFrac angle
    gtk_label_set_angle label' angle'
    touchManagedPtr label
    return ()

data LabelSetAngleMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetAngleMethodInfo a signature where
    overloadedMethod _ = labelSetAngle

-- method Label::set_attributes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "attrs", argType = TInterface (Name {namespace = "Pango", name = "AttrList"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #PangoAttrList, 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_label_set_attributes" gtk_label_set_attributes :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    Ptr Pango.AttrList.AttrList ->          -- attrs : TInterface (Name {namespace = "Pango", name = "AttrList"})
    IO ()

{- |
Sets a 'GI.Pango.Structs.AttrList.AttrList'; the attributes in the list are applied to the
label text.

The attributes set with this function will be applied
and merged with any other attributes previously effected by way
of the 'GI.Gtk.Objects.Label.Label':@/use-underline/@ or 'GI.Gtk.Objects.Label.Label':@/use-markup/@ properties.
While it is not recommended to mix markup strings with manually set
attributes, if you must; know that the attributes will be applied
to the label after the markup string is parsed.
-}
labelSetAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Maybe (Pango.AttrList.AttrList)
    {- ^ /@attrs@/: a 'GI.Pango.Structs.AttrList.AttrList', or 'Nothing' -}
    -> m ()
labelSetAttributes label attrs = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    maybeAttrs <- case attrs of
        Nothing -> return nullPtr
        Just jAttrs -> do
            jAttrs' <- unsafeManagedPtrGetPtr jAttrs
            return jAttrs'
    gtk_label_set_attributes label' maybeAttrs
    touchManagedPtr label
    whenJust attrs touchManagedPtr
    return ()

data LabelSetAttributesMethodInfo
instance (signature ~ (Maybe (Pango.AttrList.AttrList) -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetAttributesMethodInfo a signature where
    overloadedMethod _ = labelSetAttributes

-- method Label::set_ellipsize
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Pango", name = "EllipsizeMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoEllipsizeMode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_ellipsize" gtk_label_set_ellipsize :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "Pango", name = "EllipsizeMode"})
    IO ()

{- |
Sets the mode used to ellipsize (add an ellipsis: \"...\") to the text
if there is not enough space to render the entire string.

@since 2.6
-}
labelSetEllipsize ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Pango.Enums.EllipsizeMode
    {- ^ /@mode@/: a 'GI.Pango.Enums.EllipsizeMode' -}
    -> m ()
labelSetEllipsize label mode = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let mode' = (fromIntegral . fromEnum) mode
    gtk_label_set_ellipsize label' mode'
    touchManagedPtr label
    return ()

data LabelSetEllipsizeMethodInfo
instance (signature ~ (Pango.Enums.EllipsizeMode -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetEllipsizeMethodInfo a signature where
    overloadedMethod _ = labelSetEllipsize

-- method Label::set_justify
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "jtype", argType = TInterface (Name {namespace = "Gtk", name = "Justification"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkJustification", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_justify" gtk_label_set_justify :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CUInt ->                                -- jtype : TInterface (Name {namespace = "Gtk", name = "Justification"})
    IO ()

{- |
Sets the alignment of the lines in the text of the label relative to
each other. 'GI.Gtk.Enums.JustificationLeft' is the default value when the widget is
first created with 'GI.Gtk.Objects.Label.labelNew'. If you instead want to set the
alignment of the label as a whole, use 'GI.Gtk.Objects.Widget.widgetSetHalign' instead.
'GI.Gtk.Objects.Label.labelSetJustify' has no effect on labels containing only a
single line.
-}
labelSetJustify ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Gtk.Enums.Justification
    {- ^ /@jtype@/: a 'GI.Gtk.Enums.Justification' -}
    -> m ()
labelSetJustify label jtype = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let jtype' = (fromIntegral . fromEnum) jtype
    gtk_label_set_justify label' jtype'
    touchManagedPtr label
    return ()

data LabelSetJustifyMethodInfo
instance (signature ~ (Gtk.Enums.Justification -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetJustifyMethodInfo a signature where
    overloadedMethod _ = labelSetJustify

-- method Label::set_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new text to set for the 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_label_set_label" gtk_label_set_label :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CString ->                              -- str : TBasicType TUTF8
    IO ()

{- |
Sets the text of the label. The label is interpreted as
including embedded underlines and\/or Pango markup depending
on the values of the 'GI.Gtk.Objects.Label.Label':@/use-underline/@ and
'GI.Gtk.Objects.Label.Label':@/use-markup/@ properties.
-}
labelSetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> T.Text
    {- ^ /@str@/: the new text to set for the label -}
    -> m ()
labelSetLabel label str = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    str' <- textToCString str
    gtk_label_set_label label' str'
    touchManagedPtr label
    freeMem str'
    return ()

data LabelSetLabelMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetLabelMethodInfo a signature where
    overloadedMethod _ = labelSetLabel

-- method Label::set_line_wrap
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wrap", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the setting", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_line_wrap" gtk_label_set_line_wrap :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CInt ->                                 -- wrap : TBasicType TBoolean
    IO ()

{- |
Toggles line wrapping within the 'GI.Gtk.Objects.Label.Label' widget. 'True' makes it break
lines if text exceeds the widget’s size. 'False' lets the text get cut off
by the edge of the widget if it exceeds the widget size.

Note that setting line wrapping to 'True' does not make the label
wrap at its parent container’s width, because GTK+ widgets
conceptually can’t make their requisition depend on the parent
container’s size. For a label that wraps at a specific position,
set the label’s width using 'GI.Gtk.Objects.Widget.widgetSetSizeRequest'.
-}
labelSetLineWrap ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Bool
    {- ^ /@wrap@/: the setting -}
    -> m ()
labelSetLineWrap label wrap = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let wrap' = (fromIntegral . fromEnum) wrap
    gtk_label_set_line_wrap label' wrap'
    touchManagedPtr label
    return ()

data LabelSetLineWrapMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetLineWrapMethodInfo a signature where
    overloadedMethod _ = labelSetLineWrap

-- method Label::set_line_wrap_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wrap_mode", argType = TInterface (Name {namespace = "Pango", name = "WrapMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the line wrapping mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_line_wrap_mode" gtk_label_set_line_wrap_mode :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CUInt ->                                -- wrap_mode : TInterface (Name {namespace = "Pango", name = "WrapMode"})
    IO ()

{- |
If line wrapping is on (see 'GI.Gtk.Objects.Label.labelSetLineWrap') this controls how
the line wrapping is done. The default is 'GI.Pango.Enums.WrapModeWord' which means
wrap on word boundaries.

@since 2.10
-}
labelSetLineWrapMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Pango.Enums.WrapMode
    {- ^ /@wrapMode@/: the line wrapping mode -}
    -> m ()
labelSetLineWrapMode label wrapMode = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let wrapMode' = (fromIntegral . fromEnum) wrapMode
    gtk_label_set_line_wrap_mode label' wrapMode'
    touchManagedPtr label
    return ()

data LabelSetLineWrapModeMethodInfo
instance (signature ~ (Pango.Enums.WrapMode -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetLineWrapModeMethodInfo a signature where
    overloadedMethod _ = labelSetLineWrapMode

-- method Label::set_lines
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "lines", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the desired number of lines, 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_label_set_lines" gtk_label_set_lines :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    Int32 ->                                -- lines : TBasicType TInt
    IO ()

{- |
Sets the number of lines to which an ellipsized, wrapping label
should be limited. This has no effect if the label is not wrapping
or ellipsized. Set this to -1 if you don’t want to limit the
number of lines.

@since 3.10
-}
labelSetLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Int32
    {- ^ /@lines@/: the desired number of lines, or -1 -}
    -> m ()
labelSetLines label lines = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    gtk_label_set_lines label' lines
    touchManagedPtr label
    return ()

data LabelSetLinesMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetLinesMethodInfo a signature where
    overloadedMethod _ = labelSetLines

-- method Label::set_markup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a markup string (see [Pango markup format][PangoMarkupFormat])", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_markup" gtk_label_set_markup :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CString ->                              -- str : TBasicType TUTF8
    IO ()

{- |
Parses /@str@/ which is marked up with the
[Pango text markup language][PangoMarkupFormat], setting the
label’s text and attribute list based on the parse results.

If the /@str@/ is external data, you may need to escape it with
'GI.GLib.Functions.markupEscapeText' or @/g_markup_printf_escaped()/@:


=== /C code/
>
>const char *format = "<span style=\"italic\">\%s</span>";
>char *markup;
>
>markup = g_markup_printf_escaped (format, str);
>gtk_label_set_markup (GTK_LABEL (label), markup);
>g_free (markup);


This function will set the 'GI.Gtk.Objects.Label.Label':@/use-markup/@ property to 'True' as
a side effect.

If you set the label contents using the 'GI.Gtk.Objects.Label.Label':@/label/@ property you
should also ensure that you set the 'GI.Gtk.Objects.Label.Label':@/use-markup/@ property
accordingly.

See also: 'GI.Gtk.Objects.Label.labelSetText'
-}
labelSetMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> T.Text
    {- ^ /@str@/: a markup string (see [Pango markup format][PangoMarkupFormat]) -}
    -> m ()
labelSetMarkup label str = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    str' <- textToCString str
    gtk_label_set_markup label' str'
    touchManagedPtr label
    freeMem str'
    return ()

data LabelSetMarkupMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetMarkupMethodInfo a signature where
    overloadedMethod _ = labelSetMarkup

-- method Label::set_markup_with_mnemonic
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a markup string (see\n    [Pango markup format][PangoMarkupFormat])", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_markup_with_mnemonic" gtk_label_set_markup_with_mnemonic :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CString ->                              -- str : TBasicType TUTF8
    IO ()

{- |
Parses /@str@/ which is marked up with the
[Pango text markup language][PangoMarkupFormat],
setting the label’s text and attribute list based on the parse results.
If characters in /@str@/ are preceded by an underscore, they are underlined
indicating that they represent a keyboard accelerator called a mnemonic.

The mnemonic key can be used to activate another widget, chosen
automatically, or explicitly using 'GI.Gtk.Objects.Label.labelSetMnemonicWidget'.
-}
labelSetMarkupWithMnemonic ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> T.Text
    {- ^ /@str@/: a markup string (see
    [Pango markup format][PangoMarkupFormat]) -}
    -> m ()
labelSetMarkupWithMnemonic label str = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    str' <- textToCString str
    gtk_label_set_markup_with_mnemonic label' str'
    touchManagedPtr label
    freeMem str'
    return ()

data LabelSetMarkupWithMnemonicMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetMarkupWithMnemonicMethodInfo a signature where
    overloadedMethod _ = labelSetMarkupWithMnemonic

-- method Label::set_max_width_chars
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_chars", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new desired maximum width, in characters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_max_width_chars" gtk_label_set_max_width_chars :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    Int32 ->                                -- n_chars : TBasicType TInt
    IO ()

{- |
Sets the desired maximum width in characters of /@label@/ to /@nChars@/.

@since 2.6
-}
labelSetMaxWidthChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Int32
    {- ^ /@nChars@/: the new desired maximum width, in characters. -}
    -> m ()
labelSetMaxWidthChars label nChars = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    gtk_label_set_max_width_chars label' nChars
    touchManagedPtr label
    return ()

data LabelSetMaxWidthCharsMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetMaxWidthCharsMethodInfo a signature where
    overloadedMethod _ = labelSetMaxWidthChars

-- method Label::set_mnemonic_widget
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "widget", argType = TInterface (Name {namespace = "Gtk", name = "Widget"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the target #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_label_set_mnemonic_widget" gtk_label_set_mnemonic_widget :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    Ptr Gtk.Widget.Widget ->                -- widget : TInterface (Name {namespace = "Gtk", name = "Widget"})
    IO ()

{- |
If the label has been set so that it has an mnemonic key (using
i.e. 'GI.Gtk.Objects.Label.labelSetMarkupWithMnemonic',
'GI.Gtk.Objects.Label.labelSetTextWithMnemonic', 'GI.Gtk.Objects.Label.labelNewWithMnemonic'
or the “use_underline” property) the label can be associated with a
widget that is the target of the mnemonic. When the label is inside
a widget (like a 'GI.Gtk.Objects.Button.Button' or a 'GI.Gtk.Objects.Notebook.Notebook' tab) it is
automatically associated with the correct widget, but sometimes
(i.e. when the target is a 'GI.Gtk.Objects.Entry.Entry' next to the label) you need to
set it explicitly using this function.

The target widget will be accelerated by emitting the
GtkWidget::mnemonic-activate signal on it. The default handler for
this signal will activate the widget if there are no mnemonic collisions
and toggle focus between the colliding widgets otherwise.
-}
labelSetMnemonicWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a, Gtk.Widget.IsWidget b) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Maybe (b)
    {- ^ /@widget@/: the target 'GI.Gtk.Objects.Widget.Widget' -}
    -> m ()
labelSetMnemonicWidget label widget = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    maybeWidget <- case widget of
        Nothing -> return nullPtr
        Just jWidget -> do
            jWidget' <- unsafeManagedPtrCastPtr jWidget
            return jWidget'
    gtk_label_set_mnemonic_widget label' maybeWidget
    touchManagedPtr label
    whenJust widget touchManagedPtr
    return ()

data LabelSetMnemonicWidgetMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsLabel a, Gtk.Widget.IsWidget b) => O.MethodInfo LabelSetMnemonicWidgetMethodInfo a signature where
    overloadedMethod _ = labelSetMnemonicWidget

-- method Label::set_pattern
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GtkLabel you want to set the pattern to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pattern", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The pattern as described above.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_pattern" gtk_label_set_pattern :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CString ->                              -- pattern : TBasicType TUTF8
    IO ()

{- |
The pattern of underlines you want under the existing text within the
'GI.Gtk.Objects.Label.Label' widget.  For example if the current text of the label says
“FooBarBaz” passing a pattern of “___   ___” will underline
“Foo” and “Baz” but not “Bar”.
-}
labelSetPattern ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: The 'GI.Gtk.Objects.Label.Label' you want to set the pattern to. -}
    -> T.Text
    {- ^ /@pattern@/: The pattern as described above. -}
    -> m ()
labelSetPattern label pattern = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    pattern' <- textToCString pattern
    gtk_label_set_pattern label' pattern'
    touchManagedPtr label
    freeMem pattern'
    return ()

data LabelSetPatternMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetPatternMethodInfo a signature where
    overloadedMethod _ = labelSetPattern

-- method Label::set_selectable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to allow selecting text in the 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_label_set_selectable" gtk_label_set_selectable :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

{- |
Selectable labels allow the user to select text from the label, for
copy-and-paste.
-}
labelSetSelectable ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Bool
    {- ^ /@setting@/: 'True' to allow selecting text in the label -}
    -> m ()
labelSetSelectable label setting = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let setting' = (fromIntegral . fromEnum) setting
    gtk_label_set_selectable label' setting'
    touchManagedPtr label
    return ()

data LabelSetSelectableMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetSelectableMethodInfo a signature where
    overloadedMethod _ = labelSetSelectable

-- method Label::set_single_line_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "single_line_mode", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the label should be in single line mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_single_line_mode" gtk_label_set_single_line_mode :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CInt ->                                 -- single_line_mode : TBasicType TBoolean
    IO ()

{- |
Sets whether the label is in single line mode.

@since 2.6
-}
labelSetSingleLineMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Bool
    {- ^ /@singleLineMode@/: 'True' if the label should be in single line mode -}
    -> m ()
labelSetSingleLineMode label singleLineMode = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let singleLineMode' = (fromIntegral . fromEnum) singleLineMode
    gtk_label_set_single_line_mode label' singleLineMode'
    touchManagedPtr label
    return ()

data LabelSetSingleLineModeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetSingleLineModeMethodInfo a signature where
    overloadedMethod _ = labelSetSingleLineMode

-- method Label::set_text
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The text you want 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_label_set_text" gtk_label_set_text :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CString ->                              -- str : TBasicType TUTF8
    IO ()

{- |
Sets the text within the 'GI.Gtk.Objects.Label.Label' widget. It overwrites any text that
was there before.

This function will clear any previously set mnemonic accelerators, and
set the 'GI.Gtk.Objects.Label.Label':@/use-underline/@ property to 'False' as a side effect.

This function will set the 'GI.Gtk.Objects.Label.Label':@/use-markup/@ property to 'False'
as a side effect.

See also: 'GI.Gtk.Objects.Label.labelSetMarkup'
-}
labelSetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> T.Text
    {- ^ /@str@/: The text you want to set -}
    -> m ()
labelSetText label str = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    str' <- textToCString str
    gtk_label_set_text label' str'
    touchManagedPtr label
    freeMem str'
    return ()

data LabelSetTextMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetTextMethodInfo a signature where
    overloadedMethod _ = labelSetText

-- method Label::set_text_with_mnemonic
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_text_with_mnemonic" gtk_label_set_text_with_mnemonic :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CString ->                              -- str : TBasicType TUTF8
    IO ()

{- |
Sets the label’s text from the string /@str@/.
If characters in /@str@/ are preceded by an underscore, they are underlined
indicating that they represent a keyboard accelerator called a mnemonic.
The mnemonic key can be used to activate another widget, chosen
automatically, or explicitly using 'GI.Gtk.Objects.Label.labelSetMnemonicWidget'.
-}
labelSetTextWithMnemonic ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> T.Text
    {- ^ /@str@/: a string -}
    -> m ()
labelSetTextWithMnemonic label str = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    str' <- textToCString str
    gtk_label_set_text_with_mnemonic label' str'
    touchManagedPtr label
    freeMem str'
    return ()

data LabelSetTextWithMnemonicMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetTextWithMnemonicMethodInfo a signature where
    overloadedMethod _ = labelSetTextWithMnemonic

-- method Label::set_track_visited_links
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "track_links", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to track visited links", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_track_visited_links" gtk_label_set_track_visited_links :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CInt ->                                 -- track_links : TBasicType TBoolean
    IO ()

{- |
Sets whether the label should keep track of clicked
links (and use a different color for them).

@since 2.18
-}
labelSetTrackVisitedLinks ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Bool
    {- ^ /@trackLinks@/: 'True' to track visited links -}
    -> m ()
labelSetTrackVisitedLinks label trackLinks = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let trackLinks' = (fromIntegral . fromEnum) trackLinks
    gtk_label_set_track_visited_links label' trackLinks'
    touchManagedPtr label
    return ()

data LabelSetTrackVisitedLinksMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetTrackVisitedLinksMethodInfo a signature where
    overloadedMethod _ = labelSetTrackVisitedLinks

-- method Label::set_use_markup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if the label\8217s text should be parsed for markup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_use_markup" gtk_label_set_use_markup :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

{- |
Sets whether the text of the label contains markup in
[Pango’s text markup language][PangoMarkupFormat].
See 'GI.Gtk.Objects.Label.labelSetMarkup'.
-}
labelSetUseMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Bool
    {- ^ /@setting@/: 'True' if the label’s text should be parsed for markup. -}
    -> m ()
labelSetUseMarkup label setting = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let setting' = (fromIntegral . fromEnum) setting
    gtk_label_set_use_markup label' setting'
    touchManagedPtr label
    return ()

data LabelSetUseMarkupMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetUseMarkupMethodInfo a signature where
    overloadedMethod _ = labelSetUseMarkup

-- method Label::set_use_underline
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "setting", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE if underlines in the text indicate mnemonics", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_use_underline" gtk_label_set_use_underline :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CInt ->                                 -- setting : TBasicType TBoolean
    IO ()

{- |
If true, an underline in the text indicates the next character should be
used for the mnemonic accelerator key.
-}
labelSetUseUnderline ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Bool
    {- ^ /@setting@/: 'True' if underlines in the text indicate mnemonics -}
    -> m ()
labelSetUseUnderline label setting = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let setting' = (fromIntegral . fromEnum) setting
    gtk_label_set_use_underline label' setting'
    touchManagedPtr label
    return ()

data LabelSetUseUnderlineMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetUseUnderlineMethodInfo a signature where
    overloadedMethod _ = labelSetUseUnderline

-- method Label::set_width_chars
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_chars", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new desired width, in characters.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_label_set_width_chars" gtk_label_set_width_chars :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    Int32 ->                                -- n_chars : TBasicType TInt
    IO ()

{- |
Sets the desired width in characters of /@label@/ to /@nChars@/.

@since 2.6
-}
labelSetWidthChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Int32
    {- ^ /@nChars@/: the new desired width, in characters. -}
    -> m ()
labelSetWidthChars label nChars = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    gtk_label_set_width_chars label' nChars
    touchManagedPtr label
    return ()

data LabelSetWidthCharsMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetWidthCharsMethodInfo a signature where
    overloadedMethod _ = labelSetWidthChars

-- method Label::set_xalign
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new xalign value, 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_label_set_xalign" gtk_label_set_xalign :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CFloat ->                               -- xalign : TBasicType TFloat
    IO ()

{- |
Sets the 'GI.Gtk.Objects.Label.Label':@/xalign/@ property for /@label@/.

@since 3.16
-}
labelSetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Float
    {- ^ /@xalign@/: the new xalign value, between 0 and 1 -}
    -> m ()
labelSetXalign label xalign = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let xalign' = realToFrac xalign
    gtk_label_set_xalign label' xalign'
    touchManagedPtr label
    return ()

data LabelSetXalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetXalignMethodInfo a signature where
    overloadedMethod _ = labelSetXalign

-- method Label::set_yalign
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "label", argType = TInterface (Name {namespace = "Gtk", name = "Label"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkLabel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "yalign", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new yalign value, 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_label_set_yalign" gtk_label_set_yalign :: 
    Ptr Label ->                            -- label : TInterface (Name {namespace = "Gtk", name = "Label"})
    CFloat ->                               -- yalign : TBasicType TFloat
    IO ()

{- |
Sets the 'GI.Gtk.Objects.Label.Label':@/yalign/@ property for /@label@/.

@since 3.16
-}
labelSetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsLabel a) =>
    a
    {- ^ /@label@/: a 'GI.Gtk.Objects.Label.Label' -}
    -> Float
    {- ^ /@yalign@/: the new yalign value, between 0 and 1 -}
    -> m ()
labelSetYalign label yalign = liftIO $ do
    label' <- unsafeManagedPtrCastPtr label
    let yalign' = realToFrac yalign
    gtk_label_set_yalign label' yalign'
    touchManagedPtr label
    return ()

data LabelSetYalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsLabel a) => O.MethodInfo LabelSetYalignMethodInfo a signature where
    overloadedMethod _ = labelSetYalign