{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


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

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

module GI.Gtk.Objects.FontButton
    ( 

-- * Exported types
    FontButton(..)                          ,
    IsFontButton                            ,
    toFontButton                            ,


 -- * 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"), [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"), [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
-- [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"), [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"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [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"), [getFont]("GI.Gtk.Interfaces.FontChooser#g:method:getFont"), [getFontDesc]("GI.Gtk.Interfaces.FontChooser#g:method:getFontDesc"), [getFontFace]("GI.Gtk.Interfaces.FontChooser#g:method:getFontFace"), [getFontFamily]("GI.Gtk.Interfaces.FontChooser#g:method:getFontFamily"), [getFontFeatures]("GI.Gtk.Interfaces.FontChooser#g:method:getFontFeatures"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFontSize]("GI.Gtk.Interfaces.FontChooser#g:method:getFontSize"), [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.Interfaces.FontChooser#g:method:getLanguage"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLevel]("GI.Gtk.Interfaces.FontChooser#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"), [getModal]("GI.Gtk.Objects.FontButton#g:method:getModal"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [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"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPreviewText]("GI.Gtk.Interfaces.FontChooser#g:method:getPreviewText"), [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"), [getShowPreviewEntry]("GI.Gtk.Interfaces.FontChooser#g:method:getShowPreviewEntry"), [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"), [getTitle]("GI.Gtk.Objects.FontButton#g:method:getTitle"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getUseFont]("GI.Gtk.Objects.FontButton#g:method:getUseFont"), [getUseSize]("GI.Gtk.Objects.FontButton#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
-- [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setFilterFunc]("GI.Gtk.Interfaces.FontChooser#g:method:setFilterFunc"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFont]("GI.Gtk.Interfaces.FontChooser#g:method:setFont"), [setFontDesc]("GI.Gtk.Interfaces.FontChooser#g:method:setFontDesc"), [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.Interfaces.FontChooser#g:method:setLanguage"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLevel]("GI.Gtk.Interfaces.FontChooser#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"), [setModal]("GI.Gtk.Objects.FontButton#g:method:setModal"), [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"), [setPreviewText]("GI.Gtk.Interfaces.FontChooser#g:method:setPreviewText"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowPreviewEntry]("GI.Gtk.Interfaces.FontChooser#g:method:setShowPreviewEntry"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTitle]("GI.Gtk.Objects.FontButton#g:method:setTitle"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setUseFont]("GI.Gtk.Objects.FontButton#g:method:setUseFont"), [setUseSize]("GI.Gtk.Objects.FontButton#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)
    ResolveFontButtonMethod                 ,
#endif

-- ** getModal #method:getModal#

#if defined(ENABLE_OVERLOADING)
    FontButtonGetModalMethodInfo            ,
#endif
    fontButtonGetModal                      ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    FontButtonGetTitleMethodInfo            ,
#endif
    fontButtonGetTitle                      ,


-- ** getUseFont #method:getUseFont#

#if defined(ENABLE_OVERLOADING)
    FontButtonGetUseFontMethodInfo          ,
#endif
    fontButtonGetUseFont                    ,


-- ** getUseSize #method:getUseSize#

#if defined(ENABLE_OVERLOADING)
    FontButtonGetUseSizeMethodInfo          ,
#endif
    fontButtonGetUseSize                    ,


-- ** new #method:new#

    fontButtonNew                           ,


-- ** newWithFont #method:newWithFont#

    fontButtonNewWithFont                   ,


-- ** setModal #method:setModal#

#if defined(ENABLE_OVERLOADING)
    FontButtonSetModalMethodInfo            ,
#endif
    fontButtonSetModal                      ,


-- ** setTitle #method:setTitle#

#if defined(ENABLE_OVERLOADING)
    FontButtonSetTitleMethodInfo            ,
#endif
    fontButtonSetTitle                      ,


-- ** setUseFont #method:setUseFont#

#if defined(ENABLE_OVERLOADING)
    FontButtonSetUseFontMethodInfo          ,
#endif
    fontButtonSetUseFont                    ,


-- ** setUseSize #method:setUseSize#

#if defined(ENABLE_OVERLOADING)
    FontButtonSetUseSizeMethodInfo          ,
#endif
    fontButtonSetUseSize                    ,




 -- * Properties


-- ** modal #attr:modal#
-- | Whether the font chooser dialog should be modal.

#if defined(ENABLE_OVERLOADING)
    FontButtonModalPropertyInfo             ,
#endif
    constructFontButtonModal                ,
#if defined(ENABLE_OVERLOADING)
    fontButtonModal                         ,
#endif
    getFontButtonModal                      ,
    setFontButtonModal                      ,


-- ** title #attr:title#
-- | The title of the font chooser dialog.

#if defined(ENABLE_OVERLOADING)
    FontButtonTitlePropertyInfo             ,
#endif
    constructFontButtonTitle                ,
#if defined(ENABLE_OVERLOADING)
    fontButtonTitle                         ,
#endif
    getFontButtonTitle                      ,
    setFontButtonTitle                      ,


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

#if defined(ENABLE_OVERLOADING)
    FontButtonUseFontPropertyInfo           ,
#endif
    constructFontButtonUseFont              ,
#if defined(ENABLE_OVERLOADING)
    fontButtonUseFont                       ,
#endif
    getFontButtonUseFont                    ,
    setFontButtonUseFont                    ,


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

#if defined(ENABLE_OVERLOADING)
    FontButtonUseSizePropertyInfo           ,
#endif
    constructFontButtonUseSize              ,
#if defined(ENABLE_OVERLOADING)
    fontButtonUseSize                       ,
#endif
    getFontButtonUseSize                    ,
    setFontButtonUseSize                    ,




 -- * Signals


-- ** activate #signal:activate#

    FontButtonActivateCallback              ,
#if defined(ENABLE_OVERLOADING)
    FontButtonActivateSignalInfo            ,
#endif
    afterFontButtonActivate                 ,
    onFontButtonActivate                    ,


-- ** fontSet #signal:fontSet#

    FontButtonFontSetCallback               ,
#if defined(ENABLE_OVERLOADING)
    FontButtonFontSetSignalInfo             ,
#endif
    afterFontButtonFontSet                  ,
    onFontButtonFontSet                     ,




    ) 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.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.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.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.Interfaces.FontChooser as Gtk.FontChooser
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

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

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

foreign import ccall "gtk_font_button_get_type"
    c_gtk_font_button_get_type :: IO B.Types.GType

instance B.Types.TypedObject FontButton where
    glibType :: IO GType
glibType = IO GType
c_gtk_font_button_get_type

instance B.Types.GObject FontButton

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

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

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

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

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

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

#endif

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

#endif

-- signal FontButton::activate
-- | Emitted to when the font button is activated.
-- 
-- The @::activate@ signal on @GtkFontButton@ is an action signal and
-- emitting it causes the button to present its dialog.
-- 
-- /Since: 4.4/
type FontButtonActivateCallback =
    IO ()

type C_FontButtonActivateCallback =
    Ptr FontButton ->                       -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_FontButtonActivateCallback`.
foreign import ccall "wrapper"
    mk_FontButtonActivateCallback :: C_FontButtonActivateCallback -> IO (FunPtr C_FontButtonActivateCallback)

wrap_FontButtonActivateCallback :: 
    GObject a => (a -> FontButtonActivateCallback) ->
    C_FontButtonActivateCallback
wrap_FontButtonActivateCallback :: forall a. GObject a => (a -> IO ()) -> C_FontButtonActivateCallback
wrap_FontButtonActivateCallback a -> IO ()
gi'cb Ptr FontButton
gi'selfPtr Ptr ()
_ = do
    Ptr FontButton -> (FontButton -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr FontButton
gi'selfPtr ((FontButton -> IO ()) -> IO ()) -> (FontButton -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \FontButton
gi'self -> a -> IO ()
gi'cb (FontButton -> a
Coerce.coerce FontButton
gi'self) 


-- | Connect a signal handler for the [activate](#signal:activate) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' fontButton #activate callback
-- @
-- 
-- 
onFontButtonActivate :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonActivateCallback) -> m SignalHandlerId
onFontButtonActivate :: forall a (m :: * -> *).
(IsFontButton a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onFontButtonActivate a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_FontButtonActivateCallback
wrapped' = (a -> IO ()) -> C_FontButtonActivateCallback
forall a. GObject a => (a -> IO ()) -> C_FontButtonActivateCallback
wrap_FontButtonActivateCallback a -> IO ()
wrapped
    FunPtr C_FontButtonActivateCallback
wrapped'' <- C_FontButtonActivateCallback
-> IO (FunPtr C_FontButtonActivateCallback)
mk_FontButtonActivateCallback C_FontButtonActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_FontButtonActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_FontButtonActivateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activate](#signal:activate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' fontButton #activate callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterFontButtonActivate :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonActivateCallback) -> m SignalHandlerId
afterFontButtonActivate :: forall a (m :: * -> *).
(IsFontButton a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterFontButtonActivate a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_FontButtonActivateCallback
wrapped' = (a -> IO ()) -> C_FontButtonActivateCallback
forall a. GObject a => (a -> IO ()) -> C_FontButtonActivateCallback
wrap_FontButtonActivateCallback a -> IO ()
wrapped
    FunPtr C_FontButtonActivateCallback
wrapped'' <- C_FontButtonActivateCallback
-> IO (FunPtr C_FontButtonActivateCallback)
mk_FontButtonActivateCallback C_FontButtonActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_FontButtonActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate" FunPtr C_FontButtonActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data FontButtonActivateSignalInfo
instance SignalInfo FontButtonActivateSignalInfo where
    type HaskellCallbackType FontButtonActivateSignalInfo = FontButtonActivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_FontButtonActivateCallback cb
        cb'' <- mk_FontButtonActivateCallback cb'
        connectSignalFunPtr obj "activate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontButton::activate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-FontButton.html#g:signal:activate"})

#endif

-- signal FontButton::font-set
-- | Emitted when the user selects a font.
-- 
-- When handling this signal, use 'GI.Gtk.Interfaces.FontChooser.fontChooserGetFont'
-- to find out which font was just selected.
-- 
-- Note that this signal is only emitted when the user changes the font.
-- If you need to react to programmatic font changes as well, use
-- the notify[font](#g:signal:font) signal.
type FontButtonFontSetCallback =
    IO ()

type C_FontButtonFontSetCallback =
    Ptr FontButton ->                       -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_FontButtonFontSetCallback`.
foreign import ccall "wrapper"
    mk_FontButtonFontSetCallback :: C_FontButtonFontSetCallback -> IO (FunPtr C_FontButtonFontSetCallback)

wrap_FontButtonFontSetCallback :: 
    GObject a => (a -> FontButtonFontSetCallback) ->
    C_FontButtonFontSetCallback
wrap_FontButtonFontSetCallback :: forall a. GObject a => (a -> IO ()) -> C_FontButtonActivateCallback
wrap_FontButtonFontSetCallback a -> IO ()
gi'cb Ptr FontButton
gi'selfPtr Ptr ()
_ = do
    Ptr FontButton -> (FontButton -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr FontButton
gi'selfPtr ((FontButton -> IO ()) -> IO ()) -> (FontButton -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \FontButton
gi'self -> a -> IO ()
gi'cb (FontButton -> a
Coerce.coerce FontButton
gi'self) 


-- | Connect a signal handler for the [fontSet](#signal:fontSet) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' fontButton #fontSet callback
-- @
-- 
-- 
onFontButtonFontSet :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonFontSetCallback) -> m SignalHandlerId
onFontButtonFontSet :: forall a (m :: * -> *).
(IsFontButton a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onFontButtonFontSet a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_FontButtonActivateCallback
wrapped' = (a -> IO ()) -> C_FontButtonActivateCallback
forall a. GObject a => (a -> IO ()) -> C_FontButtonActivateCallback
wrap_FontButtonFontSetCallback a -> IO ()
wrapped
    FunPtr C_FontButtonActivateCallback
wrapped'' <- C_FontButtonActivateCallback
-> IO (FunPtr C_FontButtonActivateCallback)
mk_FontButtonFontSetCallback C_FontButtonActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_FontButtonActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"font-set" FunPtr C_FontButtonActivateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [fontSet](#signal:fontSet) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' fontButton #fontSet callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterFontButtonFontSet :: (IsFontButton a, MonadIO m) => a -> ((?self :: a) => FontButtonFontSetCallback) -> m SignalHandlerId
afterFontButtonFontSet :: forall a (m :: * -> *).
(IsFontButton a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterFontButtonFontSet a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_FontButtonActivateCallback
wrapped' = (a -> IO ()) -> C_FontButtonActivateCallback
forall a. GObject a => (a -> IO ()) -> C_FontButtonActivateCallback
wrap_FontButtonFontSetCallback a -> IO ()
wrapped
    FunPtr C_FontButtonActivateCallback
wrapped'' <- C_FontButtonActivateCallback
-> IO (FunPtr C_FontButtonActivateCallback)
mk_FontButtonFontSetCallback C_FontButtonActivateCallback
wrapped'
    a
-> Text
-> FunPtr C_FontButtonActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"font-set" FunPtr C_FontButtonActivateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data FontButtonFontSetSignalInfo
instance SignalInfo FontButtonFontSetSignalInfo where
    type HaskellCallbackType FontButtonFontSetSignalInfo = FontButtonFontSetCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_FontButtonFontSetCallback cb
        cb'' <- mk_FontButtonFontSetCallback cb'
        connectSignalFunPtr obj "font-set" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontButton::font-set"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-FontButton.html#g:signal:fontSet"})

#endif

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

-- | Get the value of the “@modal@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fontButton #modal
-- @
getFontButtonModal :: (MonadIO m, IsFontButton o) => o -> m Bool
getFontButtonModal :: forall (m :: * -> *) o. (MonadIO m, IsFontButton o) => o -> m Bool
getFontButtonModal o
obj = IO Bool -> m Bool
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
"modal"

-- | Set the value of the “@modal@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' fontButton [ #modal 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontButtonModal :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()
setFontButtonModal :: forall (m :: * -> *) o.
(MonadIO m, IsFontButton o) =>
o -> Bool -> m ()
setFontButtonModal o
obj Bool
val = IO () -> m ()
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
"modal" Bool
val

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

#if defined(ENABLE_OVERLOADING)
data FontButtonModalPropertyInfo
instance AttrInfo FontButtonModalPropertyInfo where
    type AttrAllowedOps FontButtonModalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FontButtonModalPropertyInfo = IsFontButton
    type AttrSetTypeConstraint FontButtonModalPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint FontButtonModalPropertyInfo = (~) Bool
    type AttrTransferType FontButtonModalPropertyInfo = Bool
    type AttrGetType FontButtonModalPropertyInfo = Bool
    type AttrLabel FontButtonModalPropertyInfo = "modal"
    type AttrOrigin FontButtonModalPropertyInfo = FontButton
    attrGet = getFontButtonModal
    attrSet = setFontButtonModal
    attrTransfer _ v = do
        return v
    attrConstruct = constructFontButtonModal
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontButton.modal"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-FontButton.html#g:attr:modal"
        })
#endif

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

-- | Get the value of the “@title@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' fontButton #title
-- @
getFontButtonTitle :: (MonadIO m, IsFontButton o) => o -> m T.Text
getFontButtonTitle :: forall (m :: * -> *) o. (MonadIO m, IsFontButton o) => o -> m Text
getFontButtonTitle o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getFontButtonTitle" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO 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
"title"

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

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

#if defined(ENABLE_OVERLOADING)
data FontButtonTitlePropertyInfo
instance AttrInfo FontButtonTitlePropertyInfo where
    type AttrAllowedOps FontButtonTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FontButtonTitlePropertyInfo = IsFontButton
    type AttrSetTypeConstraint FontButtonTitlePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint FontButtonTitlePropertyInfo = (~) T.Text
    type AttrTransferType FontButtonTitlePropertyInfo = T.Text
    type AttrGetType FontButtonTitlePropertyInfo = T.Text
    type AttrLabel FontButtonTitlePropertyInfo = "title"
    type AttrOrigin FontButtonTitlePropertyInfo = FontButton
    attrGet = getFontButtonTitle
    attrSet = setFontButtonTitle
    attrTransfer _ v = do
        return v
    attrConstruct = constructFontButtonTitle
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontButton.title"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-FontButton.html#g:attr:title"
        })
#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' fontButton #useFont
-- @
getFontButtonUseFont :: (MonadIO m, IsFontButton o) => o -> m Bool
getFontButtonUseFont :: forall (m :: * -> *) o. (MonadIO m, IsFontButton o) => o -> m Bool
getFontButtonUseFont o
obj = IO Bool -> m Bool
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' fontButton [ #useFont 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontButtonUseFont :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()
setFontButtonUseFont :: forall (m :: * -> *) o.
(MonadIO m, IsFontButton o) =>
o -> Bool -> m ()
setFontButtonUseFont o
obj Bool
val = IO () -> m ()
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`.
constructFontButtonUseFont :: (IsFontButton o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructFontButtonUseFont :: forall o (m :: * -> *).
(IsFontButton o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructFontButtonUseFont Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 FontButtonUseFontPropertyInfo
instance AttrInfo FontButtonUseFontPropertyInfo where
    type AttrAllowedOps FontButtonUseFontPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FontButtonUseFontPropertyInfo = IsFontButton
    type AttrSetTypeConstraint FontButtonUseFontPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint FontButtonUseFontPropertyInfo = (~) Bool
    type AttrTransferType FontButtonUseFontPropertyInfo = Bool
    type AttrGetType FontButtonUseFontPropertyInfo = Bool
    type AttrLabel FontButtonUseFontPropertyInfo = "use-font"
    type AttrOrigin FontButtonUseFontPropertyInfo = FontButton
    attrGet = getFontButtonUseFont
    attrSet = setFontButtonUseFont
    attrTransfer _ v = do
        return v
    attrConstruct = constructFontButtonUseFont
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontButton.useFont"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-FontButton.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' fontButton #useSize
-- @
getFontButtonUseSize :: (MonadIO m, IsFontButton o) => o -> m Bool
getFontButtonUseSize :: forall (m :: * -> *) o. (MonadIO m, IsFontButton o) => o -> m Bool
getFontButtonUseSize o
obj = IO Bool -> m Bool
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' fontButton [ #useSize 'Data.GI.Base.Attributes.:=' value ]
-- @
setFontButtonUseSize :: (MonadIO m, IsFontButton o) => o -> Bool -> m ()
setFontButtonUseSize :: forall (m :: * -> *) o.
(MonadIO m, IsFontButton o) =>
o -> Bool -> m ()
setFontButtonUseSize o
obj Bool
val = IO () -> m ()
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`.
constructFontButtonUseSize :: (IsFontButton o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructFontButtonUseSize :: forall o (m :: * -> *).
(IsFontButton o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructFontButtonUseSize Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
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 (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 FontButtonUseSizePropertyInfo
instance AttrInfo FontButtonUseSizePropertyInfo where
    type AttrAllowedOps FontButtonUseSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint FontButtonUseSizePropertyInfo = IsFontButton
    type AttrSetTypeConstraint FontButtonUseSizePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint FontButtonUseSizePropertyInfo = (~) Bool
    type AttrTransferType FontButtonUseSizePropertyInfo = Bool
    type AttrGetType FontButtonUseSizePropertyInfo = Bool
    type AttrLabel FontButtonUseSizePropertyInfo = "use-size"
    type AttrOrigin FontButtonUseSizePropertyInfo = FontButton
    attrGet = getFontButtonUseSize
    attrSet = setFontButtonUseSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructFontButtonUseSize
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gtk.Objects.FontButton.useSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-4.0.5/docs/GI-Gtk-Objects-FontButton.html#g:attr:useSize"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FontButton
type instance O.AttributeList FontButton = FontButtonAttributeList
type FontButtonAttributeList = ('[ '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("font", Gtk.FontChooser.FontChooserFontPropertyInfo), '("fontDesc", Gtk.FontChooser.FontChooserFontDescPropertyInfo), '("fontFeatures", Gtk.FontChooser.FontChooserFontFeaturesPropertyInfo), '("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", Gtk.FontChooser.FontChooserLanguagePropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("level", Gtk.FontChooser.FontChooserLevelPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("modal", FontButtonModalPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("previewText", Gtk.FontChooser.FontChooserPreviewTextPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showPreviewEntry", Gtk.FontChooser.FontChooserShowPreviewEntryPropertyInfo), '("title", FontButtonTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useFont", FontButtonUseFontPropertyInfo), '("useSize", FontButtonUseSizePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
fontButtonModal :: AttrLabelProxy "modal"
fontButtonModal = AttrLabelProxy

fontButtonTitle :: AttrLabelProxy "title"
fontButtonTitle = AttrLabelProxy

fontButtonUseFont :: AttrLabelProxy "useFont"
fontButtonUseFont = AttrLabelProxy

fontButtonUseSize :: AttrLabelProxy "useSize"
fontButtonUseSize = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList FontButton = FontButtonSignalList
type FontButtonSignalList = ('[ '("activate", FontButtonActivateSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("fontActivated", Gtk.FontChooser.FontChooserFontActivatedSignalInfo), '("fontSet", FontButtonFontSetSignalInfo), '("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, *)])

#endif

-- method FontButton::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "FontButton" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_font_button_new" gtk_font_button_new :: 
    IO (Ptr FontButton)

-- | Creates a new font picker widget.
fontButtonNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m FontButton
    -- ^ __Returns:__ a new font picker widget.
fontButtonNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m FontButton
fontButtonNew  = IO FontButton -> m FontButton
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FontButton -> m FontButton) -> IO FontButton -> m FontButton
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontButton
result <- IO (Ptr FontButton)
gtk_font_button_new
    Text -> Ptr FontButton -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fontButtonNew" Ptr FontButton
result
    FontButton
result' <- ((ManagedPtr FontButton -> FontButton)
-> Ptr FontButton -> IO FontButton
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FontButton -> FontButton
FontButton) Ptr FontButton
result
    FontButton -> IO FontButton
forall (m :: * -> *) a. Monad m => a -> m a
return FontButton
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method FontButton::new_with_font
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "fontname"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Name of font to display in font chooser dialog"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "FontButton" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_font_button_new_with_font" gtk_font_button_new_with_font :: 
    CString ->                              -- fontname : TBasicType TUTF8
    IO (Ptr FontButton)

-- | Creates a new font picker widget showing the given font.
fontButtonNewWithFont ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@fontname@/: Name of font to display in font chooser dialog
    -> m FontButton
    -- ^ __Returns:__ a new font picker widget.
fontButtonNewWithFont :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m FontButton
fontButtonNewWithFont Text
fontname = IO FontButton -> m FontButton
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FontButton -> m FontButton) -> IO FontButton -> m FontButton
forall a b. (a -> b) -> a -> b
$ do
    CString
fontname' <- Text -> IO CString
textToCString Text
fontname
    Ptr FontButton
result <- CString -> IO (Ptr FontButton)
gtk_font_button_new_with_font CString
fontname'
    Text -> Ptr FontButton -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fontButtonNewWithFont" Ptr FontButton
result
    FontButton
result' <- ((ManagedPtr FontButton -> FontButton)
-> Ptr FontButton -> IO FontButton
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FontButton -> FontButton
FontButton) Ptr FontButton
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
fontname'
    FontButton -> IO FontButton
forall (m :: * -> *) a. Monad m => a -> m a
return FontButton
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method FontButton::get_modal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "font_button"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontButton`" , 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_button_get_modal" gtk_font_button_get_modal :: 
    Ptr FontButton ->                       -- font_button : TInterface (Name {namespace = "Gtk", name = "FontButton"})
    IO CInt

-- | Gets whether the dialog is modal.
fontButtonGetModal ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontButton a) =>
    a
    -- ^ /@fontButton@/: a @GtkFontButton@
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the dialog is modal
fontButtonGetModal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontButton a) =>
a -> m Bool
fontButtonGetModal a
fontButton = IO Bool -> m Bool
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 FontButton
fontButton' <- a -> IO (Ptr FontButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fontButton
    CInt
result <- Ptr FontButton -> IO CInt
gtk_font_button_get_modal Ptr FontButton
fontButton'
    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
fontButton
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FontButtonGetModalMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFontButton a) => O.OverloadedMethod FontButtonGetModalMethodInfo a signature where
    overloadedMethod = fontButtonGetModal

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


#endif

-- method FontButton::get_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "font_button"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontButton`" , 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_button_get_title" gtk_font_button_get_title :: 
    Ptr FontButton ->                       -- font_button : TInterface (Name {namespace = "Gtk", name = "FontButton"})
    IO CString

-- | Retrieves the title of the font chooser dialog.
fontButtonGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontButton a) =>
    a
    -- ^ /@fontButton@/: a @GtkFontButton@
    -> m T.Text
    -- ^ __Returns:__ an internal copy of the title string
    --   which must not be freed.
fontButtonGetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontButton a) =>
a -> m Text
fontButtonGetTitle a
fontButton = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontButton
fontButton' <- a -> IO (Ptr FontButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fontButton
    CString
result <- Ptr FontButton -> IO CString
gtk_font_button_get_title Ptr FontButton
fontButton'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fontButtonGetTitle" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
fontButton
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data FontButtonGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsFontButton a) => O.OverloadedMethod FontButtonGetTitleMethodInfo a signature where
    overloadedMethod = fontButtonGetTitle

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


#endif

-- method FontButton::get_use_font
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "font_button"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontButton`" , 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_button_get_use_font" gtk_font_button_get_use_font :: 
    Ptr FontButton ->                       -- font_button : TInterface (Name {namespace = "Gtk", name = "FontButton"})
    IO CInt

-- | Returns whether the selected font is used in the label.
fontButtonGetUseFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontButton a) =>
    a
    -- ^ /@fontButton@/: a @GtkFontButton@
    -> m Bool
    -- ^ __Returns:__ whether the selected font is used in the label.
fontButtonGetUseFont :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontButton a) =>
a -> m Bool
fontButtonGetUseFont a
fontButton = IO Bool -> m Bool
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 FontButton
fontButton' <- a -> IO (Ptr FontButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fontButton
    CInt
result <- Ptr FontButton -> IO CInt
gtk_font_button_get_use_font Ptr FontButton
fontButton'
    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
fontButton
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FontButtonGetUseFontMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFontButton a) => O.OverloadedMethod FontButtonGetUseFontMethodInfo a signature where
    overloadedMethod = fontButtonGetUseFont

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


#endif

-- method FontButton::get_use_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "font_button"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontButton`" , 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_button_get_use_size" gtk_font_button_get_use_size :: 
    Ptr FontButton ->                       -- font_button : TInterface (Name {namespace = "Gtk", name = "FontButton"})
    IO CInt

-- | Returns whether the selected size is used in the label.
fontButtonGetUseSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontButton a) =>
    a
    -- ^ /@fontButton@/: a @GtkFontButton@
    -> m Bool
    -- ^ __Returns:__ whether the selected size is used in the label.
fontButtonGetUseSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontButton a) =>
a -> m Bool
fontButtonGetUseSize a
fontButton = IO Bool -> m Bool
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 FontButton
fontButton' <- a -> IO (Ptr FontButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fontButton
    CInt
result <- Ptr FontButton -> IO CInt
gtk_font_button_get_use_size Ptr FontButton
fontButton'
    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
fontButton
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data FontButtonGetUseSizeMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFontButton a) => O.OverloadedMethod FontButtonGetUseSizeMethodInfo a signature where
    overloadedMethod = fontButtonGetUseSize

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


