{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Gtk.Structs.WidgetClass
    ( 

-- * Exported types
    WidgetClass(..)                         ,
    newZeroWidgetClass                      ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addShortcut]("GI.Gtk.Structs.WidgetClass#g:method:addShortcut"), [bindTemplateCallbackFull]("GI.Gtk.Structs.WidgetClass#g:method:bindTemplateCallbackFull"), [bindTemplateChildFull]("GI.Gtk.Structs.WidgetClass#g:method:bindTemplateChildFull"), [installAction]("GI.Gtk.Structs.WidgetClass#g:method:installAction"), [installPropertyAction]("GI.Gtk.Structs.WidgetClass#g:method:installPropertyAction"), [queryAction]("GI.Gtk.Structs.WidgetClass#g:method:queryAction").
-- 
-- ==== Getters
-- [getAccessibleRole]("GI.Gtk.Structs.WidgetClass#g:method:getAccessibleRole"), [getActivateSignal]("GI.Gtk.Structs.WidgetClass#g:method:getActivateSignal"), [getCssName]("GI.Gtk.Structs.WidgetClass#g:method:getCssName"), [getLayoutManagerType]("GI.Gtk.Structs.WidgetClass#g:method:getLayoutManagerType").
-- 
-- ==== Setters
-- [setAccessibleRole]("GI.Gtk.Structs.WidgetClass#g:method:setAccessibleRole"), [setActivateSignal]("GI.Gtk.Structs.WidgetClass#g:method:setActivateSignal"), [setActivateSignalFromName]("GI.Gtk.Structs.WidgetClass#g:method:setActivateSignalFromName"), [setCssName]("GI.Gtk.Structs.WidgetClass#g:method:setCssName"), [setLayoutManagerType]("GI.Gtk.Structs.WidgetClass#g:method:setLayoutManagerType"), [setTemplate]("GI.Gtk.Structs.WidgetClass#g:method:setTemplate"), [setTemplateFromResource]("GI.Gtk.Structs.WidgetClass#g:method:setTemplateFromResource"), [setTemplateScope]("GI.Gtk.Structs.WidgetClass#g:method:setTemplateScope").

#if defined(ENABLE_OVERLOADING)
    ResolveWidgetClassMethod                ,
#endif

-- ** addShortcut #method:addShortcut#

#if defined(ENABLE_OVERLOADING)
    WidgetClassAddShortcutMethodInfo        ,
#endif
    widgetClassAddShortcut                  ,


-- ** bindTemplateCallbackFull #method:bindTemplateCallbackFull#

#if defined(ENABLE_OVERLOADING)
    WidgetClassBindTemplateCallbackFullMethodInfo,
#endif
    widgetClassBindTemplateCallbackFull     ,


-- ** bindTemplateChildFull #method:bindTemplateChildFull#

#if defined(ENABLE_OVERLOADING)
    WidgetClassBindTemplateChildFullMethodInfo,
#endif
    widgetClassBindTemplateChildFull        ,


-- ** getAccessibleRole #method:getAccessibleRole#

#if defined(ENABLE_OVERLOADING)
    WidgetClassGetAccessibleRoleMethodInfo  ,
#endif
    widgetClassGetAccessibleRole            ,


-- ** getActivateSignal #method:getActivateSignal#

#if defined(ENABLE_OVERLOADING)
    WidgetClassGetActivateSignalMethodInfo  ,
#endif
    widgetClassGetActivateSignal            ,


-- ** getCssName #method:getCssName#

#if defined(ENABLE_OVERLOADING)
    WidgetClassGetCssNameMethodInfo         ,
#endif
    widgetClassGetCssName                   ,


-- ** getLayoutManagerType #method:getLayoutManagerType#

#if defined(ENABLE_OVERLOADING)
    WidgetClassGetLayoutManagerTypeMethodInfo,
#endif
    widgetClassGetLayoutManagerType         ,


-- ** installAction #method:installAction#

#if defined(ENABLE_OVERLOADING)
    WidgetClassInstallActionMethodInfo      ,
#endif
    widgetClassInstallAction                ,


-- ** installPropertyAction #method:installPropertyAction#

#if defined(ENABLE_OVERLOADING)
    WidgetClassInstallPropertyActionMethodInfo,
#endif
    widgetClassInstallPropertyAction        ,


-- ** queryAction #method:queryAction#

#if defined(ENABLE_OVERLOADING)
    WidgetClassQueryActionMethodInfo        ,
#endif
    widgetClassQueryAction                  ,


-- ** setAccessibleRole #method:setAccessibleRole#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetAccessibleRoleMethodInfo  ,
#endif
    widgetClassSetAccessibleRole            ,


-- ** setActivateSignal #method:setActivateSignal#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetActivateSignalMethodInfo  ,
#endif
    widgetClassSetActivateSignal            ,


-- ** setActivateSignalFromName #method:setActivateSignalFromName#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetActivateSignalFromNameMethodInfo,
#endif
    widgetClassSetActivateSignalFromName    ,


-- ** setCssName #method:setCssName#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetCssNameMethodInfo         ,
#endif
    widgetClassSetCssName                   ,


-- ** setLayoutManagerType #method:setLayoutManagerType#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetLayoutManagerTypeMethodInfo,
#endif
    widgetClassSetLayoutManagerType         ,


-- ** setTemplate #method:setTemplate#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetTemplateMethodInfo        ,
#endif
    widgetClassSetTemplate                  ,


-- ** setTemplateFromResource #method:setTemplateFromResource#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetTemplateFromResourceMethodInfo,
#endif
    widgetClassSetTemplateFromResource      ,


-- ** setTemplateScope #method:setTemplateScope#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetTemplateScopeMethodInfo   ,
#endif
    widgetClassSetTemplateScope             ,




 -- * Properties


-- ** computeExpand #attr:computeExpand#
-- | /No description available in the introspection data./

    clearWidgetClassComputeExpand           ,
    getWidgetClassComputeExpand             ,
    setWidgetClassComputeExpand             ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_computeExpand               ,
#endif


-- ** contains #attr:contains#
-- | /No description available in the introspection data./

    clearWidgetClassContains                ,
    getWidgetClassContains                  ,
    setWidgetClassContains                  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_contains                    ,
#endif


-- ** cssChanged #attr:cssChanged#
-- | /No description available in the introspection data./

    clearWidgetClassCssChanged              ,
    getWidgetClassCssChanged                ,
    setWidgetClassCssChanged                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_cssChanged                  ,
#endif


-- ** directionChanged #attr:directionChanged#
-- | /No description available in the introspection data./

    clearWidgetClassDirectionChanged        ,
    getWidgetClassDirectionChanged          ,
    setWidgetClassDirectionChanged          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_directionChanged            ,
#endif


-- ** focus #attr:focus#
-- | /No description available in the introspection data./

    clearWidgetClassFocus                   ,
    getWidgetClassFocus                     ,
    setWidgetClassFocus                     ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_focus                       ,
#endif


-- ** getRequestMode #attr:getRequestMode#
-- | /No description available in the introspection data./

    clearWidgetClassGetRequestMode          ,
    getWidgetClassGetRequestMode            ,
    setWidgetClassGetRequestMode            ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_getRequestMode              ,
#endif


-- ** grabFocus #attr:grabFocus#
-- | /No description available in the introspection data./

    clearWidgetClassGrabFocus               ,
    getWidgetClassGrabFocus                 ,
    setWidgetClassGrabFocus                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_grabFocus                   ,
#endif


-- ** hide #attr:hide#
-- | /No description available in the introspection data./

    clearWidgetClassHide                    ,
    getWidgetClassHide                      ,
    setWidgetClassHide                      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_hide                        ,
#endif


-- ** keynavFailed #attr:keynavFailed#
-- | /No description available in the introspection data./

    clearWidgetClassKeynavFailed            ,
    getWidgetClassKeynavFailed              ,
    setWidgetClassKeynavFailed              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_keynavFailed                ,
#endif


-- ** map #attr:map#
-- | /No description available in the introspection data./

    clearWidgetClassMap                     ,
    getWidgetClassMap                       ,
    setWidgetClassMap                       ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_map                         ,
#endif


-- ** measure #attr:measure#
-- | /No description available in the introspection data./

    clearWidgetClassMeasure                 ,
    getWidgetClassMeasure                   ,
    setWidgetClassMeasure                   ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_measure                     ,
#endif


-- ** mnemonicActivate #attr:mnemonicActivate#
-- | /No description available in the introspection data./

    clearWidgetClassMnemonicActivate        ,
    getWidgetClassMnemonicActivate          ,
    setWidgetClassMnemonicActivate          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_mnemonicActivate            ,
#endif


-- ** moveFocus #attr:moveFocus#
-- | /No description available in the introspection data./

    clearWidgetClassMoveFocus               ,
    getWidgetClassMoveFocus                 ,
    setWidgetClassMoveFocus                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_moveFocus                   ,
#endif


-- ** parentClass #attr:parentClass#
-- | The object class structure needs to be the first
--   element in the widget class structure in order for the class mechanism
--   to work correctly. This allows a GtkWidgetClass pointer to be cast to
--   a GObjectClass pointer.

    getWidgetClassParentClass               ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_parentClass                 ,
#endif


-- ** queryTooltip #attr:queryTooltip#
-- | /No description available in the introspection data./

    clearWidgetClassQueryTooltip            ,
    getWidgetClassQueryTooltip              ,
    setWidgetClassQueryTooltip              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_queryTooltip                ,
#endif


-- ** realize #attr:realize#
-- | /No description available in the introspection data./

    clearWidgetClassRealize                 ,
    getWidgetClassRealize                   ,
    setWidgetClassRealize                   ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_realize                     ,
#endif


-- ** root #attr:root#
-- | /No description available in the introspection data./

    clearWidgetClassRoot                    ,
    getWidgetClassRoot                      ,
    setWidgetClassRoot                      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_root                        ,
#endif


-- ** setFocusChild #attr:setFocusChild#
-- | /No description available in the introspection data./

    clearWidgetClassSetFocusChild           ,
    getWidgetClassSetFocusChild             ,
    setWidgetClassSetFocusChild             ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_setFocusChild               ,
#endif


-- ** show #attr:show#
-- | /No description available in the introspection data./

    clearWidgetClassShow                    ,
    getWidgetClassShow                      ,
    setWidgetClassShow                      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_show                        ,
#endif


-- ** sizeAllocate #attr:sizeAllocate#
-- | /No description available in the introspection data./

    clearWidgetClassSizeAllocate            ,
    getWidgetClassSizeAllocate              ,
    setWidgetClassSizeAllocate              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_sizeAllocate                ,
#endif


-- ** snapshot #attr:snapshot#
-- | /No description available in the introspection data./

    clearWidgetClassSnapshot                ,
    getWidgetClassSnapshot                  ,
    setWidgetClassSnapshot                  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_snapshot                    ,
#endif


-- ** stateFlagsChanged #attr:stateFlagsChanged#
-- | /No description available in the introspection data./

    clearWidgetClassStateFlagsChanged       ,
    getWidgetClassStateFlagsChanged         ,
    setWidgetClassStateFlagsChanged         ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_stateFlagsChanged           ,
#endif


-- ** systemSettingChanged #attr:systemSettingChanged#
-- | /No description available in the introspection data./

    clearWidgetClassSystemSettingChanged    ,
    getWidgetClassSystemSettingChanged      ,
    setWidgetClassSystemSettingChanged      ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_systemSettingChanged        ,
#endif


-- ** unmap #attr:unmap#
-- | /No description available in the introspection data./

    clearWidgetClassUnmap                   ,
    getWidgetClassUnmap                     ,
    setWidgetClassUnmap                     ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_unmap                       ,
#endif


-- ** unrealize #attr:unrealize#
-- | /No description available in the introspection data./

    clearWidgetClassUnrealize               ,
    getWidgetClassUnrealize                 ,
    setWidgetClassUnrealize                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_unrealize                   ,
#endif


-- ** unroot #attr:unroot#
-- | /No description available in the introspection data./

    clearWidgetClassUnroot                  ,
    getWidgetClassUnroot                    ,
    setWidgetClassUnroot                    ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_unroot                      ,
#endif




    ) 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.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.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.VariantType as GLib.VariantType
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Structs.InitiallyUnownedClass as GObject.InitiallyUnownedClass
import qualified GI.Gtk.Callbacks as Gtk.Callbacks
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Interfaces.BuilderScope as Gtk.BuilderScope
import {-# SOURCE #-} qualified GI.Gtk.Objects.Shortcut as Gtk.Shortcut

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

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

instance BoxedPtr WidgetClass where
    boxedPtrCopy :: WidgetClass -> IO WidgetClass
boxedPtrCopy = \WidgetClass
p -> WidgetClass
-> (Ptr WidgetClass -> IO WidgetClass) -> IO WidgetClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr WidgetClass
p (Int -> Ptr WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
408 (Ptr WidgetClass -> IO (Ptr WidgetClass))
-> (Ptr WidgetClass -> IO WidgetClass)
-> Ptr WidgetClass
-> IO WidgetClass
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr WidgetClass -> WidgetClass)
-> Ptr WidgetClass -> IO WidgetClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr WidgetClass -> WidgetClass
WidgetClass)
    boxedPtrFree :: WidgetClass -> IO ()
boxedPtrFree = \WidgetClass
x -> WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr WidgetClass
x Ptr WidgetClass -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr WidgetClass where
    boxedPtrCalloc :: IO (Ptr WidgetClass)
boxedPtrCalloc = Int -> IO (Ptr WidgetClass)
forall a. Int -> IO (Ptr a)
callocBytes Int
408


-- | Construct a `WidgetClass` struct initialized to zero.
newZeroWidgetClass :: MonadIO m => m WidgetClass
newZeroWidgetClass :: forall (m :: * -> *). MonadIO m => m WidgetClass
newZeroWidgetClass = IO WidgetClass -> m WidgetClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO WidgetClass -> m WidgetClass)
-> IO WidgetClass -> m WidgetClass
forall a b. (a -> b) -> a -> b
$ IO (Ptr WidgetClass)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr WidgetClass)
-> (Ptr WidgetClass -> IO WidgetClass) -> IO WidgetClass
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr WidgetClass -> WidgetClass)
-> Ptr WidgetClass -> IO WidgetClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr WidgetClass -> WidgetClass
WidgetClass

instance tag ~ 'AttrSet => Constructible WidgetClass tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr WidgetClass -> WidgetClass)
-> [AttrOp WidgetClass tag] -> m WidgetClass
new ManagedPtr WidgetClass -> WidgetClass
_ [AttrOp WidgetClass tag]
attrs = do
        WidgetClass
o <- m WidgetClass
forall (m :: * -> *). MonadIO m => m WidgetClass
newZeroWidgetClass
        WidgetClass -> [AttrOp WidgetClass 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set WidgetClass
o [AttrOp WidgetClass tag]
[AttrOp WidgetClass 'AttrSet]
attrs
        WidgetClass -> m WidgetClass
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClass
o


-- | Get the value of the “@parent_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #parentClass
-- @
getWidgetClassParentClass :: MonadIO m => WidgetClass -> m GObject.InitiallyUnownedClass.InitiallyUnownedClass
getWidgetClassParentClass :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m InitiallyUnownedClass
getWidgetClassParentClass WidgetClass
s = IO InitiallyUnownedClass -> m InitiallyUnownedClass
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InitiallyUnownedClass -> m InitiallyUnownedClass)
-> IO InitiallyUnownedClass -> m InitiallyUnownedClass
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO InitiallyUnownedClass)
-> IO InitiallyUnownedClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO InitiallyUnownedClass)
 -> IO InitiallyUnownedClass)
-> (Ptr WidgetClass -> IO InitiallyUnownedClass)
-> IO InitiallyUnownedClass
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    let val :: Ptr InitiallyUnownedClass
val = Ptr WidgetClass
ptr Ptr WidgetClass -> Int -> Ptr InitiallyUnownedClass
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
    InitiallyUnownedClass
val' <- ((ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass)
-> Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass
GObject.InitiallyUnownedClass.InitiallyUnownedClass) Ptr InitiallyUnownedClass
val
    InitiallyUnownedClass -> IO InitiallyUnownedClass
forall (m :: * -> *) a. Monad m => a -> m a
return InitiallyUnownedClass
val'

