{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @GtkInscription@ is a widget to show text in a predefined area.
-- 
-- You likely want to use @GtkLabel@ instead as this widget is intended only
-- for a small subset of use cases. The main scenario envisaged is inside lists
-- such as @GtkColumnView@.
-- 
-- While a @GtkLabel@ sizes itself depending on the text that is displayed,
-- @GtkInscription@ is given a size and inscribes the given text into that
-- space as well as it can.
-- 
-- Users of this widget should take care to plan behaviour for the common case
-- where the text doesn\'t fit exactly in the allocated space, .
-- 
-- /Since: 4.8/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gtk.Objects.Inscription
    ( 

-- * Exported types
    Inscription(..)                         ,
    IsInscription                           ,
    toInscription                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getAttributes]("GI.Gtk.Objects.Inscription#g:method:getAttributes"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMinChars]("GI.Gtk.Objects.Inscription#g:method:getMinChars"), [getMinLines]("GI.Gtk.Objects.Inscription#g:method:getMinLines"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNatChars]("GI.Gtk.Objects.Inscription#g:method:getNatChars"), [getNatLines]("GI.Gtk.Objects.Inscription#g:method:getNatLines"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getText]("GI.Gtk.Objects.Inscription#g:method:getText"), [getTextOverflow]("GI.Gtk.Objects.Inscription#g:method:getTextOverflow"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth"), [getWrapMode]("GI.Gtk.Objects.Inscription#g:method:getWrapMode"), [getXalign]("GI.Gtk.Objects.Inscription#g:method:getXalign"), [getYalign]("GI.Gtk.Objects.Inscription#g:method:getYalign").
-- 
-- ==== Setters
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setAttributes]("GI.Gtk.Objects.Inscription#g:method:setAttributes"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMarkup]("GI.Gtk.Objects.Inscription#g:method:setMarkup"), [setMinChars]("GI.Gtk.Objects.Inscription#g:method:setMinChars"), [setMinLines]("GI.Gtk.Objects.Inscription#g:method:setMinLines"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setNatChars]("GI.Gtk.Objects.Inscription#g:method:setNatChars"), [setNatLines]("GI.Gtk.Objects.Inscription#g:method:setNatLines"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setText]("GI.Gtk.Objects.Inscription#g:method:setText"), [setTextOverflow]("GI.Gtk.Objects.Inscription#g:method:setTextOverflow"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setWrapMode]("GI.Gtk.Objects.Inscription#g:method:setWrapMode"), [setXalign]("GI.Gtk.Objects.Inscription#g:method:setXalign"), [setYalign]("GI.Gtk.Objects.Inscription#g:method:setYalign").

#if defined(ENABLE_OVERLOADING)
    ResolveInscriptionMethod                ,
#endif

-- ** getAttributes #method:getAttributes#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetAttributesMethodInfo      ,
#endif
    inscriptionGetAttributes                ,


-- ** getMinChars #method:getMinChars#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetMinCharsMethodInfo        ,
#endif
    inscriptionGetMinChars                  ,


-- ** getMinLines #method:getMinLines#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetMinLinesMethodInfo        ,
#endif
    inscriptionGetMinLines                  ,


-- ** getNatChars #method:getNatChars#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetNatCharsMethodInfo        ,
#endif
    inscriptionGetNatChars                  ,


-- ** getNatLines #method:getNatLines#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetNatLinesMethodInfo        ,
#endif
    inscriptionGetNatLines                  ,


-- ** getText #method:getText#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetTextMethodInfo            ,
#endif
    inscriptionGetText                      ,


-- ** getTextOverflow #method:getTextOverflow#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetTextOverflowMethodInfo    ,
#endif
    inscriptionGetTextOverflow              ,


-- ** getWrapMode #method:getWrapMode#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetWrapModeMethodInfo        ,
#endif
    inscriptionGetWrapMode                  ,


-- ** getXalign #method:getXalign#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetXalignMethodInfo          ,
#endif
    inscriptionGetXalign                    ,


-- ** getYalign #method:getYalign#

#if defined(ENABLE_OVERLOADING)
    InscriptionGetYalignMethodInfo          ,
#endif
    inscriptionGetYalign                    ,


-- ** new #method:new#

    inscriptionNew                          ,


-- ** setAttributes #method:setAttributes#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetAttributesMethodInfo      ,
#endif
    inscriptionSetAttributes                ,


-- ** setMarkup #method:setMarkup#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetMarkupMethodInfo          ,
#endif
    inscriptionSetMarkup                    ,


-- ** setMinChars #method:setMinChars#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetMinCharsMethodInfo        ,
#endif
    inscriptionSetMinChars                  ,


-- ** setMinLines #method:setMinLines#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetMinLinesMethodInfo        ,
#endif
    inscriptionSetMinLines                  ,


-- ** setNatChars #method:setNatChars#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetNatCharsMethodInfo        ,
#endif
    inscriptionSetNatChars                  ,


-- ** setNatLines #method:setNatLines#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetNatLinesMethodInfo        ,
#endif
    inscriptionSetNatLines                  ,


-- ** setText #method:setText#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetTextMethodInfo            ,
#endif
    inscriptionSetText                      ,


-- ** setTextOverflow #method:setTextOverflow#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetTextOverflowMethodInfo    ,
#endif
    inscriptionSetTextOverflow              ,


-- ** setWrapMode #method:setWrapMode#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetWrapModeMethodInfo        ,
#endif
    inscriptionSetWrapMode                  ,


-- ** setXalign #method:setXalign#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetXalignMethodInfo          ,
#endif
    inscriptionSetXalign                    ,


-- ** setYalign #method:setYalign#

#if defined(ENABLE_OVERLOADING)
    InscriptionSetYalignMethodInfo          ,
#endif
    inscriptionSetYalign                    ,




 -- * Properties


-- ** attributes #attr:attributes#
-- | A list of style attributes to apply to the text of the inscription.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionAttributesPropertyInfo       ,
#endif
    clearInscriptionAttributes              ,
    constructInscriptionAttributes          ,
    getInscriptionAttributes                ,
#if defined(ENABLE_OVERLOADING)
    inscriptionAttributes                   ,
#endif
    setInscriptionAttributes                ,


-- ** markup #attr:markup#
-- | Utility property that sets both the [Inscription:text]("GI.Gtk.Objects.Inscription#g:attr:text") and
-- [Inscription:attributes]("GI.Gtk.Objects.Inscription#g:attr:attributes") properties, mainly intended for use in
-- GtkBuilder ui files to ease translation support and bindings.
-- 
-- This function uses 'GI.Pango.Functions.parseMarkup' to parse the markup into text and
-- attributes. The markup must be valid. If you cannot ensure that, consider using
-- 'GI.Pango.Functions.parseMarkup' and setting the two properties yourself.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionMarkupPropertyInfo           ,
#endif
    clearInscriptionMarkup                  ,
    constructInscriptionMarkup              ,
#if defined(ENABLE_OVERLOADING)
    inscriptionMarkup                       ,
#endif
    setInscriptionMarkup                    ,


-- ** minChars #attr:minChars#
-- | The number of characters that should fit into the inscription at minimum.
-- 
-- This influences the requested width, not the width actually given to the widget,
-- which might turn out to be larger.
-- 
-- Note that this is an approximate character width, so some characters might be
-- wider and some might be thinner, so do not expect the number of characters to
-- exactly match.
-- 
-- If you set this property to 0, the inscription will not request any width at all
-- and its width will be determined entirely by its surroundings.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionMinCharsPropertyInfo         ,
#endif
    constructInscriptionMinChars            ,
    getInscriptionMinChars                  ,
#if defined(ENABLE_OVERLOADING)
    inscriptionMinChars                     ,
#endif
    setInscriptionMinChars                  ,


-- ** minLines #attr:minLines#
-- | The number of lines that should fit into the inscription at minimum.
-- 
-- This influences the requested height, not the height actually given to the widget,
-- which might turn out to be larger.
-- 
-- Note that this is an approximate line height, so if the text uses things like fancy
-- Unicode or attribute that influence the height, the text might not fit.
-- 
-- If you set this property to 0, the inscription will not request any height at all
-- and its height will be determined entirely by its surroundings.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionMinLinesPropertyInfo         ,
#endif
    constructInscriptionMinLines            ,
    getInscriptionMinLines                  ,
#if defined(ENABLE_OVERLOADING)
    inscriptionMinLines                     ,
#endif
    setInscriptionMinLines                  ,


-- ** natChars #attr:natChars#
-- | The number of characters that should ideally fit into the inscription.
-- 
-- This influences the requested width, not the width actually given to the widget.
-- The widget might turn out larger as well as smaller.
-- 
-- If this property is set to a value smaller than [Inscription:minChars]("GI.Gtk.Objects.Inscription#g:attr:minChars"),
-- that value will be used. In particular, for the default value of 0, this will always
-- be the case.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionNatCharsPropertyInfo         ,
#endif
    constructInscriptionNatChars            ,
    getInscriptionNatChars                  ,
#if defined(ENABLE_OVERLOADING)
    inscriptionNatChars                     ,
#endif
    setInscriptionNatChars                  ,


-- ** natLines #attr:natLines#
-- | The number of lines that should ideally fit into the inscription.
-- 
-- This influences the requested height, not the height actually given to the widget.
-- The widget might turn out larger as well as smaller.
-- 
-- If this property is set to a value smaller than [Inscription:minLines]("GI.Gtk.Objects.Inscription#g:attr:minLines"),
-- that value will be used. In particular, for the default value of 0, this will always
-- be the case.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionNatLinesPropertyInfo         ,
#endif
    constructInscriptionNatLines            ,
    getInscriptionNatLines                  ,
#if defined(ENABLE_OVERLOADING)
    inscriptionNatLines                     ,
#endif
    setInscriptionNatLines                  ,


-- ** text #attr:text#
-- | The displayed text.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionTextPropertyInfo             ,
#endif
    clearInscriptionText                    ,
    constructInscriptionText                ,
    getInscriptionText                      ,
#if defined(ENABLE_OVERLOADING)
    inscriptionText                         ,
#endif
    setInscriptionText                      ,


-- ** textOverflow #attr:textOverflow#
-- | The overflow method to use for the text.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionTextOverflowPropertyInfo     ,
#endif
    constructInscriptionTextOverflow        ,
    getInscriptionTextOverflow              ,
#if defined(ENABLE_OVERLOADING)
    inscriptionTextOverflow                 ,
#endif
    setInscriptionTextOverflow              ,


-- ** wrapMode #attr:wrapMode#
-- | Controls how the line wrapping is done.
-- 
-- Note that unlike @GtkLabel@, the default here is 'GI.Pango.Enums.WrapModeWordChar'.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionWrapModePropertyInfo         ,
#endif
    constructInscriptionWrapMode            ,
    getInscriptionWrapMode                  ,
#if defined(ENABLE_OVERLOADING)
    inscriptionWrapMode                     ,
#endif
    setInscriptionWrapMode                  ,


-- ** xalign #attr:xalign#
-- | The horizontal alignment of the text inside the allocated size.
-- 
-- Compare this to [Widget:halign]("GI.Gtk.Objects.Widget#g:attr:halign"), which determines how the
-- inscription\'s size allocation is positioned in the available space.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionXalignPropertyInfo           ,
#endif
    constructInscriptionXalign              ,
    getInscriptionXalign                    ,
#if defined(ENABLE_OVERLOADING)
    inscriptionXalign                       ,
#endif
    setInscriptionXalign                    ,


-- ** yalign #attr:yalign#
-- | The vertical alignment of the text inside the allocated size.
-- 
-- Compare this to [Widget:valign]("GI.Gtk.Objects.Widget#g:attr:valign"), which determines how the
-- inscription\'s size allocation is positioned in the available space.
-- 
-- /Since: 4.8/

#if defined(ENABLE_OVERLOADING)
    InscriptionYalignPropertyInfo           ,
#endif
    constructInscriptionYalign              ,
    getInscriptionYalign                    ,
#if defined(ENABLE_OVERLOADING)
    inscriptionYalign                       ,
#endif
    setInscriptionYalign                    ,




    ) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Pango.Enums as Pango.Enums
