{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The @GtkFontDialogButton@ is wrapped around a t'GI.Gtk.Objects.FontDialog.FontDialog'
-- and allows to open a font chooser dialog to change the font.
-- 
-- <<https://docs.gtk.org/gtk4/font-button.png An example GtkFontDialogButton>>
-- 
-- It is suitable widget for selecting a font in a preference dialog.
-- 
-- = CSS nodes
-- 
-- >fontbutton
-- >╰── button.font
-- >    ╰── [content]
-- 
-- 
-- @GtkFontDialogButton@ has a single CSS node with name fontbutton which
-- contains a button node with the .font style class.
-- 
-- /Since: 4.10/

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

module GI.Gtk.Objects.FontDialogButton
    ( 

-- * Exported types
    FontDialogButton(..)                    ,
    IsFontDialogButton                      ,
    toFontDialogButton                      ,


 -- * 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"), [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"), [getDialog]("GI.Gtk.Objects.FontDialogButton#g:method:getDialog"), [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"), [getFontDesc]("GI.Gtk.Objects.FontDialogButton#g:method:getFontDesc"), [getFontFeatures]("GI.Gtk.Objects.FontDialogButton#g:method:getFontFeatures"), [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"), [getLanguage]("GI.Gtk.Objects.FontDialogButton#g:method:getLanguage"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLevel]("GI.Gtk.Objects.FontDialogButton#g:method:getLevel"), [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"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [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"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getUseFont]("GI.Gtk.Objects.FontDialogButton#g:method:getUseFont"), [getUseSize]("GI.Gtk.Objects.FontDialogButton#g:method:getUseSize"), [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").
-- 
-- ==== Setters
-- [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [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"), [setDialog]("GI.Gtk.Objects.FontDialogButton#g:method:setDialog"), [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"), [setFontDesc]("GI.Gtk.Objects.FontDialogButton#g:method:setFontDesc"), [setFontFeatures]("GI.Gtk.Objects.FontDialogButton#g:method:setFontFeatures"), [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"), [setLanguage]("GI.Gtk.Objects.FontDialogButton#g:method:setLanguage"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLevel]("GI.Gtk.Objects.FontDialogButton#g:method:setLevel"), [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"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [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"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setUseFont]("GI.Gtk.Objects.FontDialogButton#g:method:setUseFont"), [setUseSize]("GI.Gtk.Objects.FontDialogButton#g:method:setUseSize"), [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").

#if defined(ENABLE_OVERLOADING)
    ResolveFontDialogButtonMethod           ,
#endif

-- ** getDialog #method:getDialog#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonGetDialogMethodInfo     ,
#endif
    fontDialogButtonGetDialog               ,


-- ** getFontDesc #method:getFontDesc#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonGetFontDescMethodInfo   ,
#endif
    fontDialogButtonGetFontDesc             ,


-- ** getFontFeatures #method:getFontFeatures#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonGetFontFeaturesMethodInfo,
#endif
    fontDialogButtonGetFontFeatures         ,


-- ** getLanguage #method:getLanguage#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonGetLanguageMethodInfo   ,
#endif
    fontDialogButtonGetLanguage             ,


-- ** getLevel #method:getLevel#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonGetLevelMethodInfo      ,
#endif
    fontDialogButtonGetLevel                ,


-- ** getUseFont #method:getUseFont#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonGetUseFontMethodInfo    ,
#endif
    fontDialogButtonGetUseFont              ,


-- ** getUseSize #method:getUseSize#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonGetUseSizeMethodInfo    ,
#endif
    fontDialogButtonGetUseSize              ,


-- ** new #method:new#

    fontDialogButtonNew                     ,


-- ** setDialog #method:setDialog#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonSetDialogMethodInfo     ,
#endif
    fontDialogButtonSetDialog               ,


-- ** setFontDesc #method:setFontDesc#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonSetFontDescMethodInfo   ,
#endif
    fontDialogButtonSetFontDesc             ,


-- ** setFontFeatures #method:setFontFeatures#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonSetFontFeaturesMethodInfo,
#endif
    fontDialogButtonSetFontFeatures         ,


-- ** setLanguage #method:setLanguage#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonSetLanguageMethodInfo   ,
#endif
    fontDialogButtonSetLanguage             ,


-- ** setLevel #method:setLevel#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonSetLevelMethodInfo      ,
#endif
    fontDialogButtonSetLevel                ,


-- ** setUseFont #method:setUseFont#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonSetUseFontMethodInfo    ,
#endif
    fontDialogButtonSetUseFont              ,


-- ** setUseSize #method:setUseSize#

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonSetUseSizeMethodInfo    ,
#endif
    fontDialogButtonSetUseSize              ,




 -- * Properties


-- ** dialog #attr:dialog#
-- | The @GtkFontDialog@ that contains parameters for
-- the font chooser dialog.
-- 
-- /Since: 4.10/

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonDialogPropertyInfo      ,
#endif
    constructFontDialogButtonDialog         ,
#if defined(ENABLE_OVERLOADING)
    fontDialogButtonDialog                  ,
#endif
    getFontDialogButtonDialog               ,
    setFontDialogButtonDialog               ,


-- ** fontDesc #attr:fontDesc#
-- | The selected font.
-- 
-- This property can be set to give the button its initial
-- font, and it will be updated to reflect the users choice
-- in the font chooser dialog.
-- 
-- Listen to @notify::font-desc@ to get informed about changes
-- to the buttons font.
-- 
-- /Since: 4.10/

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonFontDescPropertyInfo    ,
#endif
    constructFontDialogButtonFontDesc       ,
#if defined(ENABLE_OVERLOADING)
    fontDialogButtonFontDesc                ,
#endif
    getFontDialogButtonFontDesc             ,
    setFontDialogButtonFontDesc             ,


-- ** fontFeatures #attr:fontFeatures#
-- | The selected font features.
-- 
-- This property will be updated to reflect the users choice
-- in the font chooser dialog.
-- 
-- Listen to @notify::font-features@ to get informed about changes
-- to the buttons font features.
-- 
-- /Since: 4.10/

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonFontFeaturesPropertyInfo,
#endif
    clearFontDialogButtonFontFeatures       ,
    constructFontDialogButtonFontFeatures   ,
#if defined(ENABLE_OVERLOADING)
    fontDialogButtonFontFeatures            ,
#endif
    getFontDialogButtonFontFeatures         ,
    setFontDialogButtonFontFeatures         ,


-- ** language #attr:language#
-- | The selected language for font features.
-- 
-- This property will be updated to reflect the users choice
-- in the font chooser dialog.
-- 
-- Listen to @notify::language@ to get informed about changes
-- to the buttons language.
-- 
-- /Since: 4.10/

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonLanguagePropertyInfo    ,
#endif
    clearFontDialogButtonLanguage           ,
    constructFontDialogButtonLanguage       ,
#if defined(ENABLE_OVERLOADING)
    fontDialogButtonLanguage                ,
#endif
    getFontDialogButtonLanguage             ,
    setFontDialogButtonLanguage             ,


-- ** level #attr:level#
-- | The level of detail for the font chooser dialog.

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonLevelPropertyInfo       ,
#endif
    constructFontDialogButtonLevel          ,
#if defined(ENABLE_OVERLOADING)
    fontDialogButtonLevel                   ,
#endif
    getFontDialogButtonLevel                ,
    setFontDialogButtonLevel                ,


-- ** useFont #attr:useFont#
-- | Whether the buttons label will be drawn in the selected font.

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonUseFontPropertyInfo     ,
#endif
    constructFontDialogButtonUseFont        ,
#if defined(ENABLE_OVERLOADING)
    fontDialogButtonUseFont                 ,
#endif
    getFontDialogButtonUseFont              ,
    setFontDialogButtonUseFont              ,


-- ** useSize #attr:useSize#
-- | Whether the buttons label will use the selected font size.

#if defined(ENABLE_OVERLOADING)
    FontDialogButtonUseSizePropertyInfo     ,
#endif
    constructFontDialogButtonUseSize        ,
#if defined(ENABLE_OVERLOADING)
    fontDialogButtonUseSize                 ,
#endif
    getFontDialogButtonUseSize              ,
    setFontDialogButtonUseSize              ,




    ) 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.FontDialog as Gtk.FontDialog
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
import qualified GI.Pango.Structs.Language as Pango.Language

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

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

foreign import ccall "gtk_font_dialog_button_get_type"
    c_gtk_font_dialog_button_get_type :: IO B.Types.GType

instance B.Types.TypedObject FontDialogButton where
    glibType :: IO GType
glibType = IO GType
c_gtk_font_dialog_button_get_type

instance B.Types.GObject FontDialogButton

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

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

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

-- | Convert 'FontDialogButton' 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 FontDialogButton) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_font_dialog_button_get_type
    gvalueSet_ :: Ptr GValue -> Maybe FontDialogButton -> IO ()
gvalueSet_ Ptr GValue
gv Maybe FontDialogButton
P.Nothing = Ptr GValue -> Ptr FontDialogButton -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr FontDialogButton
forall a. Ptr a
FP.nullPtr :: FP.Ptr FontDialogButton)
    gvalueSet_ Ptr GValue
gv (P.Just FontDialogButton
obj) = FontDialogButton -> (Ptr FontDialogButton -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr FontDialogButton
obj (Ptr GValue -> Ptr FontDialogButton -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe FontDialogButton)
gvalueGet_ Ptr GValue
gv = do
        Ptr FontDialogButton
ptr <- Ptr GValue -> IO (Ptr FontDialogButton)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr FontDialogButton)
        if Ptr FontDialogButton
ptr Ptr FontDialogButton -> Ptr FontDialogButton -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr FontDialogButton
forall a. Ptr a
FP.nullPtr
        then FontDialogButton -> Maybe FontDialogButton
forall a. a -> Maybe a
P.Just (FontDialogButton -> Maybe FontDialogButton)
-> IO FontDialogButton -> IO (Maybe FontDialogButton)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr FontDialogButton -> FontDialogButton)
-> Ptr FontDialogButton -> IO FontDialogButton
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr FontDialogButton -> FontDialogButton
FontDialogButton Ptr FontDialogButton
ptr
        else Maybe FontDialogButton -> IO (Maybe FontDialogButton)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FontDialogButton