#if defined(ENABLE_OVERLOADING)
data WidgetClassParentClassFieldInfo
instance AttrInfo WidgetClassParentClassFieldInfo where
    type AttrBaseTypeConstraint WidgetClassParentClassFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassParentClassFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WidgetClassParentClassFieldInfo = (~) (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
    type AttrTransferTypeConstraint WidgetClassParentClassFieldInfo = (~)(Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
    type AttrTransferType WidgetClassParentClassFieldInfo = (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
    type AttrGetType WidgetClassParentClassFieldInfo = GObject.InitiallyUnownedClass.InitiallyUnownedClass
    type AttrLabel WidgetClassParentClassFieldInfo = "parent_class"
    type AttrOrigin WidgetClassParentClassFieldInfo = WidgetClass
    attrGet = getWidgetClassParentClass
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

widgetClass_parentClass :: AttrLabelProxy "parentClass"
widgetClass_parentClass = AttrLabelProxy

#endif


-- | Get the value of the “@show@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #show
-- @
getWidgetClassShow :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassShowFieldCallback)
getWidgetClassShow :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassShow WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassShowFieldCallback
val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
    Maybe WidgetClassShowFieldCallback
result <- FunPtr C_WidgetClassShowFieldCallback
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassShowFieldCallback
val ((FunPtr C_WidgetClassShowFieldCallback
  -> IO WidgetClassShowFieldCallback)
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassShowFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    Maybe WidgetClassShowFieldCallback
-> IO (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowFieldCallback
result

-- | Set the value of the “@show@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #show 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassShow :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback -> m ()
setWidgetClassShow :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassShow WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)

-- | Set the value of the “@show@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #show
-- @
clearWidgetClassShow :: MonadIO m => WidgetClass -> m ()
clearWidgetClassShow :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassShow WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassShowFieldInfo
instance AttrInfo WidgetClassShowFieldInfo where
    type AttrBaseTypeConstraint WidgetClassShowFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassShowFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassShowFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
    type AttrTransferTypeConstraint WidgetClassShowFieldInfo = (~)Gtk.Callbacks.WidgetClassShowFieldCallback
    type AttrTransferType WidgetClassShowFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
    type AttrGetType WidgetClassShowFieldInfo = Maybe Gtk.Callbacks.WidgetClassShowFieldCallback
    type AttrLabel WidgetClassShowFieldInfo = "show"
    type AttrOrigin WidgetClassShowFieldInfo = WidgetClass
    attrGet = getWidgetClassShow
    attrSet = setWidgetClassShow
    attrConstruct = undefined
    attrClear = clearWidgetClassShow
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassShowFieldCallback (Gtk.Callbacks.wrap_WidgetClassShowFieldCallback Nothing v)

widgetClass_show :: AttrLabelProxy "show"
widgetClass_show = AttrLabelProxy

#endif


-- | Get the value of the “@hide@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #hide
-- @
getWidgetClassHide :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassHideFieldCallback)
getWidgetClassHide :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassHide WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassShowFieldCallback
val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
    Maybe WidgetClassShowFieldCallback
result <- FunPtr C_WidgetClassShowFieldCallback
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassShowFieldCallback
val ((FunPtr C_WidgetClassShowFieldCallback
  -> IO WidgetClassShowFieldCallback)
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassHideFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    Maybe WidgetClassShowFieldCallback
-> IO (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowFieldCallback
result

-- | Set the value of the “@hide@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #hide 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassHide :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback -> m ()
setWidgetClassHide :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassHide WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)

-- | Set the value of the “@hide@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #hide
-- @
clearWidgetClassHide :: MonadIO m => WidgetClass -> m ()
clearWidgetClassHide :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassHide WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassHideFieldInfo
instance AttrInfo WidgetClassHideFieldInfo where
    type AttrBaseTypeConstraint WidgetClassHideFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassHideFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassHideFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
    type AttrTransferTypeConstraint WidgetClassHideFieldInfo = (~)Gtk.Callbacks.WidgetClassHideFieldCallback
    type AttrTransferType WidgetClassHideFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
    type AttrGetType WidgetClassHideFieldInfo = Maybe Gtk.Callbacks.WidgetClassHideFieldCallback
    type AttrLabel WidgetClassHideFieldInfo = "hide"
    type AttrOrigin WidgetClassHideFieldInfo = WidgetClass
    attrGet = getWidgetClassHide
    attrSet = setWidgetClassHide
    attrConstruct = undefined
    attrClear = clearWidgetClassHide
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassHideFieldCallback (Gtk.Callbacks.wrap_WidgetClassHideFieldCallback Nothing v)

widgetClass_hide :: AttrLabelProxy "hide"
widgetClass_hide = AttrLabelProxy

#endif


-- | Get the value of the “@map@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #map
-- @
getWidgetClassMap :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMapFieldCallback)
getWidgetClassMap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassMap WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassShowFieldCallback
val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
    Maybe WidgetClassShowFieldCallback
result <- FunPtr C_WidgetClassShowFieldCallback
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassShowFieldCallback
val ((FunPtr C_WidgetClassShowFieldCallback
  -> IO WidgetClassShowFieldCallback)
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassMapFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    Maybe WidgetClassShowFieldCallback
-> IO (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowFieldCallback
result

-- | Set the value of the “@map@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #map 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMap :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback -> m ()
setWidgetClassMap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassMap WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)

-- | Set the value of the “@map@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #map
-- @
clearWidgetClassMap :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMap :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMap WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMapFieldInfo
instance AttrInfo WidgetClassMapFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMapFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMapFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMapFieldInfo = (~)Gtk.Callbacks.WidgetClassMapFieldCallback
    type AttrTransferType WidgetClassMapFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
    type AttrGetType WidgetClassMapFieldInfo = Maybe Gtk.Callbacks.WidgetClassMapFieldCallback
    type AttrLabel WidgetClassMapFieldInfo = "map"
    type AttrOrigin WidgetClassMapFieldInfo = WidgetClass
    attrGet = getWidgetClassMap
    attrSet = setWidgetClassMap
    attrConstruct = undefined
    attrClear = clearWidgetClassMap
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMapFieldCallback (Gtk.Callbacks.wrap_WidgetClassMapFieldCallback Nothing v)

widgetClass_map :: AttrLabelProxy "map"
widgetClass_map = AttrLabelProxy

#endif


-- | Get the value of the “@unmap@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #unmap
-- @
getWidgetClassUnmap :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnmapFieldCallback)
getWidgetClassUnmap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassUnmap WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassShowFieldCallback
val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
    Maybe WidgetClassShowFieldCallback
result <- FunPtr C_WidgetClassShowFieldCallback
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassShowFieldCallback
val ((FunPtr C_WidgetClassShowFieldCallback
  -> IO WidgetClassShowFieldCallback)
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnmapFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    Maybe WidgetClassShowFieldCallback
-> IO (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowFieldCallback
result

-- | Set the value of the “@unmap@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #unmap 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassUnmap :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback -> m ()
setWidgetClassUnmap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassUnmap WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)

-- | Set the value of the “@unmap@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #unmap
-- @
clearWidgetClassUnmap :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnmap :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassUnmap WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassUnmapFieldInfo
instance AttrInfo WidgetClassUnmapFieldInfo where
    type AttrBaseTypeConstraint WidgetClassUnmapFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassUnmapFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassUnmapFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
    type AttrTransferTypeConstraint WidgetClassUnmapFieldInfo = (~)Gtk.Callbacks.WidgetClassUnmapFieldCallback
    type AttrTransferType WidgetClassUnmapFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
    type AttrGetType WidgetClassUnmapFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnmapFieldCallback
    type AttrLabel WidgetClassUnmapFieldInfo = "unmap"
    type AttrOrigin WidgetClassUnmapFieldInfo = WidgetClass
    attrGet = getWidgetClassUnmap
    attrSet = setWidgetClassUnmap
    attrConstruct = undefined
    attrClear = clearWidgetClassUnmap
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassUnmapFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnmapFieldCallback Nothing v)

widgetClass_unmap :: AttrLabelProxy "unmap"
widgetClass_unmap = AttrLabelProxy

#endif


-- | Get the value of the “@realize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #realize
-- @
getWidgetClassRealize :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassRealizeFieldCallback)
getWidgetClassRealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassRealize WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassShowFieldCallback
val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
    Maybe WidgetClassShowFieldCallback
result <- FunPtr C_WidgetClassShowFieldCallback
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassShowFieldCallback
val ((FunPtr C_WidgetClassShowFieldCallback
  -> IO WidgetClassShowFieldCallback)
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassRealizeFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    Maybe WidgetClassShowFieldCallback
-> IO (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowFieldCallback
result

-- | Set the value of the “@realize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #realize 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassRealize :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback -> m ()
setWidgetClassRealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassRealize WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)

-- | Set the value of the “@realize@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #realize
-- @
clearWidgetClassRealize :: MonadIO m => WidgetClass -> m ()
clearWidgetClassRealize :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassRealize WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassRealizeFieldInfo
instance AttrInfo WidgetClassRealizeFieldInfo where
    type AttrBaseTypeConstraint WidgetClassRealizeFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassRealizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassRealizeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
    type AttrTransferTypeConstraint WidgetClassRealizeFieldInfo = (~)Gtk.Callbacks.WidgetClassRealizeFieldCallback
    type AttrTransferType WidgetClassRealizeFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
    type AttrGetType WidgetClassRealizeFieldInfo = Maybe Gtk.Callbacks.WidgetClassRealizeFieldCallback
    type AttrLabel WidgetClassRealizeFieldInfo = "realize"
    type AttrOrigin WidgetClassRealizeFieldInfo = WidgetClass
    attrGet = getWidgetClassRealize
    attrSet = setWidgetClassRealize
    attrConstruct = undefined
    attrClear = clearWidgetClassRealize
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassRealizeFieldCallback (Gtk.Callbacks.wrap_WidgetClassRealizeFieldCallback Nothing v)

widgetClass_realize :: AttrLabelProxy "realize"
widgetClass_realize = AttrLabelProxy

#endif


-- | Get the value of the “@unrealize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #unrealize
-- @
getWidgetClassUnrealize :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnrealizeFieldCallback)
getWidgetClassUnrealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassUnrealize WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassShowFieldCallback
val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
    Maybe WidgetClassShowFieldCallback
result <- FunPtr C_WidgetClassShowFieldCallback
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassShowFieldCallback
val ((FunPtr C_WidgetClassShowFieldCallback
  -> IO WidgetClassShowFieldCallback)
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnrealizeFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    Maybe WidgetClassShowFieldCallback
-> IO (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowFieldCallback
result

-- | Set the value of the “@unrealize@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #unrealize 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassUnrealize :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback -> m ()
setWidgetClassUnrealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassUnrealize WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)

-- | Set the value of the “@unrealize@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #unrealize
-- @
clearWidgetClassUnrealize :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnrealize :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassUnrealize WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassUnrealizeFieldInfo
instance AttrInfo WidgetClassUnrealizeFieldInfo where
    type AttrBaseTypeConstraint WidgetClassUnrealizeFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassUnrealizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassUnrealizeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
    type AttrTransferTypeConstraint WidgetClassUnrealizeFieldInfo = (~)Gtk.Callbacks.WidgetClassUnrealizeFieldCallback
    type AttrTransferType WidgetClassUnrealizeFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
    type AttrGetType WidgetClassUnrealizeFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnrealizeFieldCallback
    type AttrLabel WidgetClassUnrealizeFieldInfo = "unrealize"
    type AttrOrigin WidgetClassUnrealizeFieldInfo = WidgetClass
    attrGet = getWidgetClassUnrealize
    attrSet = setWidgetClassUnrealize
    attrConstruct = undefined
    attrClear = clearWidgetClassUnrealize
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassUnrealizeFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnrealizeFieldCallback Nothing v)

widgetClass_unrealize :: AttrLabelProxy "unrealize"
widgetClass_unrealize = AttrLabelProxy

#endif


-- | Get the value of the “@root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #root
-- @
getWidgetClassRoot :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassRootFieldCallback)
getWidgetClassRoot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassRoot WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassShowFieldCallback
val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
    Maybe WidgetClassShowFieldCallback
result <- FunPtr C_WidgetClassShowFieldCallback
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassShowFieldCallback
val ((FunPtr C_WidgetClassShowFieldCallback
  -> IO WidgetClassShowFieldCallback)
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassRootFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    Maybe WidgetClassShowFieldCallback
-> IO (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowFieldCallback
result

-- | Set the value of the “@root@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #root 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassRoot :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback -> m ()
setWidgetClassRoot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassRoot WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)

-- | Set the value of the “@root@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #root
-- @
clearWidgetClassRoot :: MonadIO m => WidgetClass -> m ()
clearWidgetClassRoot :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassRoot WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassRootFieldInfo
instance AttrInfo WidgetClassRootFieldInfo where
    type AttrBaseTypeConstraint WidgetClassRootFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassRootFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassRootFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
    type AttrTransferTypeConstraint WidgetClassRootFieldInfo = (~)Gtk.Callbacks.WidgetClassRootFieldCallback
    type AttrTransferType WidgetClassRootFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
    type AttrGetType WidgetClassRootFieldInfo = Maybe Gtk.Callbacks.WidgetClassRootFieldCallback
    type AttrLabel WidgetClassRootFieldInfo = "root"
    type AttrOrigin WidgetClassRootFieldInfo = WidgetClass
    attrGet = getWidgetClassRoot
    attrSet = setWidgetClassRoot
    attrConstruct = undefined
    attrClear = clearWidgetClassRoot
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassRootFieldCallback (Gtk.Callbacks.wrap_WidgetClassRootFieldCallback Nothing v)

widgetClass_root :: AttrLabelProxy "root"
widgetClass_root = AttrLabelProxy

#endif


-- | Get the value of the “@unroot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #unroot
-- @
getWidgetClassUnroot :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnrootFieldCallback)
getWidgetClassUnroot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowFieldCallback)
getWidgetClassUnroot WidgetClass
s = IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassShowFieldCallback)
 -> m (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
-> m (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassShowFieldCallback))
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassShowFieldCallback
val <- Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> IO (FunPtr C_WidgetClassShowFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
    Maybe WidgetClassShowFieldCallback
result <- FunPtr C_WidgetClassShowFieldCallback
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassShowFieldCallback
val ((FunPtr C_WidgetClassShowFieldCallback
  -> IO WidgetClassShowFieldCallback)
 -> IO (Maybe WidgetClassShowFieldCallback))
-> (FunPtr C_WidgetClassShowFieldCallback
    -> IO WidgetClassShowFieldCallback)
-> IO (Maybe WidgetClassShowFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassShowFieldCallback
val' -> do
        let val'' :: WidgetClassShowFieldCallback
val'' = FunPtr C_WidgetClassShowFieldCallback
-> WidgetClassShowFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassShowFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnrootFieldCallback FunPtr C_WidgetClassShowFieldCallback
val'
        WidgetClassShowFieldCallback -> IO WidgetClassShowFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowFieldCallback
val''
    Maybe WidgetClassShowFieldCallback
-> IO (Maybe WidgetClassShowFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowFieldCallback
result

-- | Set the value of the “@unroot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #unroot 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassUnroot :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback -> m ()
setWidgetClassUnroot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassShowFieldCallback -> m ()
setWidgetClassUnroot WidgetClass
s FunPtr C_WidgetClassShowFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_WidgetClassShowFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)

-- | Set the value of the “@unroot@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #unroot
-- @
clearWidgetClassUnroot :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnroot :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassUnroot WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassShowFieldCallback)
-> FunPtr C_WidgetClassShowFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassShowFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_WidgetClassShowFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassUnrootFieldInfo
instance AttrInfo WidgetClassUnrootFieldInfo where
    type AttrBaseTypeConstraint WidgetClassUnrootFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassUnrootFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassUnrootFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
    type AttrTransferTypeConstraint WidgetClassUnrootFieldInfo = (~)Gtk.Callbacks.WidgetClassUnrootFieldCallback
    type AttrTransferType WidgetClassUnrootFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
    type AttrGetType WidgetClassUnrootFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnrootFieldCallback
    type AttrLabel WidgetClassUnrootFieldInfo = "unroot"
    type AttrOrigin WidgetClassUnrootFieldInfo = WidgetClass
    attrGet = getWidgetClassUnroot
    attrSet = setWidgetClassUnroot
    attrConstruct = undefined
    attrClear = clearWidgetClassUnroot
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassUnrootFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnrootFieldCallback Nothing v)