import qualified GI.Pango.Structs.AttrList as Pango.AttrList

-- | Memory-managed wrapper type.
newtype Inscription = Inscription (SP.ManagedPtr Inscription)
    deriving (Inscription -> Inscription -> Bool
(Inscription -> Inscription -> Bool)
-> (Inscription -> Inscription -> Bool) -> Eq Inscription
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Inscription -> Inscription -> Bool
== :: Inscription -> Inscription -> Bool
$c/= :: Inscription -> Inscription -> Bool
/= :: Inscription -> Inscription -> Bool
Eq)

instance SP.ManagedPtrNewtype Inscription where
    toManagedPtr :: Inscription -> ManagedPtr Inscription
toManagedPtr (Inscription ManagedPtr Inscription
p) = ManagedPtr Inscription
p

foreign import ccall "gtk_inscription_get_type"
    c_gtk_inscription_get_type :: IO B.Types.GType

instance B.Types.TypedObject Inscription where
    glibType :: IO GType
glibType = IO GType
c_gtk_inscription_get_type

instance B.Types.GObject Inscription

-- | Type class for types which can be safely cast to `Inscription`, for instance with `toInscription`.
class (SP.GObject o, O.IsDescendantOf Inscription o) => IsInscription o
instance (SP.GObject o, O.IsDescendantOf Inscription o) => IsInscription o

instance O.HasParentTypes Inscription
type instance O.ParentTypes Inscription = '[Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget]

-- | Cast to `Inscription`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toInscription :: (MIO.MonadIO m, IsInscription o) => o -> m Inscription
toInscription :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m Inscription
toInscription = IO Inscription -> m Inscription
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Inscription -> m Inscription)
-> (o -> IO Inscription) -> o -> m Inscription
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Inscription -> Inscription) -> o -> IO Inscription
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Inscription -> Inscription
Inscription

-- | Convert 'Inscription' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Inscription) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_inscription_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Inscription -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Inscription
P.Nothing = Ptr GValue -> Ptr Inscription -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Inscription
forall a. Ptr a
FP.nullPtr :: FP.Ptr Inscription)
    gvalueSet_ Ptr GValue
gv (P.Just Inscription
obj) = Inscription -> (Ptr Inscription -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Inscription
obj (Ptr GValue -> Ptr Inscription -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Inscription)
gvalueGet_ Ptr GValue
gv = do
        Ptr Inscription
ptr <- Ptr GValue -> IO (Ptr Inscription)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Inscription)
        if Ptr Inscription
ptr Ptr Inscription -> Ptr Inscription -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Inscription
forall a. Ptr a
FP.nullPtr
        then Inscription -> Maybe Inscription