forall a. Maybe a
P.Nothing
        
    

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

instance (info ~ ResolveFontDialogButtonMethod t FontDialogButton, O.OverloadedMethod info FontDialogButton p) => OL.IsLabel t (FontDialogButton -> 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 ~ ResolveFontDialogButtonMethod t FontDialogButton, O.OverloadedMethod info FontDialogButton p, R.HasField t FontDialogButton p) => R.HasField t FontDialogButton p where
    getField = O.overloadedMethod @info

#endif

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

#endif

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

-- | Get the value of the “@dialog@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fontDialogButton #dialog
-- @
getFontDialogButtonDialog :: (MonadIO m, IsFontDialogButton o) => o -> m (Maybe Gtk.FontDialog.FontDialog)
getFontDialogButtonDialog :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> m (Maybe FontDialog)
getFontDialogButtonDialog o
obj = IO (Maybe FontDialog) -> m (Maybe FontDialog)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe FontDialog) -> m (Maybe FontDialog))
-> IO (Maybe FontDialog) -> m (Maybe FontDialog)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr FontDialog -> FontDialog)
-> IO (Maybe FontDialog)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"dialog" ManagedPtr FontDialog -> FontDialog
Gtk.FontDialog.FontDialog

-- | Set the value of the “@dialog@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fontDialogButton [ #dialog 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontDialogButtonDialog :: (MonadIO m, IsFontDialogButton o, Gtk.FontDialog.IsFontDialog a) => o -> a -> m ()
setFontDialogButtonDialog :: forall (m :: * -> *) o a.
(MonadIO m, IsFontDialogButton o, IsFontDialog a) =>
o -> a -> m ()
setFontDialogButtonDialog o
obj a
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 a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"dialog" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@dialog@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFontDialogButtonDialog :: (IsFontDialogButton o, MIO.MonadIO m, Gtk.FontDialog.IsFontDialog a) => a -> m (GValueConstruct o)
constructFontDialogButtonDialog :: forall o (m :: * -> *) a.
(IsFontDialogButton o, MonadIO m, IsFontDialog a) =>
a -> m (GValueConstruct o)
constructFontDialogButtonDialog a
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 a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"dialog" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonDialogPropertyInfo
instance AttrInfo FontDialogButtonDialogPropertyInfo where
    type AttrAllowedOps FontDialogButtonDialogPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FontDialogButtonDialogPropertyInfo = IsFontDialogButton
    type AttrSetTypeConstraint FontDialogButtonDialogPropertyInfo = Gtk.FontDialog.IsFontDialog
    type AttrTransferTypeConstraint FontDialogButtonDialogPropertyInfo = Gtk.FontDialog.IsFontDialog
    type AttrTransferType FontDialogButtonDialogPropertyInfo = Gtk.FontDialog.FontDialog
    type AttrGetType FontDialogButtonDialogPropertyInfo = (Maybe Gtk.FontDialog.FontDialog)
    type AttrLabel FontDialogButtonDialogPropertyInfo = "dialog"
    type AttrOrigin FontDialogButtonDialogPropertyInfo = FontDialogButton
    attrGet = getFontDialogButtonDialog
    attrSet = setFontDialogButtonDialog
    attrTransfer _ v = do
        unsafeCastTo Gtk.FontDialog.FontDialog v
    attrConstruct = constructFontDialogButtonDialog
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontDialogButton.dialog"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-FontDialogButton.html#g:attr:dialog"
        })