widgetClass_unroot :: AttrLabelProxy "unroot"
widgetClass_unroot = AttrLabelProxy

#endif


-- | Get the value of the “@size_allocate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #sizeAllocate
-- @
getWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback)
getWidgetClassSizeAllocate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassSizeAllocateFieldCallback)
getWidgetClassSizeAllocate WidgetClass
s = IO (Maybe WidgetClassSizeAllocateFieldCallback)
-> m (Maybe WidgetClassSizeAllocateFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassSizeAllocateFieldCallback)
 -> m (Maybe WidgetClassSizeAllocateFieldCallback))
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
-> m (Maybe WidgetClassSizeAllocateFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
 -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassSizeAllocateFieldCallback
val <- Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
-> IO (FunPtr C_WidgetClassSizeAllocateFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
    Maybe WidgetClassSizeAllocateFieldCallback
result <- FunPtr C_WidgetClassSizeAllocateFieldCallback
-> (FunPtr C_WidgetClassSizeAllocateFieldCallback
    -> IO WidgetClassSizeAllocateFieldCallback)
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSizeAllocateFieldCallback
val ((FunPtr C_WidgetClassSizeAllocateFieldCallback
  -> IO WidgetClassSizeAllocateFieldCallback)
 -> IO (Maybe WidgetClassSizeAllocateFieldCallback))
-> (FunPtr C_WidgetClassSizeAllocateFieldCallback
    -> IO WidgetClassSizeAllocateFieldCallback)
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassSizeAllocateFieldCallback
val' -> do
        let val'' :: WidgetClassSizeAllocateFieldCallback
val'' = FunPtr C_WidgetClassSizeAllocateFieldCallback
-> WidgetClassSizeAllocateFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassSizeAllocateFieldCallback
-> a -> Int32 -> Int32 -> Int32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassSizeAllocateFieldCallback FunPtr C_WidgetClassSizeAllocateFieldCallback
val'
        WidgetClassSizeAllocateFieldCallback
-> IO WidgetClassSizeAllocateFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSizeAllocateFieldCallback
val''
    Maybe WidgetClassSizeAllocateFieldCallback
-> IO (Maybe WidgetClassSizeAllocateFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSizeAllocateFieldCallback
result

-- | Set the value of the “@size_allocate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #sizeAllocate 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback -> m ()
setWidgetClassSizeAllocate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSizeAllocateFieldCallback -> m ()
setWidgetClassSizeAllocate WidgetClass
s FunPtr C_WidgetClassSizeAllocateFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
-> FunPtr C_WidgetClassSizeAllocateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_WidgetClassSizeAllocateFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)

-- | Set the value of the “@size_allocate@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #sizeAllocate
-- @
clearWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSizeAllocate :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSizeAllocate WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
-> FunPtr C_WidgetClassSizeAllocateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSizeAllocateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_WidgetClassSizeAllocateFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSizeAllocateFieldInfo
instance AttrInfo WidgetClassSizeAllocateFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSizeAllocateFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSizeAllocateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSizeAllocateFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSizeAllocateFieldInfo = (~)Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback
    type AttrTransferType WidgetClassSizeAllocateFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
    type AttrGetType WidgetClassSizeAllocateFieldInfo = Maybe Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback
    type AttrLabel WidgetClassSizeAllocateFieldInfo = "size_allocate"
    type AttrOrigin WidgetClassSizeAllocateFieldInfo = WidgetClass
    attrGet = getWidgetClassSizeAllocate
    attrSet = setWidgetClassSizeAllocate
    attrConstruct = undefined
    attrClear = clearWidgetClassSizeAllocate
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSizeAllocateFieldCallback (Gtk.Callbacks.wrap_WidgetClassSizeAllocateFieldCallback Nothing v)

widgetClass_sizeAllocate :: AttrLabelProxy "sizeAllocate"
widgetClass_sizeAllocate = AttrLabelProxy

#endif


-- | Get the value of the “@state_flags_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #stateFlagsChanged
-- @
getWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback)
getWidgetClassStateFlagsChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
getWidgetClassStateFlagsChanged WidgetClass
s = IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
-> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
 -> m (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
-> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
 -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
    Maybe WidgetClassStateFlagsChangedFieldCallback
result <- FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> IO WidgetClassStateFlagsChangedFieldCallback)
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val ((FunPtr C_WidgetClassStateFlagsChangedFieldCallback
  -> IO WidgetClassStateFlagsChangedFieldCallback)
 -> IO (Maybe WidgetClassStateFlagsChangedFieldCallback))
-> (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> IO WidgetClassStateFlagsChangedFieldCallback)
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val' -> do
        let val'' :: WidgetClassStateFlagsChangedFieldCallback
val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> WidgetClassStateFlagsChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> a -> [StateFlags] -> m ()
Gtk.Callbacks.dynamic_WidgetClassStateFlagsChangedFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val'
        WidgetClassStateFlagsChangedFieldCallback
-> IO WidgetClassStateFlagsChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassStateFlagsChangedFieldCallback
val''
    Maybe WidgetClassStateFlagsChangedFieldCallback
-> IO (Maybe WidgetClassStateFlagsChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassStateFlagsChangedFieldCallback
result

-- | Set the value of the “@state_flags_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #stateFlagsChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassStateFlagsChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassStateFlagsChanged WidgetClass
s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)

-- | Set the value of the “@state_flags_changed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #stateFlagsChanged
-- @
clearWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStateFlagsChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassStateFlagsChanged WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassStateFlagsChangedFieldInfo
instance AttrInfo WidgetClassStateFlagsChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassStateFlagsChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassStateFlagsChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassStateFlagsChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassStateFlagsChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback
    type AttrTransferType WidgetClassStateFlagsChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
    type AttrGetType WidgetClassStateFlagsChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback
    type AttrLabel WidgetClassStateFlagsChangedFieldInfo = "state_flags_changed"
    type AttrOrigin WidgetClassStateFlagsChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassStateFlagsChanged
    attrSet = setWidgetClassStateFlagsChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassStateFlagsChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassStateFlagsChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassStateFlagsChangedFieldCallback Nothing v)

widgetClass_stateFlagsChanged :: AttrLabelProxy "stateFlagsChanged"
widgetClass_stateFlagsChanged = AttrLabelProxy

#endif


-- | Get the value of the “@direction_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #directionChanged
-- @
getWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback)
getWidgetClassDirectionChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDirectionChangedFieldCallback)
getWidgetClassDirectionChanged WidgetClass
s = IO (Maybe WidgetClassDirectionChangedFieldCallback)
-> m (Maybe WidgetClassDirectionChangedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDirectionChangedFieldCallback)
 -> m (Maybe WidgetClassDirectionChangedFieldCallback))
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
-> m (Maybe WidgetClassDirectionChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
 -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
216) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
    Maybe WidgetClassDirectionChangedFieldCallback
result <- FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> IO WidgetClassDirectionChangedFieldCallback)
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val ((FunPtr C_WidgetClassStateFlagsChangedFieldCallback
  -> IO WidgetClassDirectionChangedFieldCallback)
 -> IO (Maybe WidgetClassDirectionChangedFieldCallback))
-> (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> IO WidgetClassDirectionChangedFieldCallback)
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val' -> do
        let val'' :: WidgetClassDirectionChangedFieldCallback
val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> WidgetClassDirectionChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> a -> TextDirection -> m ()
Gtk.Callbacks.dynamic_WidgetClassDirectionChangedFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val'
        WidgetClassDirectionChangedFieldCallback
-> IO WidgetClassDirectionChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDirectionChangedFieldCallback
val''
    Maybe WidgetClassDirectionChangedFieldCallback
-> IO (Maybe WidgetClassDirectionChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDirectionChangedFieldCallback
result

-- | Set the value of the “@direction_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #directionChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback -> m ()
setWidgetClassDirectionChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassDirectionChanged WidgetClass
s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
216) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)

-- | Set the value of the “@direction_changed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #directionChanged
-- @
clearWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDirectionChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDirectionChanged WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
216) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDirectionChangedFieldInfo
instance AttrInfo WidgetClassDirectionChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDirectionChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDirectionChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDirectionChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDirectionChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback
    type AttrTransferType WidgetClassDirectionChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
    type AttrGetType WidgetClassDirectionChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback
    type AttrLabel WidgetClassDirectionChangedFieldInfo = "direction_changed"
    type AttrOrigin WidgetClassDirectionChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassDirectionChanged
    attrSet = setWidgetClassDirectionChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassDirectionChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDirectionChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassDirectionChangedFieldCallback Nothing v)

widgetClass_directionChanged :: AttrLabelProxy "directionChanged"
widgetClass_directionChanged = AttrLabelProxy

#endif


-- | Get the value of the “@get_request_mode@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #getRequestMode
-- @
getWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback)
getWidgetClassGetRequestMode :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGetRequestModeFieldCallback)
getWidgetClassGetRequestMode WidgetClass
s = IO (Maybe WidgetClassGetRequestModeFieldCallback)
-> m (Maybe WidgetClassGetRequestModeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassGetRequestModeFieldCallback)
 -> m (Maybe WidgetClassGetRequestModeFieldCallback))
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
-> m (Maybe WidgetClassGetRequestModeFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
 -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassGetRequestModeFieldCallback
val <- Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
-> IO (FunPtr C_WidgetClassGetRequestModeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
    Maybe WidgetClassGetRequestModeFieldCallback
result <- FunPtr C_WidgetClassGetRequestModeFieldCallback
-> (FunPtr C_WidgetClassGetRequestModeFieldCallback
    -> IO WidgetClassGetRequestModeFieldCallback)
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGetRequestModeFieldCallback
val ((FunPtr C_WidgetClassGetRequestModeFieldCallback
  -> IO WidgetClassGetRequestModeFieldCallback)
 -> IO (Maybe WidgetClassGetRequestModeFieldCallback))
-> (FunPtr C_WidgetClassGetRequestModeFieldCallback
    -> IO WidgetClassGetRequestModeFieldCallback)
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGetRequestModeFieldCallback
val' -> do
        let val'' :: WidgetClassGetRequestModeFieldCallback
val'' = FunPtr C_WidgetClassGetRequestModeFieldCallback
-> WidgetClassGetRequestModeFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGetRequestModeFieldCallback
-> a -> m SizeRequestMode
Gtk.Callbacks.dynamic_WidgetClassGetRequestModeFieldCallback FunPtr C_WidgetClassGetRequestModeFieldCallback
val'
        WidgetClassGetRequestModeFieldCallback
-> IO WidgetClassGetRequestModeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetRequestModeFieldCallback
val''
    Maybe WidgetClassGetRequestModeFieldCallback
-> IO (Maybe WidgetClassGetRequestModeFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGetRequestModeFieldCallback
result

-- | Set the value of the “@get_request_mode@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #getRequestMode 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback -> m ()
setWidgetClassGetRequestMode :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassGetRequestModeFieldCallback -> m ()
setWidgetClassGetRequestMode WidgetClass
s FunPtr C_WidgetClassGetRequestModeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
-> FunPtr C_WidgetClassGetRequestModeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) (FunPtr C_WidgetClassGetRequestModeFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)

-- | Set the value of the “@get_request_mode@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #getRequestMode
-- @
clearWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetRequestMode :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGetRequestMode WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
-> FunPtr C_WidgetClassGetRequestModeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetRequestModeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) (FunPtr C_WidgetClassGetRequestModeFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetRequestModeFieldInfo
instance AttrInfo WidgetClassGetRequestModeFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGetRequestModeFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGetRequestModeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGetRequestModeFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGetRequestModeFieldInfo = (~)Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback
    type AttrTransferType WidgetClassGetRequestModeFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
    type AttrGetType WidgetClassGetRequestModeFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback
    type AttrLabel WidgetClassGetRequestModeFieldInfo = "get_request_mode"
    type AttrOrigin WidgetClassGetRequestModeFieldInfo = WidgetClass
    attrGet = getWidgetClassGetRequestMode
    attrSet = setWidgetClassGetRequestMode
    attrConstruct = undefined
    attrClear = clearWidgetClassGetRequestMode
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGetRequestModeFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetRequestModeFieldCallback Nothing v)

widgetClass_getRequestMode :: AttrLabelProxy "getRequestMode"
widgetClass_getRequestMode = AttrLabelProxy

#endif


-- | Get the value of the “@measure@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #measure
-- @
getWidgetClassMeasure :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMeasureFieldCallback)
getWidgetClassMeasure :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassMeasureFieldCallback)
getWidgetClassMeasure WidgetClass
s = IO (Maybe WidgetClassMeasureFieldCallback)
-> m (Maybe WidgetClassMeasureFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassMeasureFieldCallback)
 -> m (Maybe WidgetClassMeasureFieldCallback))
-> IO (Maybe WidgetClassMeasureFieldCallback)
-> m (Maybe WidgetClassMeasureFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassMeasureFieldCallback))
-> IO (Maybe WidgetClassMeasureFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassMeasureFieldCallback))
 -> IO (Maybe WidgetClassMeasureFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassMeasureFieldCallback))