forall a. a -> Maybe a
P.Just (Inscription -> Maybe Inscription)
-> IO Inscription -> IO (Maybe Inscription)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Inscription -> Inscription)
-> Ptr Inscription -> IO Inscription
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Inscription -> Inscription
Inscription Ptr Inscription
ptr
        else Maybe Inscription -> IO (Maybe Inscription)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Inscription
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveInscriptionMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveInscriptionMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveInscriptionMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveInscriptionMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveInscriptionMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveInscriptionMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveInscriptionMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveInscriptionMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveInscriptionMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveInscriptionMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveInscriptionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveInscriptionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveInscriptionMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveInscriptionMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveInscriptionMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveInscriptionMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveInscriptionMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveInscriptionMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveInscriptionMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveInscriptionMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveInscriptionMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveInscriptionMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveInscriptionMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveInscriptionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveInscriptionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveInscriptionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveInscriptionMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveInscriptionMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveInscriptionMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveInscriptionMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveInscriptionMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveInscriptionMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveInscriptionMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveInscriptionMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveInscriptionMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveInscriptionMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveInscriptionMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveInscriptionMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveInscriptionMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveInscriptionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveInscriptionMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveInscriptionMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveInscriptionMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveInscriptionMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveInscriptionMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveInscriptionMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveInscriptionMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveInscriptionMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveInscriptionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveInscriptionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveInscriptionMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveInscriptionMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveInscriptionMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveInscriptionMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveInscriptionMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveInscriptionMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveInscriptionMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveInscriptionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveInscriptionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveInscriptionMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveInscriptionMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveInscriptionMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveInscriptionMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveInscriptionMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveInscriptionMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveInscriptionMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveInscriptionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveInscriptionMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveInscriptionMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveInscriptionMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveInscriptionMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveInscriptionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveInscriptionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveInscriptionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveInscriptionMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveInscriptionMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveInscriptionMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveInscriptionMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveInscriptionMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveInscriptionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveInscriptionMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveInscriptionMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
    ResolveInscriptionMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveInscriptionMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveInscriptionMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveInscriptionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveInscriptionMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
    ResolveInscriptionMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveInscriptionMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveInscriptionMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveInscriptionMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveInscriptionMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveInscriptionMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveInscriptionMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
    ResolveInscriptionMethod "getAttributes" o = InscriptionGetAttributesMethodInfo
    ResolveInscriptionMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
    ResolveInscriptionMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveInscriptionMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveInscriptionMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveInscriptionMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveInscriptionMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveInscriptionMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
    ResolveInscriptionMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveInscriptionMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveInscriptionMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveInscriptionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveInscriptionMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveInscriptionMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveInscriptionMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
    ResolveInscriptionMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveInscriptionMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveInscriptionMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveInscriptionMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveInscriptionMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveInscriptionMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveInscriptionMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveInscriptionMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveInscriptionMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveInscriptionMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveInscriptionMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveInscriptionMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveInscriptionMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveInscriptionMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveInscriptionMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveInscriptionMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveInscriptionMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveInscriptionMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveInscriptionMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveInscriptionMethod "getMinChars" o = InscriptionGetMinCharsMethodInfo
    ResolveInscriptionMethod "getMinLines" o = InscriptionGetMinLinesMethodInfo
    ResolveInscriptionMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveInscriptionMethod "getNatChars" o = InscriptionGetNatCharsMethodInfo
    ResolveInscriptionMethod "getNatLines" o = InscriptionGetNatLinesMethodInfo
    ResolveInscriptionMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveInscriptionMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
    ResolveInscriptionMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveInscriptionMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveInscriptionMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveInscriptionMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveInscriptionMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveInscriptionMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
    ResolveInscriptionMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveInscriptionMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveInscriptionMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveInscriptionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveInscriptionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveInscriptionMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveInscriptionMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveInscriptionMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveInscriptionMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveInscriptionMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveInscriptionMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveInscriptionMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveInscriptionMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveInscriptionMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveInscriptionMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveInscriptionMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveInscriptionMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveInscriptionMethod "getText" o = InscriptionGetTextMethodInfo
    ResolveInscriptionMethod "getTextOverflow" o = InscriptionGetTextOverflowMethodInfo
    ResolveInscriptionMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveInscriptionMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveInscriptionMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveInscriptionMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveInscriptionMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveInscriptionMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveInscriptionMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveInscriptionMethod "getWrapMode" o = InscriptionGetWrapModeMethodInfo
    ResolveInscriptionMethod "getXalign" o = InscriptionGetXalignMethodInfo
    ResolveInscriptionMethod "getYalign" o = InscriptionGetYalignMethodInfo
    ResolveInscriptionMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
    ResolveInscriptionMethod "setAttributes" o = InscriptionSetAttributesMethodInfo
    ResolveInscriptionMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveInscriptionMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveInscriptionMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveInscriptionMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveInscriptionMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveInscriptionMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveInscriptionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveInscriptionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveInscriptionMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveInscriptionMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveInscriptionMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveInscriptionMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveInscriptionMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveInscriptionMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveInscriptionMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveInscriptionMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveInscriptionMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveInscriptionMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveInscriptionMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveInscriptionMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveInscriptionMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveInscriptionMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveInscriptionMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveInscriptionMethod "setMarkup" o = InscriptionSetMarkupMethodInfo
    ResolveInscriptionMethod "setMinChars" o = InscriptionSetMinCharsMethodInfo
    ResolveInscriptionMethod "setMinLines" o = InscriptionSetMinLinesMethodInfo
    ResolveInscriptionMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveInscriptionMethod "setNatChars" o = InscriptionSetNatCharsMethodInfo
    ResolveInscriptionMethod "setNatLines" o = InscriptionSetNatLinesMethodInfo
    ResolveInscriptionMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveInscriptionMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveInscriptionMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveInscriptionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveInscriptionMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveInscriptionMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveInscriptionMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveInscriptionMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveInscriptionMethod "setText" o = InscriptionSetTextMethodInfo
    ResolveInscriptionMethod "setTextOverflow" o = InscriptionSetTextOverflowMethodInfo
    ResolveInscriptionMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveInscriptionMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveInscriptionMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveInscriptionMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveInscriptionMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveInscriptionMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveInscriptionMethod "setWrapMode" o = InscriptionSetWrapModeMethodInfo
    ResolveInscriptionMethod "setXalign" o = InscriptionSetXalignMethodInfo
    ResolveInscriptionMethod "setYalign" o = InscriptionSetYalignMethodInfo
    ResolveInscriptionMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveInscriptionMethod t Inscription, O.OverloadedMethod info Inscription p) => OL.IsLabel t (Inscription -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveInscriptionMethod t Inscription, O.OverloadedMethod info Inscription p, R.HasField t Inscription p) => R.HasField t Inscription p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveInscriptionMethod t Inscription, O.OverloadedMethodInfo info Inscription) => OL.IsLabel t (O.MethodProxy info Inscription) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

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

-- | Get the value of the “@attributes@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #attributes
-- @
getInscriptionAttributes :: (MonadIO m, IsInscription o) => o -> m (Maybe Pango.AttrList.AttrList)
getInscriptionAttributes :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m (Maybe AttrList)
getInscriptionAttributes o
obj = IO (Maybe AttrList) -> m (Maybe AttrList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe AttrList) -> m (Maybe AttrList))
-> IO (Maybe AttrList) -> m (Maybe AttrList)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr AttrList -> AttrList)
-> IO (Maybe AttrList)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"attributes" ManagedPtr AttrList -> AttrList
Pango.AttrList.AttrList

-- | Set the value of the “@attributes@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #attributes 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionAttributes :: (MonadIO m, IsInscription o) => o -> Pango.AttrList.AttrList -> m ()
setInscriptionAttributes :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> AttrList -> m ()
setInscriptionAttributes o
obj AttrList
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe AttrList -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"attributes" (AttrList -> Maybe AttrList
forall a. a -> Maybe a
Just AttrList
val)

-- | Construct a `GValueConstruct` with valid value for the “@attributes@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionAttributes :: (IsInscription o, MIO.MonadIO m) => Pango.AttrList.AttrList -> m (GValueConstruct o)
constructInscriptionAttributes :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
AttrList -> m (GValueConstruct o)
constructInscriptionAttributes AttrList
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe AttrList -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"attributes" (AttrList -> Maybe AttrList
forall a. a -> Maybe a
P.Just AttrList
val)

-- | Set the value of the “@attributes@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #attributes
-- @
clearInscriptionAttributes :: (MonadIO m, IsInscription o) => o -> m ()
clearInscriptionAttributes :: forall (m :: * -> *) o. (MonadIO m, IsInscription o) => o -> m ()
clearInscriptionAttributes o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe AttrList -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"attributes" (Maybe AttrList
forall a. Maybe a
Nothing :: Maybe Pango.AttrList.AttrList)

#if defined(ENABLE_OVERLOADING)
data InscriptionAttributesPropertyInfo
instance AttrInfo InscriptionAttributesPropertyInfo where
    type AttrAllowedOps InscriptionAttributesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint InscriptionAttributesPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionAttributesPropertyInfo = (~) Pango.AttrList.AttrList
    type AttrTransferTypeConstraint InscriptionAttributesPropertyInfo = (~) Pango.AttrList.AttrList
    type AttrTransferType InscriptionAttributesPropertyInfo = Pango.AttrList.AttrList
    type AttrGetType InscriptionAttributesPropertyInfo = (Maybe Pango.AttrList.AttrList)
    type AttrLabel InscriptionAttributesPropertyInfo = "attributes"
    type AttrOrigin InscriptionAttributesPropertyInfo = Inscription
    attrGet = getInscriptionAttributes
    attrSet = setInscriptionAttributes
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionAttributes
    attrClear = clearInscriptionAttributes
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.attributes"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:attributes"
        })
#endif

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

-- | Set the value of the “@markup@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #markup 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionMarkup :: (MonadIO m, IsInscription o) => o -> T.Text -> m ()
setInscriptionMarkup :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> Text -> m ()
setInscriptionMarkup o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"markup" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@markup@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionMarkup :: (IsInscription o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructInscriptionMarkup :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructInscriptionMarkup Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"markup" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@markup@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #markup
-- @
clearInscriptionMarkup :: (MonadIO m, IsInscription o) => o -> m ()
clearInscriptionMarkup :: forall (m :: * -> *) o. (MonadIO m, IsInscription o) => o -> m ()
clearInscriptionMarkup o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"markup" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data InscriptionMarkupPropertyInfo
instance AttrInfo InscriptionMarkupPropertyInfo where
    type AttrAllowedOps InscriptionMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrClear]
    type AttrBaseTypeConstraint InscriptionMarkupPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionMarkupPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint InscriptionMarkupPropertyInfo = (~) T.Text
    type AttrTransferType InscriptionMarkupPropertyInfo = T.Text
    type AttrGetType InscriptionMarkupPropertyInfo = ()
    type AttrLabel InscriptionMarkupPropertyInfo = "markup"
    type AttrOrigin InscriptionMarkupPropertyInfo = Inscription
    attrGet = undefined
    attrSet = setInscriptionMarkup
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionMarkup
    attrClear = clearInscriptionMarkup
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.markup"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:markup"
        })