#endif

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

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

-- | Set the value of the “@font-desc@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fontDialogButton [ #fontDesc 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontDialogButtonFontDesc :: (MonadIO m, IsFontDialogButton o) => o -> Pango.FontDescription.FontDescription -> m ()
setFontDialogButtonFontDesc :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> FontDescription -> m ()
setFontDialogButtonFontDesc o
obj FontDescription
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 FontDescription -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"font-desc" (FontDescription -> Maybe FontDescription
forall a. a -> Maybe a
Just FontDescription
val)

-- | Construct a `GValueConstruct` with valid value for the “@font-desc@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFontDialogButtonFontDesc :: (IsFontDialogButton o, MIO.MonadIO m) => Pango.FontDescription.FontDescription -> m (GValueConstruct o)
constructFontDialogButtonFontDesc :: forall o (m :: * -> *).
(IsFontDialogButton o, MonadIO m) =>
FontDescription -> m (GValueConstruct o)
constructFontDialogButtonFontDesc FontDescription
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 FontDescription -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"font-desc" (FontDescription -> Maybe FontDescription
forall a. a -> Maybe a
P.Just FontDescription
val)

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonFontDescPropertyInfo
instance AttrInfo FontDialogButtonFontDescPropertyInfo where
    type AttrAllowedOps FontDialogButtonFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FontDialogButtonFontDescPropertyInfo = IsFontDialogButton
    type AttrSetTypeConstraint FontDialogButtonFontDescPropertyInfo = (~) Pango.FontDescription.FontDescription
    type AttrTransferTypeConstraint FontDialogButtonFontDescPropertyInfo = (~) Pango.FontDescription.FontDescription
    type AttrTransferType FontDialogButtonFontDescPropertyInfo = Pango.FontDescription.FontDescription
    type AttrGetType FontDialogButtonFontDescPropertyInfo = (Maybe Pango.FontDescription.FontDescription)
    type AttrLabel FontDialogButtonFontDescPropertyInfo = "font-desc"
    type AttrOrigin FontDialogButtonFontDescPropertyInfo = FontDialogButton
    attrGet = getFontDialogButtonFontDesc
    attrSet = setFontDialogButtonFontDesc
    attrTransfer _ v = do
        return v
    attrConstruct = constructFontDialogButtonFontDesc
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontDialogButton.fontDesc"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-FontDialogButton.html#g:attr:fontDesc"
        })
#endif

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

-- | Get the value of the “@font-features@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fontDialogButton #fontFeatures
-- @
getFontDialogButtonFontFeatures :: (MonadIO m, IsFontDialogButton o) => o -> m (Maybe T.Text)
getFontDialogButtonFontFeatures :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> m (Maybe Text)
getFontDialogButtonFontFeatures 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
"font-features"