#endif

-- method FontButton::set_modal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "font_button"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "modal"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "%TRUE to make the dialog modal"
--                 , 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_button_set_modal" gtk_font_button_set_modal :: 
    Ptr FontButton ->                       -- font_button : TInterface (Name {namespace = "Gtk", name = "FontButton"})
    CInt ->                                 -- modal : TBasicType TBoolean
    IO ()

-- | Sets whether the dialog should be modal.
fontButtonSetModal ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontButton a) =>
    a
    -- ^ /@fontButton@/: a @GtkFontButton@
    -> Bool
    -- ^ /@modal@/: 'P.True' to make the dialog modal
    -> m ()
fontButtonSetModal :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontButton a) =>
a -> Bool -> m ()
fontButtonSetModal a
fontButton Bool
modal = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontButton
fontButton' <- a -> IO (Ptr FontButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fontButton
    let modal' :: CInt
modal' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
modal
    Ptr FontButton -> CInt -> IO ()
gtk_font_button_set_modal Ptr FontButton
fontButton' CInt
modal'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
fontButton
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FontButtonSetModalMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFontButton a) => O.OverloadedMethod FontButtonSetModalMethodInfo a signature where
    overloadedMethod = fontButtonSetModal

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


#endif

-- method FontButton::set_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "font_button"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontButton`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "title"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a string containing the font chooser dialog title"
--                 , 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_button_set_title" gtk_font_button_set_title :: 
    Ptr FontButton ->                       -- font_button : TInterface (Name {namespace = "Gtk", name = "FontButton"})
    CString ->                              -- title : TBasicType TUTF8
    IO ()

-- | Sets the title for the font chooser dialog.
fontButtonSetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontButton a) =>
    a
    -- ^ /@fontButton@/: a @GtkFontButton@
    -> T.Text
    -- ^ /@title@/: a string containing the font chooser dialog title
    -> m ()
fontButtonSetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontButton a) =>
a -> Text -> m ()
fontButtonSetTitle a
fontButton Text
title = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontButton
fontButton' <- a -> IO (Ptr FontButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fontButton
    CString
title' <- Text -> IO CString
textToCString Text
title
    Ptr FontButton -> CString -> IO ()
gtk_font_button_set_title Ptr FontButton
fontButton' CString
title'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
fontButton
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
title'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FontButtonSetTitleMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsFontButton a) => O.OverloadedMethod FontButtonSetTitleMethodInfo a signature where
    overloadedMethod = fontButtonSetTitle

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


#endif

-- method FontButton::set_use_font
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "font_button"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontButton`" , 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 font chosen."
--                 , 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_button_set_use_font" gtk_font_button_set_use_font :: 
    Ptr FontButton ->                       -- font_button : TInterface (Name {namespace = "Gtk", name = "FontButton"})
    CInt ->                                 -- use_font : TBasicType TBoolean
    IO ()

-- | If /@useFont@/ is 'P.True', the font name will be written
-- using the selected font.
fontButtonSetUseFont ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontButton a) =>
    a
    -- ^ /@fontButton@/: a @GtkFontButton@
    -> Bool
    -- ^ /@useFont@/: If 'P.True', font name will be written using font chosen.
    -> m ()
fontButtonSetUseFont :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontButton a) =>
a -> Bool -> m ()
fontButtonSetUseFont a
fontButton Bool
useFont = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontButton
fontButton' <- a -> IO (Ptr FontButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fontButton
    let useFont' :: CInt
useFont' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
useFont
    Ptr FontButton -> CInt -> IO ()
gtk_font_button_set_use_font Ptr FontButton
fontButton' CInt
useFont'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
fontButton
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FontButtonSetUseFontMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFontButton a) => O.OverloadedMethod FontButtonSetUseFontMethodInfo a signature where
    overloadedMethod = fontButtonSetUseFont

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


#endif

-- method FontButton::set_use_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "font_button"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "FontButton" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `GtkFontButton`" , 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 the\n  selected 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_button_set_use_size" gtk_font_button_set_use_size :: 
    Ptr FontButton ->                       -- font_button : TInterface (Name {namespace = "Gtk", name = "FontButton"})
    CInt ->                                 -- use_size : TBasicType TBoolean
    IO ()

-- | If /@useSize@/ is 'P.True', the font name will be written using
-- the selected size.
fontButtonSetUseSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontButton a) =>
    a
    -- ^ /@fontButton@/: a @GtkFontButton@
    -> Bool
    -- ^ /@useSize@/: If 'P.True', font name will be written using the
    --   selected size.
    -> m ()
fontButtonSetUseSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsFontButton a) =>
a -> Bool -> m ()
fontButtonSetUseSize a
fontButton Bool
useSize = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr FontButton
fontButton' <- a -> IO (Ptr FontButton)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
fontButton
    let useSize' :: CInt
useSize' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
useSize
    Ptr FontButton -> CInt -> IO ()
gtk_font_button_set_use_size Ptr FontButton
fontButton' CInt
useSize'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
fontButton
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data FontButtonSetUseSizeMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsFontButton a) => O.OverloadedMethod FontButtonSetUseSizeMethodInfo a signature where
    overloadedMethod = fontButtonSetUseSize

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


#endif