#endif

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

-- | Get the value of the “@min-chars@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #minChars
-- @
getInscriptionMinChars :: (MonadIO m, IsInscription o) => o -> m Word32
getInscriptionMinChars :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m Word32
getInscriptionMinChars o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"min-chars"

-- | Set the value of the “@min-chars@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #minChars 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionMinChars :: (MonadIO m, IsInscription o) => o -> Word32 -> m ()
setInscriptionMinChars :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> Word32 -> m ()
setInscriptionMinChars o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"min-chars" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@min-chars@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionMinChars :: (IsInscription o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructInscriptionMinChars :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructInscriptionMinChars Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"min-chars" Word32
val

#if defined(ENABLE_OVERLOADING)
data InscriptionMinCharsPropertyInfo
instance AttrInfo InscriptionMinCharsPropertyInfo where
    type AttrAllowedOps InscriptionMinCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint InscriptionMinCharsPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionMinCharsPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint InscriptionMinCharsPropertyInfo = (~) Word32
    type AttrTransferType InscriptionMinCharsPropertyInfo = Word32
    type AttrGetType InscriptionMinCharsPropertyInfo = Word32
    type AttrLabel InscriptionMinCharsPropertyInfo = "min-chars"
    type AttrOrigin InscriptionMinCharsPropertyInfo = Inscription
    attrGet = getInscriptionMinChars
    attrSet = setInscriptionMinChars
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionMinChars
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.minChars"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:minChars"
        })
#endif

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

-- | Get the value of the “@min-lines@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #minLines
-- @
getInscriptionMinLines :: (MonadIO m, IsInscription o) => o -> m Word32
getInscriptionMinLines :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m Word32
getInscriptionMinLines o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"min-lines"

-- | Set the value of the “@min-lines@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #minLines 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionMinLines :: (MonadIO m, IsInscription o) => o -> Word32 -> m ()
setInscriptionMinLines :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> Word32 -> m ()
setInscriptionMinLines o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"min-lines" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@min-lines@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionMinLines :: (IsInscription o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructInscriptionMinLines :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructInscriptionMinLines Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"min-lines" Word32
val

#if defined(ENABLE_OVERLOADING)
data InscriptionMinLinesPropertyInfo
instance AttrInfo InscriptionMinLinesPropertyInfo where
    type AttrAllowedOps InscriptionMinLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint InscriptionMinLinesPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionMinLinesPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint InscriptionMinLinesPropertyInfo = (~) Word32
    type AttrTransferType InscriptionMinLinesPropertyInfo = Word32
    type AttrGetType InscriptionMinLinesPropertyInfo = Word32
    type AttrLabel InscriptionMinLinesPropertyInfo = "min-lines"
    type AttrOrigin InscriptionMinLinesPropertyInfo = Inscription
    attrGet = getInscriptionMinLines
    attrSet = setInscriptionMinLines
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionMinLines
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.minLines"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:minLines"
        })
#endif

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

-- | Get the value of the “@nat-chars@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #natChars
-- @
getInscriptionNatChars :: (MonadIO m, IsInscription o) => o -> m Word32
getInscriptionNatChars :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m Word32
getInscriptionNatChars o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"nat-chars"

-- | Set the value of the “@nat-chars@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #natChars 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionNatChars :: (MonadIO m, IsInscription o) => o -> Word32 -> m ()
setInscriptionNatChars :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> Word32 -> m ()
setInscriptionNatChars o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"nat-chars" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@nat-chars@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionNatChars :: (IsInscription o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructInscriptionNatChars :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructInscriptionNatChars Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"nat-chars" Word32
val

#if defined(ENABLE_OVERLOADING)
data InscriptionNatCharsPropertyInfo
instance AttrInfo InscriptionNatCharsPropertyInfo where
    type AttrAllowedOps InscriptionNatCharsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint InscriptionNatCharsPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionNatCharsPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint InscriptionNatCharsPropertyInfo = (~) Word32
    type AttrTransferType InscriptionNatCharsPropertyInfo = Word32
    type AttrGetType InscriptionNatCharsPropertyInfo = Word32
    type AttrLabel InscriptionNatCharsPropertyInfo = "nat-chars"
    type AttrOrigin InscriptionNatCharsPropertyInfo = Inscription
    attrGet = getInscriptionNatChars
    attrSet = setInscriptionNatChars
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionNatChars
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.natChars"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:natChars"
        })
#endif

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

-- | Get the value of the “@nat-lines@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #natLines
-- @
getInscriptionNatLines :: (MonadIO m, IsInscription o) => o -> m Word32
getInscriptionNatLines :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m Word32
getInscriptionNatLines o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"nat-lines"

-- | Set the value of the “@nat-lines@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #natLines 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionNatLines :: (MonadIO m, IsInscription o) => o -> Word32 -> m ()
setInscriptionNatLines :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> Word32 -> m ()
setInscriptionNatLines o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"nat-lines" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@nat-lines@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionNatLines :: (IsInscription o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructInscriptionNatLines :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructInscriptionNatLines Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"nat-lines" Word32
val

#if defined(ENABLE_OVERLOADING)
data InscriptionNatLinesPropertyInfo
instance AttrInfo InscriptionNatLinesPropertyInfo where
    type AttrAllowedOps InscriptionNatLinesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint InscriptionNatLinesPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionNatLinesPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint InscriptionNatLinesPropertyInfo = (~) Word32
    type AttrTransferType InscriptionNatLinesPropertyInfo = Word32
    type AttrGetType InscriptionNatLinesPropertyInfo = Word32
    type AttrLabel InscriptionNatLinesPropertyInfo = "nat-lines"
    type AttrOrigin InscriptionNatLinesPropertyInfo = Inscription
    attrGet = getInscriptionNatLines
    attrSet = setInscriptionNatLines
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionNatLines
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.natLines"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:natLines"
        })
#endif

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

-- | Get the value of the “@text@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #text
-- @
getInscriptionText :: (MonadIO m, IsInscription o) => o -> m (Maybe T.Text)
getInscriptionText :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m (Maybe Text)
getInscriptionText o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"text"

-- | Set the value of the “@text@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #text 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionText :: (MonadIO m, IsInscription o) => o -> T.Text -> m ()
setInscriptionText :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> Text -> m ()
setInscriptionText o
obj Text
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"text" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@text@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionText :: (IsInscription o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructInscriptionText :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructInscriptionText Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"text" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@text@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #text
-- @
clearInscriptionText :: (MonadIO m, IsInscription o) => o -> m ()
clearInscriptionText :: forall (m :: * -> *) o. (MonadIO m, IsInscription o) => o -> m ()
clearInscriptionText o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"text" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data InscriptionTextPropertyInfo
instance AttrInfo InscriptionTextPropertyInfo where
    type AttrAllowedOps InscriptionTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint InscriptionTextPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionTextPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint InscriptionTextPropertyInfo = (~) T.Text
    type AttrTransferType InscriptionTextPropertyInfo = T.Text
    type AttrGetType InscriptionTextPropertyInfo = (Maybe T.Text)
    type AttrLabel InscriptionTextPropertyInfo = "text"
    type AttrOrigin InscriptionTextPropertyInfo = Inscription
    attrGet = getInscriptionText
    attrSet = setInscriptionText
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionText
    attrClear = clearInscriptionText
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:text"
        })
#endif

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

-- | Get the value of the “@text-overflow@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #textOverflow
-- @
getInscriptionTextOverflow :: (MonadIO m, IsInscription o) => o -> m Gtk.Enums.InscriptionOverflow
getInscriptionTextOverflow :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m InscriptionOverflow
getInscriptionTextOverflow o
obj = IO InscriptionOverflow -> m InscriptionOverflow
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO InscriptionOverflow -> m InscriptionOverflow)
-> IO InscriptionOverflow -> m InscriptionOverflow
forall a b. (a -> b) -> a -> b
$ o -> String -> IO InscriptionOverflow
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"text-overflow"

-- | Set the value of the “@text-overflow@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #textOverflow 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionTextOverflow :: (MonadIO m, IsInscription o) => o -> Gtk.Enums.InscriptionOverflow -> m ()
setInscriptionTextOverflow :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> InscriptionOverflow -> m ()
setInscriptionTextOverflow o
obj InscriptionOverflow
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> InscriptionOverflow -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"text-overflow" InscriptionOverflow
val