-- | Set the value of the “@font-features@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fontDialogButton [ #fontFeatures 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontDialogButtonFontFeatures :: (MonadIO m, IsFontDialogButton o) => o -> T.Text -> m ()
setFontDialogButtonFontFeatures :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> Text -> m ()
setFontDialogButtonFontFeatures 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
"font-features" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@font-features@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFontDialogButtonFontFeatures :: (IsFontDialogButton o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructFontDialogButtonFontFeatures :: forall o (m :: * -> *).
(IsFontDialogButton o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructFontDialogButtonFontFeatures 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
"font-features" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

-- | Set the value of the “@font-features@” 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' #fontFeatures
-- @
clearFontDialogButtonFontFeatures :: (MonadIO m, IsFontDialogButton o) => o -> m ()
clearFontDialogButtonFontFeatures :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> m ()
clearFontDialogButtonFontFeatures 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
"font-features" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonFontFeaturesPropertyInfo
instance AttrInfo FontDialogButtonFontFeaturesPropertyInfo where
    type AttrAllowedOps FontDialogButtonFontFeaturesPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint FontDialogButtonFontFeaturesPropertyInfo = IsFontDialogButton
    type AttrSetTypeConstraint FontDialogButtonFontFeaturesPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint FontDialogButtonFontFeaturesPropertyInfo = (~) T.Text
    type AttrTransferType FontDialogButtonFontFeaturesPropertyInfo = T.Text
    type AttrGetType FontDialogButtonFontFeaturesPropertyInfo = (Maybe T.Text)
    type AttrLabel FontDialogButtonFontFeaturesPropertyInfo = "font-features"
    type AttrOrigin FontDialogButtonFontFeaturesPropertyInfo = FontDialogButton
    attrGet = getFontDialogButtonFontFeatures
    attrSet = setFontDialogButtonFontFeatures
    attrTransfer _ v = do
        return v
    attrConstruct = constructFontDialogButtonFontFeatures
    attrClear = clearFontDialogButtonFontFeatures
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontDialogButton.fontFeatures"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-FontDialogButton.html#g:attr:fontFeatures"
        })
#endif

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

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

-- | Set the value of the “@language@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fontDialogButton [ #language 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontDialogButtonLanguage :: (MonadIO m, IsFontDialogButton o) => o -> Pango.Language.Language -> m ()
setFontDialogButtonLanguage :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> Language -> m ()
setFontDialogButtonLanguage o
obj Language
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 Language -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"language" (Language -> Maybe Language
forall a. a -> Maybe a
Just Language
val)

-- | Construct a `GValueConstruct` with valid value for the “@language@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFontDialogButtonLanguage :: (IsFontDialogButton o, MIO.MonadIO m) => Pango.Language.Language -> m (GValueConstruct o)
constructFontDialogButtonLanguage :: forall o (m :: * -> *).
(IsFontDialogButton o, MonadIO m) =>
Language -> m (GValueConstruct o)
constructFontDialogButtonLanguage Language
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 Language -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"language" (Language -> Maybe Language
forall a. a -> Maybe a
P.Just Language
val)

-- | Set the value of the “@language@” 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' #language
-- @
clearFontDialogButtonLanguage :: (MonadIO m, IsFontDialogButton o) => o -> m ()
clearFontDialogButtonLanguage :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> m ()
clearFontDialogButtonLanguage 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 Language -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"language" (Maybe Language
forall a. Maybe a
Nothing :: Maybe Pango.Language.Language)

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonLanguagePropertyInfo
instance AttrInfo FontDialogButtonLanguagePropertyInfo where
    type AttrAllowedOps FontDialogButtonLanguagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint FontDialogButtonLanguagePropertyInfo = IsFontDialogButton
    type AttrSetTypeConstraint FontDialogButtonLanguagePropertyInfo = (~) Pango.Language.Language
    type AttrTransferTypeConstraint FontDialogButtonLanguagePropertyInfo = (~) Pango.Language.Language
    type AttrTransferType FontDialogButtonLanguagePropertyInfo = Pango.Language.Language
    type AttrGetType FontDialogButtonLanguagePropertyInfo = (Maybe Pango.Language.Language)
    type AttrLabel FontDialogButtonLanguagePropertyInfo = "language"
    type AttrOrigin FontDialogButtonLanguagePropertyInfo = FontDialogButton
    attrGet = getFontDialogButtonLanguage
    attrSet = setFontDialogButtonLanguage
    attrTransfer _ v = do
        return v
    attrConstruct = constructFontDialogButtonLanguage
    attrClear = clearFontDialogButtonLanguage
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontDialogButton.language"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-FontDialogButton.html#g:attr:language"
        })
#endif

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

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