-> IO (Maybe WidgetClassMeasureFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassMeasureFieldCallback
val <- Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
-> IO (FunPtr C_WidgetClassMeasureFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)
    Maybe WidgetClassMeasureFieldCallback
result <- FunPtr C_WidgetClassMeasureFieldCallback
-> (FunPtr C_WidgetClassMeasureFieldCallback
    -> IO WidgetClassMeasureFieldCallback)
-> IO (Maybe WidgetClassMeasureFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassMeasureFieldCallback
val ((FunPtr C_WidgetClassMeasureFieldCallback
  -> IO WidgetClassMeasureFieldCallback)
 -> IO (Maybe WidgetClassMeasureFieldCallback))
-> (FunPtr C_WidgetClassMeasureFieldCallback
    -> IO WidgetClassMeasureFieldCallback)
-> IO (Maybe WidgetClassMeasureFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassMeasureFieldCallback
val' -> do
        let val'' :: WidgetClassMeasureFieldCallback
val'' = FunPtr C_WidgetClassMeasureFieldCallback
-> WidgetClassMeasureFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassMeasureFieldCallback
-> a -> Orientation -> Int32 -> m (Int32, Int32, Int32, Int32)
Gtk.Callbacks.dynamic_WidgetClassMeasureFieldCallback FunPtr C_WidgetClassMeasureFieldCallback
val'
        WidgetClassMeasureFieldCallback
-> IO WidgetClassMeasureFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMeasureFieldCallback
val''
    Maybe WidgetClassMeasureFieldCallback
-> IO (Maybe WidgetClassMeasureFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassMeasureFieldCallback
result

-- | Set the value of the “@measure@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #measure 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMeasure :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback -> m ()
setWidgetClassMeasure :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassMeasureFieldCallback -> m ()
setWidgetClassMeasure WidgetClass
s FunPtr C_WidgetClassMeasureFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
-> FunPtr C_WidgetClassMeasureFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) (FunPtr C_WidgetClassMeasureFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)

-- | Set the value of the “@measure@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #measure
-- @
clearWidgetClassMeasure :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMeasure :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMeasure WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
-> FunPtr C_WidgetClassMeasureFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMeasureFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) (FunPtr C_WidgetClassMeasureFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMeasureFieldInfo
instance AttrInfo WidgetClassMeasureFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMeasureFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMeasureFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMeasureFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMeasureFieldInfo = (~)Gtk.Callbacks.WidgetClassMeasureFieldCallback
    type AttrTransferType WidgetClassMeasureFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMeasureFieldCallback)
    type AttrGetType WidgetClassMeasureFieldInfo = Maybe Gtk.Callbacks.WidgetClassMeasureFieldCallback
    type AttrLabel WidgetClassMeasureFieldInfo = "measure"
    type AttrOrigin WidgetClassMeasureFieldInfo = WidgetClass
    attrGet = getWidgetClassMeasure
    attrSet = setWidgetClassMeasure
    attrConstruct = undefined
    attrClear = clearWidgetClassMeasure
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMeasureFieldCallback (Gtk.Callbacks.wrap_WidgetClassMeasureFieldCallback Nothing v)

widgetClass_measure :: AttrLabelProxy "measure"
widgetClass_measure = AttrLabelProxy

#endif


-- | Get the value of the “@mnemonic_activate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #mnemonicActivate
-- @
getWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback)
getWidgetClassMnemonicActivate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassMnemonicActivateFieldCallback)
getWidgetClassMnemonicActivate WidgetClass
s = IO (Maybe WidgetClassMnemonicActivateFieldCallback)
-> m (Maybe WidgetClassMnemonicActivateFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassMnemonicActivateFieldCallback)
 -> m (Maybe WidgetClassMnemonicActivateFieldCallback))
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
-> m (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
 -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassMnemonicActivateFieldCallback
val <- Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
-> IO (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
    Maybe WidgetClassMnemonicActivateFieldCallback
result <- FunPtr C_WidgetClassMnemonicActivateFieldCallback
-> (FunPtr C_WidgetClassMnemonicActivateFieldCallback
    -> IO WidgetClassMnemonicActivateFieldCallback)
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassMnemonicActivateFieldCallback
val ((FunPtr C_WidgetClassMnemonicActivateFieldCallback
  -> IO WidgetClassMnemonicActivateFieldCallback)
 -> IO (Maybe WidgetClassMnemonicActivateFieldCallback))
-> (FunPtr C_WidgetClassMnemonicActivateFieldCallback
    -> IO WidgetClassMnemonicActivateFieldCallback)
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassMnemonicActivateFieldCallback
val' -> do
        let val'' :: WidgetClassMnemonicActivateFieldCallback
val'' = FunPtr C_WidgetClassMnemonicActivateFieldCallback
-> WidgetClassMnemonicActivateFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassMnemonicActivateFieldCallback
-> a -> Bool -> m Bool
Gtk.Callbacks.dynamic_WidgetClassMnemonicActivateFieldCallback FunPtr C_WidgetClassMnemonicActivateFieldCallback
val'
        WidgetClassMnemonicActivateFieldCallback
-> IO WidgetClassMnemonicActivateFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMnemonicActivateFieldCallback
val''
    Maybe WidgetClassMnemonicActivateFieldCallback
-> IO (Maybe WidgetClassMnemonicActivateFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassMnemonicActivateFieldCallback
result

-- | Set the value of the “@mnemonic_activate@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #mnemonicActivate 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback -> m ()
setWidgetClassMnemonicActivate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> m ()
setWidgetClassMnemonicActivate WidgetClass
s FunPtr C_WidgetClassMnemonicActivateFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
-> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_WidgetClassMnemonicActivateFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)

-- | Set the value of the “@mnemonic_activate@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #mnemonicActivate
-- @
clearWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMnemonicActivate :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMnemonicActivate WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
-> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassMnemonicActivateFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_WidgetClassMnemonicActivateFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMnemonicActivateFieldInfo
instance AttrInfo WidgetClassMnemonicActivateFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMnemonicActivateFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMnemonicActivateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMnemonicActivateFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMnemonicActivateFieldInfo = (~)Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback
    type AttrTransferType WidgetClassMnemonicActivateFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
    type AttrGetType WidgetClassMnemonicActivateFieldInfo = Maybe Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback
    type AttrLabel WidgetClassMnemonicActivateFieldInfo = "mnemonic_activate"
    type AttrOrigin WidgetClassMnemonicActivateFieldInfo = WidgetClass
    attrGet = getWidgetClassMnemonicActivate
    attrSet = setWidgetClassMnemonicActivate
    attrConstruct = undefined
    attrClear = clearWidgetClassMnemonicActivate
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMnemonicActivateFieldCallback (Gtk.Callbacks.wrap_WidgetClassMnemonicActivateFieldCallback Nothing v)

widgetClass_mnemonicActivate :: AttrLabelProxy "mnemonicActivate"
widgetClass_mnemonicActivate = AttrLabelProxy

#endif


-- | Get the value of the “@grab_focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #grabFocus
-- @
getWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGrabFocusFieldCallback)
getWidgetClassGrabFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGrabFocusFieldCallback)
getWidgetClassGrabFocus WidgetClass
s = IO (Maybe WidgetClassGrabFocusFieldCallback)
-> m (Maybe WidgetClassGrabFocusFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassGrabFocusFieldCallback)
 -> m (Maybe WidgetClassGrabFocusFieldCallback))
-> IO (Maybe WidgetClassGrabFocusFieldCallback)
-> m (Maybe WidgetClassGrabFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGrabFocusFieldCallback))
-> IO (Maybe WidgetClassGrabFocusFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassGrabFocusFieldCallback))
 -> IO (Maybe WidgetClassGrabFocusFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGrabFocusFieldCallback))
-> IO (Maybe WidgetClassGrabFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassGrabFocusFieldCallback
val <- Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
-> IO (FunPtr C_WidgetClassGrabFocusFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
    Maybe WidgetClassGrabFocusFieldCallback
result <- FunPtr C_WidgetClassGrabFocusFieldCallback
-> (FunPtr C_WidgetClassGrabFocusFieldCallback
    -> IO WidgetClassGrabFocusFieldCallback)
-> IO (Maybe WidgetClassGrabFocusFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGrabFocusFieldCallback
val ((FunPtr C_WidgetClassGrabFocusFieldCallback
  -> IO WidgetClassGrabFocusFieldCallback)
 -> IO (Maybe WidgetClassGrabFocusFieldCallback))
-> (FunPtr C_WidgetClassGrabFocusFieldCallback
    -> IO WidgetClassGrabFocusFieldCallback)
-> IO (Maybe WidgetClassGrabFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGrabFocusFieldCallback
val' -> do
        let val'' :: WidgetClassGrabFocusFieldCallback
val'' = FunPtr C_WidgetClassGrabFocusFieldCallback
-> WidgetClassGrabFocusFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGrabFocusFieldCallback -> a -> m Bool
Gtk.Callbacks.dynamic_WidgetClassGrabFocusFieldCallback FunPtr C_WidgetClassGrabFocusFieldCallback
val'
        WidgetClassGrabFocusFieldCallback
-> IO WidgetClassGrabFocusFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGrabFocusFieldCallback
val''
    Maybe WidgetClassGrabFocusFieldCallback
-> IO (Maybe WidgetClassGrabFocusFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGrabFocusFieldCallback
result

-- | Set the value of the “@grab_focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #grabFocus 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGrabFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback -> m ()
setWidgetClassGrabFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassGrabFocusFieldCallback -> m ()
setWidgetClassGrabFocus WidgetClass
s FunPtr C_WidgetClassGrabFocusFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
-> FunPtr C_WidgetClassGrabFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (FunPtr C_WidgetClassGrabFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)

-- | Set the value of the “@grab_focus@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #grabFocus
-- @
clearWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabFocus WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
-> FunPtr C_WidgetClassGrabFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (FunPtr C_WidgetClassGrabFocusFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGrabFocusFieldInfo
instance AttrInfo WidgetClassGrabFocusFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGrabFocusFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGrabFocusFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGrabFocusFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGrabFocusFieldInfo = (~)Gtk.Callbacks.WidgetClassGrabFocusFieldCallback
    type AttrTransferType WidgetClassGrabFocusFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
    type AttrGetType WidgetClassGrabFocusFieldInfo = Maybe Gtk.Callbacks.WidgetClassGrabFocusFieldCallback
    type AttrLabel WidgetClassGrabFocusFieldInfo = "grab_focus"
    type AttrOrigin WidgetClassGrabFocusFieldInfo = WidgetClass
    attrGet = getWidgetClassGrabFocus
    attrSet = setWidgetClassGrabFocus
    attrConstruct = undefined
    attrClear = clearWidgetClassGrabFocus
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGrabFocusFieldCallback (Gtk.Callbacks.wrap_WidgetClassGrabFocusFieldCallback Nothing v)

widgetClass_grabFocus :: AttrLabelProxy "grabFocus"
widgetClass_grabFocus = AttrLabelProxy

#endif


-- | Get the value of the “@focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #focus
-- @
getWidgetClassFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassFocusFieldCallback)
getWidgetClassFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassFocus WidgetClass
s = IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassFocusFieldCallback)
 -> m (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
 -> IO (Maybe WidgetClassFocusFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassFocusFieldCallback
val <- Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> IO (FunPtr C_WidgetClassFocusFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
    Maybe WidgetClassFocusFieldCallback
result <- FunPtr C_WidgetClassFocusFieldCallback
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassFocusFieldCallback)
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusFieldCallback
val ((FunPtr C_WidgetClassFocusFieldCallback
  -> IO WidgetClassFocusFieldCallback)
 -> IO (Maybe WidgetClassFocusFieldCallback))
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassFocusFieldCallback)
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassFocusFieldCallback
val' -> do
        let val'' :: WidgetClassFocusFieldCallback
val'' = FunPtr C_WidgetClassFocusFieldCallback
-> WidgetClassFocusFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusFieldCallback
-> a -> DirectionType -> m Bool
Gtk.Callbacks.dynamic_WidgetClassFocusFieldCallback FunPtr C_WidgetClassFocusFieldCallback
val'
        WidgetClassFocusFieldCallback -> IO WidgetClassFocusFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusFieldCallback
val''
    Maybe WidgetClassFocusFieldCallback
-> IO (Maybe WidgetClassFocusFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassFocusFieldCallback
result

-- | Set the value of the “@focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #focus 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassFocus WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (FunPtr C_WidgetClassFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)

-- | Set the value of the “@focus@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #focus
-- @
clearWidgetClassFocus :: MonadIO m => WidgetClass -> m ()
clearWidgetClassFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassFocus WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (FunPtr C_WidgetClassFocusFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassFocusFieldInfo
instance AttrInfo WidgetClassFocusFieldInfo where
    type AttrBaseTypeConstraint WidgetClassFocusFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassFocusFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassFocusFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
    type AttrTransferTypeConstraint WidgetClassFocusFieldInfo = (~)Gtk.Callbacks.WidgetClassFocusFieldCallback
    type AttrTransferType WidgetClassFocusFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
    type AttrGetType WidgetClassFocusFieldInfo = Maybe Gtk.Callbacks.WidgetClassFocusFieldCallback
    type AttrLabel WidgetClassFocusFieldInfo = "focus"
    type AttrOrigin WidgetClassFocusFieldInfo = WidgetClass
    attrGet = getWidgetClassFocus
    attrSet = setWidgetClassFocus
    attrConstruct = undefined
    attrClear = clearWidgetClassFocus
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassFocusFieldCallback (Gtk.Callbacks.wrap_WidgetClassFocusFieldCallback Nothing v)

widgetClass_focus :: AttrLabelProxy "focus"
widgetClass_focus = AttrLabelProxy

#endif


-- | Get the value of the “@set_focus_child@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #setFocusChild
-- @
getWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSetFocusChildFieldCallback)
getWidgetClassSetFocusChild :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassSetFocusChildFieldCallback)
getWidgetClassSetFocusChild WidgetClass
s = IO (Maybe WidgetClassSetFocusChildFieldCallback)
-> m (Maybe WidgetClassSetFocusChildFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassSetFocusChildFieldCallback)
 -> m (Maybe WidgetClassSetFocusChildFieldCallback))
-> IO (Maybe WidgetClassSetFocusChildFieldCallback)
-> m (Maybe WidgetClassSetFocusChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
-> IO (Maybe WidgetClassSetFocusChildFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
 -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
-> IO (Maybe WidgetClassSetFocusChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassSetFocusChildFieldCallback
val <- Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
-> IO (FunPtr C_WidgetClassSetFocusChildFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)
    Maybe WidgetClassSetFocusChildFieldCallback
result <- FunPtr C_WidgetClassSetFocusChildFieldCallback
-> (FunPtr C_WidgetClassSetFocusChildFieldCallback
    -> IO WidgetClassSetFocusChildFieldCallback)
-> IO (Maybe WidgetClassSetFocusChildFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSetFocusChildFieldCallback
val ((FunPtr C_WidgetClassSetFocusChildFieldCallback
  -> IO WidgetClassSetFocusChildFieldCallback)
 -> IO (Maybe WidgetClassSetFocusChildFieldCallback))
-> (FunPtr C_WidgetClassSetFocusChildFieldCallback
    -> IO WidgetClassSetFocusChildFieldCallback)
-> IO (Maybe WidgetClassSetFocusChildFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassSetFocusChildFieldCallback
val' -> do
        let val'' :: WidgetClassSetFocusChildFieldCallback
val'' = FunPtr C_WidgetClassSetFocusChildFieldCallback
-> WidgetClassSetFocusChildFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
FunPtr C_WidgetClassSetFocusChildFieldCallback
-> a -> Maybe b -> m ()
Gtk.Callbacks.dynamic_WidgetClassSetFocusChildFieldCallback FunPtr C_WidgetClassSetFocusChildFieldCallback
val'
        WidgetClassSetFocusChildFieldCallback
-> IO WidgetClassSetFocusChildFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSetFocusChildFieldCallback
val''
    Maybe WidgetClassSetFocusChildFieldCallback
-> IO (Maybe WidgetClassSetFocusChildFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSetFocusChildFieldCallback
result

-- | Set the value of the “@set_focus_child@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #setFocusChild 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback -> m ()
setWidgetClassSetFocusChild :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSetFocusChildFieldCallback -> m ()
setWidgetClassSetFocusChild WidgetClass
s FunPtr C_WidgetClassSetFocusChildFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
-> FunPtr C_WidgetClassSetFocusChildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (FunPtr C_WidgetClassSetFocusChildFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)

-- | Set the value of the “@set_focus_child@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #setFocusChild
-- @
clearWidgetClassSetFocusChild :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSetFocusChild :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSetFocusChild WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
-> FunPtr C_WidgetClassSetFocusChildFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSetFocusChildFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (FunPtr C_WidgetClassSetFocusChildFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetFocusChildFieldInfo
instance AttrInfo WidgetClassSetFocusChildFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSetFocusChildFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSetFocusChildFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSetFocusChildFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSetFocusChildFieldInfo = (~)Gtk.Callbacks.WidgetClassSetFocusChildFieldCallback
    type AttrTransferType WidgetClassSetFocusChildFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSetFocusChildFieldCallback)
    type AttrGetType WidgetClassSetFocusChildFieldInfo = Maybe Gtk.Callbacks.WidgetClassSetFocusChildFieldCallback
    type AttrLabel WidgetClassSetFocusChildFieldInfo = "set_focus_child"
    type AttrOrigin WidgetClassSetFocusChildFieldInfo = WidgetClass
    attrGet = getWidgetClassSetFocusChild
    attrSet = setWidgetClassSetFocusChild
    attrConstruct = undefined
    attrClear = clearWidgetClassSetFocusChild
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSetFocusChildFieldCallback (Gtk.Callbacks.wrap_WidgetClassSetFocusChildFieldCallback Nothing v)

widgetClass_setFocusChild :: AttrLabelProxy "setFocusChild"
widgetClass_setFocusChild = AttrLabelProxy

#endif


-- | Get the value of the “@move_focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #moveFocus
-- @
getWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMoveFocusFieldCallback)
getWidgetClassMoveFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassMoveFocusFieldCallback)
getWidgetClassMoveFocus WidgetClass
s = IO (Maybe WidgetClassMoveFocusFieldCallback)
-> m (Maybe WidgetClassMoveFocusFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassMoveFocusFieldCallback)
 -> m (Maybe WidgetClassMoveFocusFieldCallback))
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
-> m (Maybe WidgetClassMoveFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassMoveFocusFieldCallback))
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassMoveFocusFieldCallback))
 -> IO (Maybe WidgetClassMoveFocusFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassMoveFocusFieldCallback))
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
    Maybe WidgetClassMoveFocusFieldCallback
result <- FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> IO WidgetClassMoveFocusFieldCallback)
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val ((FunPtr C_WidgetClassStateFlagsChangedFieldCallback
  -> IO WidgetClassMoveFocusFieldCallback)
 -> IO (Maybe WidgetClassMoveFocusFieldCallback))
-> (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> IO WidgetClassMoveFocusFieldCallback)
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val' -> do
        let val'' :: WidgetClassMoveFocusFieldCallback
val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> WidgetClassMoveFocusFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> a -> DirectionType -> m ()
Gtk.Callbacks.dynamic_WidgetClassMoveFocusFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val'
        WidgetClassMoveFocusFieldCallback
-> IO WidgetClassMoveFocusFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMoveFocusFieldCallback
val''
    Maybe WidgetClassMoveFocusFieldCallback
-> IO (Maybe WidgetClassMoveFocusFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassMoveFocusFieldCallback
result

-- | Set the value of the “@move_focus@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #moveFocus 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassMoveFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback -> m ()
setWidgetClassMoveFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassMoveFocus WidgetClass
s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)

-- | Set the value of the “@move_focus@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #moveFocus
-- @
clearWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMoveFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMoveFocus WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassMoveFocusFieldInfo
instance AttrInfo WidgetClassMoveFocusFieldInfo where
    type AttrBaseTypeConstraint WidgetClassMoveFocusFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassMoveFocusFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassMoveFocusFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
    type AttrTransferTypeConstraint WidgetClassMoveFocusFieldInfo = (~)Gtk.Callbacks.WidgetClassMoveFocusFieldCallback
    type AttrTransferType WidgetClassMoveFocusFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
    type AttrGetType WidgetClassMoveFocusFieldInfo = Maybe Gtk.Callbacks.WidgetClassMoveFocusFieldCallback
    type AttrLabel WidgetClassMoveFocusFieldInfo = "move_focus"
    type AttrOrigin WidgetClassMoveFocusFieldInfo = WidgetClass
    attrGet = getWidgetClassMoveFocus
    attrSet = setWidgetClassMoveFocus
    attrConstruct = undefined
    attrClear = clearWidgetClassMoveFocus
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassMoveFocusFieldCallback (Gtk.Callbacks.wrap_WidgetClassMoveFocusFieldCallback Nothing v)

widgetClass_moveFocus :: AttrLabelProxy "moveFocus"
widgetClass_moveFocus = AttrLabelProxy

#endif


-- | Get the value of the “@keynav_failed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #keynavFailed
-- @
getWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback)
getWidgetClassKeynavFailed :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassKeynavFailed WidgetClass
s = IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassFocusFieldCallback)
 -> m (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
-> m (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
 -> IO (Maybe WidgetClassFocusFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassFocusFieldCallback))
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassFocusFieldCallback
val <- Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> IO (FunPtr C_WidgetClassFocusFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
    Maybe WidgetClassFocusFieldCallback
result <- FunPtr C_WidgetClassFocusFieldCallback
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassFocusFieldCallback)
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusFieldCallback
val ((FunPtr C_WidgetClassFocusFieldCallback
  -> IO WidgetClassFocusFieldCallback)
 -> IO (Maybe WidgetClassFocusFieldCallback))
-> (FunPtr C_WidgetClassFocusFieldCallback
    -> IO WidgetClassFocusFieldCallback)
-> IO (Maybe WidgetClassFocusFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassFocusFieldCallback
val' -> do
        let val'' :: WidgetClassFocusFieldCallback
val'' = FunPtr C_WidgetClassFocusFieldCallback
-> WidgetClassFocusFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusFieldCallback
-> a -> DirectionType -> m Bool
Gtk.Callbacks.dynamic_WidgetClassKeynavFailedFieldCallback FunPtr C_WidgetClassFocusFieldCallback
val'
        WidgetClassFocusFieldCallback -> IO WidgetClassFocusFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusFieldCallback
val''
    Maybe WidgetClassFocusFieldCallback
-> IO (Maybe WidgetClassFocusFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassFocusFieldCallback
result

-- | Set the value of the “@keynav_failed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #keynavFailed 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback -> m ()
setWidgetClassKeynavFailed :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassKeynavFailed WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (FunPtr C_WidgetClassFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)

-- | Set the value of the “@keynav_failed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #keynavFailed
-- @
clearWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m ()
clearWidgetClassKeynavFailed :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassKeynavFailed WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassFocusFieldCallback)
-> FunPtr C_WidgetClassFocusFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassFocusFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (FunPtr C_WidgetClassFocusFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassKeynavFailedFieldInfo
instance AttrInfo WidgetClassKeynavFailedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassKeynavFailedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassKeynavFailedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassKeynavFailedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassKeynavFailedFieldInfo = (~)Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback
    type AttrTransferType WidgetClassKeynavFailedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
    type AttrGetType WidgetClassKeynavFailedFieldInfo = Maybe Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback
    type AttrLabel WidgetClassKeynavFailedFieldInfo = "keynav_failed"
    type AttrOrigin WidgetClassKeynavFailedFieldInfo = WidgetClass
    attrGet = getWidgetClassKeynavFailed
    attrSet = setWidgetClassKeynavFailed
    attrConstruct = undefined
    attrClear = clearWidgetClassKeynavFailed
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassKeynavFailedFieldCallback (Gtk.Callbacks.wrap_WidgetClassKeynavFailedFieldCallback Nothing v)

widgetClass_keynavFailed :: AttrLabelProxy "keynavFailed"
widgetClass_keynavFailed = AttrLabelProxy

#endif


-- | Get the value of the “@query_tooltip@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #queryTooltip
-- @
getWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback)
getWidgetClassQueryTooltip :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassQueryTooltipFieldCallback)
getWidgetClassQueryTooltip WidgetClass
s = IO (Maybe WidgetClassQueryTooltipFieldCallback)
-> m (Maybe WidgetClassQueryTooltipFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassQueryTooltipFieldCallback)
 -> m (Maybe WidgetClassQueryTooltipFieldCallback))
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
-> m (Maybe WidgetClassQueryTooltipFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
 -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassQueryTooltipFieldCallback
val <- Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
-> IO (FunPtr C_WidgetClassQueryTooltipFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
    Maybe WidgetClassQueryTooltipFieldCallback
result <- FunPtr C_WidgetClassQueryTooltipFieldCallback
-> (FunPtr C_WidgetClassQueryTooltipFieldCallback
    -> IO WidgetClassQueryTooltipFieldCallback)
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassQueryTooltipFieldCallback
val ((FunPtr C_WidgetClassQueryTooltipFieldCallback
  -> IO WidgetClassQueryTooltipFieldCallback)
 -> IO (Maybe WidgetClassQueryTooltipFieldCallback))
-> (FunPtr C_WidgetClassQueryTooltipFieldCallback
    -> IO WidgetClassQueryTooltipFieldCallback)
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassQueryTooltipFieldCallback
val' -> do
        let val'' :: WidgetClassQueryTooltipFieldCallback
val'' = FunPtr C_WidgetClassQueryTooltipFieldCallback
-> WidgetClassQueryTooltipFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsTooltip b) =>
FunPtr C_WidgetClassQueryTooltipFieldCallback
-> a -> Int32 -> Int32 -> Bool -> b -> m Bool
Gtk.Callbacks.dynamic_WidgetClassQueryTooltipFieldCallback FunPtr C_WidgetClassQueryTooltipFieldCallback
val'
        WidgetClassQueryTooltipFieldCallback
-> IO WidgetClassQueryTooltipFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassQueryTooltipFieldCallback
val''
    Maybe WidgetClassQueryTooltipFieldCallback
-> IO (Maybe WidgetClassQueryTooltipFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassQueryTooltipFieldCallback
result

-- | Set the value of the “@query_tooltip@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #queryTooltip 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback -> m ()
setWidgetClassQueryTooltip :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassQueryTooltipFieldCallback -> m ()
setWidgetClassQueryTooltip WidgetClass
s FunPtr C_WidgetClassQueryTooltipFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
-> FunPtr C_WidgetClassQueryTooltipFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) (FunPtr C_WidgetClassQueryTooltipFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)

-- | Set the value of the “@query_tooltip@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #queryTooltip
-- @
clearWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m ()
clearWidgetClassQueryTooltip :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassQueryTooltip WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
-> FunPtr C_WidgetClassQueryTooltipFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassQueryTooltipFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) (FunPtr C_WidgetClassQueryTooltipFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassQueryTooltipFieldInfo
instance AttrInfo WidgetClassQueryTooltipFieldInfo where
    type AttrBaseTypeConstraint WidgetClassQueryTooltipFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassQueryTooltipFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassQueryTooltipFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
    type AttrTransferTypeConstraint WidgetClassQueryTooltipFieldInfo = (~)Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback
    type AttrTransferType WidgetClassQueryTooltipFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
    type AttrGetType WidgetClassQueryTooltipFieldInfo = Maybe Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback
    type AttrLabel WidgetClassQueryTooltipFieldInfo = "query_tooltip"
    type AttrOrigin WidgetClassQueryTooltipFieldInfo = WidgetClass
    attrGet = getWidgetClassQueryTooltip
    attrSet = setWidgetClassQueryTooltip
    attrConstruct = undefined
    attrClear = clearWidgetClassQueryTooltip
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassQueryTooltipFieldCallback (Gtk.Callbacks.wrap_WidgetClassQueryTooltipFieldCallback Nothing v)

widgetClass_queryTooltip :: AttrLabelProxy "queryTooltip"
widgetClass_queryTooltip = AttrLabelProxy

#endif


-- | Get the value of the “@compute_expand@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #computeExpand
-- @
getWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassComputeExpandFieldCallback)
getWidgetClassComputeExpand :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassComputeExpandFieldCallback)
getWidgetClassComputeExpand WidgetClass
s = IO (Maybe WidgetClassComputeExpandFieldCallback)
-> m (Maybe WidgetClassComputeExpandFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassComputeExpandFieldCallback)
 -> m (Maybe WidgetClassComputeExpandFieldCallback))
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
-> m (Maybe WidgetClassComputeExpandFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassComputeExpandFieldCallback))
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassComputeExpandFieldCallback))
 -> IO (Maybe WidgetClassComputeExpandFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassComputeExpandFieldCallback))
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassComputeExpandFieldCallback
val <- Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
-> IO (FunPtr C_WidgetClassComputeExpandFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
296) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
    Maybe WidgetClassComputeExpandFieldCallback