-- | Construct a `GValueConstruct` with valid value for the “@text-overflow@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionTextOverflow :: (IsInscription o, MIO.MonadIO m) => Gtk.Enums.InscriptionOverflow -> m (GValueConstruct o)
constructInscriptionTextOverflow :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
InscriptionOverflow -> m (GValueConstruct o)
constructInscriptionTextOverflow InscriptionOverflow
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> InscriptionOverflow -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"text-overflow" InscriptionOverflow
val

#if defined(ENABLE_OVERLOADING)
data InscriptionTextOverflowPropertyInfo
instance AttrInfo InscriptionTextOverflowPropertyInfo where
    type AttrAllowedOps InscriptionTextOverflowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint InscriptionTextOverflowPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionTextOverflowPropertyInfo = (~) Gtk.Enums.InscriptionOverflow
    type AttrTransferTypeConstraint InscriptionTextOverflowPropertyInfo = (~) Gtk.Enums.InscriptionOverflow
    type AttrTransferType InscriptionTextOverflowPropertyInfo = Gtk.Enums.InscriptionOverflow
    type AttrGetType InscriptionTextOverflowPropertyInfo = Gtk.Enums.InscriptionOverflow
    type AttrLabel InscriptionTextOverflowPropertyInfo = "text-overflow"
    type AttrOrigin InscriptionTextOverflowPropertyInfo = Inscription
    attrGet = getInscriptionTextOverflow
    attrSet = setInscriptionTextOverflow
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionTextOverflow
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.textOverflow"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:textOverflow"
        })
#endif

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

-- | Get the value of the “@wrap-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #wrapMode
-- @
getInscriptionWrapMode :: (MonadIO m, IsInscription o) => o -> m Pango.Enums.WrapMode
getInscriptionWrapMode :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m WrapMode
getInscriptionWrapMode o
obj = IO WrapMode -> m WrapMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO WrapMode -> m WrapMode) -> IO WrapMode -> m WrapMode
forall a b. (a -> b) -> a -> b
$ o -> String -> IO WrapMode
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"wrap-mode"

-- | Set the value of the “@wrap-mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #wrapMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionWrapMode :: (MonadIO m, IsInscription o) => o -> Pango.Enums.WrapMode -> m ()
setInscriptionWrapMode :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> WrapMode -> m ()
setInscriptionWrapMode o
obj WrapMode
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> WrapMode -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"wrap-mode" WrapMode
val

-- | Construct a `GValueConstruct` with valid value for the “@wrap-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionWrapMode :: (IsInscription o, MIO.MonadIO m) => Pango.Enums.WrapMode -> m (GValueConstruct o)
constructInscriptionWrapMode :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
WrapMode -> m (GValueConstruct o)
constructInscriptionWrapMode WrapMode
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> WrapMode -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"wrap-mode" WrapMode
val

#if defined(ENABLE_OVERLOADING)
data InscriptionWrapModePropertyInfo
instance AttrInfo InscriptionWrapModePropertyInfo where
    type AttrAllowedOps InscriptionWrapModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint InscriptionWrapModePropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionWrapModePropertyInfo = (~) Pango.Enums.WrapMode
    type AttrTransferTypeConstraint InscriptionWrapModePropertyInfo = (~) Pango.Enums.WrapMode
    type AttrTransferType InscriptionWrapModePropertyInfo = Pango.Enums.WrapMode
    type AttrGetType InscriptionWrapModePropertyInfo = Pango.Enums.WrapMode
    type AttrLabel InscriptionWrapModePropertyInfo = "wrap-mode"
    type AttrOrigin InscriptionWrapModePropertyInfo = Inscription
    attrGet = getInscriptionWrapMode
    attrSet = setInscriptionWrapMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionWrapMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.wrapMode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:wrapMode"
        })
#endif

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

-- | Get the value of the “@xalign@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #xalign
-- @
getInscriptionXalign :: (MonadIO m, IsInscription o) => o -> m Float
getInscriptionXalign :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m Float
getInscriptionXalign o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"xalign"

-- | Set the value of the “@xalign@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #xalign 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionXalign :: (MonadIO m, IsInscription o) => o -> Float -> m ()
setInscriptionXalign :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> Float -> m ()
setInscriptionXalign o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"xalign" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@xalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionXalign :: (IsInscription o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructInscriptionXalign :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructInscriptionXalign Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"xalign" Float
val

#if defined(ENABLE_OVERLOADING)
data InscriptionXalignPropertyInfo
instance AttrInfo InscriptionXalignPropertyInfo where
    type AttrAllowedOps InscriptionXalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint InscriptionXalignPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionXalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint InscriptionXalignPropertyInfo = (~) Float
    type AttrTransferType InscriptionXalignPropertyInfo = Float
    type AttrGetType InscriptionXalignPropertyInfo = Float
    type AttrLabel InscriptionXalignPropertyInfo = "xalign"
    type AttrOrigin InscriptionXalignPropertyInfo = Inscription
    attrGet = getInscriptionXalign
    attrSet = setInscriptionXalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionXalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.xalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:xalign"
        })
#endif

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

-- | Get the value of the “@yalign@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inscription #yalign
-- @
getInscriptionYalign :: (MonadIO m, IsInscription o) => o -> m Float
getInscriptionYalign :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> m Float
getInscriptionYalign o
obj = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Float
forall a. GObject a => a -> String -> IO Float
B.Properties.getObjectPropertyFloat o
obj String
"yalign"

-- | Set the value of the “@yalign@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inscription [ #yalign 'Data.GI.Base.Attributes.:=' value ]
-- @
setInscriptionYalign :: (MonadIO m, IsInscription o) => o -> Float -> m ()
setInscriptionYalign :: forall (m :: * -> *) o.
(MonadIO m, IsInscription o) =>
o -> Float -> m ()
setInscriptionYalign o
obj Float
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Float -> IO ()
forall a. GObject a => a -> String -> Float -> IO ()
B.Properties.setObjectPropertyFloat o
obj String
"yalign" Float
val

-- | Construct a `GValueConstruct` with valid value for the “@yalign@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructInscriptionYalign :: (IsInscription o, MIO.MonadIO m) => Float -> m (GValueConstruct o)
constructInscriptionYalign :: forall o (m :: * -> *).
(IsInscription o, MonadIO m) =>
Float -> m (GValueConstruct o)
constructInscriptionYalign Float
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Float -> IO (GValueConstruct o)
forall o. String -> Float -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFloat String
"yalign" Float
val

#if defined(ENABLE_OVERLOADING)
data InscriptionYalignPropertyInfo
instance AttrInfo InscriptionYalignPropertyInfo where
    type AttrAllowedOps InscriptionYalignPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint InscriptionYalignPropertyInfo = IsInscription
    type AttrSetTypeConstraint InscriptionYalignPropertyInfo = (~) Float
    type AttrTransferTypeConstraint InscriptionYalignPropertyInfo = (~) Float
    type AttrTransferType InscriptionYalignPropertyInfo = Float
    type AttrGetType InscriptionYalignPropertyInfo = Float
    type AttrLabel InscriptionYalignPropertyInfo = "yalign"
    type AttrOrigin InscriptionYalignPropertyInfo = Inscription
    attrGet = getInscriptionYalign
    attrSet = setInscriptionYalign
    attrTransfer _ v = do
        return v
    attrConstruct = constructInscriptionYalign
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.yalign"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#g:attr:yalign"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Inscription
type instance O.AttributeList Inscription = InscriptionAttributeList
type InscriptionAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("attributes", InscriptionAttributesPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("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), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("markup", InscriptionMarkupPropertyInfo), '("minChars", InscriptionMinCharsPropertyInfo), '("minLines", InscriptionMinLinesPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("natChars", InscriptionNatCharsPropertyInfo), '("natLines", InscriptionNatLinesPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("text", InscriptionTextPropertyInfo), '("textOverflow", InscriptionTextOverflowPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("wrapMode", InscriptionWrapModePropertyInfo), '("xalign", InscriptionXalignPropertyInfo), '("yalign", InscriptionYalignPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
inscriptionAttributes :: AttrLabelProxy "attributes"
inscriptionAttributes = AttrLabelProxy

inscriptionMarkup :: AttrLabelProxy "markup"
inscriptionMarkup = AttrLabelProxy

inscriptionMinChars :: AttrLabelProxy "minChars"
inscriptionMinChars = AttrLabelProxy

inscriptionMinLines :: AttrLabelProxy "minLines"
inscriptionMinLines = AttrLabelProxy

inscriptionNatChars :: AttrLabelProxy "natChars"
inscriptionNatChars = AttrLabelProxy

inscriptionNatLines :: AttrLabelProxy "natLines"
inscriptionNatLines = AttrLabelProxy

inscriptionText :: AttrLabelProxy "text"
inscriptionText = AttrLabelProxy

inscriptionTextOverflow :: AttrLabelProxy "textOverflow"
inscriptionTextOverflow = AttrLabelProxy

inscriptionWrapMode :: AttrLabelProxy "wrapMode"
inscriptionWrapMode = AttrLabelProxy

inscriptionXalign :: AttrLabelProxy "xalign"
inscriptionXalign = AttrLabelProxy

inscriptionYalign :: AttrLabelProxy "yalign"
inscriptionYalign = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Inscription = InscriptionSignalList
type InscriptionSignalList = ('[ '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "gtk_inscription_new" gtk_inscription_new :: 
    CString ->                              -- text : TBasicType TUTF8
    IO (Ptr Inscription)

-- | Creates a new @GtkInscription@ with the given text.
-- 
-- /Since: 4.8/
inscriptionNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    -- ^ /@text@/: The text to display.
    -> m Inscription
    -- ^ __Returns:__ a new @GtkInscription@
inscriptionNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m Inscription
inscriptionNew Maybe Text
text = IO Inscription -> m Inscription
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Inscription -> m Inscription)
-> IO Inscription -> m Inscription
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
maybeText <- case Maybe Text
text of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jText -> do
            Ptr CChar
jText' <- Text -> IO (Ptr CChar)
textToCString Text
jText
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jText'
    Ptr Inscription
result <- Ptr CChar -> IO (Ptr Inscription)
gtk_inscription_new Ptr CChar
maybeText
    Text -> Ptr Inscription -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"inscriptionNew" Ptr Inscription
result
    Inscription
result' <- ((ManagedPtr Inscription -> Inscription)
-> Ptr Inscription -> IO Inscription
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Inscription -> Inscription
Inscription) Ptr Inscription
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeText
    Inscription -> IO Inscription
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Inscription
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Inscription::get_attributes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_attributes" gtk_inscription_get_attributes :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO (Ptr Pango.AttrList.AttrList)

-- | Gets the inscription\'s attribute list.
-- 
-- /Since: 4.8/
inscriptionGetAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m (Maybe Pango.AttrList.AttrList)
    -- ^ __Returns:__ the attribute list
inscriptionGetAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m (Maybe AttrList)
inscriptionGetAttributes a
self = IO (Maybe AttrList) -> m (Maybe AttrList)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe AttrList) -> m (Maybe AttrList))
-> IO (Maybe AttrList) -> m (Maybe AttrList)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AttrList
result <- Ptr Inscription -> IO (Ptr AttrList)
gtk_inscription_get_attributes Ptr Inscription
self'
    Maybe AttrList
maybeResult <- Ptr AttrList
-> (Ptr AttrList -> IO AttrList) -> IO (Maybe AttrList)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr AttrList
result ((Ptr AttrList -> IO AttrList) -> IO (Maybe AttrList))
-> (Ptr AttrList -> IO AttrList) -> IO (Maybe AttrList)
forall a b. (a -> b) -> a -> b
$ \Ptr AttrList
result' -> do
        AttrList
result'' <- ((ManagedPtr AttrList -> AttrList) -> Ptr AttrList -> IO AttrList
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr AttrList -> AttrList
Pango.AttrList.AttrList) Ptr AttrList
result'
        AttrList -> IO AttrList
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return AttrList
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe AttrList -> IO (Maybe AttrList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AttrList
maybeResult

#if defined(ENABLE_OVERLOADING)
data InscriptionGetAttributesMethodInfo
instance (signature ~ (m (Maybe Pango.AttrList.AttrList)), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetAttributesMethodInfo a signature where
    overloadedMethod = inscriptionGetAttributes

instance O.OverloadedMethodInfo InscriptionGetAttributesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetAttributes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetAttributes"
        })


#endif

-- method Inscription::get_min_chars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_min_chars" gtk_inscription_get_min_chars :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO Word32

-- | Gets the @min-chars@ of the inscription.
-- 
-- See the [Inscription:minChars]("GI.Gtk.Objects.Inscription#g:attr:minChars") property.
-- 
-- /Since: 4.8/
inscriptionGetMinChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m Word32
    -- ^ __Returns:__ the min-chars property
inscriptionGetMinChars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m Word32
inscriptionGetMinChars a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Inscription -> IO Word32
gtk_inscription_get_min_chars Ptr Inscription
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data InscriptionGetMinCharsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetMinCharsMethodInfo a signature where
    overloadedMethod = inscriptionGetMinChars

instance O.OverloadedMethodInfo InscriptionGetMinCharsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetMinChars",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetMinChars"
        })


#endif

-- method Inscription::get_min_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_min_lines" gtk_inscription_get_min_lines :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO Word32

-- | Gets the @min-lines@ of the inscription.
-- 
-- See the [Inscription:minLines]("GI.Gtk.Objects.Inscription#g:attr:minLines") property.
-- 
-- /Since: 4.8/
inscriptionGetMinLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m Word32
    -- ^ __Returns:__ the min-lines property
inscriptionGetMinLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m Word32
inscriptionGetMinLines a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Inscription -> IO Word32
gtk_inscription_get_min_lines Ptr Inscription
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data InscriptionGetMinLinesMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetMinLinesMethodInfo a signature where
    overloadedMethod = inscriptionGetMinLines

instance O.OverloadedMethodInfo InscriptionGetMinLinesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetMinLines",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetMinLines"
        })


#endif

-- method Inscription::get_nat_chars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_nat_chars" gtk_inscription_get_nat_chars :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO Word32

-- | Gets the @nat-chars@ of the inscription.
-- 
-- See the [Inscription:natChars]("GI.Gtk.Objects.Inscription#g:attr:natChars") property.
-- 
-- /Since: 4.8/
inscriptionGetNatChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m Word32
    -- ^ __Returns:__ the nat-chars property
inscriptionGetNatChars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m Word32
inscriptionGetNatChars a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Inscription -> IO Word32
gtk_inscription_get_nat_chars Ptr Inscription
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data InscriptionGetNatCharsMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetNatCharsMethodInfo a signature where
    overloadedMethod = inscriptionGetNatChars

instance O.OverloadedMethodInfo InscriptionGetNatCharsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetNatChars",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetNatChars"
        })


#endif

-- method Inscription::get_nat_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_nat_lines" gtk_inscription_get_nat_lines :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO Word32

-- | Gets the @nat-lines@ of the inscription.
-- 
-- See the [Inscription:natLines]("GI.Gtk.Objects.Inscription#g:attr:natLines") property.
-- 
-- /Since: 4.8/
inscriptionGetNatLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m Word32
    -- ^ __Returns:__ the nat-lines property
inscriptionGetNatLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m Word32
inscriptionGetNatLines a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr Inscription -> IO Word32
gtk_inscription_get_nat_lines Ptr Inscription
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data InscriptionGetNatLinesMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetNatLinesMethodInfo a signature where
    overloadedMethod = inscriptionGetNatLines

instance O.OverloadedMethodInfo InscriptionGetNatLinesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetNatLines",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetNatLines"
        })


#endif

-- method Inscription::get_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_text" gtk_inscription_get_text :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO CString

-- | Gets the text that is displayed.
-- 
-- /Since: 4.8/
inscriptionGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m (Maybe T.Text)
    -- ^ __Returns:__ The displayed text
inscriptionGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m (Maybe Text)
inscriptionGetText a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CChar
result <- Ptr Inscription -> IO (Ptr CChar)
gtk_inscription_get_text Ptr Inscription
self'
    Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
        Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data InscriptionGetTextMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetTextMethodInfo a signature where
    overloadedMethod = inscriptionGetText

instance O.OverloadedMethodInfo InscriptionGetTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetText"
        })


#endif

-- method Inscription::get_text_overflow
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Gtk" , name = "InscriptionOverflow" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_inscription_get_text_overflow" gtk_inscription_get_text_overflow :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO CUInt

-- | Gets the inscription\'s overflow method.
-- 
-- /Since: 4.8/
inscriptionGetTextOverflow ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m Gtk.Enums.InscriptionOverflow
    -- ^ __Returns:__ the overflow method
inscriptionGetTextOverflow :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m InscriptionOverflow
inscriptionGetTextOverflow a
self = IO InscriptionOverflow -> m InscriptionOverflow
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InscriptionOverflow -> m InscriptionOverflow)
-> IO InscriptionOverflow -> m InscriptionOverflow
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Inscription -> IO CUInt
gtk_inscription_get_text_overflow Ptr Inscription
self'
    let result' :: InscriptionOverflow
result' = (Int -> InscriptionOverflow
forall a. Enum a => Int -> a
toEnum (Int -> InscriptionOverflow)
-> (CUInt -> Int) -> CUInt -> InscriptionOverflow
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    InscriptionOverflow -> IO InscriptionOverflow
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InscriptionOverflow
result'

#if defined(ENABLE_OVERLOADING)
data InscriptionGetTextOverflowMethodInfo
instance (signature ~ (m Gtk.Enums.InscriptionOverflow), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetTextOverflowMethodInfo a signature where
    overloadedMethod = inscriptionGetTextOverflow

instance O.OverloadedMethodInfo InscriptionGetTextOverflowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetTextOverflow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetTextOverflow"
        })


#endif

-- method Inscription::get_wrap_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_wrap_mode" gtk_inscription_get_wrap_mode :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO CUInt

-- | Returns line wrap mode used by the inscription.
-- 
-- See 'GI.Gtk.Objects.Inscription.inscriptionSetWrapMode'.
-- 
-- /Since: 4.8/
inscriptionGetWrapMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m Pango.Enums.WrapMode
    -- ^ __Returns:__ the line wrap mode
inscriptionGetWrapMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m WrapMode
inscriptionGetWrapMode a
self = IO WrapMode -> m WrapMode
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WrapMode -> m WrapMode) -> IO WrapMode -> m WrapMode
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr Inscription -> IO CUInt
gtk_inscription_get_wrap_mode Ptr Inscription
self'
    let result' :: WrapMode
result' = (Int -> WrapMode
forall a. Enum a => Int -> a
toEnum (Int -> WrapMode) -> (CUInt -> Int) -> CUInt -> WrapMode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    WrapMode -> IO WrapMode
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return WrapMode
result'

#if defined(ENABLE_OVERLOADING)
data InscriptionGetWrapModeMethodInfo
instance (signature ~ (m Pango.Enums.WrapMode), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetWrapModeMethodInfo a signature where
    overloadedMethod = inscriptionGetWrapMode

instance O.OverloadedMethodInfo InscriptionGetWrapModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetWrapMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetWrapMode"
        })


#endif

-- method Inscription::get_xalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_xalign" gtk_inscription_get_xalign :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO CFloat

-- | Gets the @xalign@ of the inscription.
-- 
-- See the [Inscription:xalign]("GI.Gtk.Objects.Inscription#g:attr:xalign") property.
-- 
-- /Since: 4.8/
inscriptionGetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m Float
    -- ^ __Returns:__ the xalign property
inscriptionGetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m Float
inscriptionGetXalign a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Inscription -> IO CFloat
gtk_inscription_get_xalign Ptr Inscription
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data InscriptionGetXalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetXalignMethodInfo a signature where
    overloadedMethod = inscriptionGetXalign

instance O.OverloadedMethodInfo InscriptionGetXalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetXalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetXalign"
        })


#endif

-- method Inscription::get_yalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_get_yalign" gtk_inscription_get_yalign :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    IO CFloat

-- | Gets the @yalign@ of the inscription.
-- 
-- See the [Inscription:yalign]("GI.Gtk.Objects.Inscription#g:attr:yalign") property.
-- 
-- /Since: 4.8/
inscriptionGetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> m Float
    -- ^ __Returns:__ the yalign property
inscriptionGetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> m Float
inscriptionGetYalign a
self = IO Float -> m Float
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CFloat
result <- Ptr Inscription -> IO CFloat
gtk_inscription_get_yalign Ptr Inscription
self'
    let result' :: Float
result' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Float -> IO Float
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Float
result'

#if defined(ENABLE_OVERLOADING)
data InscriptionGetYalignMethodInfo
instance (signature ~ (m Float), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionGetYalignMethodInfo a signature where
    overloadedMethod = inscriptionGetYalign

instance O.OverloadedMethodInfo InscriptionGetYalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionGetYalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionGetYalign"
        })


#endif

-- method Inscription::set_attributes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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 [struct@Pango.AttrList]"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_inscription_set_attributes" gtk_inscription_set_attributes :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    Ptr Pango.AttrList.AttrList ->          -- attrs : TInterface (Name {namespace = "Pango", name = "AttrList"})
    IO ()

-- | Apply attributes to the inscription text.
-- 
-- These attributes will not be evaluated for sizing the inscription.
-- 
-- /Since: 4.8/
inscriptionSetAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Maybe (Pango.AttrList.AttrList)
    -- ^ /@attrs@/: a [struct/@pango@/.AttrList]
    -> m ()
inscriptionSetAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> Maybe AttrList -> m ()
inscriptionSetAttributes a
self Maybe AttrList
attrs = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr AttrList
maybeAttrs <- case Maybe AttrList
attrs of
        Maybe AttrList
Nothing -> Ptr AttrList -> IO (Ptr AttrList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AttrList
forall a. Ptr a
nullPtr
        Just AttrList
jAttrs -> do
            Ptr AttrList
jAttrs' <- AttrList -> IO (Ptr AttrList)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AttrList
jAttrs
            Ptr AttrList -> IO (Ptr AttrList)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr AttrList
jAttrs'
    Ptr Inscription -> Ptr AttrList -> IO ()
gtk_inscription_set_attributes Ptr Inscription
self' Ptr AttrList
maybeAttrs
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe AttrList -> (AttrList -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe AttrList
attrs AttrList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetAttributesMethodInfo
instance (signature ~ (Maybe (Pango.AttrList.AttrList) -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetAttributesMethodInfo a signature where
    overloadedMethod = inscriptionSetAttributes

instance O.OverloadedMethodInfo InscriptionSetAttributesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetAttributes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetAttributes"
        })


#endif

-- method Inscription::set_markup
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "markup"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The markup to display"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_inscription_set_markup" gtk_inscription_set_markup :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    CString ->                              -- markup : TBasicType TUTF8
    IO ()

-- | Utility function to set the text and attributes to be displayed.
-- 
-- See the [Inscription:markup]("GI.Gtk.Objects.Inscription#g:attr:markup") property.
-- 
-- /Since: 4.8/
inscriptionSetMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Maybe (T.Text)
    -- ^ /@markup@/: The markup to display
    -> m ()
inscriptionSetMarkup :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> Maybe Text -> m ()
inscriptionSetMarkup a
self Maybe Text
markup = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CChar
maybeMarkup <- case Maybe Text
markup of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jMarkup -> do
            Ptr CChar
jMarkup' <- Text -> IO (Ptr CChar)
textToCString Text
jMarkup
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jMarkup'
    Ptr Inscription -> Ptr CChar -> IO ()
gtk_inscription_set_markup Ptr Inscription
self' Ptr CChar
maybeMarkup
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeMarkup
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetMarkupMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetMarkupMethodInfo a signature where
    overloadedMethod = inscriptionSetMarkup

instance O.OverloadedMethodInfo InscriptionSetMarkupMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetMarkup",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetMarkup"
        })


#endif

-- method Inscription::set_min_chars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_chars"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the minimum number of characters that should fit, approximately"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_inscription_set_min_chars" gtk_inscription_set_min_chars :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    Word32 ->                               -- min_chars : TBasicType TUInt
    IO ()

-- | Sets the @min-chars@ of the inscription.
-- 
-- See the [Inscription:minChars]("GI.Gtk.Objects.Inscription#g:attr:minChars") property.
-- 
-- /Since: 4.8/
inscriptionSetMinChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Word32
    -- ^ /@minChars@/: the minimum number of characters that should fit, approximately
    -> m ()
inscriptionSetMinChars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> Word32 -> m ()
inscriptionSetMinChars a
self Word32
minChars = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Inscription -> Word32 -> IO ()
gtk_inscription_set_min_chars Ptr Inscription
self' Word32
minChars
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetMinCharsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetMinCharsMethodInfo a signature where
    overloadedMethod = inscriptionSetMinChars

instance O.OverloadedMethodInfo InscriptionSetMinCharsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetMinChars",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetMinChars"
        })


#endif

-- method Inscription::set_min_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "min_lines"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the minimum number of lines that should fit, approximately"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_inscription_set_min_lines" gtk_inscription_set_min_lines :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    Word32 ->                               -- min_lines : TBasicType TUInt
    IO ()

-- | Sets the @min-lines@ of the inscription.
-- 
-- See the [Inscription:minLines]("GI.Gtk.Objects.Inscription#g:attr:minLines") property.
-- 
-- /Since: 4.8/
inscriptionSetMinLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Word32
    -- ^ /@minLines@/: the minimum number of lines that should fit, approximately
    -> m ()
inscriptionSetMinLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> Word32 -> m ()
inscriptionSetMinLines a
self Word32
minLines = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Inscription -> Word32 -> IO ()
gtk_inscription_set_min_lines Ptr Inscription
self' Word32
minLines
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetMinLinesMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetMinLinesMethodInfo a signature where
    overloadedMethod = inscriptionSetMinLines