-- | Set the value of the “@level@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fontDialogButton [ #level 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontDialogButtonLevel :: (MonadIO m, IsFontDialogButton o) => o -> Gtk.Enums.FontLevel -> m ()
setFontDialogButtonLevel :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> FontLevel -> m ()
setFontDialogButtonLevel o
obj FontLevel
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 -> FontLevel -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"level" FontLevel
val

-- | Construct a `GValueConstruct` with valid value for the “@level@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFontDialogButtonLevel :: (IsFontDialogButton o, MIO.MonadIO m) => Gtk.Enums.FontLevel -> m (GValueConstruct o)
constructFontDialogButtonLevel :: forall o (m :: * -> *).
(IsFontDialogButton o, MonadIO m) =>
FontLevel -> m (GValueConstruct o)
constructFontDialogButtonLevel FontLevel
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 -> FontLevel -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"level" FontLevel
val

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

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

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

-- | Set the value of the “@use-font@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fontDialogButton [ #useFont 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontDialogButtonUseFont :: (MonadIO m, IsFontDialogButton o) => o -> Bool -> m ()
setFontDialogButtonUseFont :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> Bool -> m ()
setFontDialogButtonUseFont o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"use-font" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@use-font@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFontDialogButtonUseFont :: (IsFontDialogButton o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructFontDialogButtonUseFont :: forall o (m :: * -> *).
(IsFontDialogButton o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructFontDialogButtonUseFont Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"use-font" Bool
val

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonUseFontPropertyInfo
instance AttrInfo FontDialogButtonUseFontPropertyInfo where
    type AttrAllowedOps FontDialogButtonUseFontPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FontDialogButtonUseFontPropertyInfo = IsFontDialogButton
    type AttrSetTypeConstraint FontDialogButtonUseFontPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint FontDialogButtonUseFontPropertyInfo = (~) Bool
    type AttrTransferType FontDialogButtonUseFontPropertyInfo = Bool
    type AttrGetType FontDialogButtonUseFontPropertyInfo = Bool
    type AttrLabel FontDialogButtonUseFontPropertyInfo = "use-font"
    type AttrOrigin FontDialogButtonUseFontPropertyInfo = FontDialogButton
    attrGet = getFontDialogButtonUseFont
    attrSet = setFontDialogButtonUseFont
    attrTransfer _ v = do
        return v
    attrConstruct = constructFontDialogButtonUseFont
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontDialogButton.useFont"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-FontDialogButton.html#g:attr:useFont"
        })
#endif

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

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

-- | Set the value of the “@use-size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fontDialogButton [ #useSize 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontDialogButtonUseSize :: (MonadIO m, IsFontDialogButton o) => o -> Bool -> m ()
setFontDialogButtonUseSize :: forall (m :: * -> *) o.
(MonadIO m, IsFontDialogButton o) =>
o -> Bool -> m ()
setFontDialogButtonUseSize o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"use-size" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@use-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructFontDialogButtonUseSize :: (IsFontDialogButton o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructFontDialogButtonUseSize :: forall o (m :: * -> *).
(IsFontDialogButton o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructFontDialogButtonUseSize Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"use-size" Bool
val

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonUseSizePropertyInfo
instance AttrInfo FontDialogButtonUseSizePropertyInfo where
    type AttrAllowedOps FontDialogButtonUseSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FontDialogButtonUseSizePropertyInfo = IsFontDialogButton
    type AttrSetTypeConstraint FontDialogButtonUseSizePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint FontDialogButtonUseSizePropertyInfo = (~) Bool
    type AttrTransferType FontDialogButtonUseSizePropertyInfo = Bool
    type AttrGetType FontDialogButtonUseSizePropertyInfo = Bool
    type AttrLabel FontDialogButtonUseSizePropertyInfo = "use-size"
    type AttrOrigin FontDialogButtonUseSizePropertyInfo = FontDialogButton
    attrGet = getFontDialogButtonUseSize
    attrSet = setFontDialogButtonUseSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructFontDialogButtonUseSize
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontDialogButton.useSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.8/docs/GI-Gtk-Objects-FontDialogButton.html#g:attr:useSize"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FontDialogButton
type instance O.AttributeList FontDialogButton = FontDialogButtonAttributeList
type FontDialogButtonAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("dialog", FontDialogButtonDialogPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("fontDesc", FontDialogButtonFontDescPropertyInfo), '("fontFeatures", FontDialogButtonFontFeaturesPropertyInfo), '("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), '("language", FontDialogButtonLanguagePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("level", FontDialogButtonLevelPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("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), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useFont", FontDialogButtonUseFontPropertyInfo), '("useSize", FontDialogButtonUseSizePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
fontDialogButtonDialog :: AttrLabelProxy "dialog"
fontDialogButtonDialog = AttrLabelProxy

fontDialogButtonFontDesc :: AttrLabelProxy "fontDesc"
fontDialogButtonFontDesc = AttrLabelProxy

fontDialogButtonFontFeatures :: AttrLabelProxy "fontFeatures"
fontDialogButtonFontFeatures = AttrLabelProxy

fontDialogButtonLanguage :: AttrLabelProxy "language"
fontDialogButtonLanguage = AttrLabelProxy

fontDialogButtonLevel :: AttrLabelProxy "level"
fontDialogButtonLevel = AttrLabelProxy

fontDialogButtonUseFont :: AttrLabelProxy "useFont"
fontDialogButtonUseFont = AttrLabelProxy

fontDialogButtonUseSize :: AttrLabelProxy "useSize"
fontDialogButtonUseSize = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList FontDialogButton = FontDialogButtonSignalList
type FontDialogButtonSignalList = ('[ '("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 FontDialogButton::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "dialog"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontDialog" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the `GtkFontDialog` to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gtk" , name = "FontDialogButton" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_font_dialog_button_new" gtk_font_dialog_button_new :: 
    Ptr Gtk.FontDialog.FontDialog ->        -- dialog : TInterface (Name {namespace = "Gtk", name = "FontDialog"})
    IO (Ptr FontDialogButton)

-- | Creates a new @GtkFontDialogButton@ with the
-- given @GtkFontDialog@.
-- 
-- You can pass @NULL@ to this function and set a @GtkFontDialog@
-- later. The button will be insensitive until that happens.
-- 
-- /Since: 4.10/
fontDialogButtonNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.FontDialog.IsFontDialog a) =>
    Maybe (a)
    -- ^ /@dialog@/: the @GtkFontDialog@ to use
    -> m FontDialogButton
    -- ^ __Returns:__ the new @GtkFontDialogButton@
fontDialogButtonNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialog a) =>
Maybe a -> m FontDialogButton
fontDialogButtonNew Maybe a
dialog = IO FontDialogButton -> m FontDialogButton
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FontDialogButton -> m FontDialogButton)
-> IO FontDialogButton -> m FontDialogButton
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontDialog
maybeDialog <- case Maybe a
dialog of
        Maybe a
Nothing -> Ptr FontDialog -> IO (Ptr FontDialog)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr FontDialog
forall a. Ptr a
nullPtr
        Just a
jDialog -> do
            Ptr FontDialog
jDialog' <- a -> IO (Ptr FontDialog)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject a
jDialog
            Ptr FontDialog -> IO (Ptr FontDialog)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr FontDialog
jDialog'
    Ptr FontDialogButton
result <- Ptr FontDialog -> IO (Ptr FontDialogButton)
gtk_font_dialog_button_new Ptr FontDialog
maybeDialog
    Text -> Ptr FontDialogButton -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fontDialogButtonNew" Ptr FontDialogButton
result
    FontDialogButton
result' <- ((ManagedPtr FontDialogButton -> FontDialogButton)
-> Ptr FontDialogButton -> IO FontDialogButton
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FontDialogButton -> FontDialogButton
FontDialogButton) Ptr FontDialogButton
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
dialog a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    FontDialogButton -> IO FontDialogButton
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FontDialogButton
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "gtk_font_dialog_button_get_dialog" gtk_font_dialog_button_get_dialog :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    IO (Ptr Gtk.FontDialog.FontDialog)

-- | Returns the @GtkFontDialog@ of /@self@/.
-- 
-- /Since: 4.10/
fontDialogButtonGetDialog ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> m (Maybe Gtk.FontDialog.FontDialog)
    -- ^ __Returns:__ the @GtkFontDialog@
fontDialogButtonGetDialog :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> m (Maybe FontDialog)
fontDialogButtonGetDialog a
self = IO (Maybe FontDialog) -> m (Maybe FontDialog)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe FontDialog) -> m (Maybe FontDialog))
-> IO (Maybe FontDialog) -> m (Maybe FontDialog)
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr FontDialog
result <- Ptr FontDialogButton -> IO (Ptr FontDialog)
gtk_font_dialog_button_get_dialog Ptr FontDialogButton
self'
    Maybe FontDialog
maybeResult <- Ptr FontDialog
-> (Ptr FontDialog -> IO FontDialog) -> IO (Maybe FontDialog)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr FontDialog
result ((Ptr FontDialog -> IO FontDialog) -> IO (Maybe FontDialog))
-> (Ptr FontDialog -> IO FontDialog) -> IO (Maybe FontDialog)
forall a b. (a -> b) -> a -> b
$ \Ptr FontDialog
result' -> do
        FontDialog
result'' <- ((ManagedPtr FontDialog -> FontDialog)
-> Ptr FontDialog -> IO FontDialog
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FontDialog -> FontDialog
Gtk.FontDialog.FontDialog) Ptr FontDialog
result'
        FontDialog -> IO FontDialog
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FontDialog
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe FontDialog -> IO (Maybe FontDialog)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FontDialog
maybeResult

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonGetDialogMethodInfo
instance (signature ~ (m (Maybe Gtk.FontDialog.FontDialog)), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonGetDialogMethodInfo a signature where
    overloadedMethod = fontDialogButtonGetDialog

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


#endif

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

foreign import ccall "gtk_font_dialog_button_get_font_desc" gtk_font_dialog_button_get_font_desc :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    IO (Ptr Pango.FontDescription.FontDescription)

-- | Returns the font of the button.
-- 
-- This function is what should be used to obtain
-- the font that was chosen by the user. To get
-- informed about changes, listen to \"notify[fontDesc](#g:signal:fontDesc)\".
-- 
-- /Since: 4.10/
fontDialogButtonGetFontDesc ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> m (Maybe Pango.FontDescription.FontDescription)
    -- ^ __Returns:__ the font
fontDialogButtonGetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> m (Maybe FontDescription)
fontDialogButtonGetFontDesc a
self = IO (Maybe FontDescription) -> m (Maybe FontDescription)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe FontDescription) -> m (Maybe FontDescription))
-> IO (Maybe FontDescription) -> m (Maybe FontDescription)
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr FontDescription
result <- Ptr FontDialogButton -> IO (Ptr FontDescription)
gtk_font_dialog_button_get_font_desc Ptr FontDialogButton
self'
    Maybe FontDescription
maybeResult <- Ptr FontDescription
-> (Ptr FontDescription -> IO FontDescription)
-> IO (Maybe FontDescription)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr FontDescription
result ((Ptr FontDescription -> IO FontDescription)
 -> IO (Maybe FontDescription))
-> (Ptr FontDescription -> IO FontDescription)
-> IO (Maybe FontDescription)
forall a b. (a -> b) -> a -> b
$ \Ptr FontDescription
result' -> do
        FontDescription
result'' <- ((ManagedPtr FontDescription -> FontDescription)
-> Ptr FontDescription -> IO FontDescription
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr FontDescription -> FontDescription
Pango.FontDescription.FontDescription) Ptr FontDescription
result'
        FontDescription -> IO FontDescription
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FontDescription
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe FontDescription -> IO (Maybe FontDescription)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FontDescription
maybeResult

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonGetFontDescMethodInfo
instance (signature ~ (m (Maybe Pango.FontDescription.FontDescription)), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonGetFontDescMethodInfo a signature where
    overloadedMethod = fontDialogButtonGetFontDesc

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


#endif

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

-- | Returns the font features of the button.
-- 
-- This function is what should be used to obtain the font features
-- that were chosen by the user. To get informed about changes, listen
-- to \"notify[fontFeatures](#g:signal:fontFeatures)\".
-- 
-- Note that the button will only let users choose font features
-- if [FontDialogButton:level]("GI.Gtk.Objects.FontDialogButton#g:attr:level") is set to
-- @GTK_FONT_LEVEL_FEATURES@.
-- 
-- /Since: 4.10/
fontDialogButtonGetFontFeatures ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the font features
fontDialogButtonGetFontFeatures :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> m (Maybe Text)
fontDialogButtonGetFontFeatures 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 FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr FontDialogButton -> IO CString
gtk_font_dialog_button_get_font_features Ptr FontDialogButton
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
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 FontDialogButtonGetFontFeaturesMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonGetFontFeaturesMethodInfo a signature where
    overloadedMethod = fontDialogButtonGetFontFeatures

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


#endif

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

foreign import ccall "gtk_font_dialog_button_get_language" gtk_font_dialog_button_get_language :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    IO (Ptr Pango.Language.Language)

-- | Returns the language that is used for font features.
-- 
-- /Since: 4.10/
fontDialogButtonGetLanguage ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> m (Maybe Pango.Language.Language)
    -- ^ __Returns:__ the language
fontDialogButtonGetLanguage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> m (Maybe Language)
fontDialogButtonGetLanguage a
self = IO (Maybe Language) -> m (Maybe Language)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Language) -> m (Maybe Language))
-> IO (Maybe Language) -> m (Maybe Language)
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Language
result <- Ptr FontDialogButton -> IO (Ptr Language)
gtk_font_dialog_button_get_language Ptr FontDialogButton
self'
    Maybe Language