result <- FunPtr C_WidgetClassComputeExpandFieldCallback
-> (FunPtr C_WidgetClassComputeExpandFieldCallback
    -> IO WidgetClassComputeExpandFieldCallback)
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassComputeExpandFieldCallback
val ((FunPtr C_WidgetClassComputeExpandFieldCallback
  -> IO WidgetClassComputeExpandFieldCallback)
 -> IO (Maybe WidgetClassComputeExpandFieldCallback))
-> (FunPtr C_WidgetClassComputeExpandFieldCallback
    -> IO WidgetClassComputeExpandFieldCallback)
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassComputeExpandFieldCallback
val' -> do
        let val'' :: WidgetClassComputeExpandFieldCallback
val'' = FunPtr C_WidgetClassComputeExpandFieldCallback
-> WidgetClassComputeExpandFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassComputeExpandFieldCallback
-> a -> Bool -> Bool -> m ()
Gtk.Callbacks.dynamic_WidgetClassComputeExpandFieldCallback FunPtr C_WidgetClassComputeExpandFieldCallback
val'
        WidgetClassComputeExpandFieldCallback
-> IO WidgetClassComputeExpandFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassComputeExpandFieldCallback
val''
    Maybe WidgetClassComputeExpandFieldCallback
-> IO (Maybe WidgetClassComputeExpandFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassComputeExpandFieldCallback
result

-- | Set the value of the “@compute_expand@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #computeExpand 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassComputeExpand :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback -> m ()
setWidgetClassComputeExpand :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassComputeExpandFieldCallback -> m ()
setWidgetClassComputeExpand WidgetClass
s FunPtr C_WidgetClassComputeExpandFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
-> FunPtr C_WidgetClassComputeExpandFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
296) (FunPtr C_WidgetClassComputeExpandFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)

-- | Set the value of the “@compute_expand@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #computeExpand
-- @
clearWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m ()
clearWidgetClassComputeExpand :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassComputeExpand WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
-> FunPtr C_WidgetClassComputeExpandFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassComputeExpandFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
296) (FunPtr C_WidgetClassComputeExpandFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassComputeExpandFieldInfo
instance AttrInfo WidgetClassComputeExpandFieldInfo where
    type AttrBaseTypeConstraint WidgetClassComputeExpandFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassComputeExpandFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassComputeExpandFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
    type AttrTransferTypeConstraint WidgetClassComputeExpandFieldInfo = (~)Gtk.Callbacks.WidgetClassComputeExpandFieldCallback
    type AttrTransferType WidgetClassComputeExpandFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
    type AttrGetType WidgetClassComputeExpandFieldInfo = Maybe Gtk.Callbacks.WidgetClassComputeExpandFieldCallback
    type AttrLabel WidgetClassComputeExpandFieldInfo = "compute_expand"
    type AttrOrigin WidgetClassComputeExpandFieldInfo = WidgetClass
    attrGet = getWidgetClassComputeExpand
    attrSet = setWidgetClassComputeExpand
    attrConstruct = undefined
    attrClear = clearWidgetClassComputeExpand
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassComputeExpandFieldCallback (Gtk.Callbacks.wrap_WidgetClassComputeExpandFieldCallback Nothing v)

widgetClass_computeExpand :: AttrLabelProxy "computeExpand"
widgetClass_computeExpand = AttrLabelProxy

#endif


-- | Get the value of the “@css_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #cssChanged
-- @
getWidgetClassCssChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassCssChangedFieldCallback)
getWidgetClassCssChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassCssChangedFieldCallback)
getWidgetClassCssChanged WidgetClass
s = IO (Maybe WidgetClassCssChangedFieldCallback)
-> m (Maybe WidgetClassCssChangedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassCssChangedFieldCallback)
 -> m (Maybe WidgetClassCssChangedFieldCallback))
-> IO (Maybe WidgetClassCssChangedFieldCallback)
-> m (Maybe WidgetClassCssChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassCssChangedFieldCallback))
-> IO (Maybe WidgetClassCssChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassCssChangedFieldCallback))
 -> IO (Maybe WidgetClassCssChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassCssChangedFieldCallback))
-> IO (Maybe WidgetClassCssChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassCssChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
-> IO (FunPtr C_WidgetClassCssChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)
    Maybe WidgetClassCssChangedFieldCallback
result <- FunPtr C_WidgetClassCssChangedFieldCallback
-> (FunPtr C_WidgetClassCssChangedFieldCallback
    -> IO WidgetClassCssChangedFieldCallback)
-> IO (Maybe WidgetClassCssChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassCssChangedFieldCallback
val ((FunPtr C_WidgetClassCssChangedFieldCallback
  -> IO WidgetClassCssChangedFieldCallback)
 -> IO (Maybe WidgetClassCssChangedFieldCallback))
-> (FunPtr C_WidgetClassCssChangedFieldCallback
    -> IO WidgetClassCssChangedFieldCallback)
-> IO (Maybe WidgetClassCssChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassCssChangedFieldCallback
val' -> do
        let val'' :: WidgetClassCssChangedFieldCallback
val'' = FunPtr C_WidgetClassCssChangedFieldCallback
-> WidgetClassCssChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassCssChangedFieldCallback
-> a -> CssStyleChange -> m ()
Gtk.Callbacks.dynamic_WidgetClassCssChangedFieldCallback FunPtr C_WidgetClassCssChangedFieldCallback
val'
        WidgetClassCssChangedFieldCallback
-> IO WidgetClassCssChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassCssChangedFieldCallback
val''
    Maybe WidgetClassCssChangedFieldCallback
-> IO (Maybe WidgetClassCssChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassCssChangedFieldCallback
result

-- | Set the value of the “@css_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #cssChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassCssChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback -> m ()
setWidgetClassCssChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassCssChangedFieldCallback -> m ()
setWidgetClassCssChanged WidgetClass
s FunPtr C_WidgetClassCssChangedFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
-> FunPtr C_WidgetClassCssChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) (FunPtr C_WidgetClassCssChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)

-- | Set the value of the “@css_changed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #cssChanged
-- @
clearWidgetClassCssChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassCssChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassCssChanged WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
-> FunPtr C_WidgetClassCssChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCssChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) (FunPtr C_WidgetClassCssChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassCssChangedFieldInfo
instance AttrInfo WidgetClassCssChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassCssChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassCssChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassCssChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassCssChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassCssChangedFieldCallback
    type AttrTransferType WidgetClassCssChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassCssChangedFieldCallback)
    type AttrGetType WidgetClassCssChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassCssChangedFieldCallback
    type AttrLabel WidgetClassCssChangedFieldInfo = "css_changed"
    type AttrOrigin WidgetClassCssChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassCssChanged
    attrSet = setWidgetClassCssChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassCssChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassCssChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassCssChangedFieldCallback Nothing v)

widgetClass_cssChanged :: AttrLabelProxy "cssChanged"
widgetClass_cssChanged = AttrLabelProxy

#endif


-- | Get the value of the “@system_setting_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #systemSettingChanged
-- @
getWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSystemSettingChangedFieldCallback)
getWidgetClassSystemSettingChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassSystemSettingChangedFieldCallback)
getWidgetClassSystemSettingChanged WidgetClass
s = IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
-> m (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
 -> m (Maybe WidgetClassSystemSettingChangedFieldCallback))
-> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
-> m (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
-> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass
  -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
 -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
-> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val <- Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> IO (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)
    Maybe WidgetClassSystemSettingChangedFieldCallback
result <- FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> IO WidgetClassSystemSettingChangedFieldCallback)
-> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val ((FunPtr C_WidgetClassStateFlagsChangedFieldCallback
  -> IO WidgetClassSystemSettingChangedFieldCallback)
 -> IO (Maybe WidgetClassSystemSettingChangedFieldCallback))
-> (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
    -> IO WidgetClassSystemSettingChangedFieldCallback)
-> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val' -> do
        let val'' :: WidgetClassSystemSettingChangedFieldCallback
val'' = FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> WidgetClassSystemSettingChangedFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateFlagsChangedFieldCallback
-> a -> SystemSetting -> m ()
Gtk.Callbacks.dynamic_WidgetClassSystemSettingChangedFieldCallback FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val'
        WidgetClassSystemSettingChangedFieldCallback
-> IO WidgetClassSystemSettingChangedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSystemSettingChangedFieldCallback
val''
    Maybe WidgetClassSystemSettingChangedFieldCallback
-> IO (Maybe WidgetClassSystemSettingChangedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSystemSettingChangedFieldCallback
result

-- | Set the value of the “@system_setting_changed@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #systemSettingChanged 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback -> m ()
setWidgetClassSystemSettingChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassSystemSettingChanged WidgetClass
s FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)

-- | Set the value of the “@system_setting_changed@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #systemSettingChanged
-- @
clearWidgetClassSystemSettingChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSystemSettingChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSystemSettingChanged WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassStateFlagsChangedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) (FunPtr C_WidgetClassStateFlagsChangedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSystemSettingChangedFieldInfo
instance AttrInfo WidgetClassSystemSettingChangedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSystemSettingChangedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSystemSettingChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSystemSettingChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSystemSettingChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassSystemSettingChangedFieldCallback
    type AttrTransferType WidgetClassSystemSettingChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSystemSettingChangedFieldCallback)
    type AttrGetType WidgetClassSystemSettingChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassSystemSettingChangedFieldCallback
    type AttrLabel WidgetClassSystemSettingChangedFieldInfo = "system_setting_changed"
    type AttrOrigin WidgetClassSystemSettingChangedFieldInfo = WidgetClass
    attrGet = getWidgetClassSystemSettingChanged
    attrSet = setWidgetClassSystemSettingChanged
    attrConstruct = undefined
    attrClear = clearWidgetClassSystemSettingChanged
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSystemSettingChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassSystemSettingChangedFieldCallback Nothing v)

widgetClass_systemSettingChanged :: AttrLabelProxy "systemSettingChanged"
widgetClass_systemSettingChanged = AttrLabelProxy

#endif


-- | Get the value of the “@snapshot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #snapshot
-- @
getWidgetClassSnapshot :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSnapshotFieldCallback)
getWidgetClassSnapshot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassSnapshotFieldCallback)
getWidgetClassSnapshot WidgetClass
s = IO (Maybe WidgetClassSnapshotFieldCallback)
-> m (Maybe WidgetClassSnapshotFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassSnapshotFieldCallback)
 -> m (Maybe WidgetClassSnapshotFieldCallback))
-> IO (Maybe WidgetClassSnapshotFieldCallback)
-> m (Maybe WidgetClassSnapshotFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassSnapshotFieldCallback))
-> IO (Maybe WidgetClassSnapshotFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassSnapshotFieldCallback))
 -> IO (Maybe WidgetClassSnapshotFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassSnapshotFieldCallback))
-> IO (Maybe WidgetClassSnapshotFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassSnapshotFieldCallback
val <- Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
-> IO (FunPtr C_WidgetClassSnapshotFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)
    Maybe WidgetClassSnapshotFieldCallback
result <- FunPtr C_WidgetClassSnapshotFieldCallback
-> (FunPtr C_WidgetClassSnapshotFieldCallback
    -> IO WidgetClassSnapshotFieldCallback)
-> IO (Maybe WidgetClassSnapshotFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSnapshotFieldCallback
val ((FunPtr C_WidgetClassSnapshotFieldCallback
  -> IO WidgetClassSnapshotFieldCallback)
 -> IO (Maybe WidgetClassSnapshotFieldCallback))
-> (FunPtr C_WidgetClassSnapshotFieldCallback
    -> IO WidgetClassSnapshotFieldCallback)
-> IO (Maybe WidgetClassSnapshotFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassSnapshotFieldCallback
val' -> do
        let val'' :: WidgetClassSnapshotFieldCallback
val'' = FunPtr C_WidgetClassSnapshotFieldCallback
-> WidgetClassSnapshotFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsSnapshot b) =>
FunPtr C_WidgetClassSnapshotFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassSnapshotFieldCallback FunPtr C_WidgetClassSnapshotFieldCallback
val'
        WidgetClassSnapshotFieldCallback
-> IO WidgetClassSnapshotFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSnapshotFieldCallback
val''
    Maybe WidgetClassSnapshotFieldCallback
-> IO (Maybe WidgetClassSnapshotFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSnapshotFieldCallback
result

-- | Set the value of the “@snapshot@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #snapshot 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassSnapshot :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback -> m ()
setWidgetClassSnapshot :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassSnapshotFieldCallback -> m ()
setWidgetClassSnapshot WidgetClass
s FunPtr C_WidgetClassSnapshotFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
-> FunPtr C_WidgetClassSnapshotFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) (FunPtr C_WidgetClassSnapshotFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)

-- | Set the value of the “@snapshot@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #snapshot
-- @
clearWidgetClassSnapshot :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSnapshot :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSnapshot WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
-> FunPtr C_WidgetClassSnapshotFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassSnapshotFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) (FunPtr C_WidgetClassSnapshotFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassSnapshotFieldInfo
instance AttrInfo WidgetClassSnapshotFieldInfo where
    type AttrBaseTypeConstraint WidgetClassSnapshotFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassSnapshotFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassSnapshotFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)
    type AttrTransferTypeConstraint WidgetClassSnapshotFieldInfo = (~)Gtk.Callbacks.WidgetClassSnapshotFieldCallback
    type AttrTransferType WidgetClassSnapshotFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSnapshotFieldCallback)
    type AttrGetType WidgetClassSnapshotFieldInfo = Maybe Gtk.Callbacks.WidgetClassSnapshotFieldCallback
    type AttrLabel WidgetClassSnapshotFieldInfo = "snapshot"
    type AttrOrigin WidgetClassSnapshotFieldInfo = WidgetClass
    attrGet = getWidgetClassSnapshot
    attrSet = setWidgetClassSnapshot
    attrConstruct = undefined
    attrClear = clearWidgetClassSnapshot
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassSnapshotFieldCallback (Gtk.Callbacks.wrap_WidgetClassSnapshotFieldCallback Nothing v)

widgetClass_snapshot :: AttrLabelProxy "snapshot"
widgetClass_snapshot = AttrLabelProxy

#endif


-- | Get the value of the “@contains@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #contains
-- @
getWidgetClassContains :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassContainsFieldCallback)
getWidgetClassContains :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassContainsFieldCallback)
getWidgetClassContains WidgetClass
s = IO (Maybe WidgetClassContainsFieldCallback)
-> m (Maybe WidgetClassContainsFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassContainsFieldCallback)
 -> m (Maybe WidgetClassContainsFieldCallback))
-> IO (Maybe WidgetClassContainsFieldCallback)
-> m (Maybe WidgetClassContainsFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassContainsFieldCallback))
-> IO (Maybe WidgetClassContainsFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassContainsFieldCallback))
 -> IO (Maybe WidgetClassContainsFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassContainsFieldCallback))
-> IO (Maybe WidgetClassContainsFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassContainsFieldCallback
val <- Ptr (FunPtr C_WidgetClassContainsFieldCallback)
-> IO (FunPtr C_WidgetClassContainsFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassContainsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)
    Maybe WidgetClassContainsFieldCallback
result <- FunPtr C_WidgetClassContainsFieldCallback
-> (FunPtr C_WidgetClassContainsFieldCallback
    -> IO WidgetClassContainsFieldCallback)
-> IO (Maybe WidgetClassContainsFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassContainsFieldCallback
val ((FunPtr C_WidgetClassContainsFieldCallback
  -> IO WidgetClassContainsFieldCallback)
 -> IO (Maybe WidgetClassContainsFieldCallback))
-> (FunPtr C_WidgetClassContainsFieldCallback
    -> IO WidgetClassContainsFieldCallback)
-> IO (Maybe WidgetClassContainsFieldCallback)
forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassContainsFieldCallback
val' -> do
        let val'' :: WidgetClassContainsFieldCallback
val'' = FunPtr C_WidgetClassContainsFieldCallback
-> WidgetClassContainsFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassContainsFieldCallback
-> a -> Double -> Double -> m Bool
Gtk.Callbacks.dynamic_WidgetClassContainsFieldCallback FunPtr C_WidgetClassContainsFieldCallback
val'
        WidgetClassContainsFieldCallback
-> IO WidgetClassContainsFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassContainsFieldCallback
val''
    Maybe WidgetClassContainsFieldCallback
-> IO (Maybe WidgetClassContainsFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassContainsFieldCallback
result

-- | Set the value of the “@contains@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #contains 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassContains :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback -> m ()
setWidgetClassContains :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassContainsFieldCallback -> m ()
setWidgetClassContains WidgetClass
s FunPtr C_WidgetClassContainsFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassContainsFieldCallback)
-> FunPtr C_WidgetClassContainsFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassContainsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) (FunPtr C_WidgetClassContainsFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)

-- | Set the value of the “@contains@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #contains
-- @
clearWidgetClassContains :: MonadIO m => WidgetClass -> m ()
clearWidgetClassContains :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassContains WidgetClass
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ WidgetClass -> (Ptr WidgetClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO ()) -> IO ())
-> (Ptr WidgetClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassContainsFieldCallback)
-> FunPtr C_WidgetClassContainsFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassContainsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) (FunPtr C_WidgetClassContainsFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassContainsFieldInfo
instance AttrInfo WidgetClassContainsFieldInfo where
    type AttrBaseTypeConstraint WidgetClassContainsFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassContainsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassContainsFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)
    type AttrTransferTypeConstraint WidgetClassContainsFieldInfo = (~)Gtk.Callbacks.WidgetClassContainsFieldCallback
    type AttrTransferType WidgetClassContainsFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassContainsFieldCallback)
    type AttrGetType WidgetClassContainsFieldInfo = Maybe Gtk.Callbacks.WidgetClassContainsFieldCallback
    type AttrLabel WidgetClassContainsFieldInfo = "contains"
    type AttrOrigin WidgetClassContainsFieldInfo = WidgetClass
    attrGet = getWidgetClassContains
    attrSet = setWidgetClassContains
    attrConstruct = undefined
    attrClear = clearWidgetClassContains
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassContainsFieldCallback (Gtk.Callbacks.wrap_WidgetClassContainsFieldCallback Nothing v)

widgetClass_contains :: AttrLabelProxy "contains"
widgetClass_contains = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList WidgetClass
type instance O.AttributeList WidgetClass = WidgetClassAttributeList
type WidgetClassAttributeList = ('[ '("parentClass", WidgetClassParentClassFieldInfo), '("show", WidgetClassShowFieldInfo), '("hide", WidgetClassHideFieldInfo), '("map", WidgetClassMapFieldInfo), '("unmap", WidgetClassUnmapFieldInfo), '("realize", WidgetClassRealizeFieldInfo), '("unrealize", WidgetClassUnrealizeFieldInfo), '("root", WidgetClassRootFieldInfo), '("unroot", WidgetClassUnrootFieldInfo), '("sizeAllocate", WidgetClassSizeAllocateFieldInfo), '("stateFlagsChanged", WidgetClassStateFlagsChangedFieldInfo), '("directionChanged", WidgetClassDirectionChangedFieldInfo), '("getRequestMode", WidgetClassGetRequestModeFieldInfo), '("measure", WidgetClassMeasureFieldInfo), '("mnemonicActivate", WidgetClassMnemonicActivateFieldInfo), '("grabFocus", WidgetClassGrabFocusFieldInfo), '("focus", WidgetClassFocusFieldInfo), '("setFocusChild", WidgetClassSetFocusChildFieldInfo), '("moveFocus", WidgetClassMoveFocusFieldInfo), '("keynavFailed", WidgetClassKeynavFailedFieldInfo), '("queryTooltip", WidgetClassQueryTooltipFieldInfo), '("computeExpand", WidgetClassComputeExpandFieldInfo), '("cssChanged", WidgetClassCssChangedFieldInfo), '("systemSettingChanged", WidgetClassSystemSettingChangedFieldInfo), '("snapshot", WidgetClassSnapshotFieldInfo), '("contains", WidgetClassContainsFieldInfo)] :: [(Symbol, *)])
#endif

-- method WidgetClass::add_shortcut
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the class to add the shortcut to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "shortcut"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "Shortcut" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkShortcut to add"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_add_shortcut" gtk_widget_class_add_shortcut :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Ptr Gtk.Shortcut.Shortcut ->            -- shortcut : TInterface (Name {namespace = "Gtk", name = "Shortcut"})
    IO ()

-- | Installs a shortcut in /@widgetClass@/. Every instance created for
-- /@widgetClass@/ or its subclasses will inherit this shortcut and
-- trigger it.
-- 
-- Shortcuts added this way will be triggered in the /@gTKPHASEBUBBLE@/
-- phase, which means they may also trigger if child widgets have focus.
-- 
-- This function must only be used in class initialization functions
-- otherwise it is not guaranteed that the shortcut will be installed.
widgetClassAddShortcut ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.Shortcut.IsShortcut a) =>
    WidgetClass
    -- ^ /@widgetClass@/: the class to add the shortcut to
    -> a
    -- ^ /@shortcut@/: the t'GI.Gtk.Objects.Shortcut.Shortcut' to add
    -> m ()
widgetClassAddShortcut :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsShortcut a) =>
WidgetClass -> a -> m ()
widgetClassAddShortcut WidgetClass
widgetClass a
shortcut = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    Ptr Shortcut
shortcut' <- a -> IO (Ptr Shortcut)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
shortcut
    Ptr WidgetClass -> Ptr Shortcut -> IO ()
gtk_widget_class_add_shortcut Ptr WidgetClass
widgetClass' Ptr Shortcut
shortcut'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
shortcut
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassAddShortcutMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Gtk.Shortcut.IsShortcut a) => O.OverloadedMethod WidgetClassAddShortcutMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassAddShortcut

instance O.OverloadedMethodInfo WidgetClassAddShortcutMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassAddShortcut",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassAddShortcut"
        }


#endif

-- method WidgetClass::bind_template_callback_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The name of the callback as expected in the template XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback_symbol"
--           , argType =
--               TInterface Name { namespace = "GObject" , name = "Callback" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The callback symbol"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_bind_template_callback_full" gtk_widget_class_bind_template_callback_full :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- callback_name : TBasicType TUTF8
    FunPtr GObject.Callbacks.C_Callback ->  -- callback_symbol : TInterface (Name {namespace = "GObject", name = "Callback"})
    IO ()

-- | Declares a /@callbackSymbol@/ to handle /@callbackName@/ from the template XML
-- defined for /@widgetType@/. This function is not supported after
-- 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateScope' has been used on /@widgetClass@/.
-- See 'GI.Gtk.Objects.BuilderCScope.builderCScopeAddCallbackSymbol'.
-- 
-- Note that this must be called from a composite widget classes class
-- initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
widgetClassBindTemplateCallbackFull ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@callbackName@/: The name of the callback as expected in the template XML
    -> GObject.Callbacks.Callback
    -- ^ /@callbackSymbol@/: The callback symbol
    -> m ()
widgetClassBindTemplateCallbackFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> IO () -> m ()
widgetClassBindTemplateCallbackFull WidgetClass
widgetClass Text
callbackName IO ()
callbackSymbol = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
callbackName' <- Text -> IO CString
textToCString Text
callbackName
    Ptr (FunPtr (IO ()))
ptrcallbackSymbol <- IO (Ptr (FunPtr (IO ())))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr GObject.Callbacks.C_Callback))
    FunPtr (IO ())