instance O.OverloadedMethodInfo InscriptionSetMinLinesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetMinLines",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetMinLines"
        })


#endif

-- method Inscription::set_nat_chars
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "nat_chars"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the number of characters that should ideally fit, approximately"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_inscription_set_nat_chars" gtk_inscription_set_nat_chars :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    Word32 ->                               -- nat_chars : TBasicType TUInt
    IO ()

-- | Sets the @nat-chars@ of the inscription.
-- 
-- See the [Inscription:natChars]("GI.Gtk.Objects.Inscription#g:attr:natChars") property.
-- 
-- /Since: 4.8/
inscriptionSetNatChars ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Word32
    -- ^ /@natChars@/: the number of characters that should ideally fit, approximately
    -> m ()
inscriptionSetNatChars :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> Word32 -> m ()
inscriptionSetNatChars a
self Word32
natChars = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Inscription -> Word32 -> IO ()
gtk_inscription_set_nat_chars Ptr Inscription
self' Word32
natChars
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetNatCharsMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetNatCharsMethodInfo a signature where
    overloadedMethod = inscriptionSetNatChars

instance O.OverloadedMethodInfo InscriptionSetNatCharsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetNatChars",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetNatChars"
        })


#endif

-- method Inscription::set_nat_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "nat_lines"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the number of lines that should ideally fit"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_inscription_set_nat_lines" gtk_inscription_set_nat_lines :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    Word32 ->                               -- nat_lines : TBasicType TUInt
    IO ()

-- | Sets the @nat-lines@ of the inscription.
-- 
-- See the [Inscription:natLines]("GI.Gtk.Objects.Inscription#g:attr:natLines") property.
-- 
-- /Since: 4.8/
inscriptionSetNatLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Word32
    -- ^ /@natLines@/: the number of lines that should ideally fit
    -> m ()
inscriptionSetNatLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> Word32 -> m ()
inscriptionSetNatLines a
self Word32
natLines = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Inscription -> Word32 -> IO ()
gtk_inscription_set_nat_lines Ptr Inscription
self' Word32
natLines
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetNatLinesMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetNatLinesMethodInfo a signature where
    overloadedMethod = inscriptionSetNatLines

instance O.OverloadedMethodInfo InscriptionSetNatLinesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetNatLines",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetNatLines"
        })


#endif

-- method Inscription::set_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The text to display"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_inscription_set_text" gtk_inscription_set_text :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    CString ->                              -- text : TBasicType TUTF8
    IO ()

-- | Sets the text to be displayed.
-- 
-- /Since: 4.8/
inscriptionSetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Maybe (T.Text)
    -- ^ /@text@/: The text to display
    -> m ()
inscriptionSetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> Maybe Text -> m ()
inscriptionSetText a
self Maybe Text
text = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr CChar
maybeText <- case Maybe Text
text of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jText -> do
            Ptr CChar
jText' <- Text -> IO (Ptr CChar)
textToCString Text
jText
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jText'
    Ptr Inscription -> Ptr CChar -> IO ()
gtk_inscription_set_text Ptr Inscription
self' Ptr CChar
maybeText
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeText
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetTextMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetTextMethodInfo a signature where
    overloadedMethod = inscriptionSetText

instance O.OverloadedMethodInfo InscriptionSetTextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetText"
        })


#endif

-- method Inscription::set_text_overflow
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "overflow"
--           , argType =
--               TInterface
--                 Name { namespace = "Gtk" , name = "InscriptionOverflow" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the overflow method to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_inscription_set_text_overflow" gtk_inscription_set_text_overflow :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    CUInt ->                                -- overflow : TInterface (Name {namespace = "Gtk", name = "InscriptionOverflow"})
    IO ()

-- | Sets what to do when the text doesn\'t fit.
-- 
-- /Since: 4.8/
inscriptionSetTextOverflow ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Gtk.Enums.InscriptionOverflow
    -- ^ /@overflow@/: the overflow method to use
    -> m ()
inscriptionSetTextOverflow :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> InscriptionOverflow -> m ()
inscriptionSetTextOverflow a
self InscriptionOverflow
overflow = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let overflow' :: CUInt
overflow' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (InscriptionOverflow -> Int) -> InscriptionOverflow -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InscriptionOverflow -> Int
forall a. Enum a => a -> Int
fromEnum) InscriptionOverflow
overflow
    Ptr Inscription -> CUInt -> IO ()
gtk_inscription_set_text_overflow Ptr Inscription
self' CUInt
overflow'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetTextOverflowMethodInfo
instance (signature ~ (Gtk.Enums.InscriptionOverflow -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetTextOverflowMethodInfo a signature where
    overloadedMethod = inscriptionSetTextOverflow

instance O.OverloadedMethodInfo InscriptionSetTextOverflowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetTextOverflow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetTextOverflow"
        })


#endif

-- method Inscription::set_wrap_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_set_wrap_mode" gtk_inscription_set_wrap_mode :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    CUInt ->                                -- wrap_mode : TInterface (Name {namespace = "Pango", name = "WrapMode"})
    IO ()

-- | Controls how line wrapping is done.
-- 
-- /Since: 4.8/
inscriptionSetWrapMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Pango.Enums.WrapMode
    -- ^ /@wrapMode@/: the line wrapping mode
    -> m ()
inscriptionSetWrapMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> WrapMode -> m ()
inscriptionSetWrapMode a
self WrapMode
wrapMode = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let wrapMode' :: CUInt
wrapMode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (WrapMode -> Int) -> WrapMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. WrapMode -> Int
forall a. Enum a => a -> Int
fromEnum) WrapMode
wrapMode
    Ptr Inscription -> CUInt -> IO ()
gtk_inscription_set_wrap_mode Ptr Inscription
self' CUInt
wrapMode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetWrapModeMethodInfo
instance (signature ~ (Pango.Enums.WrapMode -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetWrapModeMethodInfo a signature where
    overloadedMethod = inscriptionSetWrapMode

instance O.OverloadedMethodInfo InscriptionSetWrapModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetWrapMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetWrapMode"
        })


#endif

-- method Inscription::set_xalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_set_xalign" gtk_inscription_set_xalign :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    CFloat ->                               -- xalign : TBasicType TFloat
    IO ()

-- | Sets the @xalign@ of the inscription.
-- 
-- See the [Inscription:xalign]("GI.Gtk.Objects.Inscription#g:attr:xalign") property.
-- 
-- /Since: 4.8/
inscriptionSetXalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Float
    -- ^ /@xalign@/: the new xalign value, between 0 and 1
    -> m ()
inscriptionSetXalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> Float -> m ()
inscriptionSetXalign a
self Float
xalign = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let xalign' :: CFloat
xalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
xalign
    Ptr Inscription -> CFloat -> IO ()
gtk_inscription_set_xalign Ptr Inscription
self' CFloat
xalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetXalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetXalignMethodInfo a signature where
    overloadedMethod = inscriptionSetXalign

instance O.OverloadedMethodInfo InscriptionSetXalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetXalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetXalign"
        })


#endif

-- method Inscription::set_yalign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Inscription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkInscription`" , 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_inscription_set_yalign" gtk_inscription_set_yalign :: 
    Ptr Inscription ->                      -- self : TInterface (Name {namespace = "Gtk", name = "Inscription"})
    CFloat ->                               -- yalign : TBasicType TFloat
    IO ()

-- | Sets the @yalign@ of the inscription.
-- 
-- See the [Inscription:yalign]("GI.Gtk.Objects.Inscription#g:attr:yalign") property.
-- 
-- /Since: 4.8/
inscriptionSetYalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsInscription a) =>
    a
    -- ^ /@self@/: a @GtkInscription@
    -> Float
    -- ^ /@yalign@/: the new yalign value, between 0 and 1
    -> m ()
inscriptionSetYalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInscription a) =>
a -> Float -> m ()
inscriptionSetYalign a
self Float
yalign = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Inscription
self' <- a -> IO (Ptr Inscription)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let yalign' :: CFloat
yalign' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
yalign
    Ptr Inscription -> CFloat -> IO ()
gtk_inscription_set_yalign Ptr Inscription
self' CFloat
yalign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InscriptionSetYalignMethodInfo
instance (signature ~ (Float -> m ()), MonadIO m, IsInscription a) => O.OverloadedMethod InscriptionSetYalignMethodInfo a signature where
    overloadedMethod = inscriptionSetYalign

instance O.OverloadedMethodInfo InscriptionSetYalignMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.Inscription.inscriptionSetYalign",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-Inscription.html#v:inscriptionSetYalign"
        })


#endif