maybeResult <- Ptr Language
-> (Ptr Language -> IO Language) -> IO (Maybe Language)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Language
result ((Ptr Language -> IO Language) -> IO (Maybe Language))
-> (Ptr Language -> IO Language) -> IO (Maybe Language)
forall a b. (a -> b) -> a -> b
$ \Ptr Language
result' -> do
        Language
result'' <- ((ManagedPtr Language -> Language) -> Ptr Language -> IO Language
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Language -> Language
Pango.Language.Language) Ptr Language
result'
        Language -> IO Language
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Language
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Language -> IO (Maybe Language)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Language
maybeResult

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonGetLanguageMethodInfo
instance (signature ~ (m (Maybe Pango.Language.Language)), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonGetLanguageMethodInfo a signature where
    overloadedMethod = fontDialogButtonGetLanguage

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


#endif

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

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

-- | Returns the level of detail at which this dialog
-- lets the user select fonts.
-- 
-- /Since: 4.10/
fontDialogButtonGetLevel ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a \`GtkFontDialogButton
    -> m Gtk.Enums.FontLevel
    -- ^ __Returns:__ the level of detail
fontDialogButtonGetLevel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> m FontLevel
fontDialogButtonGetLevel a
self = IO FontLevel -> m FontLevel
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FontLevel -> m FontLevel) -> IO FontLevel -> m FontLevel
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr FontDialogButton -> IO CUInt
gtk_font_dialog_button_get_level Ptr FontDialogButton
self'
    let result' :: FontLevel
result' = (Int -> FontLevel
forall a. Enum a => Int -> a
toEnum (Int -> FontLevel) -> (CUInt -> Int) -> CUInt -> FontLevel
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
    FontLevel -> IO FontLevel
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FontLevel
result'

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonGetLevelMethodInfo
instance (signature ~ (m Gtk.Enums.FontLevel), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonGetLevelMethodInfo a signature where
    overloadedMethod = fontDialogButtonGetLevel

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


#endif

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

foreign import ccall "gtk_font_dialog_button_get_use_font" gtk_font_dialog_button_get_use_font :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    IO CInt

-- | Returns whether the selected font is used in the label.
-- 
-- /Since: 4.10/
fontDialogButtonGetUseFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> m Bool
    -- ^ __Returns:__ whether the selected font is used in the label
fontDialogButtonGetUseFont :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> m Bool
fontDialogButtonGetUseFont a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr FontDialogButton -> IO CInt
gtk_font_dialog_button_get_use_font Ptr FontDialogButton
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonGetUseFontMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonGetUseFontMethodInfo a signature where
    overloadedMethod = fontDialogButtonGetUseFont

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


#endif

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

foreign import ccall "gtk_font_dialog_button_get_use_size" gtk_font_dialog_button_get_use_size :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    IO CInt

-- | Returns whether the selected font size is used in the label.
-- 
-- /Since: 4.10/
fontDialogButtonGetUseSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> m Bool
    -- ^ __Returns:__ whether the selected font size is used in the label
fontDialogButtonGetUseSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> m Bool
fontDialogButtonGetUseSize a
self = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr FontDialogButton -> IO CInt
gtk_font_dialog_button_get_use_size Ptr FontDialogButton
self'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonGetUseSizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonGetUseSizeMethodInfo a signature where
    overloadedMethod = fontDialogButtonGetUseSize

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


#endif

-- method FontDialogButton::set_dialog
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontDialogButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontDialogButton`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dialog"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontDialog" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new `GtkFontDialog`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_font_dialog_button_set_dialog" gtk_font_dialog_button_set_dialog :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    Ptr Gtk.FontDialog.FontDialog ->        -- dialog : TInterface (Name {namespace = "Gtk", name = "FontDialog"})
    IO ()

-- | Sets a @GtkFontDialog@ object to use for
-- creating the font chooser dialog that is
-- presented when the user clicks the button.
-- 
-- /Since: 4.10/
fontDialogButtonSetDialog ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a, Gtk.FontDialog.IsFontDialog b) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> b
    -- ^ /@dialog@/: the new @GtkFontDialog@
    -> m ()