callbackSymbol' <- IO () -> IO (FunPtr (IO ()))
GObject.Callbacks.mk_Callback (Maybe (Ptr (FunPtr (IO ()))) -> IO () -> IO ()
GObject.Callbacks.wrap_Callback (Ptr (FunPtr (IO ())) -> Maybe (Ptr (FunPtr (IO ())))
forall a. a -> Maybe a
Just Ptr (FunPtr (IO ()))
ptrcallbackSymbol) IO ()
callbackSymbol)
    Ptr (FunPtr (IO ())) -> FunPtr (IO ()) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr (IO ()))
ptrcallbackSymbol FunPtr (IO ())
callbackSymbol'
    Ptr WidgetClass -> CString -> FunPtr (IO ()) -> IO ()
gtk_widget_class_bind_template_callback_full Ptr WidgetClass
widgetClass' CString
callbackName' FunPtr (IO ())
callbackSymbol'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
callbackName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassBindTemplateCallbackFullMethodInfo
instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassBindTemplateCallbackFull

instance O.OverloadedMethodInfo WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassBindTemplateCallbackFull",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassBindTemplateCallbackFull"
        }


#endif

-- method WidgetClass::bind_template_child_full
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The \8220id\8221 of the child defined in the template XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "internal_child"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Whether the child should be accessible as an \8220internal-child\8221\n                 when this class is used in GtkBuilder XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "struct_offset"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The structure offset into the composite widget\8217s instance public or private structure\n                where the automated child pointer should be set, or 0 to not assign the pointer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_bind_template_child_full" gtk_widget_class_bind_template_child_full :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- name : TBasicType TUTF8
    CInt ->                                 -- internal_child : TBasicType TBoolean
    Int64 ->                                -- struct_offset : TBasicType TInt64
    IO ()

-- | Automatically assign an object declared in the class template XML to be set to a location
-- on a freshly built instance’s private data, or alternatively accessible via 'GI.Gtk.Objects.Widget.widgetGetTemplateChild'.
-- 
-- The struct can point either into the public instance, then you should use G_STRUCT_OFFSET(WidgetType, member)
-- for /@structOffset@/,  or in the private struct, then you should use G_PRIVATE_OFFSET(WidgetType, member).
-- 
-- An explicit strong reference will be held automatically for the duration of your
-- instance’s life cycle, it will be released automatically when t'GI.GObject.Structs.ObjectClass.ObjectClass'.@/dispose/@() runs
-- on your instance and if a /@structOffset@/ that is != 0 is specified, then the automatic location
-- in your instance public or private data will be set to 'P.Nothing'. You can however access an automated child
-- pointer the first time your classes t'GI.GObject.Structs.ObjectClass.ObjectClass'.@/dispose/@() runs, or alternatively in
-- t'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/destroy/@().
-- 
-- If /@internalChild@/ is specified, t'GI.Gtk.Structs.BuildableIface.BuildableIface'.@/get_internal_child/@() will be automatically
-- implemented by the t'GI.Gtk.Objects.Widget.Widget' class so there is no need to implement it manually.
-- 
-- The wrapper macros @/gtk_widget_class_bind_template_child()/@, @/gtk_widget_class_bind_template_child_internal()/@,
-- @/gtk_widget_class_bind_template_child_private()/@ and @/gtk_widget_class_bind_template_child_internal_private()/@
-- might be more convenient to use.
-- 
-- Note that this must be called from a composite widget classes class
-- initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
widgetClassBindTemplateChildFull ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@name@/: The “id” of the child defined in the template XML
    -> Bool
    -- ^ /@internalChild@/: Whether the child should be accessible as an “internal-child”
    --                  when this class is used in GtkBuilder XML
    -> Int64
    -- ^ /@structOffset@/: The structure offset into the composite widget’s instance public or private structure
    --                 where the automated child pointer should be set, or 0 to not assign the pointer.
    -> m ()
widgetClassBindTemplateChildFull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> Bool -> Int64 -> m ()
widgetClassBindTemplateChildFull WidgetClass
widgetClass Text
name Bool
internalChild Int64
structOffset = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
name' <- Text -> IO CString
textToCString Text
name
    let internalChild' :: CInt
internalChild' = (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
internalChild
    Ptr WidgetClass -> CString -> CInt -> Int64 -> IO ()
gtk_widget_class_bind_template_child_full Ptr WidgetClass
widgetClass' CString
name' CInt
internalChild' Int64
structOffset
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassBindTemplateChildFullMethodInfo
instance (signature ~ (T.Text -> Bool -> Int64 -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassBindTemplateChildFullMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassBindTemplateChildFull

instance O.OverloadedMethodInfo WidgetClassBindTemplateChildFullMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassBindTemplateChildFull",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassBindTemplateChildFull"
        }


#endif

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

foreign import ccall "gtk_widget_class_get_accessible_role" gtk_widget_class_get_accessible_role :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    IO CUInt

-- | Retrieves the accessible role used by the given t'GI.Gtk.Objects.Widget.Widget' class.
-- 
-- Different accessible roles have different states, and are rendered
-- differently by assistive technologies.
-- 
-- See also: 'GI.Gtk.Interfaces.Accessible.accessibleGetAccessibleRole'
widgetClassGetAccessibleRole ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> m Gtk.Enums.AccessibleRole
    -- ^ __Returns:__ the accessible role for the widget class
widgetClassGetAccessibleRole :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> m AccessibleRole
widgetClassGetAccessibleRole WidgetClass
widgetClass = IO AccessibleRole -> m AccessibleRole
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AccessibleRole -> m AccessibleRole)
-> IO AccessibleRole -> m AccessibleRole
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CUInt
result <- Ptr WidgetClass -> IO CUInt
gtk_widget_class_get_accessible_role Ptr WidgetClass
widgetClass'
    let result' :: AccessibleRole
result' = (Int -> AccessibleRole
forall a. Enum a => Int -> a
toEnum (Int -> AccessibleRole)
-> (CUInt -> Int) -> CUInt -> AccessibleRole
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    AccessibleRole -> IO AccessibleRole
forall (m :: * -> *) a. Monad m => a -> m a
return AccessibleRole
result'

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetAccessibleRoleMethodInfo
instance (signature ~ (m Gtk.Enums.AccessibleRole), MonadIO m) => O.OverloadedMethod WidgetClassGetAccessibleRoleMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassGetAccessibleRole

instance O.OverloadedMethodInfo WidgetClassGetAccessibleRoleMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassGetAccessibleRole",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetAccessibleRole"
        }


#endif

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

foreign import ccall "gtk_widget_class_get_activate_signal" gtk_widget_class_get_activate_signal :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    IO Word32

-- | Retrieves the signal id for the activation signal set using
-- 'GI.Gtk.Structs.WidgetClass.widgetClassSetActivateSignal'.
widgetClassGetActivateSignal ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> m Word32
    -- ^ __Returns:__ a signal id, or 0 if the widget class does not
    --   specify an activation signal
widgetClassGetActivateSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> m Word32
widgetClassGetActivateSignal WidgetClass
widgetClass = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    Word32
result <- Ptr WidgetClass -> IO Word32
gtk_widget_class_get_activate_signal Ptr WidgetClass
widgetClass'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetActivateSignalMethodInfo
instance (signature ~ (m Word32), MonadIO m) => O.OverloadedMethod WidgetClassGetActivateSignalMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassGetActivateSignal

instance O.OverloadedMethodInfo WidgetClassGetActivateSignalMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassGetActivateSignal",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetActivateSignal"
        }


#endif

-- method WidgetClass::get_css_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "class to set the name on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_get_css_name" gtk_widget_class_get_css_name :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    IO CString

-- | Gets the name used by this class for matching in CSS code. See
-- 'GI.Gtk.Structs.WidgetClass.widgetClassSetCssName' for details.
widgetClassGetCssName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the name on
    -> m T.Text
    -- ^ __Returns:__ the CSS name of the given class
widgetClassGetCssName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> m Text
widgetClassGetCssName WidgetClass
widgetClass = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
result <- Ptr WidgetClass -> IO CString
gtk_widget_class_get_css_name Ptr WidgetClass
widgetClass'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"widgetClassGetCssName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetCssNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod WidgetClassGetCssNameMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassGetCssName

instance O.OverloadedMethodInfo WidgetClassGetCssNameMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassGetCssName",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetCssName"
        }


#endif

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

foreign import ccall "gtk_widget_class_get_layout_manager_type" gtk_widget_class_get_layout_manager_type :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    IO CGType

-- | Retrieves the type of the t'GI.Gtk.Objects.LayoutManager.LayoutManager' used by the t'GI.Gtk.Objects.Widget.Widget' class.
-- 
-- See also: 'GI.Gtk.Structs.WidgetClass.widgetClassSetLayoutManagerType'
widgetClassGetLayoutManagerType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> m GType
    -- ^ __Returns:__ a t'GI.Gtk.Objects.LayoutManager.LayoutManager' subclass, or @/G_TYPE_INVALID/@
widgetClassGetLayoutManagerType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> m GType
widgetClassGetLayoutManagerType WidgetClass
widgetClass = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CGType
result <- Ptr WidgetClass -> IO CGType
gtk_widget_class_get_layout_manager_type Ptr WidgetClass
widgetClass'
    let result' :: GType
result' = CGType -> GType
GType CGType
result
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetLayoutManagerTypeMethodInfo
instance (signature ~ (m GType), MonadIO m) => O.OverloadedMethod WidgetClassGetLayoutManagerTypeMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassGetLayoutManagerType

instance O.OverloadedMethodInfo WidgetClassGetLayoutManagerTypeMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassGetLayoutManagerType",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetLayoutManagerType"
        }


#endif

-- method WidgetClass::install_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "action_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a prefixed action name, such as \"clipboard.paste\""
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "parameter_type"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the parameter type, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "activate"
--           , argType =
--               TInterface
--                 Name { namespace = "Gtk" , name = "WidgetActionActivateFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "callback to use when the action is activated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_install_action" gtk_widget_class_install_action :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- action_name : TBasicType TUTF8
    CString ->                              -- parameter_type : TBasicType TUTF8
    FunPtr Gtk.Callbacks.C_WidgetActionActivateFunc -> -- activate : TInterface (Name {namespace = "Gtk", name = "WidgetActionActivateFunc"})
    IO ()

-- | This should be called at class initialization time to specify
-- actions to be added for all instances of this class.
-- 
-- Actions installed by this function are stateless. The only state
-- they have is whether they are enabled or not.
widgetClassInstallAction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@actionName@/: a prefixed action name, such as \"clipboard.paste\"
    -> Maybe (T.Text)
    -- ^ /@parameterType@/: the parameter type, or 'P.Nothing'
    -> Gtk.Callbacks.WidgetActionActivateFunc
    -- ^ /@activate@/: callback to use when the action is activated
    -> m ()
widgetClassInstallAction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass
-> Text -> Maybe Text -> WidgetActionActivateFunc -> m ()
widgetClassInstallAction WidgetClass
widgetClass Text
actionName Maybe Text
parameterType WidgetActionActivateFunc
activate = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
actionName' <- Text -> IO CString
textToCString Text
actionName
    CString
maybeParameterType <- case Maybe Text
parameterType of
        Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jParameterType -> do
            CString
jParameterType' <- Text -> IO CString
textToCString Text
jParameterType
            CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jParameterType'
    FunPtr C_WidgetActionActivateFunc
activate' <- C_WidgetActionActivateFunc
-> IO (FunPtr C_WidgetActionActivateFunc)
Gtk.Callbacks.mk_WidgetActionActivateFunc (Maybe (Ptr (FunPtr C_WidgetActionActivateFunc))
-> WidgetActionActivateFunc -> C_WidgetActionActivateFunc
Gtk.Callbacks.wrap_WidgetActionActivateFunc Maybe (Ptr (FunPtr C_WidgetActionActivateFunc))
forall a. Maybe a
Nothing WidgetActionActivateFunc
activate)
    Ptr WidgetClass
-> CString -> CString -> FunPtr C_WidgetActionActivateFunc -> IO ()
gtk_widget_class_install_action Ptr WidgetClass
widgetClass' CString
actionName' CString
maybeParameterType FunPtr C_WidgetActionActivateFunc
activate'
    Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_WidgetActionActivateFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_WidgetActionActivateFunc
activate'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
actionName'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeParameterType
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassInstallActionMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> Gtk.Callbacks.WidgetActionActivateFunc -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassInstallActionMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassInstallAction

instance O.OverloadedMethodInfo WidgetClassInstallActionMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassInstallAction",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassInstallAction"
        }


#endif

-- method WidgetClass::install_property_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "action_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of the action" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "name of the property in instances of @widget_class\n  or any parent class."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_install_property_action" gtk_widget_class_install_property_action :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- action_name : TBasicType TUTF8
    CString ->                              -- property_name : TBasicType TUTF8
    IO ()

-- | Installs an action called /@actionName@/ on /@widgetClass@/ and binds its
-- state to the value of the /@propertyName@/ property.
-- 
-- This function will perform a few santity checks on the property selected
-- via /@propertyName@/. Namely, the property must exist, must be readable,
-- writable and must not be construct-only. There are also restrictions
-- on the type of the given property, it must be boolean, int, unsigned int,
-- double or string. If any of these conditions are not met, a critical
-- warning will be printed and no action will be added.
-- 
-- The state type of the action matches the property type.
-- 
-- If the property is boolean, the action will have no parameter and
-- toggle the property value. Otherwise, the action will have a parameter
-- of the same type as the property.
widgetClassInstallPropertyAction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@actionName@/: name of the action
    -> T.Text
    -- ^ /@propertyName@/: name of the property in instances of /@widgetClass@/
    --   or any parent class.
    -> m ()
widgetClassInstallPropertyAction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> Text -> m ()
widgetClassInstallPropertyAction WidgetClass
widgetClass Text
actionName Text
propertyName = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
actionName' <- Text -> IO CString
textToCString Text
actionName
    CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
    Ptr WidgetClass -> CString -> CString -> IO ()
gtk_widget_class_install_property_action Ptr WidgetClass
widgetClass' CString
actionName' CString
propertyName'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
actionName'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassInstallPropertyActionMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassInstallPropertyActionMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassInstallPropertyAction

instance O.OverloadedMethodInfo WidgetClassInstallPropertyActionMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassInstallPropertyAction",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassInstallPropertyAction"
        }


#endif

-- method WidgetClass::query_action
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index_"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "position of the action to query"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "owner"
--           , argType = TBasicType TGType
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the type where the action was defined"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "action_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the action name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "parameter_type"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "VariantType" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the parameter type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "property_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for the property name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_query_action" gtk_widget_class_query_action :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Word32 ->                               -- index_ : TBasicType TUInt
    Ptr CGType ->                           -- owner : TBasicType TGType
    Ptr CString ->                          -- action_name : TBasicType TUTF8
    Ptr (Ptr GLib.VariantType.VariantType) -> -- parameter_type : TInterface (Name {namespace = "GLib", name = "VariantType"})
    Ptr CString ->                          -- property_name : TBasicType TUTF8
    IO CInt

-- | Queries the actions that have been installed for
-- a widget class using 'GI.Gtk.Structs.WidgetClass.widgetClassInstallAction'
-- during class initialization.
-- 
-- Note that this function will also return actions defined
-- by parent classes. You can identify those by looking
-- at /@owner@/.
widgetClassQueryAction ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> Word32
    -- ^ /@index_@/: position of the action to query
    -> m ((Bool, GType, T.Text, GLib.VariantType.VariantType, T.Text))
    -- ^ __Returns:__ 'P.True' if the action was found,
    --     'P.False' if /@index_@/ is out of range
