{-# 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                      ,
    noWidgetClass                           ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveWidgetClassMethod                ,
#endif


-- ** bindTemplateCallbackFull #method:bindTemplateCallbackFull#

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


-- ** bindTemplateChildFull #method:bindTemplateChildFull#

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


-- ** getCssName #method:getCssName#

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


-- ** getLayoutManagerType #method:getLayoutManagerType#

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


-- ** setAccessibleRole #method:setAccessibleRole#

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


-- ** setAccessibleType #method:setAccessibleType#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetAccessibleTypeMethodInfo  ,
#endif
    widgetClassSetAccessibleType            ,


-- ** setConnectFunc #method:setConnectFunc#

#if defined(ENABLE_OVERLOADING)
    WidgetClassSetConnectFuncMethodInfo     ,
#endif
    widgetClassSetConnectFunc               ,


-- ** 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      ,




 -- * Properties
-- ** activateSignal #attr:activateSignal#
-- | The signal to emit when a widget of this class is
--   activated, 'GI.Gtk.Objects.Widget.widgetActivate' handles the emission.
--   Implementation of this signal is optional.

    getWidgetClassActivateSignal            ,
    setWidgetClassActivateSignal            ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_activateSignal              ,
#endif


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

    clearWidgetClassCanActivateAccel        ,
    getWidgetClassCanActivateAccel          ,
    setWidgetClassCanActivateAccel          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_canActivateAccel            ,
#endif


-- ** 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


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

    clearWidgetClassDestroy                 ,
    getWidgetClassDestroy                   ,
    setWidgetClassDestroy                   ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_destroy                     ,
#endif


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

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


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

    clearWidgetClassDragBegin               ,
    getWidgetClassDragBegin                 ,
    setWidgetClassDragBegin                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragBegin                   ,
#endif


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

    clearWidgetClassDragDataDelete          ,
    getWidgetClassDragDataDelete            ,
    setWidgetClassDragDataDelete            ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragDataDelete              ,
#endif


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

    clearWidgetClassDragDataGet             ,
    getWidgetClassDragDataGet               ,
    setWidgetClassDragDataGet               ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragDataGet                 ,
#endif


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

    clearWidgetClassDragDataReceived        ,
    getWidgetClassDragDataReceived          ,
    setWidgetClassDragDataReceived          ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragDataReceived            ,
#endif


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

    clearWidgetClassDragDrop                ,
    getWidgetClassDragDrop                  ,
    setWidgetClassDragDrop                  ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragDrop                    ,
#endif


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

    clearWidgetClassDragEnd                 ,
    getWidgetClassDragEnd                   ,
    setWidgetClassDragEnd                   ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragEnd                     ,
#endif


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

    clearWidgetClassDragFailed              ,
    getWidgetClassDragFailed                ,
    setWidgetClassDragFailed                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragFailed                  ,
#endif


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

    clearWidgetClassDragLeave               ,
    getWidgetClassDragLeave                 ,
    setWidgetClassDragLeave                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragLeave                   ,
#endif


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

    clearWidgetClassDragMotion              ,
    getWidgetClassDragMotion                ,
    setWidgetClassDragMotion                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_dragMotion                  ,
#endif


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

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


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

    clearWidgetClassGetAccessible           ,
    getWidgetClassGetAccessible             ,
    setWidgetClassGetAccessible             ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_getAccessible               ,
#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


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

    clearWidgetClassGrabNotify              ,
    getWidgetClassGrabNotify                ,
    setWidgetClassGrabNotify                ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_grabNotify                  ,
#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


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

    clearWidgetClassPopupMenu               ,
    getWidgetClassPopupMenu                 ,
    setWidgetClassPopupMenu                 ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_popupMenu                   ,
#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


-- ** 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


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

    clearWidgetClassStyleUpdated            ,
    getWidgetClassStyleUpdated              ,
    setWidgetClassStyleUpdated              ,
#if defined(ENABLE_OVERLOADING)
    widgetClass_styleUpdated                ,
#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.ManagedPtr as B.ManagedPtr
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 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 GI.Atk.Enums as Atk.Enums
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
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

-- | Memory-managed wrapper type.
newtype WidgetClass = WidgetClass (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 WrappedPtr WidgetClass where
    wrappedPtrCalloc :: IO (Ptr WidgetClass)
wrappedPtrCalloc = Int -> IO (Ptr WidgetClass)
forall a. Int -> IO (Ptr a)
callocBytes 456
    wrappedPtrCopy :: WidgetClass -> IO WidgetClass
wrappedPtrCopy = \p :: WidgetClass
p -> WidgetClass
-> (Ptr WidgetClass -> IO WidgetClass) -> IO WidgetClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
p (Int -> Ptr WidgetClass -> IO (Ptr WidgetClass)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 456 (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, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr WidgetClass -> WidgetClass
WidgetClass)
    wrappedPtrFree :: Maybe (GDestroyNotify WidgetClass)
wrappedPtrFree = GDestroyNotify WidgetClass -> Maybe (GDestroyNotify WidgetClass)
forall a. a -> Maybe a
Just GDestroyNotify WidgetClass
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `WidgetClass` struct initialized to zero.
newZeroWidgetClass :: MonadIO m => m WidgetClass
newZeroWidgetClass :: 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. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc 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, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr WidgetClass -> WidgetClass
WidgetClass

instance tag ~ 'AttrSet => Constructible WidgetClass tag where
    new :: (ManagedPtr WidgetClass -> WidgetClass)
-> [AttrOp WidgetClass tag] -> m WidgetClass
new _ attrs :: [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


-- | A convenience alias for `Nothing` :: `Maybe` `WidgetClass`.
noWidgetClass :: Maybe WidgetClass
noWidgetClass :: Maybe WidgetClass
noWidgetClass = Maybe WidgetClass
forall a. Maybe a
Nothing

-- | 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 :: WidgetClass -> m InitiallyUnownedClass
getWidgetClassParentClass s :: 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 :: 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` 0 :: (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
    InitiallyUnownedClass
val' <- ((ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass)
-> Ptr InitiallyUnownedClass -> IO InitiallyUnownedClass
forall a.
(HasCallStack, WrappedPtr 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 “@activate_signal@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #activateSignal
-- @
getWidgetClassActivateSignal :: MonadIO m => WidgetClass -> m Word32
getWidgetClassActivateSignal :: WidgetClass -> m Word32
getWidgetClassActivateSignal s :: WidgetClass
s = 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
$ WidgetClass -> (Ptr WidgetClass -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO Word32) -> IO Word32)
-> (Ptr WidgetClass -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 136) :: IO Word32
    Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@activate_signal@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #activateSignal 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassActivateSignal :: MonadIO m => WidgetClass -> Word32 -> m ()
setWidgetClassActivateSignal :: WidgetClass -> Word32 -> m ()
setWidgetClassActivateSignal s :: WidgetClass
s val :: Word32
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 :: Ptr WidgetClass
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 136) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data WidgetClassActivateSignalFieldInfo
instance AttrInfo WidgetClassActivateSignalFieldInfo where
    type AttrBaseTypeConstraint WidgetClassActivateSignalFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassActivateSignalFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint WidgetClassActivateSignalFieldInfo = (~) Word32
    type AttrTransferTypeConstraint WidgetClassActivateSignalFieldInfo = (~)Word32
    type AttrTransferType WidgetClassActivateSignalFieldInfo = Word32
    type AttrGetType WidgetClassActivateSignalFieldInfo = Word32
    type AttrLabel WidgetClassActivateSignalFieldInfo = "activate_signal"
    type AttrOrigin WidgetClassActivateSignalFieldInfo = WidgetClass
    attrGet = getWidgetClassActivateSignal
    attrSet = setWidgetClassActivateSignal
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

widgetClass_activateSignal :: AttrLabelProxy "activateSignal"
widgetClass_activateSignal = AttrLabelProxy

#endif


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

-- | Set the value of the “@destroy@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #destroy 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDestroy :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassDestroy :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassDestroy s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 144) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback)

-- | Set the value of the “@destroy@” 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' #destroy
-- @
clearWidgetClassDestroy :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDestroy :: WidgetClass -> m ()
clearWidgetClassDestroy s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 144) (FunPtr C_WidgetClassDestroyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDestroyFieldInfo
instance AttrInfo WidgetClassDestroyFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDestroyFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDestroyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDestroyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDestroyFieldInfo = (~)Gtk.Callbacks.WidgetClassDestroyFieldCallback
    type AttrTransferType WidgetClassDestroyFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback)
    type AttrGetType WidgetClassDestroyFieldInfo = Maybe Gtk.Callbacks.WidgetClassDestroyFieldCallback
    type AttrLabel WidgetClassDestroyFieldInfo = "destroy"
    type AttrOrigin WidgetClassDestroyFieldInfo = WidgetClass
    attrGet = getWidgetClassDestroy
    attrSet = setWidgetClassDestroy
    attrConstruct = undefined
    attrClear = clearWidgetClassDestroy
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDestroyFieldCallback (Gtk.Callbacks.wrap_WidgetClassDestroyFieldCallback Nothing v)

widgetClass_destroy :: AttrLabelProxy "destroy"
widgetClass_destroy = 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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassShow s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 152) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassShowFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassShow s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 152) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassShow s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 152) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassHide s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 160) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassHideFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassHide s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 160) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassHide s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 160) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassMap s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 168) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassMapFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassMap s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 168) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassMap s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 168) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassUnmap s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 176) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnmapFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassUnmap s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 176) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassUnmap s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 176) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassRealize s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 184) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassRealizeFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassRealize s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 184) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassRealize s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 184) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassUnrealize s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 192) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnrealizeFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassUnrealize s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 192) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassUnrealize s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 192) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassRoot s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 200) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRootFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassRootFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassRoot s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 200) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassRoot s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 200) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassUnroot s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 208) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrootFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnrootFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassUnroot s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 208) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassUnroot s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 208) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m (Maybe WidgetClassSizeAllocateFieldCallback)
getWidgetClassSizeAllocate s :: 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 :: 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` 216) :: 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
$ \val' :: 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 :: WidgetClass
-> FunPtr C_WidgetClassSizeAllocateFieldCallback -> m ()
setWidgetClassSizeAllocate s :: WidgetClass
s val :: 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 :: 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` 216) (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 :: WidgetClass -> m ()
clearWidgetClassSizeAllocate s :: 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 :: 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` 216) (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 :: WidgetClass -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
getWidgetClassStateFlagsChanged s :: 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 :: 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` 224) :: 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
$ \val' :: 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 :: WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassStateFlagsChanged s :: WidgetClass
s val :: 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 :: 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` 224) (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 :: WidgetClass -> m ()
clearWidgetClassStateFlagsChanged s :: 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 :: 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` 224) (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 :: WidgetClass -> m (Maybe WidgetClassDirectionChangedFieldCallback)
getWidgetClassDirectionChanged s :: 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 :: 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` 232) :: 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
$ \val' :: 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 :: WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassDirectionChanged s :: WidgetClass
s val :: 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 :: 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` 232) (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 :: WidgetClass -> m ()
clearWidgetClassDirectionChanged s :: 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 :: 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` 232) (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 “@grab_notify@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #grabNotify
-- @
getWidgetClassGrabNotify :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGrabNotifyFieldCallback)
getWidgetClassGrabNotify :: WidgetClass -> m (Maybe WidgetClassGrabNotifyFieldCallback)
getWidgetClassGrabNotify s :: WidgetClass
s = IO (Maybe WidgetClassGrabNotifyFieldCallback)
-> m (Maybe WidgetClassGrabNotifyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassGrabNotifyFieldCallback)
 -> m (Maybe WidgetClassGrabNotifyFieldCallback))
-> IO (Maybe WidgetClassGrabNotifyFieldCallback)
-> m (Maybe WidgetClassGrabNotifyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGrabNotifyFieldCallback))
-> IO (Maybe WidgetClassGrabNotifyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassGrabNotifyFieldCallback))
 -> IO (Maybe WidgetClassGrabNotifyFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassGrabNotifyFieldCallback))
-> IO (Maybe WidgetClassGrabNotifyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassGrabNotifyFieldCallback
val <- Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)
-> IO (FunPtr C_WidgetClassGrabNotifyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 240) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)
    Maybe WidgetClassGrabNotifyFieldCallback
result <- FunPtr C_WidgetClassGrabNotifyFieldCallback
-> (FunPtr C_WidgetClassGrabNotifyFieldCallback
    -> IO WidgetClassGrabNotifyFieldCallback)
-> IO (Maybe WidgetClassGrabNotifyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGrabNotifyFieldCallback
val ((FunPtr C_WidgetClassGrabNotifyFieldCallback
  -> IO WidgetClassGrabNotifyFieldCallback)
 -> IO (Maybe WidgetClassGrabNotifyFieldCallback))
-> (FunPtr C_WidgetClassGrabNotifyFieldCallback
    -> IO WidgetClassGrabNotifyFieldCallback)
-> IO (Maybe WidgetClassGrabNotifyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassGrabNotifyFieldCallback
val' -> do
        let val'' :: WidgetClassGrabNotifyFieldCallback
val'' = FunPtr C_WidgetClassGrabNotifyFieldCallback
-> WidgetClassGrabNotifyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGrabNotifyFieldCallback -> a -> Bool -> m ()
Gtk.Callbacks.dynamic_WidgetClassGrabNotifyFieldCallback FunPtr C_WidgetClassGrabNotifyFieldCallback
val'
        WidgetClassGrabNotifyFieldCallback
-> IO WidgetClassGrabNotifyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGrabNotifyFieldCallback
val''
    Maybe WidgetClassGrabNotifyFieldCallback
-> IO (Maybe WidgetClassGrabNotifyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGrabNotifyFieldCallback
result

-- | Set the value of the “@grab_notify@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #grabNotify 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGrabNotify :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback -> m ()
setWidgetClassGrabNotify :: WidgetClass -> FunPtr C_WidgetClassGrabNotifyFieldCallback -> m ()
setWidgetClassGrabNotify s :: WidgetClass
s val :: FunPtr C_WidgetClassGrabNotifyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)
-> FunPtr C_WidgetClassGrabNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 240) (FunPtr C_WidgetClassGrabNotifyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)

-- | Set the value of the “@grab_notify@” 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' #grabNotify
-- @
clearWidgetClassGrabNotify :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabNotify :: WidgetClass -> m ()
clearWidgetClassGrabNotify s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)
-> FunPtr C_WidgetClassGrabNotifyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGrabNotifyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 240) (FunPtr C_WidgetClassGrabNotifyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGrabNotifyFieldInfo
instance AttrInfo WidgetClassGrabNotifyFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGrabNotifyFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGrabNotifyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGrabNotifyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGrabNotifyFieldInfo = (~)Gtk.Callbacks.WidgetClassGrabNotifyFieldCallback
    type AttrTransferType WidgetClassGrabNotifyFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)
    type AttrGetType WidgetClassGrabNotifyFieldInfo = Maybe Gtk.Callbacks.WidgetClassGrabNotifyFieldCallback
    type AttrLabel WidgetClassGrabNotifyFieldInfo = "grab_notify"
    type AttrOrigin WidgetClassGrabNotifyFieldInfo = WidgetClass
    attrGet = getWidgetClassGrabNotify
    attrSet = setWidgetClassGrabNotify
    attrConstruct = undefined
    attrClear = clearWidgetClassGrabNotify
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGrabNotifyFieldCallback (Gtk.Callbacks.wrap_WidgetClassGrabNotifyFieldCallback Nothing v)