fontDialogButtonSetDialog :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsFontDialogButton a, IsFontDialog b) =>
a -> b -> m ()
fontDialogButtonSetDialog a
self b
dialog = 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 FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr FontDialog
dialog' <- b -> IO (Ptr FontDialog)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
dialog
    Ptr FontDialogButton -> Ptr FontDialog -> IO ()
gtk_font_dialog_button_set_dialog Ptr FontDialogButton
self' Ptr FontDialog
dialog'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
dialog
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonSetDialogMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsFontDialogButton a, Gtk.FontDialog.IsFontDialog b) => O.OverloadedMethod FontDialogButtonSetDialogMethodInfo a signature where
    overloadedMethod = fontDialogButtonSetDialog

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


#endif

-- method FontDialogButton::set_font_desc
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontDialogButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontDialogButton`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_desc"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "FontDescription" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new font" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_font_dialog_button_set_font_desc" gtk_font_dialog_button_set_font_desc :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    Ptr Pango.FontDescription.FontDescription -> -- font_desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
    IO ()

-- | Sets the font of the button.
-- 
-- /Since: 4.10/
fontDialogButtonSetFontDesc ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> Pango.FontDescription.FontDescription
    -- ^ /@fontDesc@/: the new font
    -> m ()
fontDialogButtonSetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> FontDescription -> m ()
fontDialogButtonSetFontDesc a
self FontDescription
fontDesc = 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 FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr FontDescription
fontDesc' <- FontDescription -> IO (Ptr FontDescription)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr FontDescription
fontDesc
    Ptr FontDialogButton -> Ptr FontDescription -> IO ()
gtk_font_dialog_button_set_font_desc Ptr FontDialogButton
self' Ptr FontDescription
fontDesc'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    FontDescription -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr FontDescription
fontDesc
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FontDialogButtonSetFontDescMethodInfo
instance (signature ~ (Pango.FontDescription.FontDescription -> m ()), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonSetFontDescMethodInfo a signature where
    overloadedMethod = fontDialogButtonSetFontDesc

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


#endif

-- method FontDialogButton::set_font_features
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontDialogButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontDialogButton`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_features"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the font features" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Sets the font features of the button.
-- 
-- /Since: 4.10/
fontDialogButtonSetFontFeatures ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> Maybe (T.Text)
    -- ^ /@fontFeatures@/: the font features
    -> m ()
fontDialogButtonSetFontFeatures :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> Maybe Text -> m ()
fontDialogButtonSetFontFeatures a
self Maybe Text
fontFeatures = 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 FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeFontFeatures <- case Maybe Text
fontFeatures of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jFontFeatures -> do
            CString
jFontFeatures' <- Text -> IO CString
textToCString Text
jFontFeatures
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFontFeatures'
    Ptr FontDialogButton -> CString -> IO ()
gtk_font_dialog_button_set_font_features Ptr FontDialogButton
self' CString
maybeFontFeatures
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFontFeatures
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method FontDialogButton::set_language
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontDialogButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontDialogButton`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "language"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "Language" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new language" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_font_dialog_button_set_language" gtk_font_dialog_button_set_language :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    Ptr Pango.Language.Language ->          -- language : TInterface (Name {namespace = "Pango", name = "Language"})
    IO ()

-- | Sets the language to use for font features.
-- 
-- /Since: 4.10/
fontDialogButtonSetLanguage ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> Maybe (Pango.Language.Language)
    -- ^ /@language@/: the new language
    -> m ()
fontDialogButtonSetLanguage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> Maybe Language -> m ()
fontDialogButtonSetLanguage a
self Maybe Language
language = 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 FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Language
maybeLanguage <- case Maybe Language
language of
        Maybe Language
Nothing -> Ptr Language -> IO (Ptr Language)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Language
forall a. Ptr a
nullPtr
        Just Language
jLanguage -> do
            Ptr Language
jLanguage' <- Language -> IO (Ptr Language)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Language
jLanguage
            Ptr Language -> IO (Ptr Language)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Language
jLanguage'
    Ptr FontDialogButton -> Ptr Language -> IO ()
gtk_font_dialog_button_set_language Ptr FontDialogButton
self' Ptr Language
maybeLanguage
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Language -> (Language -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Language
language Language -> 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 FontDialogButtonSetLanguageMethodInfo
instance (signature ~ (Maybe (Pango.Language.Language) -> m ()), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonSetLanguageMethodInfo a signature where
    overloadedMethod = fontDialogButtonSetLanguage

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


#endif

-- method FontDialogButton::set_level
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontDialogButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontDialogButton`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "level"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontLevel" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the level of detail"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_font_dialog_button_set_level" gtk_font_dialog_button_set_level :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    CUInt ->                                -- level : TInterface (Name {namespace = "Gtk", name = "FontLevel"})
    IO ()

-- | Sets the level of detail at which this dialog
-- lets the user select fonts.
-- 
-- /Since: 4.10/
fontDialogButtonSetLevel ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> Gtk.Enums.FontLevel
    -- ^ /@level@/: the level of detail
    -> m ()
fontDialogButtonSetLevel :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> FontLevel -> m ()
fontDialogButtonSetLevel a
self FontLevel
level = 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 FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let level' :: CUInt
level' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (FontLevel -> Int) -> FontLevel -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FontLevel -> Int
forall a. Enum a => a -> Int
fromEnum) FontLevel
level
    Ptr FontDialogButton -> CUInt -> IO ()
gtk_font_dialog_button_set_level Ptr FontDialogButton
self' CUInt
level'
    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 FontDialogButtonSetLevelMethodInfo
instance (signature ~ (Gtk.Enums.FontLevel -> m ()), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonSetLevelMethodInfo a signature where
    overloadedMethod = fontDialogButtonSetLevel

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


#endif

-- method FontDialogButton::set_use_font
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontDialogButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontDialogButton`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "use_font"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "If `TRUE`, font name will be written using\n  the chosen font"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_font_dialog_button_set_use_font" gtk_font_dialog_button_set_use_font :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    CInt ->                                 -- use_font : TBasicType TBoolean
    IO ()

-- | If /@useFont@/ is @TRUE@, the font name will be written
-- using the selected font.
-- 
-- /Since: 4.10/
fontDialogButtonSetUseFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> Bool
    -- ^ /@useFont@/: If @TRUE@, font name will be written using
    --   the chosen font
    -> m ()
fontDialogButtonSetUseFont :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> Bool -> m ()
fontDialogButtonSetUseFont a
self Bool
useFont = 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 FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let useFont' :: CInt
useFont' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
useFont
    Ptr FontDialogButton -> CInt -> IO ()
gtk_font_dialog_button_set_use_font Ptr FontDialogButton
self' CInt
useFont'
    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 FontDialogButtonSetUseFontMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonSetUseFontMethodInfo a signature where
    overloadedMethod = fontDialogButtonSetUseFont

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


#endif

-- method FontDialogButton::set_use_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontDialogButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontDialogButton`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "use_size"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "If `TRUE`, font name will be written using\n  the chosen font size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_font_dialog_button_set_use_size" gtk_font_dialog_button_set_use_size :: 
    Ptr FontDialogButton ->                 -- self : TInterface (Name {namespace = "Gtk", name = "FontDialogButton"})
    CInt ->                                 -- use_size : TBasicType TBoolean
    IO ()

-- | If /@useSize@/ is @TRUE@, the font name will be written
-- using the selected font size.
-- 
-- /Since: 4.10/
fontDialogButtonSetUseSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontDialogButton a) =>
    a
    -- ^ /@self@/: a @GtkFontDialogButton@
    -> Bool
    -- ^ /@useSize@/: If @TRUE@, font name will be written using
    --   the chosen font size
    -> m ()
fontDialogButtonSetUseSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontDialogButton a) =>
a -> Bool -> m ()
fontDialogButtonSetUseSize a
self Bool
useSize = 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 FontDialogButton
self' <- a -> IO (Ptr FontDialogButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let useSize' :: CInt
useSize' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
useSize
    Ptr FontDialogButton -> CInt -> IO ()
gtk_font_dialog_button_set_use_size Ptr FontDialogButton
self' CInt
useSize'
    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 FontDialogButtonSetUseSizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFontDialogButton a) => O.OverloadedMethod FontDialogButtonSetUseSizeMethodInfo a signature where
    overloadedMethod = fontDialogButtonSetUseSize

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


#endif