{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Structs.WidgetClass
(
WidgetClass(..) ,
newZeroWidgetClass ,
noWidgetClass ,
#if defined(ENABLE_OVERLOADING)
ResolveWidgetClassMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
WidgetClassBindTemplateCallbackFullMethodInfo,
#endif
widgetClassBindTemplateCallbackFull ,
#if defined(ENABLE_OVERLOADING)
WidgetClassBindTemplateChildFullMethodInfo,
#endif
widgetClassBindTemplateChildFull ,
#if defined(ENABLE_OVERLOADING)
WidgetClassGetCssNameMethodInfo ,
#endif
widgetClassGetCssName ,
#if defined(ENABLE_OVERLOADING)
WidgetClassGetLayoutManagerTypeMethodInfo,
#endif
widgetClassGetLayoutManagerType ,
#if defined(ENABLE_OVERLOADING)
WidgetClassSetAccessibleRoleMethodInfo ,
#endif
widgetClassSetAccessibleRole ,
#if defined(ENABLE_OVERLOADING)
WidgetClassSetAccessibleTypeMethodInfo ,
#endif
widgetClassSetAccessibleType ,
#if defined(ENABLE_OVERLOADING)
WidgetClassSetConnectFuncMethodInfo ,
#endif
widgetClassSetConnectFunc ,
#if defined(ENABLE_OVERLOADING)
WidgetClassSetCssNameMethodInfo ,
#endif
widgetClassSetCssName ,
#if defined(ENABLE_OVERLOADING)
WidgetClassSetLayoutManagerTypeMethodInfo,
#endif
widgetClassSetLayoutManagerType ,
#if defined(ENABLE_OVERLOADING)
WidgetClassSetTemplateMethodInfo ,
#endif
widgetClassSetTemplate ,
#if defined(ENABLE_OVERLOADING)
WidgetClassSetTemplateFromResourceMethodInfo,
#endif
widgetClassSetTemplateFromResource ,
getWidgetClassActivateSignal ,
setWidgetClassActivateSignal ,
#if defined(ENABLE_OVERLOADING)
widgetClass_activateSignal ,
#endif
clearWidgetClassCanActivateAccel ,
getWidgetClassCanActivateAccel ,
setWidgetClassCanActivateAccel ,
#if defined(ENABLE_OVERLOADING)
widgetClass_canActivateAccel ,
#endif
clearWidgetClassComputeExpand ,
getWidgetClassComputeExpand ,
setWidgetClassComputeExpand ,
#if defined(ENABLE_OVERLOADING)
widgetClass_computeExpand ,
#endif
clearWidgetClassContains ,
getWidgetClassContains ,
setWidgetClassContains ,
#if defined(ENABLE_OVERLOADING)
widgetClass_contains ,
#endif
clearWidgetClassDestroy ,
getWidgetClassDestroy ,
setWidgetClassDestroy ,
#if defined(ENABLE_OVERLOADING)
widgetClass_destroy ,
#endif
clearWidgetClassDirectionChanged ,
getWidgetClassDirectionChanged ,
setWidgetClassDirectionChanged ,
#if defined(ENABLE_OVERLOADING)
widgetClass_directionChanged ,
#endif
clearWidgetClassDragBegin ,
getWidgetClassDragBegin ,
setWidgetClassDragBegin ,
#if defined(ENABLE_OVERLOADING)
widgetClass_dragBegin ,
#endif
clearWidgetClassDragDataDelete ,
getWidgetClassDragDataDelete ,
setWidgetClassDragDataDelete ,
#if defined(ENABLE_OVERLOADING)
widgetClass_dragDataDelete ,
#endif
clearWidgetClassDragDataGet ,
getWidgetClassDragDataGet ,
setWidgetClassDragDataGet ,
#if defined(ENABLE_OVERLOADING)
widgetClass_dragDataGet ,
#endif
clearWidgetClassDragDataReceived ,
getWidgetClassDragDataReceived ,
setWidgetClassDragDataReceived ,
#if defined(ENABLE_OVERLOADING)
widgetClass_dragDataReceived ,
#endif
clearWidgetClassDragDrop ,
getWidgetClassDragDrop ,
setWidgetClassDragDrop ,
#if defined(ENABLE_OVERLOADING)
widgetClass_dragDrop ,
#endif
clearWidgetClassDragEnd ,
getWidgetClassDragEnd ,
setWidgetClassDragEnd ,
#if defined(ENABLE_OVERLOADING)
widgetClass_dragEnd ,
#endif
clearWidgetClassDragFailed ,
getWidgetClassDragFailed ,
setWidgetClassDragFailed ,
#if defined(ENABLE_OVERLOADING)
widgetClass_dragFailed ,
#endif
clearWidgetClassDragLeave ,
getWidgetClassDragLeave ,
setWidgetClassDragLeave ,
#if defined(ENABLE_OVERLOADING)
widgetClass_dragLeave ,
#endif
clearWidgetClassDragMotion ,
getWidgetClassDragMotion ,
setWidgetClassDragMotion ,
#if defined(ENABLE_OVERLOADING)
widgetClass_dragMotion ,
#endif
clearWidgetClassFocus ,
getWidgetClassFocus ,
setWidgetClassFocus ,
#if defined(ENABLE_OVERLOADING)
widgetClass_focus ,
#endif
clearWidgetClassGetAccessible ,
getWidgetClassGetAccessible ,
setWidgetClassGetAccessible ,
#if defined(ENABLE_OVERLOADING)
widgetClass_getAccessible ,
#endif
clearWidgetClassGetRequestMode ,
getWidgetClassGetRequestMode ,
setWidgetClassGetRequestMode ,
#if defined(ENABLE_OVERLOADING)
widgetClass_getRequestMode ,
#endif
clearWidgetClassGrabFocus ,
getWidgetClassGrabFocus ,
setWidgetClassGrabFocus ,
#if defined(ENABLE_OVERLOADING)
widgetClass_grabFocus ,
#endif
clearWidgetClassGrabNotify ,
getWidgetClassGrabNotify ,
setWidgetClassGrabNotify ,
#if defined(ENABLE_OVERLOADING)
widgetClass_grabNotify ,
#endif
clearWidgetClassHide ,
getWidgetClassHide ,
setWidgetClassHide ,
#if defined(ENABLE_OVERLOADING)
widgetClass_hide ,
#endif
clearWidgetClassKeynavFailed ,
getWidgetClassKeynavFailed ,
setWidgetClassKeynavFailed ,
#if defined(ENABLE_OVERLOADING)
widgetClass_keynavFailed ,
#endif
clearWidgetClassMap ,
getWidgetClassMap ,
setWidgetClassMap ,
#if defined(ENABLE_OVERLOADING)
widgetClass_map ,
#endif
clearWidgetClassMeasure ,
getWidgetClassMeasure ,
setWidgetClassMeasure ,
#if defined(ENABLE_OVERLOADING)
widgetClass_measure ,
#endif
clearWidgetClassMnemonicActivate ,
getWidgetClassMnemonicActivate ,
setWidgetClassMnemonicActivate ,
#if defined(ENABLE_OVERLOADING)
widgetClass_mnemonicActivate ,
#endif
clearWidgetClassMoveFocus ,
getWidgetClassMoveFocus ,
setWidgetClassMoveFocus ,
#if defined(ENABLE_OVERLOADING)
widgetClass_moveFocus ,
#endif
getWidgetClassParentClass ,
#if defined(ENABLE_OVERLOADING)
widgetClass_parentClass ,
#endif
clearWidgetClassPopupMenu ,
getWidgetClassPopupMenu ,
setWidgetClassPopupMenu ,
#if defined(ENABLE_OVERLOADING)
widgetClass_popupMenu ,
#endif
clearWidgetClassQueryTooltip ,
getWidgetClassQueryTooltip ,
setWidgetClassQueryTooltip ,
#if defined(ENABLE_OVERLOADING)
widgetClass_queryTooltip ,
#endif
clearWidgetClassRealize ,
getWidgetClassRealize ,
setWidgetClassRealize ,
#if defined(ENABLE_OVERLOADING)
widgetClass_realize ,
#endif
clearWidgetClassRoot ,
getWidgetClassRoot ,
setWidgetClassRoot ,
#if defined(ENABLE_OVERLOADING)
widgetClass_root ,
#endif
clearWidgetClassShow ,
getWidgetClassShow ,
setWidgetClassShow ,
#if defined(ENABLE_OVERLOADING)
widgetClass_show ,
#endif
clearWidgetClassSizeAllocate ,
getWidgetClassSizeAllocate ,
setWidgetClassSizeAllocate ,
#if defined(ENABLE_OVERLOADING)
widgetClass_sizeAllocate ,
#endif
clearWidgetClassSnapshot ,
getWidgetClassSnapshot ,
setWidgetClassSnapshot ,
#if defined(ENABLE_OVERLOADING)
widgetClass_snapshot ,
#endif
clearWidgetClassStateFlagsChanged ,
getWidgetClassStateFlagsChanged ,
setWidgetClassStateFlagsChanged ,
#if defined(ENABLE_OVERLOADING)
widgetClass_stateFlagsChanged ,
#endif
clearWidgetClassStyleUpdated ,
getWidgetClassStyleUpdated ,
setWidgetClassStyleUpdated ,
#if defined(ENABLE_OVERLOADING)
widgetClass_styleUpdated ,
#endif
clearWidgetClassUnmap ,
getWidgetClassUnmap ,
setWidgetClassUnmap ,
#if defined(ENABLE_OVERLOADING)
widgetClass_unmap ,
#endif
clearWidgetClassUnrealize ,
getWidgetClassUnrealize ,
setWidgetClassUnrealize ,
#if defined(ENABLE_OVERLOADING)
widgetClass_unrealize ,
#endif
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
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
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
noWidgetClass :: Maybe WidgetClass
noWidgetClass :: Maybe WidgetClass
noWidgetClass = Maybe WidgetClass
forall a. Maybe a
Nothing
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
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
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
getWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassPopupMenuFieldCallback)
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
setWidgetClassPopupMenu :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback -> m ()
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)
clearWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m ()
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
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
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)
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
foreign import ccall "gtk_widget_class_bind_template_callback_full" gtk_widget_class_bind_template_callback_full ::
Ptr WidgetClass ->
CString ->
FunPtr GObject.Callbacks.C_Callback ->
IO ()
widgetClassBindTemplateCallbackFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> T.Text
-> GObject.Callbacks.Callback
-> 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
foreign import ccall "gtk_widget_class_bind_template_child_full" gtk_widget_class_bind_template_child_full ::
Ptr WidgetClass ->
CString ->
CInt ->
Int64 ->
IO ()
widgetClassBindTemplateChildFull ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> T.Text
-> Bool
-> Int64
-> 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
foreign import ccall "gtk_widget_class_get_css_name" gtk_widget_class_get_css_name ::
Ptr WidgetClass ->
IO CString
widgetClassGetCssName ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> m T.Text
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
foreign import ccall "gtk_widget_class_get_layout_manager_type" gtk_widget_class_get_layout_manager_type ::
Ptr WidgetClass ->
IO CGType
widgetClassGetLayoutManagerType ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> m GType
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
foreign import ccall "gtk_widget_class_set_accessible_role" gtk_widget_class_set_accessible_role ::
Ptr WidgetClass ->
CUInt ->
IO ()
widgetClassSetAccessibleRole ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> Atk.Enums.Role
-> 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
foreign import ccall "gtk_widget_class_set_accessible_type" gtk_widget_class_set_accessible_type ::
Ptr WidgetClass ->
CGType ->
IO ()
widgetClassSetAccessibleType ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> GType
-> 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
foreign import ccall "gtk_widget_class_set_connect_func" gtk_widget_class_set_connect_func ::
Ptr WidgetClass ->
FunPtr Gtk.Callbacks.C_BuilderConnectFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
widgetClassSetConnectFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> Gtk.Callbacks.BuilderConnectFunc
-> 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
foreign import ccall "gtk_widget_class_set_css_name" gtk_widget_class_set_css_name ::
Ptr WidgetClass ->
CString ->
IO ()
widgetClassSetCssName ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> T.Text
-> 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
foreign import ccall "gtk_widget_class_set_layout_manager_type" gtk_widget_class_set_layout_manager_type ::
Ptr WidgetClass ->
CGType ->
IO ()
widgetClassSetLayoutManagerType ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> GType
-> 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
foreign import ccall "gtk_widget_class_set_template" gtk_widget_class_set_template ::
Ptr WidgetClass ->
Ptr GLib.Bytes.Bytes ->
IO ()
widgetClassSetTemplate ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> GLib.Bytes.Bytes
-> 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
foreign import ccall "gtk_widget_class_set_template_from_resource" gtk_widget_class_set_template_from_resource ::
Ptr WidgetClass ->
CString ->
IO ()
widgetClassSetTemplateFromResource ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> T.Text
-> 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