widgetClass_grabNotify :: AttrLabelProxy "grabNotify"
widgetClass_grabNotify = 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 :: WidgetClass -> m (Maybe WidgetClassGetRequestModeFieldCallback)
getWidgetClassGetRequestMode s :: 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 :: 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` 248) :: 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
$ \val' :: 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 :: WidgetClass
-> FunPtr C_WidgetClassGetRequestModeFieldCallback -> m ()
setWidgetClassGetRequestMode s :: WidgetClass
s val :: 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 :: 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` 248) (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 :: WidgetClass -> m ()
clearWidgetClassGetRequestMode s :: 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 :: 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` 248) (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 :: WidgetClass -> m (Maybe WidgetClassMeasureFieldCallback)
getWidgetClassMeasure s :: 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 :: 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` 256) :: 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
$ \val' :: 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 :: WidgetClass -> FunPtr C_WidgetClassMeasureFieldCallback -> m ()
setWidgetClassMeasure s :: WidgetClass
s val :: 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 :: 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` 256) (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 :: WidgetClass -> m ()
clearWidgetClassMeasure s :: 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 :: 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` 256) (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 :: WidgetClass -> m (Maybe WidgetClassMnemonicActivateFieldCallback)
getWidgetClassMnemonicActivate s :: 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 :: 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` 264) :: 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
$ \val' :: 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 :: WidgetClass
-> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> m ()
setWidgetClassMnemonicActivate s :: WidgetClass
s val :: 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 :: 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` 264) (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 :: WidgetClass -> m ()
clearWidgetClassMnemonicActivate s :: 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 :: 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` 264) (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 :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassGrabFocus s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 272) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassGrabFocusFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
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 :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassGrabFocus s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 272) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m ()
clearWidgetClassGrabFocus s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 272) (FunPtr C_WidgetClassDestroyFieldCallback
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 :: WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassFocus s :: 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 :: 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` 280) :: 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
$ \val' :: 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 :: WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassFocus s :: WidgetClass
s val :: 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 :: 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` 280) (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 :: WidgetClass -> m ()
clearWidgetClassFocus s :: 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 :: 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` 280) (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 “@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 :: WidgetClass -> m (Maybe WidgetClassMoveFocusFieldCallback)
getWidgetClassMoveFocus s :: 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 :: 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` 288) :: 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
$ \val' :: 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 :: WidgetClass
-> FunPtr C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassMoveFocus s :: WidgetClass
s val :: 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 :: 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` 288) (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 :: WidgetClass -> m ()
clearWidgetClassMoveFocus s :: 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 :: 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` 288) (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 :: WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassKeynavFailed s :: 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 :: 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` 296) :: 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
$ \val' :: 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 :: WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassKeynavFailed s :: WidgetClass
s val :: 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 :: 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` 296) (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 :: WidgetClass -> m ()
clearWidgetClassKeynavFailed s :: 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 :: 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` 296) (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 “@drag_begin@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #dragBegin
-- @
getWidgetClassDragBegin :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragBeginFieldCallback)
getWidgetClassDragBegin :: WidgetClass -> m (Maybe WidgetClassDragBeginFieldCallback)
getWidgetClassDragBegin s :: WidgetClass
s = IO (Maybe WidgetClassDragBeginFieldCallback)
-> m (Maybe WidgetClassDragBeginFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDragBeginFieldCallback)
 -> m (Maybe WidgetClassDragBeginFieldCallback))
-> IO (Maybe WidgetClassDragBeginFieldCallback)
-> m (Maybe WidgetClassDragBeginFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDragBeginFieldCallback))
-> IO (Maybe WidgetClassDragBeginFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDragBeginFieldCallback))
 -> IO (Maybe WidgetClassDragBeginFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDragBeginFieldCallback))
-> IO (Maybe WidgetClassDragBeginFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDragBeginFieldCallback
val <- Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
-> IO (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 304) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)
    Maybe WidgetClassDragBeginFieldCallback
result <- FunPtr C_WidgetClassDragBeginFieldCallback
-> (FunPtr C_WidgetClassDragBeginFieldCallback
    -> IO WidgetClassDragBeginFieldCallback)
-> IO (Maybe WidgetClassDragBeginFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragBeginFieldCallback
val ((FunPtr C_WidgetClassDragBeginFieldCallback
  -> IO WidgetClassDragBeginFieldCallback)
 -> IO (Maybe WidgetClassDragBeginFieldCallback))
-> (FunPtr C_WidgetClassDragBeginFieldCallback
    -> IO WidgetClassDragBeginFieldCallback)
-> IO (Maybe WidgetClassDragBeginFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDragBeginFieldCallback
val' -> do
        let val'' :: WidgetClassDragBeginFieldCallback
val'' = FunPtr C_WidgetClassDragBeginFieldCallback
-> WidgetClassDragBeginFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDrag b) =>
FunPtr C_WidgetClassDragBeginFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassDragBeginFieldCallback FunPtr C_WidgetClassDragBeginFieldCallback
val'
        WidgetClassDragBeginFieldCallback
-> IO WidgetClassDragBeginFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragBeginFieldCallback
val''
    Maybe WidgetClassDragBeginFieldCallback
-> IO (Maybe WidgetClassDragBeginFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragBeginFieldCallback
result

-- | Set the value of the “@drag_begin@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragBegin 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragBegin :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragBegin :: WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragBegin s :: WidgetClass
s val :: FunPtr C_WidgetClassDragBeginFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 304) (FunPtr C_WidgetClassDragBeginFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)

-- | Set the value of the “@drag_begin@” 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' #dragBegin
-- @
clearWidgetClassDragBegin :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragBegin :: WidgetClass -> m ()
clearWidgetClassDragBegin s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 304) (FunPtr C_WidgetClassDragBeginFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragBeginFieldInfo
instance AttrInfo WidgetClassDragBeginFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragBeginFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragBeginFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragBeginFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragBeginFieldInfo = (~)Gtk.Callbacks.WidgetClassDragBeginFieldCallback
    type AttrTransferType WidgetClassDragBeginFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)
    type AttrGetType WidgetClassDragBeginFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragBeginFieldCallback
    type AttrLabel WidgetClassDragBeginFieldInfo = "drag_begin"
    type AttrOrigin WidgetClassDragBeginFieldInfo = WidgetClass
    attrGet = getWidgetClassDragBegin
    attrSet = setWidgetClassDragBegin
    attrConstruct = undefined
    attrClear = clearWidgetClassDragBegin
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragBeginFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragBeginFieldCallback Nothing v)

widgetClass_dragBegin :: AttrLabelProxy "dragBegin"
widgetClass_dragBegin = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_end@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragEnd 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragEnd :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback -> m ()
setWidgetClassDragEnd :: WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragEnd s :: WidgetClass
s val :: FunPtr C_WidgetClassDragBeginFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 312) (FunPtr C_WidgetClassDragBeginFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)

-- | Set the value of the “@drag_end@” 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' #dragEnd
-- @
clearWidgetClassDragEnd :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragEnd :: WidgetClass -> m ()
clearWidgetClassDragEnd s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 312) (FunPtr C_WidgetClassDragBeginFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragEndFieldInfo
instance AttrInfo WidgetClassDragEndFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragEndFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragEndFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragEndFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragEndFieldInfo = (~)Gtk.Callbacks.WidgetClassDragEndFieldCallback
    type AttrTransferType WidgetClassDragEndFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)
    type AttrGetType WidgetClassDragEndFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragEndFieldCallback
    type AttrLabel WidgetClassDragEndFieldInfo = "drag_end"
    type AttrOrigin WidgetClassDragEndFieldInfo = WidgetClass
    attrGet = getWidgetClassDragEnd
    attrSet = setWidgetClassDragEnd
    attrConstruct = undefined
    attrClear = clearWidgetClassDragEnd
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragEndFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragEndFieldCallback Nothing v)

widgetClass_dragEnd :: AttrLabelProxy "dragEnd"
widgetClass_dragEnd = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_data_get@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragDataGet 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragDataGet :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback -> m ()
setWidgetClassDragDataGet :: WidgetClass -> FunPtr C_WidgetClassDragDataGetFieldCallback -> m ()
setWidgetClassDragDataGet s :: WidgetClass
s val :: FunPtr C_WidgetClassDragDataGetFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)
-> FunPtr C_WidgetClassDragDataGetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 320) (FunPtr C_WidgetClassDragDataGetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)

-- | Set the value of the “@drag_data_get@” 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' #dragDataGet
-- @
clearWidgetClassDragDataGet :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataGet :: WidgetClass -> m ()
clearWidgetClassDragDataGet s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)
-> FunPtr C_WidgetClassDragDataGetFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragDataGetFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 320) (FunPtr C_WidgetClassDragDataGetFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragDataGetFieldInfo
instance AttrInfo WidgetClassDragDataGetFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragDataGetFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragDataGetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragDataGetFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragDataGetFieldInfo = (~)Gtk.Callbacks.WidgetClassDragDataGetFieldCallback
    type AttrTransferType WidgetClassDragDataGetFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)
    type AttrGetType WidgetClassDragDataGetFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragDataGetFieldCallback
    type AttrLabel WidgetClassDragDataGetFieldInfo = "drag_data_get"
    type AttrOrigin WidgetClassDragDataGetFieldInfo = WidgetClass
    attrGet = getWidgetClassDragDataGet
    attrSet = setWidgetClassDragDataGet
    attrConstruct = undefined
    attrClear = clearWidgetClassDragDataGet
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragDataGetFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragDataGetFieldCallback Nothing v)

widgetClass_dragDataGet :: AttrLabelProxy "dragDataGet"
widgetClass_dragDataGet = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_data_delete@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragDataDelete 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback -> m ()
setWidgetClassDragDataDelete :: WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragDataDelete s :: WidgetClass
s val :: FunPtr C_WidgetClassDragBeginFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 328) (FunPtr C_WidgetClassDragBeginFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)

-- | Set the value of the “@drag_data_delete@” 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' #dragDataDelete
-- @
clearWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataDelete :: WidgetClass -> m ()
clearWidgetClassDragDataDelete s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
-> FunPtr C_WidgetClassDragBeginFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragBeginFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 328) (FunPtr C_WidgetClassDragBeginFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragDataDeleteFieldInfo
instance AttrInfo WidgetClassDragDataDeleteFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragDataDeleteFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragDataDeleteFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragDataDeleteFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragDataDeleteFieldInfo = (~)Gtk.Callbacks.WidgetClassDragDataDeleteFieldCallback
    type AttrTransferType WidgetClassDragDataDeleteFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)
    type AttrGetType WidgetClassDragDataDeleteFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragDataDeleteFieldCallback
    type AttrLabel WidgetClassDragDataDeleteFieldInfo = "drag_data_delete"
    type AttrOrigin WidgetClassDragDataDeleteFieldInfo = WidgetClass
    attrGet = getWidgetClassDragDataDelete
    attrSet = setWidgetClassDragDataDelete
    attrConstruct = undefined
    attrClear = clearWidgetClassDragDataDelete
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragDataDeleteFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragDataDeleteFieldCallback Nothing v)

widgetClass_dragDataDelete :: AttrLabelProxy "dragDataDelete"
widgetClass_dragDataDelete = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_leave@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragLeave 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragLeave :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback -> m ()
setWidgetClassDragLeave :: WidgetClass -> FunPtr C_WidgetClassDragLeaveFieldCallback -> m ()
setWidgetClassDragLeave s :: WidgetClass
s val :: FunPtr C_WidgetClassDragLeaveFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)
-> FunPtr C_WidgetClassDragLeaveFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 336) (FunPtr C_WidgetClassDragLeaveFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)

-- | Set the value of the “@drag_leave@” 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' #dragLeave
-- @
clearWidgetClassDragLeave :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragLeave :: WidgetClass -> m ()
clearWidgetClassDragLeave s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)
-> FunPtr C_WidgetClassDragLeaveFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragLeaveFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 336) (FunPtr C_WidgetClassDragLeaveFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragLeaveFieldInfo
instance AttrInfo WidgetClassDragLeaveFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragLeaveFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragLeaveFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragLeaveFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragLeaveFieldInfo = (~)Gtk.Callbacks.WidgetClassDragLeaveFieldCallback
    type AttrTransferType WidgetClassDragLeaveFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)
    type AttrGetType WidgetClassDragLeaveFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragLeaveFieldCallback
    type AttrLabel WidgetClassDragLeaveFieldInfo = "drag_leave"
    type AttrOrigin WidgetClassDragLeaveFieldInfo = WidgetClass
    attrGet = getWidgetClassDragLeave
    attrSet = setWidgetClassDragLeave
    attrConstruct = undefined
    attrClear = clearWidgetClassDragLeave
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragLeaveFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragLeaveFieldCallback Nothing v)

widgetClass_dragLeave :: AttrLabelProxy "dragLeave"
widgetClass_dragLeave = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_motion@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragMotion 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragMotion :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback -> m ()
setWidgetClassDragMotion :: WidgetClass -> FunPtr C_WidgetClassDragMotionFieldCallback -> m ()
setWidgetClassDragMotion s :: WidgetClass
s val :: FunPtr C_WidgetClassDragMotionFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
-> FunPtr C_WidgetClassDragMotionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 344) (FunPtr C_WidgetClassDragMotionFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)

-- | Set the value of the “@drag_motion@” 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' #dragMotion
-- @
clearWidgetClassDragMotion :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragMotion :: WidgetClass -> m ()
clearWidgetClassDragMotion s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
-> FunPtr C_WidgetClassDragMotionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 344) (FunPtr C_WidgetClassDragMotionFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragMotionFieldInfo
instance AttrInfo WidgetClassDragMotionFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragMotionFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragMotionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragMotionFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragMotionFieldInfo = (~)Gtk.Callbacks.WidgetClassDragMotionFieldCallback
    type AttrTransferType WidgetClassDragMotionFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)
    type AttrGetType WidgetClassDragMotionFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragMotionFieldCallback
    type AttrLabel WidgetClassDragMotionFieldInfo = "drag_motion"
    type AttrOrigin WidgetClassDragMotionFieldInfo = WidgetClass
    attrGet = getWidgetClassDragMotion
    attrSet = setWidgetClassDragMotion
    attrConstruct = undefined
    attrClear = clearWidgetClassDragMotion
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragMotionFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragMotionFieldCallback Nothing v)

widgetClass_dragMotion :: AttrLabelProxy "dragMotion"
widgetClass_dragMotion = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_drop@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragDrop 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragDrop :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback -> m ()
setWidgetClassDragDrop :: WidgetClass -> FunPtr C_WidgetClassDragMotionFieldCallback -> m ()
setWidgetClassDragDrop s :: WidgetClass
s val :: FunPtr C_WidgetClassDragMotionFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
-> FunPtr C_WidgetClassDragMotionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 352) (FunPtr C_WidgetClassDragMotionFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)

-- | Set the value of the “@drag_drop@” 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' #dragDrop
-- @
clearWidgetClassDragDrop :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDrop :: WidgetClass -> m ()
clearWidgetClassDragDrop s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
-> FunPtr C_WidgetClassDragMotionFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragMotionFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 352) (FunPtr C_WidgetClassDragMotionFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragDropFieldInfo
instance AttrInfo WidgetClassDragDropFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragDropFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragDropFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragDropFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragDropFieldInfo = (~)Gtk.Callbacks.WidgetClassDragDropFieldCallback
    type AttrTransferType WidgetClassDragDropFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)
    type AttrGetType WidgetClassDragDropFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragDropFieldCallback
    type AttrLabel WidgetClassDragDropFieldInfo = "drag_drop"
    type AttrOrigin WidgetClassDragDropFieldInfo = WidgetClass
    attrGet = getWidgetClassDragDrop
    attrSet = setWidgetClassDragDrop
    attrConstruct = undefined
    attrClear = clearWidgetClassDragDrop
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragDropFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragDropFieldCallback Nothing v)

widgetClass_dragDrop :: AttrLabelProxy "dragDrop"
widgetClass_dragDrop = AttrLabelProxy

#endif


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

-- | Set the value of the “@drag_data_received@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #dragDataReceived 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback -> m ()
setWidgetClassDragDataReceived :: WidgetClass
-> FunPtr C_WidgetClassDragDataReceivedFieldCallback -> m ()
setWidgetClassDragDataReceived s :: WidgetClass
s val :: FunPtr C_WidgetClassDragDataReceivedFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)
-> FunPtr C_WidgetClassDragDataReceivedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 360) (FunPtr C_WidgetClassDragDataReceivedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)

-- | Set the value of the “@drag_data_received@” 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' #dragDataReceived
-- @
clearWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataReceived :: WidgetClass -> m ()
clearWidgetClassDragDataReceived s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)
-> FunPtr C_WidgetClassDragDataReceivedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragDataReceivedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 360) (FunPtr C_WidgetClassDragDataReceivedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragDataReceivedFieldInfo
instance AttrInfo WidgetClassDragDataReceivedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragDataReceivedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragDataReceivedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragDataReceivedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragDataReceivedFieldInfo = (~)Gtk.Callbacks.WidgetClassDragDataReceivedFieldCallback
    type AttrTransferType WidgetClassDragDataReceivedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)
    type AttrGetType WidgetClassDragDataReceivedFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragDataReceivedFieldCallback
    type AttrLabel WidgetClassDragDataReceivedFieldInfo = "drag_data_received"
    type AttrOrigin WidgetClassDragDataReceivedFieldInfo = WidgetClass
    attrGet = getWidgetClassDragDataReceived
    attrSet = setWidgetClassDragDataReceived
    attrConstruct = undefined
    attrClear = clearWidgetClassDragDataReceived
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragDataReceivedFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragDataReceivedFieldCallback Nothing v)

widgetClass_dragDataReceived :: AttrLabelProxy "dragDataReceived"
widgetClass_dragDataReceived = AttrLabelProxy

#endif


-- | Get the value of the “@drag_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 #dragFailed
-- @
getWidgetClassDragFailed :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragFailedFieldCallback)
getWidgetClassDragFailed :: WidgetClass -> m (Maybe WidgetClassDragFailedFieldCallback)
getWidgetClassDragFailed s :: WidgetClass
s = IO (Maybe WidgetClassDragFailedFieldCallback)
-> m (Maybe WidgetClassDragFailedFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDragFailedFieldCallback)
 -> m (Maybe WidgetClassDragFailedFieldCallback))
-> IO (Maybe WidgetClassDragFailedFieldCallback)
-> m (Maybe WidgetClassDragFailedFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDragFailedFieldCallback))
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDragFailedFieldCallback))
 -> IO (Maybe WidgetClassDragFailedFieldCallback))
-> (Ptr WidgetClass
    -> IO (Maybe WidgetClassDragFailedFieldCallback))
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDragFailedFieldCallback
val <- Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
-> IO (FunPtr C_WidgetClassDragFailedFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 368) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)
    Maybe WidgetClassDragFailedFieldCallback
result <- FunPtr C_WidgetClassDragFailedFieldCallback
-> (FunPtr C_WidgetClassDragFailedFieldCallback
    -> IO WidgetClassDragFailedFieldCallback)
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragFailedFieldCallback
val ((FunPtr C_WidgetClassDragFailedFieldCallback
  -> IO WidgetClassDragFailedFieldCallback)
 -> IO (Maybe WidgetClassDragFailedFieldCallback))
-> (FunPtr C_WidgetClassDragFailedFieldCallback
    -> IO WidgetClassDragFailedFieldCallback)
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDragFailedFieldCallback
val' -> do
        let val'' :: WidgetClassDragFailedFieldCallback
val'' = FunPtr C_WidgetClassDragFailedFieldCallback
-> WidgetClassDragFailedFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDrag b) =>
FunPtr C_WidgetClassDragFailedFieldCallback
-> a -> b -> DragResult -> m Bool
Gtk.Callbacks.dynamic_WidgetClassDragFailedFieldCallback FunPtr C_WidgetClassDragFailedFieldCallback
val'
        WidgetClassDragFailedFieldCallback
-> IO WidgetClassDragFailedFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragFailedFieldCallback
val''
    Maybe WidgetClassDragFailedFieldCallback
-> IO (Maybe WidgetClassDragFailedFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragFailedFieldCallback
result

-- | Set the value of the “@drag_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 [ #dragFailed 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassDragFailed :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback -> m ()
setWidgetClassDragFailed :: WidgetClass -> FunPtr C_WidgetClassDragFailedFieldCallback -> m ()
setWidgetClassDragFailed s :: WidgetClass
s val :: FunPtr C_WidgetClassDragFailedFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
-> FunPtr C_WidgetClassDragFailedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 368) (FunPtr C_WidgetClassDragFailedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)

-- | Set the value of the “@drag_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' #dragFailed
-- @
clearWidgetClassDragFailed :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragFailed :: WidgetClass -> m ()
clearWidgetClassDragFailed s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
-> FunPtr C_WidgetClassDragFailedFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDragFailedFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 368) (FunPtr C_WidgetClassDragFailedFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassDragFailedFieldInfo
instance AttrInfo WidgetClassDragFailedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassDragFailedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassDragFailedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassDragFailedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassDragFailedFieldInfo = (~)Gtk.Callbacks.WidgetClassDragFailedFieldCallback
    type AttrTransferType WidgetClassDragFailedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)
    type AttrGetType WidgetClassDragFailedFieldInfo = Maybe Gtk.Callbacks.WidgetClassDragFailedFieldCallback
    type AttrLabel WidgetClassDragFailedFieldInfo = "drag_failed"
    type AttrOrigin WidgetClassDragFailedFieldInfo = WidgetClass
    attrGet = getWidgetClassDragFailed
    attrSet = setWidgetClassDragFailed
    attrConstruct = undefined
    attrClear = clearWidgetClassDragFailed
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassDragFailedFieldCallback (Gtk.Callbacks.wrap_WidgetClassDragFailedFieldCallback Nothing v)

widgetClass_dragFailed :: AttrLabelProxy "dragFailed"
widgetClass_dragFailed = AttrLabelProxy

#endif


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

-- | Set the value of the “@popup_menu@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #popupMenu 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassPopupMenu :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback -> m ()
setWidgetClassPopupMenu :: WidgetClass -> FunPtr C_WidgetClassPopupMenuFieldCallback -> m ()
setWidgetClassPopupMenu s :: WidgetClass
s val :: FunPtr C_WidgetClassPopupMenuFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)
-> FunPtr C_WidgetClassPopupMenuFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 376) (FunPtr C_WidgetClassPopupMenuFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)

-- | Set the value of the “@popup_menu@” 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' #popupMenu
-- @
clearWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m ()
clearWidgetClassPopupMenu :: WidgetClass -> m ()
clearWidgetClassPopupMenu s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)
-> FunPtr C_WidgetClassPopupMenuFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassPopupMenuFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 376) (FunPtr C_WidgetClassPopupMenuFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassPopupMenuFieldInfo
instance AttrInfo WidgetClassPopupMenuFieldInfo where
    type AttrBaseTypeConstraint WidgetClassPopupMenuFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassPopupMenuFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassPopupMenuFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)
    type AttrTransferTypeConstraint WidgetClassPopupMenuFieldInfo = (~)Gtk.Callbacks.WidgetClassPopupMenuFieldCallback
    type AttrTransferType WidgetClassPopupMenuFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)
    type AttrGetType WidgetClassPopupMenuFieldInfo = Maybe Gtk.Callbacks.WidgetClassPopupMenuFieldCallback
    type AttrLabel WidgetClassPopupMenuFieldInfo = "popup_menu"
    type AttrOrigin WidgetClassPopupMenuFieldInfo = WidgetClass
    attrGet = getWidgetClassPopupMenu
    attrSet = setWidgetClassPopupMenu
    attrConstruct = undefined
    attrClear = clearWidgetClassPopupMenu
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassPopupMenuFieldCallback (Gtk.Callbacks.wrap_WidgetClassPopupMenuFieldCallback Nothing v)

widgetClass_popupMenu :: AttrLabelProxy "popupMenu"
widgetClass_popupMenu = AttrLabelProxy

#endif


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

-- | Set the value of the “@get_accessible@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #getAccessible 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassGetAccessible :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback -> m ()
setWidgetClassGetAccessible :: WidgetClass
-> FunPtr C_WidgetClassGetAccessibleFieldCallback -> m ()
setWidgetClassGetAccessible s :: WidgetClass
s val :: FunPtr C_WidgetClassGetAccessibleFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)
-> FunPtr C_WidgetClassGetAccessibleFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 384) (FunPtr C_WidgetClassGetAccessibleFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)

-- | Set the value of the “@get_accessible@” 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' #getAccessible
-- @
clearWidgetClassGetAccessible :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetAccessible :: WidgetClass -> m ()
clearWidgetClassGetAccessible s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)
-> FunPtr C_WidgetClassGetAccessibleFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassGetAccessibleFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 384) (FunPtr C_WidgetClassGetAccessibleFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassGetAccessibleFieldInfo
instance AttrInfo WidgetClassGetAccessibleFieldInfo where
    type AttrBaseTypeConstraint WidgetClassGetAccessibleFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassGetAccessibleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassGetAccessibleFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)
    type AttrTransferTypeConstraint WidgetClassGetAccessibleFieldInfo = (~)Gtk.Callbacks.WidgetClassGetAccessibleFieldCallback
    type AttrTransferType WidgetClassGetAccessibleFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)
    type AttrGetType WidgetClassGetAccessibleFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetAccessibleFieldCallback
    type AttrLabel WidgetClassGetAccessibleFieldInfo = "get_accessible"
    type AttrOrigin WidgetClassGetAccessibleFieldInfo = WidgetClass
    attrGet = getWidgetClassGetAccessible
    attrSet = setWidgetClassGetAccessible
    attrConstruct = undefined
    attrClear = clearWidgetClassGetAccessible
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassGetAccessibleFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetAccessibleFieldCallback Nothing v)

widgetClass_getAccessible :: AttrLabelProxy "getAccessible"
widgetClass_getAccessible = AttrLabelProxy

#endif


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

-- | Set the value of the “@can_activate_accel@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #canActivateAccel 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback -> m ()
setWidgetClassCanActivateAccel :: WidgetClass
-> FunPtr C_WidgetClassCanActivateAccelFieldCallback -> m ()
setWidgetClassCanActivateAccel s :: WidgetClass
s val :: FunPtr C_WidgetClassCanActivateAccelFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)
-> FunPtr C_WidgetClassCanActivateAccelFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 392) (FunPtr C_WidgetClassCanActivateAccelFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)

-- | Set the value of the “@can_activate_accel@” 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' #canActivateAccel
-- @
clearWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> m ()
clearWidgetClassCanActivateAccel :: WidgetClass -> m ()
clearWidgetClassCanActivateAccel s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)
-> FunPtr C_WidgetClassCanActivateAccelFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassCanActivateAccelFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 392) (FunPtr C_WidgetClassCanActivateAccelFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassCanActivateAccelFieldInfo
instance AttrInfo WidgetClassCanActivateAccelFieldInfo where
    type AttrBaseTypeConstraint WidgetClassCanActivateAccelFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassCanActivateAccelFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassCanActivateAccelFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)
    type AttrTransferTypeConstraint WidgetClassCanActivateAccelFieldInfo = (~)Gtk.Callbacks.WidgetClassCanActivateAccelFieldCallback
    type AttrTransferType WidgetClassCanActivateAccelFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)
    type AttrGetType WidgetClassCanActivateAccelFieldInfo = Maybe Gtk.Callbacks.WidgetClassCanActivateAccelFieldCallback
    type AttrLabel WidgetClassCanActivateAccelFieldInfo = "can_activate_accel"
    type AttrOrigin WidgetClassCanActivateAccelFieldInfo = WidgetClass
    attrGet = getWidgetClassCanActivateAccel
    attrSet = setWidgetClassCanActivateAccel
    attrConstruct = undefined
    attrClear = clearWidgetClassCanActivateAccel
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassCanActivateAccelFieldCallback (Gtk.Callbacks.wrap_WidgetClassCanActivateAccelFieldCallback Nothing v)

widgetClass_canActivateAccel :: AttrLabelProxy "canActivateAccel"
widgetClass_canActivateAccel = 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 :: WidgetClass -> m (Maybe WidgetClassQueryTooltipFieldCallback)
getWidgetClassQueryTooltip s :: 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 :: 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` 400) :: 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
$ \val' :: 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 :: WidgetClass
-> FunPtr C_WidgetClassQueryTooltipFieldCallback -> m ()
setWidgetClassQueryTooltip s :: WidgetClass
s val :: 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 :: 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` 400) (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 :: WidgetClass -> m ()
clearWidgetClassQueryTooltip s :: 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 :: 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` 400) (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 :: WidgetClass -> m (Maybe WidgetClassComputeExpandFieldCallback)
getWidgetClassComputeExpand s :: 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 :: 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` 408) :: 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
$ \val' :: 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 :: WidgetClass
-> FunPtr C_WidgetClassComputeExpandFieldCallback -> m ()
setWidgetClassComputeExpand s :: WidgetClass
s val :: 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 :: 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` 408) (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 :: WidgetClass -> m ()
clearWidgetClassComputeExpand s :: 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 :: 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` 408) (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 “@style_updated@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' widgetClass #styleUpdated
-- @
getWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassStyleUpdatedFieldCallback)
getWidgetClassStyleUpdated :: WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassStyleUpdated s :: WidgetClass
s = IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe WidgetClassDestroyFieldCallback)
 -> m (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
-> m (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ WidgetClass
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s ((Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (Ptr WidgetClass -> IO (Maybe WidgetClassDestroyFieldCallback))
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr WidgetClass
ptr -> do
    FunPtr C_WidgetClassDestroyFieldCallback
val <- Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> IO (FunPtr C_WidgetClassDestroyFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 416) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)
    Maybe WidgetClassDestroyFieldCallback
result <- FunPtr C_WidgetClassDestroyFieldCallback
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val ((FunPtr C_WidgetClassDestroyFieldCallback
  -> IO WidgetClassDestroyFieldCallback)
 -> IO (Maybe WidgetClassDestroyFieldCallback))
-> (FunPtr C_WidgetClassDestroyFieldCallback
    -> IO WidgetClassDestroyFieldCallback)
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
        let val'' :: WidgetClassDestroyFieldCallback
val'' = FunPtr C_WidgetClassDestroyFieldCallback
-> WidgetClassDestroyFieldCallback
forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassStyleUpdatedFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
        WidgetClassDestroyFieldCallback
-> IO WidgetClassDestroyFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
    Maybe WidgetClassDestroyFieldCallback
-> IO (Maybe WidgetClassDestroyFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result

-- | Set the value of the “@style_updated@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' widgetClass [ #styleUpdated 'Data.GI.Base.Attributes.:=' value ]
-- @
setWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback -> m ()
setWidgetClassStyleUpdated :: WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassStyleUpdated s :: WidgetClass
s val :: FunPtr C_WidgetClassDestroyFieldCallback
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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 416) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)

-- | Set the value of the “@style_updated@” 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' #styleUpdated
-- @
clearWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStyleUpdated :: WidgetClass -> m ()
clearWidgetClassStyleUpdated s :: 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 :: Ptr WidgetClass
ptr -> do
    Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
-> FunPtr C_WidgetClassDestroyFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr Ptr WidgetClass
-> Int -> Ptr (FunPtr C_WidgetClassDestroyFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 416) (FunPtr C_WidgetClassDestroyFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)

#if defined(ENABLE_OVERLOADING)
data WidgetClassStyleUpdatedFieldInfo
instance AttrInfo WidgetClassStyleUpdatedFieldInfo where
    type AttrBaseTypeConstraint WidgetClassStyleUpdatedFieldInfo = (~) WidgetClass
    type AttrAllowedOps WidgetClassStyleUpdatedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WidgetClassStyleUpdatedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)
    type AttrTransferTypeConstraint WidgetClassStyleUpdatedFieldInfo = (~)Gtk.Callbacks.WidgetClassStyleUpdatedFieldCallback
    type AttrTransferType WidgetClassStyleUpdatedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)
    type AttrGetType WidgetClassStyleUpdatedFieldInfo = Maybe Gtk.Callbacks.WidgetClassStyleUpdatedFieldCallback
    type AttrLabel WidgetClassStyleUpdatedFieldInfo = "style_updated"
    type AttrOrigin WidgetClassStyleUpdatedFieldInfo = WidgetClass
    attrGet = getWidgetClassStyleUpdated
    attrSet = setWidgetClassStyleUpdated
    attrConstruct = undefined
    attrClear = clearWidgetClassStyleUpdated
    attrTransfer _ v = do
        Gtk.Callbacks.mk_WidgetClassStyleUpdatedFieldCallback (Gtk.Callbacks.wrap_WidgetClassStyleUpdatedFieldCallback Nothing v)

widgetClass_styleUpdated :: AttrLabelProxy "styleUpdated"
widgetClass_styleUpdated = 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 :: WidgetClass -> m (Maybe WidgetClassSnapshotFieldCallback)
getWidgetClassSnapshot s :: 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 :: 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` 424) :: 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
$ \val' :: 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 :: WidgetClass -> FunPtr C_WidgetClassSnapshotFieldCallback -> m ()
setWidgetClassSnapshot s :: WidgetClass
s val :: 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 :: 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` 424) (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 :: WidgetClass -> m ()
clearWidgetClassSnapshot s :: 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 :: 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` 424) (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 :: WidgetClass -> m (Maybe WidgetClassContainsFieldCallback)
getWidgetClassContains s :: 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 :: 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` 432) :: 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
$ \val' :: 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 :: WidgetClass -> FunPtr C_WidgetClassContainsFieldCallback -> m ()
setWidgetClassContains s :: WidgetClass
s val :: 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 :: 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` 432) (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 :: WidgetClass -> m ()
clearWidgetClassContains s :: 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 :: 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` 432) (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), '("activateSignal", WidgetClassActivateSignalFieldInfo), '("destroy", WidgetClassDestroyFieldInfo), '("show", WidgetClassShowFieldInfo), '("hide", WidgetClassHideFieldInfo), '("map", WidgetClassMapFieldInfo), '("unmap", WidgetClassUnmapFieldInfo), '("realize", WidgetClassRealizeFieldInfo), '("unrealize", WidgetClassUnrealizeFieldInfo), '("root", WidgetClassRootFieldInfo), '("unroot", WidgetClassUnrootFieldInfo), '("sizeAllocate", WidgetClassSizeAllocateFieldInfo), '("stateFlagsChanged", WidgetClassStateFlagsChangedFieldInfo), '("directionChanged", WidgetClassDirectionChangedFieldInfo), '("grabNotify", WidgetClassGrabNotifyFieldInfo), '("getRequestMode", WidgetClassGetRequestModeFieldInfo), '("measure", WidgetClassMeasureFieldInfo), '("mnemonicActivate", WidgetClassMnemonicActivateFieldInfo), '("grabFocus", WidgetClassGrabFocusFieldInfo), '("focus", WidgetClassFocusFieldInfo), '("moveFocus", WidgetClassMoveFocusFieldInfo), '("keynavFailed", WidgetClassKeynavFailedFieldInfo), '("dragBegin", WidgetClassDragBeginFieldInfo), '("dragEnd", WidgetClassDragEndFieldInfo), '("dragDataGet", WidgetClassDragDataGetFieldInfo), '("dragDataDelete", WidgetClassDragDataDeleteFieldInfo), '("dragLeave", WidgetClassDragLeaveFieldInfo), '("dragMotion", WidgetClassDragMotionFieldInfo), '("dragDrop", WidgetClassDragDropFieldInfo), '("dragDataReceived", WidgetClassDragDataReceivedFieldInfo), '("dragFailed", WidgetClassDragFailedFieldInfo), '("popupMenu", WidgetClassPopupMenuFieldInfo), '("getAccessible", WidgetClassGetAccessibleFieldInfo), '("canActivateAccel", WidgetClassCanActivateAccelFieldInfo), '("queryTooltip", WidgetClassQueryTooltipFieldInfo), '("computeExpand", WidgetClassComputeExpandFieldInfo), '("styleUpdated", WidgetClassStyleUpdatedFieldInfo), '("snapshot", WidgetClassSnapshotFieldInfo), '("contains", WidgetClassContainsFieldInfo)] :: [(Symbol, *)])
#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@/. See 'GI.Gtk.Objects.Builder.builderAddCallbackSymbol'.
-- 
-- 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 :: WidgetClass -> Text -> IO () -> m ()
widgetClassBindTemplateCallbackFull widgetClass :: WidgetClass
widgetClass callbackName :: Text
callbackName callbackSymbol :: 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.MethodInfo WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass signature where
    overloadedMethod = 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 :: WidgetClass -> Text -> Bool -> Int64 -> m ()
widgetClassBindTemplateChildFull widgetClass :: WidgetClass
widgetClass name :: Text
name internalChild :: Bool
internalChild structOffset :: 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.MethodInfo WidgetClassBindTemplateChildFullMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassBindTemplateChildFull

#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 :: WidgetClass -> m Text
widgetClassGetCssName widgetClass :: 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 "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.MethodInfo WidgetClassGetCssNameMethodInfo WidgetClass signature where
    overloadedMethod = 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 :: WidgetClass -> m GType
widgetClassGetLayoutManagerType widgetClass :: 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.MethodInfo WidgetClassGetLayoutManagerTypeMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassGetLayoutManagerType

#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 "class to set the accessible role for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "role"
--           , argType = TInterface Name { namespace = "Atk" , name = "Role" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The role to use for accessibles created 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_accessible_role" gtk_widget_class_set_accessible_role :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CUInt ->                                -- role : TInterface (Name {namespace = "Atk", name = "Role"})
    IO ()

-- | Sets the default t'GI.Atk.Enums.Role' to be set on accessibles created for
-- widgets of /@widgetClass@/. Accessibles may decide to not honor this
-- setting if their role reporting is more refined. Calls to
-- 'GI.Gtk.Structs.WidgetClass.widgetClassSetAccessibleType' will reset this value.
-- 
-- In cases where you want more fine-grained control over the role of
-- accessibles created for /@widgetClass@/, you should provide your own
-- accessible type and use 'GI.Gtk.Structs.WidgetClass.widgetClassSetAccessibleType'
-- instead.
-- 
-- If /@role@/ is @/ATK_ROLE_INVALID/@, the default role will not be changed
-- and the accessible’s default role will be used instead.
-- 
-- This function should only be called from class init functions of widgets.
widgetClassSetAccessibleRole ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the accessible role for
    -> Atk.Enums.Role
    -- ^ /@role@/: The role to use for accessibles created for /@widgetClass@/
    -> m ()
widgetClassSetAccessibleRole :: WidgetClass -> Role -> m ()
widgetClassSetAccessibleRole widgetClass :: WidgetClass
widgetClass role :: Role
role = 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 role' :: CUInt
role' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Role -> Int) -> Role -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Role -> Int
forall a. Enum a => a -> Int
fromEnum) Role
role
    Ptr WidgetClass -> CUInt -> IO ()
gtk_widget_class_set_accessible_role Ptr WidgetClass
widgetClass' CUInt
role'
    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 ~ (Atk.Enums.Role -> m ()), MonadIO m) => O.MethodInfo WidgetClassSetAccessibleRoleMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetAccessibleRole

#endif

-- method WidgetClass::set_accessible_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 accessible 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 accessible 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_accessible_type" gtk_widget_class_set_accessible_type :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    CGType ->                               -- type : TBasicType TGType
    IO ()

-- | Sets the type to be used for creating accessibles for widgets of
-- /@widgetClass@/. The given /@type@/ must be a subtype of the type used for
-- accessibles of the parent class.
-- 
-- This function should only be called from class init functions of widgets.
widgetClassSetAccessibleType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the accessible type for
    -> GType
    -- ^ /@type@/: The object type that implements the accessible for /@widgetClass@/
    -> m ()
widgetClassSetAccessibleType :: WidgetClass -> GType -> m ()
widgetClassSetAccessibleType widgetClass :: WidgetClass
widgetClass type_ :: 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_accessible_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 WidgetClassSetAccessibleTypeMethodInfo
instance (signature ~ (GType -> m ()), MonadIO m) => O.MethodInfo WidgetClassSetAccessibleTypeMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetAccessibleType

#endif

-- method WidgetClass::set_connect_func
-- 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 = "connect_func"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "BuilderConnectFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The #GtkBuilderConnectFunc to use when connecting signals in the class template"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeNotified
--           , argClosure = 2
--           , argDestroy = 3
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connect_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The data to pass to @connect_func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connect_data_destroy"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DestroyNotify" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The #GDestroyNotify to free @connect_data, this will only be used at\n                       class finalization time, when no classes of type @widget_type are in use anymore."
--                 , 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_set_connect_func" gtk_widget_class_set_connect_func :: 
    Ptr WidgetClass ->                      -- widget_class : TInterface (Name {namespace = "Gtk", name = "WidgetClass"})
    FunPtr Gtk.Callbacks.C_BuilderConnectFunc -> -- connect_func : TInterface (Name {namespace = "Gtk", name = "BuilderConnectFunc"})
    Ptr () ->                               -- connect_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- connect_data_destroy : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

-- | For use in language bindings, this will override the default t'GI.Gtk.Callbacks.BuilderConnectFunc' 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'.
widgetClassSetConnectFunc ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: A t'GI.Gtk.Structs.WidgetClass.WidgetClass'
    -> Gtk.Callbacks.BuilderConnectFunc
    -- ^ /@connectFunc@/: The t'GI.Gtk.Callbacks.BuilderConnectFunc' to use when connecting signals in the class template
    -> m ()
widgetClassSetConnectFunc :: WidgetClass -> BuilderConnectFunc -> m ()
widgetClassSetConnectFunc widgetClass :: WidgetClass
widgetClass connectFunc :: BuilderConnectFunc
connectFunc = 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
    FunPtr C_BuilderConnectFunc
connectFunc' <- C_BuilderConnectFunc -> IO (FunPtr C_BuilderConnectFunc)
Gtk.Callbacks.mk_BuilderConnectFunc (Maybe (Ptr (FunPtr C_BuilderConnectFunc))
-> BuilderConnectFunc_WithClosures -> C_BuilderConnectFunc
Gtk.Callbacks.wrap_BuilderConnectFunc Maybe (Ptr (FunPtr C_BuilderConnectFunc))
forall a. Maybe a
Nothing (BuilderConnectFunc -> BuilderConnectFunc_WithClosures
Gtk.Callbacks.drop_closures_BuilderConnectFunc BuilderConnectFunc
connectFunc))
    let connectData :: Ptr ()
connectData = FunPtr C_BuilderConnectFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_BuilderConnectFunc
connectFunc'
    let connectDataDestroy :: FunPtr (Ptr a -> IO ())
connectDataDestroy = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
    Ptr WidgetClass
-> FunPtr C_BuilderConnectFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gtk_widget_class_set_connect_func Ptr WidgetClass
widgetClass' FunPtr C_BuilderConnectFunc
connectFunc' Ptr ()
connectData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
connectDataDestroy
    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 WidgetClassSetConnectFuncMethodInfo
instance (signature ~ (Gtk.Callbacks.BuilderConnectFunc -> m ()), MonadIO m) => O.MethodInfo WidgetClassSetConnectFuncMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetConnectFunc

#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
-- of the parent class is used.
widgetClassSetCssName ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    WidgetClass
    -- ^ /@widgetClass@/: class to set the name on
    -> T.Text
    -- ^ /@name@/: name to use
    -> m ()
widgetClassSetCssName :: WidgetClass -> Text -> m ()
widgetClassSetCssName widgetClass :: WidgetClass
widgetClass name :: 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.MethodInfo WidgetClassSetCssNameMethodInfo WidgetClass signature where
    overloadedMethod = 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 :: WidgetClass -> GType -> m ()
widgetClassSetLayoutManagerType widgetClass :: WidgetClass
widgetClass type_ :: 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.MethodInfo WidgetClassSetLayoutManagerTypeMethodInfo WidgetClass signature where
    overloadedMethod = 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 :: WidgetClass -> Bytes -> m ()
widgetClassSetTemplate widgetClass :: WidgetClass
widgetClass templateBytes :: 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.MethodInfo WidgetClassSetTemplateMethodInfo WidgetClass signature where
    overloadedMethod = 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 :: WidgetClass -> Text -> m ()
widgetClassSetTemplateFromResource widgetClass :: WidgetClass
widgetClass resourceName :: 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.MethodInfo WidgetClassSetTemplateFromResourceMethodInfo WidgetClass signature where
    overloadedMethod = widgetClassSetTemplateFromResource

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveWidgetClassMethod (t :: Symbol) (o :: *) :: * where
    ResolveWidgetClassMethod "bindTemplateCallbackFull" o = WidgetClassBindTemplateCallbackFullMethodInfo
    ResolveWidgetClassMethod "bindTemplateChildFull" o = WidgetClassBindTemplateChildFullMethodInfo
    ResolveWidgetClassMethod "getCssName" o = WidgetClassGetCssNameMethodInfo
    ResolveWidgetClassMethod "getLayoutManagerType" o = WidgetClassGetLayoutManagerTypeMethodInfo
    ResolveWidgetClassMethod "setAccessibleRole" o = WidgetClassSetAccessibleRoleMethodInfo
    ResolveWidgetClassMethod "setAccessibleType" o = WidgetClassSetAccessibleTypeMethodInfo
    ResolveWidgetClassMethod "setConnectFunc" o = WidgetClassSetConnectFuncMethodInfo
    ResolveWidgetClassMethod "setCssName" o = WidgetClassSetCssNameMethodInfo
    ResolveWidgetClassMethod "setLayoutManagerType" o = WidgetClassSetLayoutManagerTypeMethodInfo
    ResolveWidgetClassMethod "setTemplate" o = WidgetClassSetTemplateMethodInfo
    ResolveWidgetClassMethod "setTemplateFromResource" o = WidgetClassSetTemplateFromResourceMethodInfo
    ResolveWidgetClassMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWidgetClassMethod t WidgetClass, O.MethodInfo 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

#endif