widgetClassQueryAction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Word32 -> m (Bool, GType, Text, VariantType, Text)
widgetClassQueryAction WidgetClass
widgetClass Word32
index_ = IO (Bool, GType, Text, VariantType, Text)
-> m (Bool, GType, Text, VariantType, Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, GType, Text, VariantType, Text)
 -> m (Bool, GType, Text, VariantType, Text))
-> IO (Bool, GType, Text, VariantType, Text)
-> m (Bool, GType, Text, VariantType, Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    Ptr CGType
owner <- IO (Ptr CGType)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CGType)
    Ptr CString
actionName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr (Ptr VariantType)
parameterType <- IO (Ptr (Ptr VariantType))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GLib.VariantType.VariantType))
    Ptr CString
propertyName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    CInt
result <- Ptr WidgetClass
-> Word32
-> Ptr CGType
-> Ptr CString
-> Ptr (Ptr VariantType)
-> Ptr CString
-> IO CInt
gtk_widget_class_query_action Ptr WidgetClass
widgetClass' Word32
index_ Ptr CGType
owner Ptr CString
actionName Ptr (Ptr VariantType)
parameterType Ptr CString
propertyName
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CGType
owner' <- Ptr CGType -> IO CGType
forall a. Storable a => Ptr a -> IO a
peek Ptr CGType
owner
    let owner'' :: GType
owner'' = CGType -> GType
GType CGType
owner'
    CString
actionName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
actionName
    Text
actionName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
actionName'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
actionName'
    Ptr VariantType
parameterType' <- Ptr (Ptr VariantType) -> IO (Ptr VariantType)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr VariantType)
parameterType
    VariantType
parameterType'' <- ((ManagedPtr VariantType -> VariantType)
-> Ptr VariantType -> IO VariantType
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VariantType -> VariantType
GLib.VariantType.VariantType) Ptr VariantType
parameterType'
    CString
propertyName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
propertyName
    Text
propertyName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
propertyName'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    Ptr CGType -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CGType
owner
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
actionName
    Ptr (Ptr VariantType) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr VariantType)
parameterType
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
propertyName
    (Bool, GType, Text, VariantType, Text)
-> IO (Bool, GType, Text, VariantType, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', GType
owner'', Text
actionName'', VariantType
parameterType'', Text
propertyName'')

#if defined(ENABLE_OVERLOADING)
data WidgetClassQueryActionMethodInfo
instance (signature ~ (Word32 -> m ((Bool, GType, T.Text, GLib.VariantType.VariantType, T.Text))), MonadIO m) => O.OverloadedMethod WidgetClassQueryActionMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassQueryAction

instance O.OverloadedMethodInfo WidgetClassQueryActionMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassQueryAction",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassQueryAction"
        }


#endif

-- method WidgetClass::set_accessible_role
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "accessible_role"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "AccessibleRole" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GtkAccessibleRole used by the @widget_class"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_set_accessible_role" gtk_widget_class_set_accessible_role :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CUInt ->                                -- accessible_role : TInterface (Name {namespace = "Gtk", name = "AccessibleRole"})
    IO ()

-- | Sets the accessible role used by the given t'GI.Gtk.Objects.Widget.Widget' class.
-- 
-- Different accessible roles have different states, and are rendered
-- differently by assistive technologies.
widgetClassSetAccessibleRole ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> Gtk.Enums.AccessibleRole
    -- ^ /@accessibleRole@/: the t'GI.Gtk.Enums.AccessibleRole' used by the /@widgetClass@/
    -> m ()
widgetClassSetAccessibleRole :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> AccessibleRole -> m ()
widgetClassSetAccessibleRole WidgetClass
widgetClass AccessibleRole
accessibleRole = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    let accessibleRole' :: CUInt
accessibleRole' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (AccessibleRole -> Int) -> AccessibleRole -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AccessibleRole -> Int
forall a. Enum a => a -> Int
fromEnum) AccessibleRole
accessibleRole
    Ptr WidgetClass -> CUInt -> IO ()
gtk_widget_class_set_accessible_role Ptr WidgetClass
widgetClass' CUInt
accessibleRole'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetAccessibleRoleMethodInfo
instance (signature ~ (Gtk.Enums.AccessibleRole -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetAccessibleRoleMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetAccessibleRole

instance O.OverloadedMethodInfo WidgetClassSetAccessibleRoleMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassSetAccessibleRole",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetAccessibleRole"
        }


#endif

-- method WidgetClass::set_activate_signal
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signal_id"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the id for the activate signal"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_set_activate_signal" gtk_widget_class_set_activate_signal :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Word32 ->                               -- signal_id : TBasicType TUInt
    IO ()

-- | Sets the t'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/activate_signal/@ field with the
-- given /@signalId@/; the signal will be emitted when calling
-- 'GI.Gtk.Objects.Widget.widgetActivate'.
-- 
-- The /@signalId@/ must have been registered with @/g_signal_new()/@
-- or @/g_signal_newv()/@ before calling this function.
widgetClassSetActivateSignal ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> Word32
    -- ^ /@signalId@/: the id for the activate signal
    -> m ()
widgetClassSetActivateSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Word32 -> m ()
widgetClassSetActivateSignal WidgetClass
widgetClass Word32
signalId = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    Ptr WidgetClass -> Word32 -> IO ()
gtk_widget_class_set_activate_signal Ptr WidgetClass
widgetClass' Word32
signalId
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetActivateSignalMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetActivateSignalMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetActivateSignal

instance O.OverloadedMethodInfo WidgetClassSetActivateSignalMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassSetActivateSignal",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetActivateSignal"
        }


#endif

-- method WidgetClass::set_activate_signal_from_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "signal_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the name of the activate signal of @widget_type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_set_activate_signal_from_name" gtk_widget_class_set_activate_signal_from_name :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- signal_name : TBasicType TUTF8
    IO ()

-- | Sets the t'GI.Gtk.Structs.WidgetClass.WidgetClass'.@/activate_signal/@ field with the signal id for
-- the given /@signalName@/; the signal will be emitted when calling
-- 'GI.Gtk.Objects.Widget.widgetActivate'.
-- 
-- The /@signalName@/ of /@widgetType@/ must have been registered with
-- @/g_signal_new()/@ or @/g_signal_newv()/@ before calling this function.
widgetClassSetActivateSignalFromName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: a t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@signalName@/: the name of the activate signal of /@widgetType@/
    -> m ()
widgetClassSetActivateSignalFromName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> m ()
widgetClassSetActivateSignalFromName WidgetClass
widgetClass Text
signalName = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
signalName' <- Text -> IO CString
textToCString Text
signalName
    Ptr WidgetClass -> CString -> IO ()
gtk_widget_class_set_activate_signal_from_name Ptr WidgetClass
widgetClass' CString
signalName'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
signalName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetActivateSignalFromNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetActivateSignalFromNameMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetActivateSignalFromName

instance O.OverloadedMethodInfo WidgetClassSetActivateSignalFromNameMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassSetActivateSignalFromName",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetActivateSignalFromName"
        }


#endif

-- method WidgetClass::set_css_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "class to set the name on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name to use" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_set_css_name" gtk_widget_class_set_css_name :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Sets the name to be used for CSS matching of widgets.
-- 
-- If this function is not called for a given class, the name
-- set on the parent class is used. By default, GtkWidget uses
-- the name \"widget\".
widgetClassSetCssName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the name on
    -> T.Text
    -- ^ /@name@/: name to use
    -> m ()
widgetClassSetCssName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> m ()
widgetClassSetCssName WidgetClass
widgetClass Text
name = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr WidgetClass -> CString -> IO ()
gtk_widget_class_set_css_name Ptr WidgetClass
widgetClass' CString
name'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetCssNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetCssNameMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetCssName

instance O.OverloadedMethodInfo WidgetClassSetCssNameMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassSetCssName",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetCssName"
        }


#endif

-- method WidgetClass::set_layout_manager_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "class to set the layout manager type for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The object type that implements the #GtkLayoutManager for @widget_class"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_set_layout_manager_type" gtk_widget_class_set_layout_manager_type :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CGType ->                               -- type : TBasicType TGType
    IO ()

-- | Sets the type to be used for creating layout managers for widgets of
-- /@widgetClass@/. The given /@type@/ must be a subtype of t'GI.Gtk.Objects.LayoutManager.LayoutManager'.
-- 
-- This function should only be called from class init functions of widgets.
widgetClassSetLayoutManagerType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the layout manager type for
    -> GType
    -- ^ /@type@/: The object type that implements the t'GI.Gtk.Objects.LayoutManager.LayoutManager' for /@widgetClass@/
    -> m ()
widgetClassSetLayoutManagerType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> GType -> m ()
widgetClassSetLayoutManagerType WidgetClass
widgetClass GType
type_ = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    let type_' :: CGType
type_' = GType -> CGType
gtypeToCGType GType
type_
    Ptr WidgetClass -> CGType -> IO ()
gtk_widget_class_set_layout_manager_type Ptr WidgetClass
widgetClass' CGType
type_'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetLayoutManagerTypeMethodInfo
instance (signature ~ (GType -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetLayoutManagerTypeMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetLayoutManagerType

instance O.OverloadedMethodInfo WidgetClassSetLayoutManagerTypeMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassSetLayoutManagerType",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetLayoutManagerType"
        }


#endif

-- method WidgetClass::set_template
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "template_bytes"
--           , argType = TInterface Name { namespace = "GLib" , name = "Bytes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GBytes holding the #GtkBuilder XML"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_set_template" gtk_widget_class_set_template :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Ptr GLib.Bytes.Bytes ->                 -- template_bytes : TInterface (Name {namespace = "GLib", name = "Bytes"})
    IO ()

-- | This should be called at class initialization time to specify
-- the GtkBuilder XML to be used to extend a widget.
-- 
-- For convenience, 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateFromResource' is also provided.
-- 
-- Note that any class that installs templates must call 'GI.Gtk.Objects.Widget.widgetInitTemplate'
-- in the widget’s instance initializer.
widgetClassSetTemplate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> GLib.Bytes.Bytes
    -- ^ /@templateBytes@/: A t'GI.GLib.Structs.Bytes.Bytes' holding the t'GI.Gtk.Objects.Builder.Builder' XML
    -> m ()
widgetClassSetTemplate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Bytes -> m ()
widgetClassSetTemplate WidgetClass
widgetClass Bytes
templateBytes = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    Ptr Bytes
templateBytes' <- Bytes -> IO (Ptr Bytes)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Bytes
templateBytes
    Ptr WidgetClass -> Ptr Bytes -> IO ()
gtk_widget_class_set_template Ptr WidgetClass
widgetClass' Ptr Bytes
templateBytes'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    Bytes -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
templateBytes
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetTemplateMethodInfo
instance (signature ~ (GLib.Bytes.Bytes -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetTemplateMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetTemplate

instance O.OverloadedMethodInfo WidgetClassSetTemplateMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplate"
        }


#endif

-- method WidgetClass::set_template_from_resource
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "resource_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The name of the resource to load the template from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_set_template_from_resource" gtk_widget_class_set_template_from_resource :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CString ->                              -- resource_name : TBasicType TUTF8
    IO ()

-- | A convenience function to call 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
-- 
-- Note that any class that installs templates must call 'GI.Gtk.Objects.Widget.widgetInitTemplate'
-- in the widget’s instance initializer.
widgetClassSetTemplateFromResource ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> T.Text
    -- ^ /@resourceName@/: The name of the resource to load the template from
    -> m ()
widgetClassSetTemplateFromResource :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> m ()
widgetClassSetTemplateFromResource WidgetClass
widgetClass Text
resourceName = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    CString
resourceName' <- Text -> IO CString
textToCString Text
resourceName
    Ptr WidgetClass -> CString -> IO ()
gtk_widget_class_set_template_from_resource Ptr WidgetClass
widgetClass' CString
resourceName'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
resourceName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetTemplateFromResourceMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetTemplateFromResourceMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetTemplateFromResource

instance O.OverloadedMethodInfo WidgetClassSetTemplateFromResourceMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateFromResource",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplateFromResource"
        }


#endif

-- method WidgetClass::set_template_scope
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "widget_class"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "WidgetClass" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GtkWidgetClass" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "scope"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "BuilderScope" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The #GtkBuilderScope to use when loading the class template"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_widget_class_set_template_scope" gtk_widget_class_set_template_scope :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    Ptr Gtk.BuilderScope.BuilderScope ->    -- scope : TInterface (Name {namespace = "Gtk", name = "BuilderScope"})
    IO ()

-- | For use in language bindings, this will override the default t'GI.Gtk.Interfaces.BuilderScope.BuilderScope' to be
-- used when parsing GtkBuilder XML from this class’s template data.
-- 
-- Note that this must be called from a composite widget classes class
-- initializer after calling 'GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate'.
widgetClassSetTemplateScope ::
    (B.CallStack.HasCallStack, MonadIO m, Gtk.BuilderScope.IsBuilderScope a) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> a
    -- ^ /@scope@/: The t'GI.Gtk.Interfaces.BuilderScope.BuilderScope' to use when loading the class template
    -> m ()
widgetClassSetTemplateScope :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilderScope a) =>
WidgetClass -> a -> m ()
widgetClassSetTemplateScope WidgetClass
widgetClass a
scope = 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 WidgetClass
widgetClass' <- WidgetClass -> IO (Ptr WidgetClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
    Ptr BuilderScope
scope' <- a -> IO (Ptr BuilderScope)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
scope
    Ptr WidgetClass -> Ptr BuilderScope -> IO ()
gtk_widget_class_set_template_scope Ptr WidgetClass
widgetClass' Ptr BuilderScope
scope'
    WidgetClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
scope
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data WidgetClassSetTemplateScopeMethodInfo
instance (signature ~ (a -> m ()), MonadIO m, Gtk.BuilderScope.IsBuilderScope a) => O.OverloadedMethod WidgetClassSetTemplateScopeMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetTemplateScope

instance O.OverloadedMethodInfo WidgetClassSetTemplateScopeMethodInfo WidgetClass where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateScope",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gtk-4.0.4/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplateScope"
        }


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveWidgetClassMethod (t :: Symbol) (o :: *) :: * where
    ResolveWidgetClassMethod "addShortcut" o = WidgetClassAddShortcutMethodInfo
    ResolveWidgetClassMethod "bindTemplateCallbackFull" o = WidgetClassBindTemplateCallbackFullMethodInfo
    ResolveWidgetClassMethod "bindTemplateChildFull" o = WidgetClassBindTemplateChildFullMethodInfo
    ResolveWidgetClassMethod "installAction" o = WidgetClassInstallActionMethodInfo
    ResolveWidgetClassMethod "installPropertyAction" o = WidgetClassInstallPropertyActionMethodInfo
    ResolveWidgetClassMethod "queryAction" o = WidgetClassQueryActionMethodInfo
    ResolveWidgetClassMethod "getAccessibleRole" o = WidgetClassGetAccessibleRoleMethodInfo
    ResolveWidgetClassMethod "getActivateSignal" o = WidgetClassGetActivateSignalMethodInfo
    ResolveWidgetClassMethod "getCssName" o = WidgetClassGetCssNameMethodInfo
    ResolveWidgetClassMethod "getLayoutManagerType" o = WidgetClassGetLayoutManagerTypeMethodInfo
    ResolveWidgetClassMethod "setAccessibleRole" o = WidgetClassSetAccessibleRoleMethodInfo
    ResolveWidgetClassMethod "setActivateSignal" o = WidgetClassSetActivateSignalMethodInfo
    ResolveWidgetClassMethod "setActivateSignalFromName" o = WidgetClassSetActivateSignalFromNameMethodInfo
    ResolveWidgetClassMethod "setCssName" o = WidgetClassSetCssNameMethodInfo
    ResolveWidgetClassMethod "setLayoutManagerType" o = WidgetClassSetLayoutManagerTypeMethodInfo
    ResolveWidgetClassMethod "setTemplate" o = WidgetClassSetTemplateMethodInfo
    ResolveWidgetClassMethod "setTemplateFromResource" o = WidgetClassSetTemplateFromResourceMethodInfo
    ResolveWidgetClassMethod "setTemplateScope" o = WidgetClassSetTemplateScopeMethodInfo
    ResolveWidgetClassMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif