{-# 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 ,
#if defined(ENABLE_OVERLOADING)
ResolveWidgetClassMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
WidgetClassBindTemplateCallbackFullMethodInfo,
#endif
widgetClassBindTemplateCallbackFull ,
#if defined(ENABLE_OVERLOADING)
WidgetClassBindTemplateChildFullMethodInfo,
#endif
widgetClassBindTemplateChildFull ,
#if defined(ENABLE_OVERLOADING)
WidgetClassFindStylePropertyMethodInfo ,
#endif
widgetClassFindStyleProperty ,
#if defined(ENABLE_OVERLOADING)
WidgetClassGetCssNameMethodInfo ,
#endif
widgetClassGetCssName ,
#if defined(ENABLE_OVERLOADING)
WidgetClassInstallStylePropertyMethodInfo,
#endif
widgetClassInstallStyleProperty ,
#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)
WidgetClassSetTemplateMethodInfo ,
#endif
widgetClassSetTemplate ,
#if defined(ENABLE_OVERLOADING)
WidgetClassSetTemplateFromResourceMethodInfo,
#endif
widgetClassSetTemplateFromResource ,
getWidgetClassActivateSignal ,
setWidgetClassActivateSignal ,
#if defined(ENABLE_OVERLOADING)
widgetClass_activateSignal ,
#endif
clearWidgetClassAdjustBaselineAllocation,
getWidgetClassAdjustBaselineAllocation ,
setWidgetClassAdjustBaselineAllocation ,
#if defined(ENABLE_OVERLOADING)
widgetClass_adjustBaselineAllocation ,
#endif
clearWidgetClassAdjustBaselineRequest ,
getWidgetClassAdjustBaselineRequest ,
setWidgetClassAdjustBaselineRequest ,
#if defined(ENABLE_OVERLOADING)
widgetClass_adjustBaselineRequest ,
#endif
clearWidgetClassAdjustSizeAllocation ,
getWidgetClassAdjustSizeAllocation ,
setWidgetClassAdjustSizeAllocation ,
#if defined(ENABLE_OVERLOADING)
widgetClass_adjustSizeAllocation ,
#endif
clearWidgetClassAdjustSizeRequest ,
getWidgetClassAdjustSizeRequest ,
setWidgetClassAdjustSizeRequest ,
#if defined(ENABLE_OVERLOADING)
widgetClass_adjustSizeRequest ,
#endif
clearWidgetClassButtonPressEvent ,
getWidgetClassButtonPressEvent ,
setWidgetClassButtonPressEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_buttonPressEvent ,
#endif
clearWidgetClassButtonReleaseEvent ,
getWidgetClassButtonReleaseEvent ,
setWidgetClassButtonReleaseEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_buttonReleaseEvent ,
#endif
clearWidgetClassCanActivateAccel ,
getWidgetClassCanActivateAccel ,
setWidgetClassCanActivateAccel ,
#if defined(ENABLE_OVERLOADING)
widgetClass_canActivateAccel ,
#endif
clearWidgetClassChildNotify ,
getWidgetClassChildNotify ,
setWidgetClassChildNotify ,
#if defined(ENABLE_OVERLOADING)
widgetClass_childNotify ,
#endif
clearWidgetClassCompositedChanged ,
getWidgetClassCompositedChanged ,
setWidgetClassCompositedChanged ,
#if defined(ENABLE_OVERLOADING)
widgetClass_compositedChanged ,
#endif
clearWidgetClassComputeExpand ,
getWidgetClassComputeExpand ,
setWidgetClassComputeExpand ,
#if defined(ENABLE_OVERLOADING)
widgetClass_computeExpand ,
#endif
clearWidgetClassConfigureEvent ,
getWidgetClassConfigureEvent ,
setWidgetClassConfigureEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_configureEvent ,
#endif
clearWidgetClassDamageEvent ,
getWidgetClassDamageEvent ,
setWidgetClassDamageEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_damageEvent ,
#endif
clearWidgetClassDeleteEvent ,
getWidgetClassDeleteEvent ,
setWidgetClassDeleteEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_deleteEvent ,
#endif
clearWidgetClassDestroy ,
getWidgetClassDestroy ,
setWidgetClassDestroy ,
#if defined(ENABLE_OVERLOADING)
widgetClass_destroy ,
#endif
clearWidgetClassDestroyEvent ,
getWidgetClassDestroyEvent ,
setWidgetClassDestroyEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_destroyEvent ,
#endif
clearWidgetClassDirectionChanged ,
getWidgetClassDirectionChanged ,
setWidgetClassDirectionChanged ,
#if defined(ENABLE_OVERLOADING)
widgetClass_directionChanged ,
#endif
clearWidgetClassDispatchChildPropertiesChanged,
getWidgetClassDispatchChildPropertiesChanged,
setWidgetClassDispatchChildPropertiesChanged,
#if defined(ENABLE_OVERLOADING)
widgetClass_dispatchChildPropertiesChanged,
#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
clearWidgetClassDraw ,
getWidgetClassDraw ,
setWidgetClassDraw ,
#if defined(ENABLE_OVERLOADING)
widgetClass_draw ,
#endif
clearWidgetClassEnterNotifyEvent ,
getWidgetClassEnterNotifyEvent ,
setWidgetClassEnterNotifyEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_enterNotifyEvent ,
#endif
clearWidgetClassEvent ,
getWidgetClassEvent ,
setWidgetClassEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_event ,
#endif
clearWidgetClassFocus ,
getWidgetClassFocus ,
setWidgetClassFocus ,
#if defined(ENABLE_OVERLOADING)
widgetClass_focus ,
#endif
clearWidgetClassFocusInEvent ,
getWidgetClassFocusInEvent ,
setWidgetClassFocusInEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_focusInEvent ,
#endif
clearWidgetClassFocusOutEvent ,
getWidgetClassFocusOutEvent ,
setWidgetClassFocusOutEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_focusOutEvent ,
#endif
clearWidgetClassGetAccessible ,
getWidgetClassGetAccessible ,
setWidgetClassGetAccessible ,
#if defined(ENABLE_OVERLOADING)
widgetClass_getAccessible ,
#endif
clearWidgetClassGetPreferredHeight ,
getWidgetClassGetPreferredHeight ,
setWidgetClassGetPreferredHeight ,
#if defined(ENABLE_OVERLOADING)
widgetClass_getPreferredHeight ,
#endif
clearWidgetClassGetPreferredHeightAndBaselineForWidth,
getWidgetClassGetPreferredHeightAndBaselineForWidth,
setWidgetClassGetPreferredHeightAndBaselineForWidth,
#if defined(ENABLE_OVERLOADING)
widgetClass_getPreferredHeightAndBaselineForWidth,
#endif
clearWidgetClassGetPreferredHeightForWidth,
getWidgetClassGetPreferredHeightForWidth,
setWidgetClassGetPreferredHeightForWidth,
#if defined(ENABLE_OVERLOADING)
widgetClass_getPreferredHeightForWidth ,
#endif
clearWidgetClassGetPreferredWidth ,
getWidgetClassGetPreferredWidth ,
setWidgetClassGetPreferredWidth ,
#if defined(ENABLE_OVERLOADING)
widgetClass_getPreferredWidth ,
#endif
clearWidgetClassGetPreferredWidthForHeight,
getWidgetClassGetPreferredWidthForHeight,
setWidgetClassGetPreferredWidthForHeight,
#if defined(ENABLE_OVERLOADING)
widgetClass_getPreferredWidthForHeight ,
#endif
clearWidgetClassGetRequestMode ,
getWidgetClassGetRequestMode ,
setWidgetClassGetRequestMode ,
#if defined(ENABLE_OVERLOADING)
widgetClass_getRequestMode ,
#endif
clearWidgetClassGrabBrokenEvent ,
getWidgetClassGrabBrokenEvent ,
setWidgetClassGrabBrokenEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_grabBrokenEvent ,
#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
clearWidgetClassHierarchyChanged ,
getWidgetClassHierarchyChanged ,
setWidgetClassHierarchyChanged ,
#if defined(ENABLE_OVERLOADING)
widgetClass_hierarchyChanged ,
#endif
clearWidgetClassKeyPressEvent ,
getWidgetClassKeyPressEvent ,
setWidgetClassKeyPressEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_keyPressEvent ,
#endif
clearWidgetClassKeyReleaseEvent ,
getWidgetClassKeyReleaseEvent ,
setWidgetClassKeyReleaseEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_keyReleaseEvent ,
#endif
clearWidgetClassKeynavFailed ,
getWidgetClassKeynavFailed ,
setWidgetClassKeynavFailed ,
#if defined(ENABLE_OVERLOADING)
widgetClass_keynavFailed ,
#endif
clearWidgetClassLeaveNotifyEvent ,
getWidgetClassLeaveNotifyEvent ,
setWidgetClassLeaveNotifyEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_leaveNotifyEvent ,
#endif
clearWidgetClassMap ,
getWidgetClassMap ,
setWidgetClassMap ,
#if defined(ENABLE_OVERLOADING)
widgetClass_map ,
#endif
clearWidgetClassMapEvent ,
getWidgetClassMapEvent ,
setWidgetClassMapEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_mapEvent ,
#endif
clearWidgetClassMnemonicActivate ,
getWidgetClassMnemonicActivate ,
setWidgetClassMnemonicActivate ,
#if defined(ENABLE_OVERLOADING)
widgetClass_mnemonicActivate ,
#endif
clearWidgetClassMotionNotifyEvent ,
getWidgetClassMotionNotifyEvent ,
setWidgetClassMotionNotifyEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_motionNotifyEvent ,
#endif
clearWidgetClassMoveFocus ,
getWidgetClassMoveFocus ,
setWidgetClassMoveFocus ,
#if defined(ENABLE_OVERLOADING)
widgetClass_moveFocus ,
#endif
getWidgetClassParentClass ,
#if defined(ENABLE_OVERLOADING)
widgetClass_parentClass ,
#endif
clearWidgetClassParentSet ,
getWidgetClassParentSet ,
setWidgetClassParentSet ,
#if defined(ENABLE_OVERLOADING)
widgetClass_parentSet ,
#endif
clearWidgetClassPopupMenu ,
getWidgetClassPopupMenu ,
setWidgetClassPopupMenu ,
#if defined(ENABLE_OVERLOADING)
widgetClass_popupMenu ,
#endif
clearWidgetClassPropertyNotifyEvent ,
getWidgetClassPropertyNotifyEvent ,
setWidgetClassPropertyNotifyEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_propertyNotifyEvent ,
#endif
clearWidgetClassProximityInEvent ,
getWidgetClassProximityInEvent ,
setWidgetClassProximityInEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_proximityInEvent ,
#endif
clearWidgetClassProximityOutEvent ,
getWidgetClassProximityOutEvent ,
setWidgetClassProximityOutEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_proximityOutEvent ,
#endif
clearWidgetClassQueryTooltip ,
getWidgetClassQueryTooltip ,
setWidgetClassQueryTooltip ,
#if defined(ENABLE_OVERLOADING)
widgetClass_queryTooltip ,
#endif
clearWidgetClassQueueDrawRegion ,
getWidgetClassQueueDrawRegion ,
setWidgetClassQueueDrawRegion ,
#if defined(ENABLE_OVERLOADING)
widgetClass_queueDrawRegion ,
#endif
clearWidgetClassRealize ,
getWidgetClassRealize ,
setWidgetClassRealize ,
#if defined(ENABLE_OVERLOADING)
widgetClass_realize ,
#endif
clearWidgetClassScreenChanged ,
getWidgetClassScreenChanged ,
setWidgetClassScreenChanged ,
#if defined(ENABLE_OVERLOADING)
widgetClass_screenChanged ,
#endif
clearWidgetClassScrollEvent ,
getWidgetClassScrollEvent ,
setWidgetClassScrollEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_scrollEvent ,
#endif
clearWidgetClassSelectionClearEvent ,
getWidgetClassSelectionClearEvent ,
setWidgetClassSelectionClearEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_selectionClearEvent ,
#endif
clearWidgetClassSelectionGet ,
getWidgetClassSelectionGet ,
setWidgetClassSelectionGet ,
#if defined(ENABLE_OVERLOADING)
widgetClass_selectionGet ,
#endif
clearWidgetClassSelectionNotifyEvent ,
getWidgetClassSelectionNotifyEvent ,
setWidgetClassSelectionNotifyEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_selectionNotifyEvent ,
#endif
clearWidgetClassSelectionReceived ,
getWidgetClassSelectionReceived ,
setWidgetClassSelectionReceived ,
#if defined(ENABLE_OVERLOADING)
widgetClass_selectionReceived ,
#endif
clearWidgetClassSelectionRequestEvent ,
getWidgetClassSelectionRequestEvent ,
setWidgetClassSelectionRequestEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_selectionRequestEvent ,
#endif
clearWidgetClassShow ,
getWidgetClassShow ,
setWidgetClassShow ,
#if defined(ENABLE_OVERLOADING)
widgetClass_show ,
#endif
clearWidgetClassShowAll ,
getWidgetClassShowAll ,
setWidgetClassShowAll ,
#if defined(ENABLE_OVERLOADING)
widgetClass_showAll ,
#endif
clearWidgetClassShowHelp ,
getWidgetClassShowHelp ,
setWidgetClassShowHelp ,
#if defined(ENABLE_OVERLOADING)
widgetClass_showHelp ,
#endif
clearWidgetClassSizeAllocate ,
getWidgetClassSizeAllocate ,
setWidgetClassSizeAllocate ,
#if defined(ENABLE_OVERLOADING)
widgetClass_sizeAllocate ,
#endif
clearWidgetClassStateChanged ,
getWidgetClassStateChanged ,
setWidgetClassStateChanged ,
#if defined(ENABLE_OVERLOADING)
widgetClass_stateChanged ,
#endif
clearWidgetClassStateFlagsChanged ,
getWidgetClassStateFlagsChanged ,
setWidgetClassStateFlagsChanged ,
#if defined(ENABLE_OVERLOADING)
widgetClass_stateFlagsChanged ,
#endif
clearWidgetClassStyleSet ,
getWidgetClassStyleSet ,
setWidgetClassStyleSet ,
#if defined(ENABLE_OVERLOADING)
widgetClass_styleSet ,
#endif
clearWidgetClassStyleUpdated ,
getWidgetClassStyleUpdated ,
setWidgetClassStyleUpdated ,
#if defined(ENABLE_OVERLOADING)
widgetClass_styleUpdated ,
#endif
clearWidgetClassTouchEvent ,
getWidgetClassTouchEvent ,
setWidgetClassTouchEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_touchEvent ,
#endif
clearWidgetClassUnmap ,
getWidgetClassUnmap ,
setWidgetClassUnmap ,
#if defined(ENABLE_OVERLOADING)
widgetClass_unmap ,
#endif
clearWidgetClassUnmapEvent ,
getWidgetClassUnmapEvent ,
setWidgetClassUnmapEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_unmapEvent ,
#endif
clearWidgetClassUnrealize ,
getWidgetClassUnrealize ,
setWidgetClassUnrealize ,
#if defined(ENABLE_OVERLOADING)
widgetClass_unrealize ,
#endif
clearWidgetClassVisibilityNotifyEvent ,
getWidgetClassVisibilityNotifyEvent ,
setWidgetClassVisibilityNotifyEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_visibilityNotifyEvent ,
#endif
clearWidgetClassWindowStateEvent ,
getWidgetClassWindowStateEvent ,
setWidgetClassWindowStateEvent ,
#if defined(ENABLE_OVERLOADING)
widgetClass_windowStateEvent ,
#endif
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.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 (SP.ManagedPtr WidgetClass)
deriving (WidgetClass -> WidgetClass -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WidgetClass -> WidgetClass -> Bool
$c/= :: WidgetClass -> WidgetClass -> Bool
== :: WidgetClass -> WidgetClass -> Bool
$c== :: WidgetClass -> WidgetClass -> Bool
Eq)
instance SP.ManagedPtrNewtype WidgetClass where
toManagedPtr :: WidgetClass -> ManagedPtr WidgetClass
toManagedPtr (WidgetClass ManagedPtr WidgetClass
p) = ManagedPtr WidgetClass
p
instance BoxedPtr WidgetClass where
boxedPtrCopy :: WidgetClass -> IO WidgetClass
boxedPtrCopy = \WidgetClass
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr WidgetClass
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
824 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr WidgetClass -> WidgetClass
WidgetClass)
boxedPtrFree :: WidgetClass -> IO ()
boxedPtrFree = \WidgetClass
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr WidgetClass
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr WidgetClass where
boxedPtrCalloc :: IO (Ptr WidgetClass)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
824
newZeroWidgetClass :: MonadIO m => m WidgetClass
newZeroWidgetClass :: forall (m :: * -> *). MonadIO m => m WidgetClass
newZeroWidgetClass = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr WidgetClass -> WidgetClass
WidgetClass
instance tag ~ 'AttrSet => Constructible WidgetClass tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr WidgetClass -> WidgetClass)
-> [AttrOp WidgetClass tag] -> m WidgetClass
new ManagedPtr WidgetClass -> WidgetClass
_ [AttrOp WidgetClass tag]
attrs = do
WidgetClass
o <- forall (m :: * -> *). MonadIO m => m WidgetClass
newZeroWidgetClass
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set WidgetClass
o [AttrOp WidgetClass tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClass
o
getWidgetClassParentClass :: MonadIO m => WidgetClass -> m GObject.InitiallyUnownedClass.InitiallyUnownedClass
getWidgetClassParentClass :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m InitiallyUnownedClass
getWidgetClassParentClass WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
let val :: Ptr InitiallyUnownedClass
val = Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr GObject.InitiallyUnownedClass.InitiallyUnownedClass)
InitiallyUnownedClass
val' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr InitiallyUnownedClass -> InitiallyUnownedClass
GObject.InitiallyUnownedClass.InitiallyUnownedClass) Ptr InitiallyUnownedClass
val
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.parentClass"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:parentClass"
})
widgetClass_parentClass :: AttrLabelProxy "parentClass"
widgetClass_parentClass = AttrLabelProxy
#endif
getWidgetClassActivateSignal :: MonadIO m => WidgetClass -> m Word32
getWidgetClassActivateSignal :: forall (m :: * -> *). MonadIO m => WidgetClass -> m Word32
getWidgetClassActivateSignal WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setWidgetClassActivateSignal :: MonadIO m => WidgetClass -> Word32 -> m ()
setWidgetClassActivateSignal :: forall (m :: * -> *). MonadIO m => WidgetClass -> Word32 -> m ()
setWidgetClassActivateSignal WidgetClass
s Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.activateSignal"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:activateSignal"
})
widgetClass_activateSignal :: AttrLabelProxy "activateSignal"
widgetClass_activateSignal = AttrLabelProxy
#endif
getWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDispatchChildPropertiesChangedFieldCallback)
getWidgetClassDispatchChildPropertiesChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback)
getWidgetClassDispatchChildPropertiesChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val' -> do
let val'' :: WidgetClassDispatchChildPropertiesChangedFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
-> a -> Word32 -> GParamSpec -> m ()
Gtk.Callbacks.dynamic_WidgetClassDispatchChildPropertiesChangedFieldCallback FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDispatchChildPropertiesChangedFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDispatchChildPropertiesChangedFieldCallback
result
setWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback -> m ()
setWidgetClassDispatchChildPropertiesChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
-> m ()
setWidgetClassDispatchChildPropertiesChanged WidgetClass
s FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_WidgetClassDispatchChildPropertiesChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
clearWidgetClassDispatchChildPropertiesChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDispatchChildPropertiesChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDispatchChildPropertiesChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassDispatchChildPropertiesChangedFieldInfo
instance AttrInfo WidgetClassDispatchChildPropertiesChangedFieldInfo where
type AttrBaseTypeConstraint WidgetClassDispatchChildPropertiesChangedFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassDispatchChildPropertiesChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassDispatchChildPropertiesChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
type AttrTransferTypeConstraint WidgetClassDispatchChildPropertiesChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassDispatchChildPropertiesChangedFieldCallback
type AttrTransferType WidgetClassDispatchChildPropertiesChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDispatchChildPropertiesChangedFieldCallback)
type AttrGetType WidgetClassDispatchChildPropertiesChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassDispatchChildPropertiesChangedFieldCallback
type AttrLabel WidgetClassDispatchChildPropertiesChangedFieldInfo = "dispatch_child_properties_changed"
type AttrOrigin WidgetClassDispatchChildPropertiesChangedFieldInfo = WidgetClass
attrGet = getWidgetClassDispatchChildPropertiesChanged
attrSet = setWidgetClassDispatchChildPropertiesChanged
attrConstruct = undefined
attrClear = clearWidgetClassDispatchChildPropertiesChanged
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassDispatchChildPropertiesChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassDispatchChildPropertiesChangedFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dispatchChildPropertiesChanged"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dispatchChildPropertiesChanged"
})
widgetClass_dispatchChildPropertiesChanged :: AttrLabelProxy "dispatchChildPropertiesChanged"
widgetClass_dispatchChildPropertiesChanged = AttrLabelProxy
#endif
getWidgetClassDestroy :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDestroyFieldCallback)
getWidgetClassDestroy :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassDestroy WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassDestroyFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassDestroy :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassDestroy :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassDestroy WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDestroyFieldCallback)
clearWidgetClassDestroy :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDestroy :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDestroy WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.destroy"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:destroy"
})
widgetClass_destroy :: AttrLabelProxy "destroy"
widgetClass_destroy = AttrLabelProxy
#endif
getWidgetClassShow :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassShowFieldCallback)
getWidgetClassShow :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassShow WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassShowFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassShow :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback -> m ()
setWidgetClassShow :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassShow WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassShowFieldCallback)
clearWidgetClassShow :: MonadIO m => WidgetClass -> m ()
clearWidgetClassShow :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassShow WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.show"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:show"
})
widgetClass_show :: AttrLabelProxy "show"
widgetClass_show = AttrLabelProxy
#endif
getWidgetClassShowAll :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassShowAllFieldCallback)
getWidgetClassShowAll :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassShowAll WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassShowAllFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassShowAll :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback -> m ()
setWidgetClassShowAll :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassShowAll WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback)
clearWidgetClassShowAll :: MonadIO m => WidgetClass -> m ()
clearWidgetClassShowAll :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassShowAll WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassShowAllFieldInfo
instance AttrInfo WidgetClassShowAllFieldInfo where
type AttrBaseTypeConstraint WidgetClassShowAllFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassShowAllFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassShowAllFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback)
type AttrTransferTypeConstraint WidgetClassShowAllFieldInfo = (~)Gtk.Callbacks.WidgetClassShowAllFieldCallback
type AttrTransferType WidgetClassShowAllFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassShowAllFieldCallback)
type AttrGetType WidgetClassShowAllFieldInfo = Maybe Gtk.Callbacks.WidgetClassShowAllFieldCallback
type AttrLabel WidgetClassShowAllFieldInfo = "show_all"
type AttrOrigin WidgetClassShowAllFieldInfo = WidgetClass
attrGet = getWidgetClassShowAll
attrSet = setWidgetClassShowAll
attrConstruct = undefined
attrClear = clearWidgetClassShowAll
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassShowAllFieldCallback (Gtk.Callbacks.wrap_WidgetClassShowAllFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.showAll"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:showAll"
})
widgetClass_showAll :: AttrLabelProxy "showAll"
widgetClass_showAll = AttrLabelProxy
#endif
getWidgetClassHide :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassHideFieldCallback)
getWidgetClassHide :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassHide WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassHideFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassHide :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback -> m ()
setWidgetClassHide :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassHide WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassHideFieldCallback)
clearWidgetClassHide :: MonadIO m => WidgetClass -> m ()
clearWidgetClassHide :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassHide WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.hide"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:hide"
})
widgetClass_hide :: AttrLabelProxy "hide"
widgetClass_hide = AttrLabelProxy
#endif
getWidgetClassMap :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMapFieldCallback)
getWidgetClassMap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassMap WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassMapFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassMap :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback -> m ()
setWidgetClassMap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassMap WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMapFieldCallback)
clearWidgetClassMap :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMap :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMap WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.map"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:map"
})
widgetClass_map :: AttrLabelProxy "map"
widgetClass_map = AttrLabelProxy
#endif
getWidgetClassUnmap :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnmapFieldCallback)
getWidgetClassUnmap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassUnmap WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnmapFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassUnmap :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback -> m ()
setWidgetClassUnmap :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassUnmap WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapFieldCallback)
clearWidgetClassUnmap :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnmap :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassUnmap WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.unmap"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:unmap"
})
widgetClass_unmap :: AttrLabelProxy "unmap"
widgetClass_unmap = AttrLabelProxy
#endif
getWidgetClassRealize :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassRealizeFieldCallback)
getWidgetClassRealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassRealize WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassRealizeFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassRealize :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback -> m ()
setWidgetClassRealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassRealize WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassRealizeFieldCallback)
clearWidgetClassRealize :: MonadIO m => WidgetClass -> m ()
clearWidgetClassRealize :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassRealize WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.realize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:realize"
})
widgetClass_realize :: AttrLabelProxy "realize"
widgetClass_realize = AttrLabelProxy
#endif
getWidgetClassUnrealize :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnrealizeFieldCallback)
getWidgetClassUnrealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassUnrealize WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassUnrealizeFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassUnrealize :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback -> m ()
setWidgetClassUnrealize :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassUnrealize WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnrealizeFieldCallback)
clearWidgetClassUnrealize :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnrealize :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassUnrealize WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
208) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.unrealize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:unrealize"
})
widgetClass_unrealize :: AttrLabelProxy "unrealize"
widgetClass_unrealize = AttrLabelProxy
#endif
getWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSizeAllocateFieldCallback)
getWidgetClassSizeAllocate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassSizeAllocateFieldCallback)
getWidgetClassSizeAllocate WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassSizeAllocateFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
216) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
Maybe WidgetClassSizeAllocateFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSizeAllocateFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassSizeAllocateFieldCallback
val' -> do
let val'' :: WidgetClassSizeAllocateFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassSizeAllocateFieldCallback
-> a -> Rectangle -> m ()
Gtk.Callbacks.dynamic_WidgetClassSizeAllocateFieldCallback FunPtr C_WidgetClassSizeAllocateFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSizeAllocateFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSizeAllocateFieldCallback
result
setWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback -> m ()
setWidgetClassSizeAllocate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSizeAllocateFieldCallback -> m ()
setWidgetClassSizeAllocate WidgetClass
s FunPtr C_WidgetClassSizeAllocateFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
216) (FunPtr C_WidgetClassSizeAllocateFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSizeAllocateFieldCallback)
clearWidgetClassSizeAllocate :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSizeAllocate :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSizeAllocate WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
216) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.sizeAllocate"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:sizeAllocate"
})
widgetClass_sizeAllocate :: AttrLabelProxy "sizeAllocate"
widgetClass_sizeAllocate = AttrLabelProxy
#endif
getWidgetClassStateChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassStateChangedFieldCallback)
getWidgetClassStateChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassStateChangedFieldCallback)
getWidgetClassStateChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassStateChangedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)
Maybe WidgetClassStateChangedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateChangedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateChangedFieldCallback
val' -> do
let val'' :: WidgetClassStateChangedFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateChangedFieldCallback
-> a -> StateType -> m ()
Gtk.Callbacks.dynamic_WidgetClassStateChangedFieldCallback FunPtr C_WidgetClassStateChangedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassStateChangedFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassStateChangedFieldCallback
result
setWidgetClassStateChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassStateChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassStateChanged WidgetClass
s FunPtr C_WidgetClassStateChangedFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) (FunPtr C_WidgetClassStateChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)
clearWidgetClassStateChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStateChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassStateChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
224) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassStateChangedFieldInfo
instance AttrInfo WidgetClassStateChangedFieldInfo where
type AttrBaseTypeConstraint WidgetClassStateChangedFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassStateChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassStateChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)
type AttrTransferTypeConstraint WidgetClassStateChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassStateChangedFieldCallback
type AttrTransferType WidgetClassStateChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassStateChangedFieldCallback)
type AttrGetType WidgetClassStateChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassStateChangedFieldCallback
type AttrLabel WidgetClassStateChangedFieldInfo = "state_changed"
type AttrOrigin WidgetClassStateChangedFieldInfo = WidgetClass
attrGet = getWidgetClassStateChanged
attrSet = setWidgetClassStateChanged
attrConstruct = undefined
attrClear = clearWidgetClassStateChanged
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassStateChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassStateChangedFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.stateChanged"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:stateChanged"
})
widgetClass_stateChanged :: AttrLabelProxy "stateChanged"
widgetClass_stateChanged = AttrLabelProxy
#endif
getWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassStateFlagsChangedFieldCallback)
getWidgetClassStateFlagsChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassStateFlagsChangedFieldCallback)
getWidgetClassStateFlagsChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassStateChangedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
Maybe WidgetClassStateFlagsChangedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateChangedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateChangedFieldCallback
val' -> do
let val'' :: WidgetClassStateFlagsChangedFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateChangedFieldCallback
-> a -> [StateFlags] -> m ()
Gtk.Callbacks.dynamic_WidgetClassStateFlagsChangedFieldCallback FunPtr C_WidgetClassStateChangedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassStateFlagsChangedFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassStateFlagsChangedFieldCallback
result
setWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback -> m ()
setWidgetClassStateFlagsChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassStateFlagsChanged WidgetClass
s FunPtr C_WidgetClassStateChangedFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) (FunPtr C_WidgetClassStateChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassStateFlagsChangedFieldCallback)
clearWidgetClassStateFlagsChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStateFlagsChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassStateFlagsChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
232) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.stateFlagsChanged"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:stateFlagsChanged"
})
widgetClass_stateFlagsChanged :: AttrLabelProxy "stateFlagsChanged"
widgetClass_stateFlagsChanged = AttrLabelProxy
#endif
getWidgetClassParentSet :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassParentSetFieldCallback)
getWidgetClassParentSet :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassParentSetFieldCallback)
getWidgetClassParentSet WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassParentSetFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback)
Maybe WidgetClassParentSetFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassParentSetFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassParentSetFieldCallback
val' -> do
let val'' :: WidgetClassParentSetFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
FunPtr C_WidgetClassParentSetFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassParentSetFieldCallback FunPtr C_WidgetClassParentSetFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassParentSetFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassParentSetFieldCallback
result
setWidgetClassParentSet :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback -> m ()
setWidgetClassParentSet :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassParentSetFieldCallback -> m ()
setWidgetClassParentSet WidgetClass
s FunPtr C_WidgetClassParentSetFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (FunPtr C_WidgetClassParentSetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback)
clearWidgetClassParentSet :: MonadIO m => WidgetClass -> m ()
clearWidgetClassParentSet :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassParentSet WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
240) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassParentSetFieldInfo
instance AttrInfo WidgetClassParentSetFieldInfo where
type AttrBaseTypeConstraint WidgetClassParentSetFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassParentSetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassParentSetFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback)
type AttrTransferTypeConstraint WidgetClassParentSetFieldInfo = (~)Gtk.Callbacks.WidgetClassParentSetFieldCallback
type AttrTransferType WidgetClassParentSetFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassParentSetFieldCallback)
type AttrGetType WidgetClassParentSetFieldInfo = Maybe Gtk.Callbacks.WidgetClassParentSetFieldCallback
type AttrLabel WidgetClassParentSetFieldInfo = "parent_set"
type AttrOrigin WidgetClassParentSetFieldInfo = WidgetClass
attrGet = getWidgetClassParentSet
attrSet = setWidgetClassParentSet
attrConstruct = undefined
attrClear = clearWidgetClassParentSet
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassParentSetFieldCallback (Gtk.Callbacks.wrap_WidgetClassParentSetFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.parentSet"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:parentSet"
})
widgetClass_parentSet :: AttrLabelProxy "parentSet"
widgetClass_parentSet = AttrLabelProxy
#endif
getWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassHierarchyChangedFieldCallback)
getWidgetClassHierarchyChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassParentSetFieldCallback)
getWidgetClassHierarchyChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassParentSetFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)
Maybe WidgetClassParentSetFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassParentSetFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassParentSetFieldCallback
val' -> do
let val'' :: WidgetClassParentSetFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsWidget b) =>
FunPtr C_WidgetClassParentSetFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassHierarchyChangedFieldCallback FunPtr C_WidgetClassParentSetFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassParentSetFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassParentSetFieldCallback
result
setWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback -> m ()
setWidgetClassHierarchyChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassParentSetFieldCallback -> m ()
setWidgetClassHierarchyChanged WidgetClass
s FunPtr C_WidgetClassParentSetFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (FunPtr C_WidgetClassParentSetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)
clearWidgetClassHierarchyChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassHierarchyChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassHierarchyChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
248) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassHierarchyChangedFieldInfo
instance AttrInfo WidgetClassHierarchyChangedFieldInfo where
type AttrBaseTypeConstraint WidgetClassHierarchyChangedFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassHierarchyChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassHierarchyChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)
type AttrTransferTypeConstraint WidgetClassHierarchyChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassHierarchyChangedFieldCallback
type AttrTransferType WidgetClassHierarchyChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassHierarchyChangedFieldCallback)
type AttrGetType WidgetClassHierarchyChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassHierarchyChangedFieldCallback
type AttrLabel WidgetClassHierarchyChangedFieldInfo = "hierarchy_changed"
type AttrOrigin WidgetClassHierarchyChangedFieldInfo = WidgetClass
attrGet = getWidgetClassHierarchyChanged
attrSet = setWidgetClassHierarchyChanged
attrConstruct = undefined
attrClear = clearWidgetClassHierarchyChanged
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassHierarchyChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassHierarchyChangedFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.hierarchyChanged"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:hierarchyChanged"
})
widgetClass_hierarchyChanged :: AttrLabelProxy "hierarchyChanged"
widgetClass_hierarchyChanged = AttrLabelProxy
#endif
getWidgetClassStyleSet :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassStyleSetFieldCallback)
getWidgetClassStyleSet :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassStyleSetFieldCallback)
getWidgetClassStyleSet WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassStyleSetFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStyleSetFieldCallback)
Maybe WidgetClassStyleSetFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStyleSetFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStyleSetFieldCallback
val' -> do
let val'' :: WidgetClassStyleSetFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsStyle b) =>
FunPtr C_WidgetClassStyleSetFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassStyleSetFieldCallback FunPtr C_WidgetClassStyleSetFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassStyleSetFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassStyleSetFieldCallback
result
setWidgetClassStyleSet :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStyleSetFieldCallback -> m ()
setWidgetClassStyleSet :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassStyleSetFieldCallback -> m ()
setWidgetClassStyleSet WidgetClass
s FunPtr C_WidgetClassStyleSetFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (FunPtr C_WidgetClassStyleSetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassStyleSetFieldCallback)
clearWidgetClassStyleSet :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStyleSet :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassStyleSet WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
256) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassStyleSetFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassStyleSetFieldInfo
instance AttrInfo WidgetClassStyleSetFieldInfo where
type AttrBaseTypeConstraint WidgetClassStyleSetFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassStyleSetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassStyleSetFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassStyleSetFieldCallback)
type AttrTransferTypeConstraint WidgetClassStyleSetFieldInfo = (~)Gtk.Callbacks.WidgetClassStyleSetFieldCallback
type AttrTransferType WidgetClassStyleSetFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassStyleSetFieldCallback)
type AttrGetType WidgetClassStyleSetFieldInfo = Maybe Gtk.Callbacks.WidgetClassStyleSetFieldCallback
type AttrLabel WidgetClassStyleSetFieldInfo = "style_set"
type AttrOrigin WidgetClassStyleSetFieldInfo = WidgetClass
attrGet = getWidgetClassStyleSet
attrSet = setWidgetClassStyleSet
attrConstruct = undefined
attrClear = clearWidgetClassStyleSet
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassStyleSetFieldCallback (Gtk.Callbacks.wrap_WidgetClassStyleSetFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.styleSet"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:styleSet"
})
widgetClass_styleSet :: AttrLabelProxy "styleSet"
widgetClass_styleSet = AttrLabelProxy
#endif
getWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDirectionChangedFieldCallback)
getWidgetClassDirectionChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDirectionChangedFieldCallback)
getWidgetClassDirectionChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassStateChangedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
Maybe WidgetClassDirectionChangedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateChangedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateChangedFieldCallback
val' -> do
let val'' :: WidgetClassDirectionChangedFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateChangedFieldCallback
-> a -> TextDirection -> m ()
Gtk.Callbacks.dynamic_WidgetClassDirectionChangedFieldCallback FunPtr C_WidgetClassStateChangedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDirectionChangedFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDirectionChangedFieldCallback
result
setWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback -> m ()
setWidgetClassDirectionChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassDirectionChanged WidgetClass
s FunPtr C_WidgetClassStateChangedFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (FunPtr C_WidgetClassStateChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDirectionChangedFieldCallback)
clearWidgetClassDirectionChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDirectionChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDirectionChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
264) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.directionChanged"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:directionChanged"
})
widgetClass_directionChanged :: AttrLabelProxy "directionChanged"
widgetClass_directionChanged = AttrLabelProxy
#endif
getWidgetClassGrabNotify :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGrabNotifyFieldCallback)
getWidgetClassGrabNotify :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGrabNotifyFieldCallback)
getWidgetClassGrabNotify WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassGrabNotifyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)
Maybe WidgetClassGrabNotifyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGrabNotifyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGrabNotifyFieldCallback
val' -> do
let val'' :: WidgetClassGrabNotifyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGrabNotifyFieldCallback -> a -> Bool -> m ()
Gtk.Callbacks.dynamic_WidgetClassGrabNotifyFieldCallback FunPtr C_WidgetClassGrabNotifyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGrabNotifyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGrabNotifyFieldCallback
result
setWidgetClassGrabNotify :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback -> m ()
setWidgetClassGrabNotify :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassGrabNotifyFieldCallback -> m ()
setWidgetClassGrabNotify WidgetClass
s FunPtr C_WidgetClassGrabNotifyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (FunPtr C_WidgetClassGrabNotifyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGrabNotifyFieldCallback)
clearWidgetClassGrabNotify :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabNotify :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabNotify WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
272) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.grabNotify"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:grabNotify"
})
widgetClass_grabNotify :: AttrLabelProxy "grabNotify"
widgetClass_grabNotify = AttrLabelProxy
#endif
getWidgetClassChildNotify :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassChildNotifyFieldCallback)
getWidgetClassChildNotify :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassChildNotifyFieldCallback)
getWidgetClassChildNotify WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassChildNotifyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback)
Maybe WidgetClassChildNotifyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassChildNotifyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassChildNotifyFieldCallback
val' -> do
let val'' :: WidgetClassChildNotifyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassChildNotifyFieldCallback
-> a -> GParamSpec -> m ()
Gtk.Callbacks.dynamic_WidgetClassChildNotifyFieldCallback FunPtr C_WidgetClassChildNotifyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassChildNotifyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassChildNotifyFieldCallback
result
setWidgetClassChildNotify :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback -> m ()
setWidgetClassChildNotify :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassChildNotifyFieldCallback -> m ()
setWidgetClassChildNotify WidgetClass
s FunPtr C_WidgetClassChildNotifyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (FunPtr C_WidgetClassChildNotifyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback)
clearWidgetClassChildNotify :: MonadIO m => WidgetClass -> m ()
clearWidgetClassChildNotify :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassChildNotify WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
280) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassChildNotifyFieldInfo
instance AttrInfo WidgetClassChildNotifyFieldInfo where
type AttrBaseTypeConstraint WidgetClassChildNotifyFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassChildNotifyFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassChildNotifyFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback)
type AttrTransferTypeConstraint WidgetClassChildNotifyFieldInfo = (~)Gtk.Callbacks.WidgetClassChildNotifyFieldCallback
type AttrTransferType WidgetClassChildNotifyFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassChildNotifyFieldCallback)
type AttrGetType WidgetClassChildNotifyFieldInfo = Maybe Gtk.Callbacks.WidgetClassChildNotifyFieldCallback
type AttrLabel WidgetClassChildNotifyFieldInfo = "child_notify"
type AttrOrigin WidgetClassChildNotifyFieldInfo = WidgetClass
attrGet = getWidgetClassChildNotify
attrSet = setWidgetClassChildNotify
attrConstruct = undefined
attrClear = clearWidgetClassChildNotify
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassChildNotifyFieldCallback (Gtk.Callbacks.wrap_WidgetClassChildNotifyFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.childNotify"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:childNotify"
})
widgetClass_childNotify :: AttrLabelProxy "childNotify"
widgetClass_childNotify = AttrLabelProxy
#endif
getWidgetClassDraw :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDrawFieldCallback)
getWidgetClassDraw :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDrawFieldCallback)
getWidgetClassDraw WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDrawFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDrawFieldCallback)
Maybe WidgetClassDrawFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDrawFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDrawFieldCallback
val' -> do
let val'' :: WidgetClassDrawFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDrawFieldCallback -> a -> Context -> m Bool
Gtk.Callbacks.dynamic_WidgetClassDrawFieldCallback FunPtr C_WidgetClassDrawFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDrawFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDrawFieldCallback
result
setWidgetClassDraw :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDrawFieldCallback -> m ()
setWidgetClassDraw :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDrawFieldCallback -> m ()
setWidgetClassDraw WidgetClass
s FunPtr C_WidgetClassDrawFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) (FunPtr C_WidgetClassDrawFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDrawFieldCallback)
clearWidgetClassDraw :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDraw :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDraw WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
288) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDrawFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassDrawFieldInfo
instance AttrInfo WidgetClassDrawFieldInfo where
type AttrBaseTypeConstraint WidgetClassDrawFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassDrawFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassDrawFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDrawFieldCallback)
type AttrTransferTypeConstraint WidgetClassDrawFieldInfo = (~)Gtk.Callbacks.WidgetClassDrawFieldCallback
type AttrTransferType WidgetClassDrawFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDrawFieldCallback)
type AttrGetType WidgetClassDrawFieldInfo = Maybe Gtk.Callbacks.WidgetClassDrawFieldCallback
type AttrLabel WidgetClassDrawFieldInfo = "draw"
type AttrOrigin WidgetClassDrawFieldInfo = WidgetClass
attrGet = getWidgetClassDraw
attrSet = setWidgetClassDraw
attrConstruct = undefined
attrClear = clearWidgetClassDraw
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassDrawFieldCallback (Gtk.Callbacks.wrap_WidgetClassDrawFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.draw"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:draw"
})
widgetClass_draw :: AttrLabelProxy "draw"
widgetClass_draw = AttrLabelProxy
#endif
getWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetRequestModeFieldCallback)
getWidgetClassGetRequestMode :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGetRequestModeFieldCallback)
getWidgetClassGetRequestMode WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassGetRequestModeFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
296) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
Maybe WidgetClassGetRequestModeFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGetRequestModeFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGetRequestModeFieldCallback
val' -> do
let val'' :: WidgetClassGetRequestModeFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGetRequestModeFieldCallback
-> a -> m SizeRequestMode
Gtk.Callbacks.dynamic_WidgetClassGetRequestModeFieldCallback FunPtr C_WidgetClassGetRequestModeFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetRequestModeFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGetRequestModeFieldCallback
result
setWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback -> m ()
setWidgetClassGetRequestMode :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassGetRequestModeFieldCallback -> m ()
setWidgetClassGetRequestMode WidgetClass
s FunPtr C_WidgetClassGetRequestModeFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
296) (FunPtr C_WidgetClassGetRequestModeFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetRequestModeFieldCallback)
clearWidgetClassGetRequestMode :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetRequestMode :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGetRequestMode WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
296) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.getRequestMode"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:getRequestMode"
})
widgetClass_getRequestMode :: AttrLabelProxy "getRequestMode"
widgetClass_getRequestMode = AttrLabelProxy
#endif
getWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetPreferredHeightFieldCallback)
getWidgetClassGetPreferredHeight :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGetPreferredHeightFieldCallback)
getWidgetClassGetPreferredHeight WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback)
Maybe WidgetClassGetPreferredHeightFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val' -> do
let val'' :: WidgetClassGetPreferredHeightFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGetPreferredHeightFieldCallback
-> a -> m (Int32, Int32)
Gtk.Callbacks.dynamic_WidgetClassGetPreferredHeightFieldCallback FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetPreferredHeightFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGetPreferredHeightFieldCallback
result
setWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback -> m ()
setWidgetClassGetPreferredHeight :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> m ()
setWidgetClassGetPreferredHeight WidgetClass
s FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) (FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback)
clearWidgetClassGetPreferredHeight :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredHeight :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredHeight WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
304) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredHeightFieldInfo
instance AttrInfo WidgetClassGetPreferredHeightFieldInfo where
type AttrBaseTypeConstraint WidgetClassGetPreferredHeightFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassGetPreferredHeightFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassGetPreferredHeightFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback)
type AttrTransferTypeConstraint WidgetClassGetPreferredHeightFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredHeightFieldCallback
type AttrTransferType WidgetClassGetPreferredHeightFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightFieldCallback)
type AttrGetType WidgetClassGetPreferredHeightFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredHeightFieldCallback
type AttrLabel WidgetClassGetPreferredHeightFieldInfo = "get_preferred_height"
type AttrOrigin WidgetClassGetPreferredHeightFieldInfo = WidgetClass
attrGet = getWidgetClassGetPreferredHeight
attrSet = setWidgetClassGetPreferredHeight
attrConstruct = undefined
attrClear = clearWidgetClassGetPreferredHeight
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassGetPreferredHeightFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredHeightFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.getPreferredHeight"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:getPreferredHeight"
})
widgetClass_getPreferredHeight :: AttrLabelProxy "getPreferredHeight"
widgetClass_getPreferredHeight = AttrLabelProxy
#endif
getWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetPreferredWidthForHeightFieldCallback)
getWidgetClassGetPreferredWidthForHeight :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassGetPreferredWidthForHeightFieldCallback)
getWidgetClassGetPreferredWidthForHeight WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback)
Maybe WidgetClassGetPreferredWidthForHeightFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val' -> do
let val'' :: WidgetClassGetPreferredWidthForHeightFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> a -> Int32 -> m (Int32, Int32)
Gtk.Callbacks.dynamic_WidgetClassGetPreferredWidthForHeightFieldCallback FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetPreferredWidthForHeightFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGetPreferredWidthForHeightFieldCallback
result
setWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback -> m ()
setWidgetClassGetPreferredWidthForHeight :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> m ()
setWidgetClassGetPreferredWidthForHeight WidgetClass
s FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback)
clearWidgetClassGetPreferredWidthForHeight :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredWidthForHeight :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredWidthForHeight WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
312) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredWidthForHeightFieldInfo
instance AttrInfo WidgetClassGetPreferredWidthForHeightFieldInfo where
type AttrBaseTypeConstraint WidgetClassGetPreferredWidthForHeightFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassGetPreferredWidthForHeightFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassGetPreferredWidthForHeightFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback)
type AttrTransferTypeConstraint WidgetClassGetPreferredWidthForHeightFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredWidthForHeightFieldCallback
type AttrTransferType WidgetClassGetPreferredWidthForHeightFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthForHeightFieldCallback)
type AttrGetType WidgetClassGetPreferredWidthForHeightFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredWidthForHeightFieldCallback
type AttrLabel WidgetClassGetPreferredWidthForHeightFieldInfo = "get_preferred_width_for_height"
type AttrOrigin WidgetClassGetPreferredWidthForHeightFieldInfo = WidgetClass
attrGet = getWidgetClassGetPreferredWidthForHeight
attrSet = setWidgetClassGetPreferredWidthForHeight
attrConstruct = undefined
attrClear = clearWidgetClassGetPreferredWidthForHeight
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassGetPreferredWidthForHeightFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredWidthForHeightFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.getPreferredWidthForHeight"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:getPreferredWidthForHeight"
})
widgetClass_getPreferredWidthForHeight :: AttrLabelProxy "getPreferredWidthForHeight"
widgetClass_getPreferredWidthForHeight = AttrLabelProxy
#endif
getWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetPreferredWidthFieldCallback)
getWidgetClassGetPreferredWidth :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGetPreferredHeightFieldCallback)
getWidgetClassGetPreferredWidth WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback)
Maybe WidgetClassGetPreferredHeightFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val' -> do
let val'' :: WidgetClassGetPreferredHeightFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGetPreferredHeightFieldCallback
-> a -> m (Int32, Int32)
Gtk.Callbacks.dynamic_WidgetClassGetPreferredWidthFieldCallback FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetPreferredHeightFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGetPreferredHeightFieldCallback
result
setWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback -> m ()
setWidgetClassGetPreferredWidth :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassGetPreferredHeightFieldCallback -> m ()
setWidgetClassGetPreferredWidth WidgetClass
s FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) (FunPtr C_WidgetClassGetPreferredHeightFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback)
clearWidgetClassGetPreferredWidth :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredWidth :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredWidth WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
320) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredWidthFieldInfo
instance AttrInfo WidgetClassGetPreferredWidthFieldInfo where
type AttrBaseTypeConstraint WidgetClassGetPreferredWidthFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassGetPreferredWidthFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassGetPreferredWidthFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback)
type AttrTransferTypeConstraint WidgetClassGetPreferredWidthFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredWidthFieldCallback
type AttrTransferType WidgetClassGetPreferredWidthFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredWidthFieldCallback)
type AttrGetType WidgetClassGetPreferredWidthFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredWidthFieldCallback
type AttrLabel WidgetClassGetPreferredWidthFieldInfo = "get_preferred_width"
type AttrOrigin WidgetClassGetPreferredWidthFieldInfo = WidgetClass
attrGet = getWidgetClassGetPreferredWidth
attrSet = setWidgetClassGetPreferredWidth
attrConstruct = undefined
attrClear = clearWidgetClassGetPreferredWidth
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassGetPreferredWidthFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredWidthFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.getPreferredWidth"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:getPreferredWidth"
})
widgetClass_getPreferredWidth :: AttrLabelProxy "getPreferredWidth"
widgetClass_getPreferredWidth = AttrLabelProxy
#endif
getWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetPreferredHeightForWidthFieldCallback)
getWidgetClassGetPreferredHeightForWidth :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassGetPreferredWidthForHeightFieldCallback)
getWidgetClassGetPreferredHeightForWidth WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback)
Maybe WidgetClassGetPreferredWidthForHeightFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val' -> do
let val'' :: WidgetClassGetPreferredWidthForHeightFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> a -> Int32 -> m (Int32, Int32)
Gtk.Callbacks.dynamic_WidgetClassGetPreferredHeightForWidthFieldCallback FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetPreferredWidthForHeightFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGetPreferredWidthForHeightFieldCallback
result
setWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback -> m ()
setWidgetClassGetPreferredHeightForWidth :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
-> m ()
setWidgetClassGetPreferredHeightForWidth WidgetClass
s FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) (FunPtr C_WidgetClassGetPreferredWidthForHeightFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback)
clearWidgetClassGetPreferredHeightForWidth :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredHeightForWidth :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredHeightForWidth WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
328) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredHeightForWidthFieldInfo
instance AttrInfo WidgetClassGetPreferredHeightForWidthFieldInfo where
type AttrBaseTypeConstraint WidgetClassGetPreferredHeightForWidthFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassGetPreferredHeightForWidthFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassGetPreferredHeightForWidthFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback)
type AttrTransferTypeConstraint WidgetClassGetPreferredHeightForWidthFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredHeightForWidthFieldCallback
type AttrTransferType WidgetClassGetPreferredHeightForWidthFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightForWidthFieldCallback)
type AttrGetType WidgetClassGetPreferredHeightForWidthFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredHeightForWidthFieldCallback
type AttrLabel WidgetClassGetPreferredHeightForWidthFieldInfo = "get_preferred_height_for_width"
type AttrOrigin WidgetClassGetPreferredHeightForWidthFieldInfo = WidgetClass
attrGet = getWidgetClassGetPreferredHeightForWidth
attrSet = setWidgetClassGetPreferredHeightForWidth
attrConstruct = undefined
attrClear = clearWidgetClassGetPreferredHeightForWidth
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassGetPreferredHeightForWidthFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredHeightForWidthFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.getPreferredHeightForWidth"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:getPreferredHeightForWidth"
})
widgetClass_getPreferredHeightForWidth :: AttrLabelProxy "getPreferredHeightForWidth"
widgetClass_getPreferredHeightForWidth = AttrLabelProxy
#endif
getWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMnemonicActivateFieldCallback)
getWidgetClassMnemonicActivate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassMnemonicActivateFieldCallback)
getWidgetClassMnemonicActivate WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassMnemonicActivateFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
336) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
Maybe WidgetClassMnemonicActivateFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassMnemonicActivateFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassMnemonicActivateFieldCallback
val' -> do
let val'' :: WidgetClassMnemonicActivateFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassMnemonicActivateFieldCallback
-> a -> Bool -> m Bool
Gtk.Callbacks.dynamic_WidgetClassMnemonicActivateFieldCallback FunPtr C_WidgetClassMnemonicActivateFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMnemonicActivateFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassMnemonicActivateFieldCallback
result
setWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback -> m ()
setWidgetClassMnemonicActivate :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassMnemonicActivateFieldCallback -> m ()
setWidgetClassMnemonicActivate WidgetClass
s FunPtr C_WidgetClassMnemonicActivateFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
336) (FunPtr C_WidgetClassMnemonicActivateFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMnemonicActivateFieldCallback)
clearWidgetClassMnemonicActivate :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMnemonicActivate :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMnemonicActivate WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
336) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.mnemonicActivate"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:mnemonicActivate"
})
widgetClass_mnemonicActivate :: AttrLabelProxy "mnemonicActivate"
widgetClass_mnemonicActivate = AttrLabelProxy
#endif
getWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGrabFocusFieldCallback)
getWidgetClassGrabFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassGrabFocus WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
344) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassGrabFocusFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassGrabFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback -> m ()
setWidgetClassGrabFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassGrabFocus WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
344) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGrabFocusFieldCallback)
clearWidgetClassGrabFocus :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabFocus WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
344) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.grabFocus"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:grabFocus"
})
widgetClass_grabFocus :: AttrLabelProxy "grabFocus"
widgetClass_grabFocus = AttrLabelProxy
#endif
getWidgetClassFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassFocusFieldCallback)
getWidgetClassFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassFocus WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassFocusFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
352) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
Maybe WidgetClassFocusFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassFocusFieldCallback
val' -> do
let val'' :: WidgetClassFocusFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusFieldCallback
-> a -> DirectionType -> m Bool
Gtk.Callbacks.dynamic_WidgetClassFocusFieldCallback FunPtr C_WidgetClassFocusFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassFocusFieldCallback
result
setWidgetClassFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassFocus WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
352) (FunPtr C_WidgetClassFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassFocusFieldCallback)
clearWidgetClassFocus :: MonadIO m => WidgetClass -> m ()
clearWidgetClassFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassFocus WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
352) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.focus"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:focus"
})
widgetClass_focus :: AttrLabelProxy "focus"
widgetClass_focus = AttrLabelProxy
#endif
getWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMoveFocusFieldCallback)
getWidgetClassMoveFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassMoveFocusFieldCallback)
getWidgetClassMoveFocus WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassStateChangedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
360) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
Maybe WidgetClassMoveFocusFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassStateChangedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassStateChangedFieldCallback
val' -> do
let val'' :: WidgetClassMoveFocusFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassStateChangedFieldCallback
-> a -> DirectionType -> m ()
Gtk.Callbacks.dynamic_WidgetClassMoveFocusFieldCallback FunPtr C_WidgetClassStateChangedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMoveFocusFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassMoveFocusFieldCallback
result
setWidgetClassMoveFocus :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback -> m ()
setWidgetClassMoveFocus :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassStateChangedFieldCallback -> m ()
setWidgetClassMoveFocus WidgetClass
s FunPtr C_WidgetClassStateChangedFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
360) (FunPtr C_WidgetClassStateChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMoveFocusFieldCallback)
clearWidgetClassMoveFocus :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMoveFocus :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMoveFocus WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
360) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.moveFocus"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:moveFocus"
})
widgetClass_moveFocus :: AttrLabelProxy "moveFocus"
widgetClass_moveFocus = AttrLabelProxy
#endif
getWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassKeynavFailedFieldCallback)
getWidgetClassKeynavFailed :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassFocusFieldCallback)
getWidgetClassKeynavFailed WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassFocusFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
368) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
Maybe WidgetClassFocusFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassFocusFieldCallback
val' -> do
let val'' :: WidgetClassFocusFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusFieldCallback
-> a -> DirectionType -> m Bool
Gtk.Callbacks.dynamic_WidgetClassKeynavFailedFieldCallback FunPtr C_WidgetClassFocusFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassFocusFieldCallback
result
setWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback -> m ()
setWidgetClassKeynavFailed :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassKeynavFailed WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
368) (FunPtr C_WidgetClassFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassKeynavFailedFieldCallback)
clearWidgetClassKeynavFailed :: MonadIO m => WidgetClass -> m ()
clearWidgetClassKeynavFailed :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassKeynavFailed WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
368) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.keynavFailed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:keynavFailed"
})
widgetClass_keynavFailed :: AttrLabelProxy "keynavFailed"
widgetClass_keynavFailed = AttrLabelProxy
#endif
getWidgetClassEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassEventFieldCallback)
getWidgetClassEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassEventFieldCallback)
getWidgetClassEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
376) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback)
Maybe WidgetClassEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassEventFieldCallback
val' -> do
let val'' :: WidgetClassEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassEventFieldCallback -> a -> Event -> m Bool
Gtk.Callbacks.dynamic_WidgetClassEventFieldCallback FunPtr C_WidgetClassEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassEventFieldCallback
result
setWidgetClassEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback -> m ()
setWidgetClassEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassEventFieldCallback -> m ()
setWidgetClassEvent WidgetClass
s FunPtr C_WidgetClassEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
376) (FunPtr C_WidgetClassEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback)
clearWidgetClassEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
376) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassEventFieldInfo
instance AttrInfo WidgetClassEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassEventFieldInfo = (~)Gtk.Callbacks.WidgetClassEventFieldCallback
type AttrTransferType WidgetClassEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassEventFieldCallback)
type AttrGetType WidgetClassEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassEventFieldCallback
type AttrLabel WidgetClassEventFieldInfo = "event"
type AttrOrigin WidgetClassEventFieldInfo = WidgetClass
attrGet = getWidgetClassEvent
attrSet = setWidgetClassEvent
attrConstruct = undefined
attrClear = clearWidgetClassEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.event"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:event"
})
widgetClass_event :: AttrLabelProxy "event"
widgetClass_event = AttrLabelProxy
#endif
getWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassButtonPressEventFieldCallback)
getWidgetClassButtonPressEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassButtonPressEventFieldCallback)
getWidgetClassButtonPressEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassButtonPressEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
384) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback)
Maybe WidgetClassButtonPressEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassButtonPressEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassButtonPressEventFieldCallback
val' -> do
let val'' :: WidgetClassButtonPressEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassButtonPressEventFieldCallback
-> a -> EventButton -> m Bool
Gtk.Callbacks.dynamic_WidgetClassButtonPressEventFieldCallback FunPtr C_WidgetClassButtonPressEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassButtonPressEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassButtonPressEventFieldCallback
result
setWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback -> m ()
setWidgetClassButtonPressEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassButtonPressEventFieldCallback -> m ()
setWidgetClassButtonPressEvent WidgetClass
s FunPtr C_WidgetClassButtonPressEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
384) (FunPtr C_WidgetClassButtonPressEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback)
clearWidgetClassButtonPressEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassButtonPressEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassButtonPressEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
384) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassButtonPressEventFieldInfo
instance AttrInfo WidgetClassButtonPressEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassButtonPressEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassButtonPressEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassButtonPressEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassButtonPressEventFieldInfo = (~)Gtk.Callbacks.WidgetClassButtonPressEventFieldCallback
type AttrTransferType WidgetClassButtonPressEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassButtonPressEventFieldCallback)
type AttrGetType WidgetClassButtonPressEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassButtonPressEventFieldCallback
type AttrLabel WidgetClassButtonPressEventFieldInfo = "button_press_event"
type AttrOrigin WidgetClassButtonPressEventFieldInfo = WidgetClass
attrGet = getWidgetClassButtonPressEvent
attrSet = setWidgetClassButtonPressEvent
attrConstruct = undefined
attrClear = clearWidgetClassButtonPressEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassButtonPressEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassButtonPressEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.buttonPressEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:buttonPressEvent"
})
widgetClass_buttonPressEvent :: AttrLabelProxy "buttonPressEvent"
widgetClass_buttonPressEvent = AttrLabelProxy
#endif
getWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassButtonReleaseEventFieldCallback)
getWidgetClassButtonReleaseEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassButtonPressEventFieldCallback)
getWidgetClassButtonReleaseEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassButtonPressEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
392) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback)
Maybe WidgetClassButtonPressEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassButtonPressEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassButtonPressEventFieldCallback
val' -> do
let val'' :: WidgetClassButtonPressEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassButtonPressEventFieldCallback
-> a -> EventButton -> m Bool
Gtk.Callbacks.dynamic_WidgetClassButtonReleaseEventFieldCallback FunPtr C_WidgetClassButtonPressEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassButtonPressEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassButtonPressEventFieldCallback
result
setWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback -> m ()
setWidgetClassButtonReleaseEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassButtonPressEventFieldCallback -> m ()
setWidgetClassButtonReleaseEvent WidgetClass
s FunPtr C_WidgetClassButtonPressEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
392) (FunPtr C_WidgetClassButtonPressEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback)
clearWidgetClassButtonReleaseEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassButtonReleaseEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassButtonReleaseEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
392) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassButtonReleaseEventFieldInfo
instance AttrInfo WidgetClassButtonReleaseEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassButtonReleaseEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassButtonReleaseEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassButtonReleaseEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassButtonReleaseEventFieldInfo = (~)Gtk.Callbacks.WidgetClassButtonReleaseEventFieldCallback
type AttrTransferType WidgetClassButtonReleaseEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassButtonReleaseEventFieldCallback)
type AttrGetType WidgetClassButtonReleaseEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassButtonReleaseEventFieldCallback
type AttrLabel WidgetClassButtonReleaseEventFieldInfo = "button_release_event"
type AttrOrigin WidgetClassButtonReleaseEventFieldInfo = WidgetClass
attrGet = getWidgetClassButtonReleaseEvent
attrSet = setWidgetClassButtonReleaseEvent
attrConstruct = undefined
attrClear = clearWidgetClassButtonReleaseEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassButtonReleaseEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassButtonReleaseEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.buttonReleaseEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:buttonReleaseEvent"
})
widgetClass_buttonReleaseEvent :: AttrLabelProxy "buttonReleaseEvent"
widgetClass_buttonReleaseEvent = AttrLabelProxy
#endif
getWidgetClassScrollEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassScrollEventFieldCallback)
getWidgetClassScrollEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassScrollEventFieldCallback)
getWidgetClassScrollEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassScrollEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
400) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback)
Maybe WidgetClassScrollEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassScrollEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassScrollEventFieldCallback
val' -> do
let val'' :: WidgetClassScrollEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassScrollEventFieldCallback
-> a -> EventScroll -> m Bool
Gtk.Callbacks.dynamic_WidgetClassScrollEventFieldCallback FunPtr C_WidgetClassScrollEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassScrollEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassScrollEventFieldCallback
result
setWidgetClassScrollEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback -> m ()
setWidgetClassScrollEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassScrollEventFieldCallback -> m ()
setWidgetClassScrollEvent WidgetClass
s FunPtr C_WidgetClassScrollEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
400) (FunPtr C_WidgetClassScrollEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback)
clearWidgetClassScrollEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassScrollEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassScrollEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
400) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassScrollEventFieldInfo
instance AttrInfo WidgetClassScrollEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassScrollEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassScrollEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassScrollEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassScrollEventFieldInfo = (~)Gtk.Callbacks.WidgetClassScrollEventFieldCallback
type AttrTransferType WidgetClassScrollEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassScrollEventFieldCallback)
type AttrGetType WidgetClassScrollEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassScrollEventFieldCallback
type AttrLabel WidgetClassScrollEventFieldInfo = "scroll_event"
type AttrOrigin WidgetClassScrollEventFieldInfo = WidgetClass
attrGet = getWidgetClassScrollEvent
attrSet = setWidgetClassScrollEvent
attrConstruct = undefined
attrClear = clearWidgetClassScrollEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassScrollEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassScrollEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.scrollEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:scrollEvent"
})
widgetClass_scrollEvent :: AttrLabelProxy "scrollEvent"
widgetClass_scrollEvent = AttrLabelProxy
#endif
getWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMotionNotifyEventFieldCallback)
getWidgetClassMotionNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassMotionNotifyEventFieldCallback)
getWidgetClassMotionNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassMotionNotifyEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
408) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback)
Maybe WidgetClassMotionNotifyEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassMotionNotifyEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassMotionNotifyEventFieldCallback
val' -> do
let val'' :: WidgetClassMotionNotifyEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassMotionNotifyEventFieldCallback
-> a -> EventMotion -> m Bool
Gtk.Callbacks.dynamic_WidgetClassMotionNotifyEventFieldCallback FunPtr C_WidgetClassMotionNotifyEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassMotionNotifyEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassMotionNotifyEventFieldCallback
result
setWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback -> m ()
setWidgetClassMotionNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassMotionNotifyEventFieldCallback -> m ()
setWidgetClassMotionNotifyEvent WidgetClass
s FunPtr C_WidgetClassMotionNotifyEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
408) (FunPtr C_WidgetClassMotionNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback)
clearWidgetClassMotionNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMotionNotifyEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMotionNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
408) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassMotionNotifyEventFieldInfo
instance AttrInfo WidgetClassMotionNotifyEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassMotionNotifyEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassMotionNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassMotionNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassMotionNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassMotionNotifyEventFieldCallback
type AttrTransferType WidgetClassMotionNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMotionNotifyEventFieldCallback)
type AttrGetType WidgetClassMotionNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassMotionNotifyEventFieldCallback
type AttrLabel WidgetClassMotionNotifyEventFieldInfo = "motion_notify_event"
type AttrOrigin WidgetClassMotionNotifyEventFieldInfo = WidgetClass
attrGet = getWidgetClassMotionNotifyEvent
attrSet = setWidgetClassMotionNotifyEvent
attrConstruct = undefined
attrClear = clearWidgetClassMotionNotifyEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassMotionNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassMotionNotifyEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.motionNotifyEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:motionNotifyEvent"
})
widgetClass_motionNotifyEvent :: AttrLabelProxy "motionNotifyEvent"
widgetClass_motionNotifyEvent = AttrLabelProxy
#endif
getWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDeleteEventFieldCallback)
getWidgetClassDeleteEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDeleteEventFieldCallback)
getWidgetClassDeleteEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDeleteEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
416) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback)
Maybe WidgetClassDeleteEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDeleteEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDeleteEventFieldCallback
val' -> do
let val'' :: WidgetClassDeleteEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDeleteEventFieldCallback
-> a -> EventAny -> m Bool
Gtk.Callbacks.dynamic_WidgetClassDeleteEventFieldCallback FunPtr C_WidgetClassDeleteEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDeleteEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDeleteEventFieldCallback
result
setWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassDeleteEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassDeleteEvent WidgetClass
s FunPtr C_WidgetClassDeleteEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
416) (FunPtr C_WidgetClassDeleteEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback)
clearWidgetClassDeleteEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDeleteEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDeleteEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
416) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassDeleteEventFieldInfo
instance AttrInfo WidgetClassDeleteEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassDeleteEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassDeleteEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassDeleteEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassDeleteEventFieldInfo = (~)Gtk.Callbacks.WidgetClassDeleteEventFieldCallback
type AttrTransferType WidgetClassDeleteEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDeleteEventFieldCallback)
type AttrGetType WidgetClassDeleteEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassDeleteEventFieldCallback
type AttrLabel WidgetClassDeleteEventFieldInfo = "delete_event"
type AttrOrigin WidgetClassDeleteEventFieldInfo = WidgetClass
attrGet = getWidgetClassDeleteEvent
attrSet = setWidgetClassDeleteEvent
attrConstruct = undefined
attrClear = clearWidgetClassDeleteEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassDeleteEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassDeleteEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.deleteEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:deleteEvent"
})
widgetClass_deleteEvent :: AttrLabelProxy "deleteEvent"
widgetClass_deleteEvent = AttrLabelProxy
#endif
getWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDestroyEventFieldCallback)
getWidgetClassDestroyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDeleteEventFieldCallback)
getWidgetClassDestroyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDeleteEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
424) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback)
Maybe WidgetClassDeleteEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDeleteEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDeleteEventFieldCallback
val' -> do
let val'' :: WidgetClassDeleteEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDeleteEventFieldCallback
-> a -> EventAny -> m Bool
Gtk.Callbacks.dynamic_WidgetClassDestroyEventFieldCallback FunPtr C_WidgetClassDeleteEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDeleteEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDeleteEventFieldCallback
result
setWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback -> m ()
setWidgetClassDestroyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassDestroyEvent WidgetClass
s FunPtr C_WidgetClassDeleteEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
424) (FunPtr C_WidgetClassDeleteEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback)
clearWidgetClassDestroyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDestroyEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDestroyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
424) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassDestroyEventFieldInfo
instance AttrInfo WidgetClassDestroyEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassDestroyEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassDestroyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassDestroyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassDestroyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassDestroyEventFieldCallback
type AttrTransferType WidgetClassDestroyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDestroyEventFieldCallback)
type AttrGetType WidgetClassDestroyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassDestroyEventFieldCallback
type AttrLabel WidgetClassDestroyEventFieldInfo = "destroy_event"
type AttrOrigin WidgetClassDestroyEventFieldInfo = WidgetClass
attrGet = getWidgetClassDestroyEvent
attrSet = setWidgetClassDestroyEvent
attrConstruct = undefined
attrClear = clearWidgetClassDestroyEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassDestroyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassDestroyEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.destroyEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:destroyEvent"
})
widgetClass_destroyEvent :: AttrLabelProxy "destroyEvent"
widgetClass_destroyEvent = AttrLabelProxy
#endif
getWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassKeyPressEventFieldCallback)
getWidgetClassKeyPressEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassKeyPressEventFieldCallback)
getWidgetClassKeyPressEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassKeyPressEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
432) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback)
Maybe WidgetClassKeyPressEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassKeyPressEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassKeyPressEventFieldCallback
val' -> do
let val'' :: WidgetClassKeyPressEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassKeyPressEventFieldCallback
-> a -> EventKey -> m Bool
Gtk.Callbacks.dynamic_WidgetClassKeyPressEventFieldCallback FunPtr C_WidgetClassKeyPressEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassKeyPressEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassKeyPressEventFieldCallback
result
setWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback -> m ()
setWidgetClassKeyPressEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassKeyPressEventFieldCallback -> m ()
setWidgetClassKeyPressEvent WidgetClass
s FunPtr C_WidgetClassKeyPressEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
432) (FunPtr C_WidgetClassKeyPressEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback)
clearWidgetClassKeyPressEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassKeyPressEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassKeyPressEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
432) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassKeyPressEventFieldInfo
instance AttrInfo WidgetClassKeyPressEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassKeyPressEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassKeyPressEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassKeyPressEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassKeyPressEventFieldInfo = (~)Gtk.Callbacks.WidgetClassKeyPressEventFieldCallback
type AttrTransferType WidgetClassKeyPressEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassKeyPressEventFieldCallback)
type AttrGetType WidgetClassKeyPressEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassKeyPressEventFieldCallback
type AttrLabel WidgetClassKeyPressEventFieldInfo = "key_press_event"
type AttrOrigin WidgetClassKeyPressEventFieldInfo = WidgetClass
attrGet = getWidgetClassKeyPressEvent
attrSet = setWidgetClassKeyPressEvent
attrConstruct = undefined
attrClear = clearWidgetClassKeyPressEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassKeyPressEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassKeyPressEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.keyPressEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:keyPressEvent"
})
widgetClass_keyPressEvent :: AttrLabelProxy "keyPressEvent"
widgetClass_keyPressEvent = AttrLabelProxy
#endif
getWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassKeyReleaseEventFieldCallback)
getWidgetClassKeyReleaseEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassKeyPressEventFieldCallback)
getWidgetClassKeyReleaseEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassKeyPressEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
440) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback)
Maybe WidgetClassKeyPressEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassKeyPressEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassKeyPressEventFieldCallback
val' -> do
let val'' :: WidgetClassKeyPressEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassKeyPressEventFieldCallback
-> a -> EventKey -> m Bool
Gtk.Callbacks.dynamic_WidgetClassKeyReleaseEventFieldCallback FunPtr C_WidgetClassKeyPressEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassKeyPressEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassKeyPressEventFieldCallback
result
setWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback -> m ()
setWidgetClassKeyReleaseEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassKeyPressEventFieldCallback -> m ()
setWidgetClassKeyReleaseEvent WidgetClass
s FunPtr C_WidgetClassKeyPressEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
440) (FunPtr C_WidgetClassKeyPressEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback)
clearWidgetClassKeyReleaseEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassKeyReleaseEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassKeyReleaseEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
440) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassKeyReleaseEventFieldInfo
instance AttrInfo WidgetClassKeyReleaseEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassKeyReleaseEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassKeyReleaseEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassKeyReleaseEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassKeyReleaseEventFieldInfo = (~)Gtk.Callbacks.WidgetClassKeyReleaseEventFieldCallback
type AttrTransferType WidgetClassKeyReleaseEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassKeyReleaseEventFieldCallback)
type AttrGetType WidgetClassKeyReleaseEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassKeyReleaseEventFieldCallback
type AttrLabel WidgetClassKeyReleaseEventFieldInfo = "key_release_event"
type AttrOrigin WidgetClassKeyReleaseEventFieldInfo = WidgetClass
attrGet = getWidgetClassKeyReleaseEvent
attrSet = setWidgetClassKeyReleaseEvent
attrConstruct = undefined
attrClear = clearWidgetClassKeyReleaseEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassKeyReleaseEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassKeyReleaseEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.keyReleaseEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:keyReleaseEvent"
})
widgetClass_keyReleaseEvent :: AttrLabelProxy "keyReleaseEvent"
widgetClass_keyReleaseEvent = AttrLabelProxy
#endif
getWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassEnterNotifyEventFieldCallback)
getWidgetClassEnterNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassEnterNotifyEventFieldCallback)
getWidgetClassEnterNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
448) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback)
Maybe WidgetClassEnterNotifyEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val' -> do
let val'' :: WidgetClassEnterNotifyEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassEnterNotifyEventFieldCallback
-> a -> EventCrossing -> m Bool
Gtk.Callbacks.dynamic_WidgetClassEnterNotifyEventFieldCallback FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassEnterNotifyEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassEnterNotifyEventFieldCallback
result
setWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback -> m ()
setWidgetClassEnterNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> m ()
setWidgetClassEnterNotifyEvent WidgetClass
s FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
448) (FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback)
clearWidgetClassEnterNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassEnterNotifyEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassEnterNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
448) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassEnterNotifyEventFieldInfo
instance AttrInfo WidgetClassEnterNotifyEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassEnterNotifyEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassEnterNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassEnterNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassEnterNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassEnterNotifyEventFieldCallback
type AttrTransferType WidgetClassEnterNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassEnterNotifyEventFieldCallback)
type AttrGetType WidgetClassEnterNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassEnterNotifyEventFieldCallback
type AttrLabel WidgetClassEnterNotifyEventFieldInfo = "enter_notify_event"
type AttrOrigin WidgetClassEnterNotifyEventFieldInfo = WidgetClass
attrGet = getWidgetClassEnterNotifyEvent
attrSet = setWidgetClassEnterNotifyEvent
attrConstruct = undefined
attrClear = clearWidgetClassEnterNotifyEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassEnterNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassEnterNotifyEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.enterNotifyEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:enterNotifyEvent"
})
widgetClass_enterNotifyEvent :: AttrLabelProxy "enterNotifyEvent"
widgetClass_enterNotifyEvent = AttrLabelProxy
#endif
getWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassLeaveNotifyEventFieldCallback)
getWidgetClassLeaveNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassEnterNotifyEventFieldCallback)
getWidgetClassLeaveNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
456) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback)
Maybe WidgetClassEnterNotifyEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val' -> do
let val'' :: WidgetClassEnterNotifyEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassEnterNotifyEventFieldCallback
-> a -> EventCrossing -> m Bool
Gtk.Callbacks.dynamic_WidgetClassLeaveNotifyEventFieldCallback FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassEnterNotifyEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassEnterNotifyEventFieldCallback
result
setWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback -> m ()
setWidgetClassLeaveNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassEnterNotifyEventFieldCallback -> m ()
setWidgetClassLeaveNotifyEvent WidgetClass
s FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
456) (FunPtr C_WidgetClassEnterNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback)
clearWidgetClassLeaveNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassLeaveNotifyEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassLeaveNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
456) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassLeaveNotifyEventFieldInfo
instance AttrInfo WidgetClassLeaveNotifyEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassLeaveNotifyEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassLeaveNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassLeaveNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassLeaveNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassLeaveNotifyEventFieldCallback
type AttrTransferType WidgetClassLeaveNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassLeaveNotifyEventFieldCallback)
type AttrGetType WidgetClassLeaveNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassLeaveNotifyEventFieldCallback
type AttrLabel WidgetClassLeaveNotifyEventFieldInfo = "leave_notify_event"
type AttrOrigin WidgetClassLeaveNotifyEventFieldInfo = WidgetClass
attrGet = getWidgetClassLeaveNotifyEvent
attrSet = setWidgetClassLeaveNotifyEvent
attrConstruct = undefined
attrClear = clearWidgetClassLeaveNotifyEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassLeaveNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassLeaveNotifyEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.leaveNotifyEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:leaveNotifyEvent"
})
widgetClass_leaveNotifyEvent :: AttrLabelProxy "leaveNotifyEvent"
widgetClass_leaveNotifyEvent = AttrLabelProxy
#endif
getWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassConfigureEventFieldCallback)
getWidgetClassConfigureEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassConfigureEventFieldCallback)
getWidgetClassConfigureEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassConfigureEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
464) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback)
Maybe WidgetClassConfigureEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassConfigureEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassConfigureEventFieldCallback
val' -> do
let val'' :: WidgetClassConfigureEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassConfigureEventFieldCallback
-> a -> EventConfigure -> m Bool
Gtk.Callbacks.dynamic_WidgetClassConfigureEventFieldCallback FunPtr C_WidgetClassConfigureEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassConfigureEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassConfigureEventFieldCallback
result
setWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback -> m ()
setWidgetClassConfigureEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassConfigureEventFieldCallback -> m ()
setWidgetClassConfigureEvent WidgetClass
s FunPtr C_WidgetClassConfigureEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
464) (FunPtr C_WidgetClassConfigureEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback)
clearWidgetClassConfigureEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassConfigureEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassConfigureEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
464) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassConfigureEventFieldInfo
instance AttrInfo WidgetClassConfigureEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassConfigureEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassConfigureEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassConfigureEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassConfigureEventFieldInfo = (~)Gtk.Callbacks.WidgetClassConfigureEventFieldCallback
type AttrTransferType WidgetClassConfigureEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassConfigureEventFieldCallback)
type AttrGetType WidgetClassConfigureEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassConfigureEventFieldCallback
type AttrLabel WidgetClassConfigureEventFieldInfo = "configure_event"
type AttrOrigin WidgetClassConfigureEventFieldInfo = WidgetClass
attrGet = getWidgetClassConfigureEvent
attrSet = setWidgetClassConfigureEvent
attrConstruct = undefined
attrClear = clearWidgetClassConfigureEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassConfigureEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassConfigureEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.configureEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:configureEvent"
})
widgetClass_configureEvent :: AttrLabelProxy "configureEvent"
widgetClass_configureEvent = AttrLabelProxy
#endif
getWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassFocusInEventFieldCallback)
getWidgetClassFocusInEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassFocusInEventFieldCallback)
getWidgetClassFocusInEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassFocusInEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
472) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback)
Maybe WidgetClassFocusInEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusInEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassFocusInEventFieldCallback
val' -> do
let val'' :: WidgetClassFocusInEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusInEventFieldCallback
-> a -> EventFocus -> m Bool
Gtk.Callbacks.dynamic_WidgetClassFocusInEventFieldCallback FunPtr C_WidgetClassFocusInEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusInEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassFocusInEventFieldCallback
result
setWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback -> m ()
setWidgetClassFocusInEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassFocusInEventFieldCallback -> m ()
setWidgetClassFocusInEvent WidgetClass
s FunPtr C_WidgetClassFocusInEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
472) (FunPtr C_WidgetClassFocusInEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback)
clearWidgetClassFocusInEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassFocusInEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassFocusInEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
472) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassFocusInEventFieldInfo
instance AttrInfo WidgetClassFocusInEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassFocusInEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassFocusInEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassFocusInEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassFocusInEventFieldInfo = (~)Gtk.Callbacks.WidgetClassFocusInEventFieldCallback
type AttrTransferType WidgetClassFocusInEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassFocusInEventFieldCallback)
type AttrGetType WidgetClassFocusInEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassFocusInEventFieldCallback
type AttrLabel WidgetClassFocusInEventFieldInfo = "focus_in_event"
type AttrOrigin WidgetClassFocusInEventFieldInfo = WidgetClass
attrGet = getWidgetClassFocusInEvent
attrSet = setWidgetClassFocusInEvent
attrConstruct = undefined
attrClear = clearWidgetClassFocusInEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassFocusInEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassFocusInEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.focusInEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:focusInEvent"
})
widgetClass_focusInEvent :: AttrLabelProxy "focusInEvent"
widgetClass_focusInEvent = AttrLabelProxy
#endif
getWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassFocusOutEventFieldCallback)
getWidgetClassFocusOutEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassFocusInEventFieldCallback)
getWidgetClassFocusOutEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassFocusInEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
480) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback)
Maybe WidgetClassFocusInEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusInEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassFocusInEventFieldCallback
val' -> do
let val'' :: WidgetClassFocusInEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusInEventFieldCallback
-> a -> EventFocus -> m Bool
Gtk.Callbacks.dynamic_WidgetClassFocusOutEventFieldCallback FunPtr C_WidgetClassFocusInEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassFocusInEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassFocusInEventFieldCallback
result
setWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback -> m ()
setWidgetClassFocusOutEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassFocusInEventFieldCallback -> m ()
setWidgetClassFocusOutEvent WidgetClass
s FunPtr C_WidgetClassFocusInEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
480) (FunPtr C_WidgetClassFocusInEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback)
clearWidgetClassFocusOutEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassFocusOutEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassFocusOutEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
480) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassFocusOutEventFieldInfo
instance AttrInfo WidgetClassFocusOutEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassFocusOutEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassFocusOutEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassFocusOutEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassFocusOutEventFieldInfo = (~)Gtk.Callbacks.WidgetClassFocusOutEventFieldCallback
type AttrTransferType WidgetClassFocusOutEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassFocusOutEventFieldCallback)
type AttrGetType WidgetClassFocusOutEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassFocusOutEventFieldCallback
type AttrLabel WidgetClassFocusOutEventFieldInfo = "focus_out_event"
type AttrOrigin WidgetClassFocusOutEventFieldInfo = WidgetClass
attrGet = getWidgetClassFocusOutEvent
attrSet = setWidgetClassFocusOutEvent
attrConstruct = undefined
attrClear = clearWidgetClassFocusOutEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassFocusOutEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassFocusOutEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.focusOutEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:focusOutEvent"
})
widgetClass_focusOutEvent :: AttrLabelProxy "focusOutEvent"
widgetClass_focusOutEvent = AttrLabelProxy
#endif
getWidgetClassMapEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassMapEventFieldCallback)
getWidgetClassMapEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDeleteEventFieldCallback)
getWidgetClassMapEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDeleteEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
488) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback)
Maybe WidgetClassDeleteEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDeleteEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDeleteEventFieldCallback
val' -> do
let val'' :: WidgetClassDeleteEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDeleteEventFieldCallback
-> a -> EventAny -> m Bool
Gtk.Callbacks.dynamic_WidgetClassMapEventFieldCallback FunPtr C_WidgetClassDeleteEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDeleteEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDeleteEventFieldCallback
result
setWidgetClassMapEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback -> m ()
setWidgetClassMapEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassMapEvent WidgetClass
s FunPtr C_WidgetClassDeleteEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
488) (FunPtr C_WidgetClassDeleteEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback)
clearWidgetClassMapEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassMapEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassMapEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
488) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassMapEventFieldInfo
instance AttrInfo WidgetClassMapEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassMapEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassMapEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassMapEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassMapEventFieldInfo = (~)Gtk.Callbacks.WidgetClassMapEventFieldCallback
type AttrTransferType WidgetClassMapEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassMapEventFieldCallback)
type AttrGetType WidgetClassMapEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassMapEventFieldCallback
type AttrLabel WidgetClassMapEventFieldInfo = "map_event"
type AttrOrigin WidgetClassMapEventFieldInfo = WidgetClass
attrGet = getWidgetClassMapEvent
attrSet = setWidgetClassMapEvent
attrConstruct = undefined
attrClear = clearWidgetClassMapEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassMapEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassMapEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.mapEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:mapEvent"
})
widgetClass_mapEvent :: AttrLabelProxy "mapEvent"
widgetClass_mapEvent = AttrLabelProxy
#endif
getWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassUnmapEventFieldCallback)
getWidgetClassUnmapEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDeleteEventFieldCallback)
getWidgetClassUnmapEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDeleteEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
496) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback)
Maybe WidgetClassDeleteEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDeleteEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDeleteEventFieldCallback
val' -> do
let val'' :: WidgetClassDeleteEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDeleteEventFieldCallback
-> a -> EventAny -> m Bool
Gtk.Callbacks.dynamic_WidgetClassUnmapEventFieldCallback FunPtr C_WidgetClassDeleteEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDeleteEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDeleteEventFieldCallback
result
setWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback -> m ()
setWidgetClassUnmapEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDeleteEventFieldCallback -> m ()
setWidgetClassUnmapEvent WidgetClass
s FunPtr C_WidgetClassDeleteEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
496) (FunPtr C_WidgetClassDeleteEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback)
clearWidgetClassUnmapEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassUnmapEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassUnmapEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
496) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassUnmapEventFieldInfo
instance AttrInfo WidgetClassUnmapEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassUnmapEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassUnmapEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassUnmapEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassUnmapEventFieldInfo = (~)Gtk.Callbacks.WidgetClassUnmapEventFieldCallback
type AttrTransferType WidgetClassUnmapEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassUnmapEventFieldCallback)
type AttrGetType WidgetClassUnmapEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassUnmapEventFieldCallback
type AttrLabel WidgetClassUnmapEventFieldInfo = "unmap_event"
type AttrOrigin WidgetClassUnmapEventFieldInfo = WidgetClass
attrGet = getWidgetClassUnmapEvent
attrSet = setWidgetClassUnmapEvent
attrConstruct = undefined
attrClear = clearWidgetClassUnmapEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassUnmapEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassUnmapEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.unmapEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:unmapEvent"
})
widgetClass_unmapEvent :: AttrLabelProxy "unmapEvent"
widgetClass_unmapEvent = AttrLabelProxy
#endif
getWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassPropertyNotifyEventFieldCallback)
getWidgetClassPropertyNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassPropertyNotifyEventFieldCallback)
getWidgetClassPropertyNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
504) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback)
Maybe WidgetClassPropertyNotifyEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
val' -> do
let val'' :: WidgetClassPropertyNotifyEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
-> a -> EventProperty -> m Bool
Gtk.Callbacks.dynamic_WidgetClassPropertyNotifyEventFieldCallback FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassPropertyNotifyEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassPropertyNotifyEventFieldCallback
result
setWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback -> m ()
setWidgetClassPropertyNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassPropertyNotifyEventFieldCallback -> m ()
setWidgetClassPropertyNotifyEvent WidgetClass
s FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
504) (FunPtr C_WidgetClassPropertyNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback)
clearWidgetClassPropertyNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassPropertyNotifyEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassPropertyNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
504) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassPropertyNotifyEventFieldInfo
instance AttrInfo WidgetClassPropertyNotifyEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassPropertyNotifyEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassPropertyNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassPropertyNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassPropertyNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassPropertyNotifyEventFieldCallback
type AttrTransferType WidgetClassPropertyNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassPropertyNotifyEventFieldCallback)
type AttrGetType WidgetClassPropertyNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassPropertyNotifyEventFieldCallback
type AttrLabel WidgetClassPropertyNotifyEventFieldInfo = "property_notify_event"
type AttrOrigin WidgetClassPropertyNotifyEventFieldInfo = WidgetClass
attrGet = getWidgetClassPropertyNotifyEvent
attrSet = setWidgetClassPropertyNotifyEvent
attrConstruct = undefined
attrClear = clearWidgetClassPropertyNotifyEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassPropertyNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassPropertyNotifyEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.propertyNotifyEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:propertyNotifyEvent"
})
widgetClass_propertyNotifyEvent :: AttrLabelProxy "propertyNotifyEvent"
widgetClass_propertyNotifyEvent = AttrLabelProxy
#endif
getWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSelectionClearEventFieldCallback)
getWidgetClassSelectionClearEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassSelectionClearEventFieldCallback)
getWidgetClassSelectionClearEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassSelectionClearEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
512) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback)
Maybe WidgetClassSelectionClearEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSelectionClearEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassSelectionClearEventFieldCallback
val' -> do
let val'' :: WidgetClassSelectionClearEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassSelectionClearEventFieldCallback
-> a -> EventSelection -> m Bool
Gtk.Callbacks.dynamic_WidgetClassSelectionClearEventFieldCallback FunPtr C_WidgetClassSelectionClearEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSelectionClearEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSelectionClearEventFieldCallback
result
setWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback -> m ()
setWidgetClassSelectionClearEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> m ()
setWidgetClassSelectionClearEvent WidgetClass
s FunPtr C_WidgetClassSelectionClearEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
512) (FunPtr C_WidgetClassSelectionClearEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback)
clearWidgetClassSelectionClearEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionClearEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionClearEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
512) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionClearEventFieldInfo
instance AttrInfo WidgetClassSelectionClearEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassSelectionClearEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassSelectionClearEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassSelectionClearEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassSelectionClearEventFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionClearEventFieldCallback
type AttrTransferType WidgetClassSelectionClearEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionClearEventFieldCallback)
type AttrGetType WidgetClassSelectionClearEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionClearEventFieldCallback
type AttrLabel WidgetClassSelectionClearEventFieldInfo = "selection_clear_event"
type AttrOrigin WidgetClassSelectionClearEventFieldInfo = WidgetClass
attrGet = getWidgetClassSelectionClearEvent
attrSet = setWidgetClassSelectionClearEvent
attrConstruct = undefined
attrClear = clearWidgetClassSelectionClearEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassSelectionClearEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionClearEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.selectionClearEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:selectionClearEvent"
})
widgetClass_selectionClearEvent :: AttrLabelProxy "selectionClearEvent"
widgetClass_selectionClearEvent = AttrLabelProxy
#endif
getWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSelectionRequestEventFieldCallback)
getWidgetClassSelectionRequestEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassSelectionClearEventFieldCallback)
getWidgetClassSelectionRequestEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassSelectionClearEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
520) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback)
Maybe WidgetClassSelectionClearEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSelectionClearEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassSelectionClearEventFieldCallback
val' -> do
let val'' :: WidgetClassSelectionClearEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassSelectionClearEventFieldCallback
-> a -> EventSelection -> m Bool
Gtk.Callbacks.dynamic_WidgetClassSelectionRequestEventFieldCallback FunPtr C_WidgetClassSelectionClearEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSelectionClearEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSelectionClearEventFieldCallback
result
setWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback -> m ()
setWidgetClassSelectionRequestEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> m ()
setWidgetClassSelectionRequestEvent WidgetClass
s FunPtr C_WidgetClassSelectionClearEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
520) (FunPtr C_WidgetClassSelectionClearEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback)
clearWidgetClassSelectionRequestEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionRequestEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionRequestEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
520) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionRequestEventFieldInfo
instance AttrInfo WidgetClassSelectionRequestEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassSelectionRequestEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassSelectionRequestEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassSelectionRequestEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassSelectionRequestEventFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionRequestEventFieldCallback
type AttrTransferType WidgetClassSelectionRequestEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionRequestEventFieldCallback)
type AttrGetType WidgetClassSelectionRequestEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionRequestEventFieldCallback
type AttrLabel WidgetClassSelectionRequestEventFieldInfo = "selection_request_event"
type AttrOrigin WidgetClassSelectionRequestEventFieldInfo = WidgetClass
attrGet = getWidgetClassSelectionRequestEvent
attrSet = setWidgetClassSelectionRequestEvent
attrConstruct = undefined
attrClear = clearWidgetClassSelectionRequestEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassSelectionRequestEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionRequestEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.selectionRequestEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:selectionRequestEvent"
})
widgetClass_selectionRequestEvent :: AttrLabelProxy "selectionRequestEvent"
widgetClass_selectionRequestEvent = AttrLabelProxy
#endif
getWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSelectionNotifyEventFieldCallback)
getWidgetClassSelectionNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassSelectionClearEventFieldCallback)
getWidgetClassSelectionNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassSelectionClearEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
528) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback)
Maybe WidgetClassSelectionClearEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSelectionClearEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassSelectionClearEventFieldCallback
val' -> do
let val'' :: WidgetClassSelectionClearEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassSelectionClearEventFieldCallback
-> a -> EventSelection -> m Bool
Gtk.Callbacks.dynamic_WidgetClassSelectionNotifyEventFieldCallback FunPtr C_WidgetClassSelectionClearEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSelectionClearEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSelectionClearEventFieldCallback
result
setWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback -> m ()
setWidgetClassSelectionNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSelectionClearEventFieldCallback -> m ()
setWidgetClassSelectionNotifyEvent WidgetClass
s FunPtr C_WidgetClassSelectionClearEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
528) (FunPtr C_WidgetClassSelectionClearEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback)
clearWidgetClassSelectionNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionNotifyEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
528) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionNotifyEventFieldInfo
instance AttrInfo WidgetClassSelectionNotifyEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassSelectionNotifyEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassSelectionNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassSelectionNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassSelectionNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionNotifyEventFieldCallback
type AttrTransferType WidgetClassSelectionNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionNotifyEventFieldCallback)
type AttrGetType WidgetClassSelectionNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionNotifyEventFieldCallback
type AttrLabel WidgetClassSelectionNotifyEventFieldInfo = "selection_notify_event"
type AttrOrigin WidgetClassSelectionNotifyEventFieldInfo = WidgetClass
attrGet = getWidgetClassSelectionNotifyEvent
attrSet = setWidgetClassSelectionNotifyEvent
attrConstruct = undefined
attrClear = clearWidgetClassSelectionNotifyEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassSelectionNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionNotifyEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.selectionNotifyEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:selectionNotifyEvent"
})
widgetClass_selectionNotifyEvent :: AttrLabelProxy "selectionNotifyEvent"
widgetClass_selectionNotifyEvent = AttrLabelProxy
#endif
getWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassProximityInEventFieldCallback)
getWidgetClassProximityInEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassProximityInEventFieldCallback)
getWidgetClassProximityInEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassProximityInEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
536) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback)
Maybe WidgetClassProximityInEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassProximityInEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassProximityInEventFieldCallback
val' -> do
let val'' :: WidgetClassProximityInEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassProximityInEventFieldCallback
-> a -> EventProximity -> m Bool
Gtk.Callbacks.dynamic_WidgetClassProximityInEventFieldCallback FunPtr C_WidgetClassProximityInEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassProximityInEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassProximityInEventFieldCallback
result
setWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback -> m ()
setWidgetClassProximityInEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassProximityInEventFieldCallback -> m ()
setWidgetClassProximityInEvent WidgetClass
s FunPtr C_WidgetClassProximityInEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
536) (FunPtr C_WidgetClassProximityInEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback)
clearWidgetClassProximityInEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassProximityInEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassProximityInEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
536) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassProximityInEventFieldInfo
instance AttrInfo WidgetClassProximityInEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassProximityInEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassProximityInEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassProximityInEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassProximityInEventFieldInfo = (~)Gtk.Callbacks.WidgetClassProximityInEventFieldCallback
type AttrTransferType WidgetClassProximityInEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassProximityInEventFieldCallback)
type AttrGetType WidgetClassProximityInEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassProximityInEventFieldCallback
type AttrLabel WidgetClassProximityInEventFieldInfo = "proximity_in_event"
type AttrOrigin WidgetClassProximityInEventFieldInfo = WidgetClass
attrGet = getWidgetClassProximityInEvent
attrSet = setWidgetClassProximityInEvent
attrConstruct = undefined
attrClear = clearWidgetClassProximityInEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassProximityInEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassProximityInEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.proximityInEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:proximityInEvent"
})
widgetClass_proximityInEvent :: AttrLabelProxy "proximityInEvent"
widgetClass_proximityInEvent = AttrLabelProxy
#endif
getWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassProximityOutEventFieldCallback)
getWidgetClassProximityOutEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassProximityInEventFieldCallback)
getWidgetClassProximityOutEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassProximityInEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
544) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback)
Maybe WidgetClassProximityInEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassProximityInEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassProximityInEventFieldCallback
val' -> do
let val'' :: WidgetClassProximityInEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassProximityInEventFieldCallback
-> a -> EventProximity -> m Bool
Gtk.Callbacks.dynamic_WidgetClassProximityOutEventFieldCallback FunPtr C_WidgetClassProximityInEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassProximityInEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassProximityInEventFieldCallback
result
setWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback -> m ()
setWidgetClassProximityOutEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassProximityInEventFieldCallback -> m ()
setWidgetClassProximityOutEvent WidgetClass
s FunPtr C_WidgetClassProximityInEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
544) (FunPtr C_WidgetClassProximityInEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback)
clearWidgetClassProximityOutEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassProximityOutEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassProximityOutEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
544) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassProximityOutEventFieldInfo
instance AttrInfo WidgetClassProximityOutEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassProximityOutEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassProximityOutEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassProximityOutEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassProximityOutEventFieldInfo = (~)Gtk.Callbacks.WidgetClassProximityOutEventFieldCallback
type AttrTransferType WidgetClassProximityOutEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassProximityOutEventFieldCallback)
type AttrGetType WidgetClassProximityOutEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassProximityOutEventFieldCallback
type AttrLabel WidgetClassProximityOutEventFieldInfo = "proximity_out_event"
type AttrOrigin WidgetClassProximityOutEventFieldInfo = WidgetClass
attrGet = getWidgetClassProximityOutEvent
attrSet = setWidgetClassProximityOutEvent
attrConstruct = undefined
attrClear = clearWidgetClassProximityOutEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassProximityOutEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassProximityOutEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.proximityOutEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:proximityOutEvent"
})
widgetClass_proximityOutEvent :: AttrLabelProxy "proximityOutEvent"
widgetClass_proximityOutEvent = AttrLabelProxy
#endif
getWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassVisibilityNotifyEventFieldCallback)
getWidgetClassVisibilityNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassVisibilityNotifyEventFieldCallback)
getWidgetClassVisibilityNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
552) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback)
Maybe WidgetClassVisibilityNotifyEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
val' -> do
let val'' :: WidgetClassVisibilityNotifyEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
-> a -> EventVisibility -> m Bool
Gtk.Callbacks.dynamic_WidgetClassVisibilityNotifyEventFieldCallback FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassVisibilityNotifyEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassVisibilityNotifyEventFieldCallback
result
setWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback -> m ()
setWidgetClassVisibilityNotifyEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback -> m ()
setWidgetClassVisibilityNotifyEvent WidgetClass
s FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
552) (FunPtr C_WidgetClassVisibilityNotifyEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback)
clearWidgetClassVisibilityNotifyEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassVisibilityNotifyEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassVisibilityNotifyEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
552) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassVisibilityNotifyEventFieldInfo
instance AttrInfo WidgetClassVisibilityNotifyEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassVisibilityNotifyEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassVisibilityNotifyEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassVisibilityNotifyEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassVisibilityNotifyEventFieldInfo = (~)Gtk.Callbacks.WidgetClassVisibilityNotifyEventFieldCallback
type AttrTransferType WidgetClassVisibilityNotifyEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassVisibilityNotifyEventFieldCallback)
type AttrGetType WidgetClassVisibilityNotifyEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassVisibilityNotifyEventFieldCallback
type AttrLabel WidgetClassVisibilityNotifyEventFieldInfo = "visibility_notify_event"
type AttrOrigin WidgetClassVisibilityNotifyEventFieldInfo = WidgetClass
attrGet = getWidgetClassVisibilityNotifyEvent
attrSet = setWidgetClassVisibilityNotifyEvent
attrConstruct = undefined
attrClear = clearWidgetClassVisibilityNotifyEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassVisibilityNotifyEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassVisibilityNotifyEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.visibilityNotifyEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:visibilityNotifyEvent"
})
widgetClass_visibilityNotifyEvent :: AttrLabelProxy "visibilityNotifyEvent"
widgetClass_visibilityNotifyEvent = AttrLabelProxy
#endif
getWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassWindowStateEventFieldCallback)
getWidgetClassWindowStateEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassWindowStateEventFieldCallback)
getWidgetClassWindowStateEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassWindowStateEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
560) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback)
Maybe WidgetClassWindowStateEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassWindowStateEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassWindowStateEventFieldCallback
val' -> do
let val'' :: WidgetClassWindowStateEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassWindowStateEventFieldCallback
-> a -> EventWindowState -> m Bool
Gtk.Callbacks.dynamic_WidgetClassWindowStateEventFieldCallback FunPtr C_WidgetClassWindowStateEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassWindowStateEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassWindowStateEventFieldCallback
result
setWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback -> m ()
setWidgetClassWindowStateEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassWindowStateEventFieldCallback -> m ()
setWidgetClassWindowStateEvent WidgetClass
s FunPtr C_WidgetClassWindowStateEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
560) (FunPtr C_WidgetClassWindowStateEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback)
clearWidgetClassWindowStateEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassWindowStateEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassWindowStateEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
560) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassWindowStateEventFieldInfo
instance AttrInfo WidgetClassWindowStateEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassWindowStateEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassWindowStateEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassWindowStateEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassWindowStateEventFieldInfo = (~)Gtk.Callbacks.WidgetClassWindowStateEventFieldCallback
type AttrTransferType WidgetClassWindowStateEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassWindowStateEventFieldCallback)
type AttrGetType WidgetClassWindowStateEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassWindowStateEventFieldCallback
type AttrLabel WidgetClassWindowStateEventFieldInfo = "window_state_event"
type AttrOrigin WidgetClassWindowStateEventFieldInfo = WidgetClass
attrGet = getWidgetClassWindowStateEvent
attrSet = setWidgetClassWindowStateEvent
attrConstruct = undefined
attrClear = clearWidgetClassWindowStateEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassWindowStateEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassWindowStateEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.windowStateEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:windowStateEvent"
})
widgetClass_windowStateEvent :: AttrLabelProxy "windowStateEvent"
widgetClass_windowStateEvent = AttrLabelProxy
#endif
getWidgetClassDamageEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDamageEventFieldCallback)
getWidgetClassDamageEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDamageEventFieldCallback)
getWidgetClassDamageEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDamageEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
568) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback)
Maybe WidgetClassDamageEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDamageEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDamageEventFieldCallback
val' -> do
let val'' :: WidgetClassDamageEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDamageEventFieldCallback
-> a -> EventExpose -> m Bool
Gtk.Callbacks.dynamic_WidgetClassDamageEventFieldCallback FunPtr C_WidgetClassDamageEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDamageEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDamageEventFieldCallback
result
setWidgetClassDamageEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback -> m ()
setWidgetClassDamageEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDamageEventFieldCallback -> m ()
setWidgetClassDamageEvent WidgetClass
s FunPtr C_WidgetClassDamageEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
568) (FunPtr C_WidgetClassDamageEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback)
clearWidgetClassDamageEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDamageEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDamageEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
568) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassDamageEventFieldInfo
instance AttrInfo WidgetClassDamageEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassDamageEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassDamageEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassDamageEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassDamageEventFieldInfo = (~)Gtk.Callbacks.WidgetClassDamageEventFieldCallback
type AttrTransferType WidgetClassDamageEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassDamageEventFieldCallback)
type AttrGetType WidgetClassDamageEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassDamageEventFieldCallback
type AttrLabel WidgetClassDamageEventFieldInfo = "damage_event"
type AttrOrigin WidgetClassDamageEventFieldInfo = WidgetClass
attrGet = getWidgetClassDamageEvent
attrSet = setWidgetClassDamageEvent
attrConstruct = undefined
attrClear = clearWidgetClassDamageEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassDamageEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassDamageEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.damageEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:damageEvent"
})
widgetClass_damageEvent :: AttrLabelProxy "damageEvent"
widgetClass_damageEvent = AttrLabelProxy
#endif
getWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGrabBrokenEventFieldCallback)
getWidgetClassGrabBrokenEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGrabBrokenEventFieldCallback)
getWidgetClassGrabBrokenEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassGrabBrokenEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
576) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback)
Maybe WidgetClassGrabBrokenEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGrabBrokenEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGrabBrokenEventFieldCallback
val' -> do
let val'' :: WidgetClassGrabBrokenEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGrabBrokenEventFieldCallback
-> a -> EventGrabBroken -> m Bool
Gtk.Callbacks.dynamic_WidgetClassGrabBrokenEventFieldCallback FunPtr C_WidgetClassGrabBrokenEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGrabBrokenEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGrabBrokenEventFieldCallback
result
setWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback -> m ()
setWidgetClassGrabBrokenEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassGrabBrokenEventFieldCallback -> m ()
setWidgetClassGrabBrokenEvent WidgetClass
s FunPtr C_WidgetClassGrabBrokenEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
576) (FunPtr C_WidgetClassGrabBrokenEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback)
clearWidgetClassGrabBrokenEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabBrokenEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGrabBrokenEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
576) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassGrabBrokenEventFieldInfo
instance AttrInfo WidgetClassGrabBrokenEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassGrabBrokenEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassGrabBrokenEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassGrabBrokenEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassGrabBrokenEventFieldInfo = (~)Gtk.Callbacks.WidgetClassGrabBrokenEventFieldCallback
type AttrTransferType WidgetClassGrabBrokenEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGrabBrokenEventFieldCallback)
type AttrGetType WidgetClassGrabBrokenEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassGrabBrokenEventFieldCallback
type AttrLabel WidgetClassGrabBrokenEventFieldInfo = "grab_broken_event"
type AttrOrigin WidgetClassGrabBrokenEventFieldInfo = WidgetClass
attrGet = getWidgetClassGrabBrokenEvent
attrSet = setWidgetClassGrabBrokenEvent
attrConstruct = undefined
attrClear = clearWidgetClassGrabBrokenEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassGrabBrokenEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassGrabBrokenEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.grabBrokenEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:grabBrokenEvent"
})
widgetClass_grabBrokenEvent :: AttrLabelProxy "grabBrokenEvent"
widgetClass_grabBrokenEvent = AttrLabelProxy
#endif
getWidgetClassSelectionGet :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSelectionGetFieldCallback)
getWidgetClassSelectionGet :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassSelectionGetFieldCallback)
getWidgetClassSelectionGet WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassSelectionGetFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
584) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback)
Maybe WidgetClassSelectionGetFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSelectionGetFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassSelectionGetFieldCallback
val' -> do
let val'' :: WidgetClassSelectionGetFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassSelectionGetFieldCallback
-> a -> SelectionData -> Word32 -> Word32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassSelectionGetFieldCallback FunPtr C_WidgetClassSelectionGetFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSelectionGetFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSelectionGetFieldCallback
result
setWidgetClassSelectionGet :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback -> m ()
setWidgetClassSelectionGet :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSelectionGetFieldCallback -> m ()
setWidgetClassSelectionGet WidgetClass
s FunPtr C_WidgetClassSelectionGetFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
584) (FunPtr C_WidgetClassSelectionGetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback)
clearWidgetClassSelectionGet :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionGet :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionGet WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
584) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionGetFieldInfo
instance AttrInfo WidgetClassSelectionGetFieldInfo where
type AttrBaseTypeConstraint WidgetClassSelectionGetFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassSelectionGetFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassSelectionGetFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback)
type AttrTransferTypeConstraint WidgetClassSelectionGetFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionGetFieldCallback
type AttrTransferType WidgetClassSelectionGetFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionGetFieldCallback)
type AttrGetType WidgetClassSelectionGetFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionGetFieldCallback
type AttrLabel WidgetClassSelectionGetFieldInfo = "selection_get"
type AttrOrigin WidgetClassSelectionGetFieldInfo = WidgetClass
attrGet = getWidgetClassSelectionGet
attrSet = setWidgetClassSelectionGet
attrConstruct = undefined
attrClear = clearWidgetClassSelectionGet
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassSelectionGetFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionGetFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.selectionGet"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:selectionGet"
})
widgetClass_selectionGet :: AttrLabelProxy "selectionGet"
widgetClass_selectionGet = AttrLabelProxy
#endif
getWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassSelectionReceivedFieldCallback)
getWidgetClassSelectionReceived :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassSelectionReceivedFieldCallback)
getWidgetClassSelectionReceived WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassSelectionReceivedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
592) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback)
Maybe WidgetClassSelectionReceivedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassSelectionReceivedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassSelectionReceivedFieldCallback
val' -> do
let val'' :: WidgetClassSelectionReceivedFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassSelectionReceivedFieldCallback
-> a -> SelectionData -> Word32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassSelectionReceivedFieldCallback FunPtr C_WidgetClassSelectionReceivedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassSelectionReceivedFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassSelectionReceivedFieldCallback
result
setWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback -> m ()
setWidgetClassSelectionReceived :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassSelectionReceivedFieldCallback -> m ()
setWidgetClassSelectionReceived WidgetClass
s FunPtr C_WidgetClassSelectionReceivedFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
592) (FunPtr C_WidgetClassSelectionReceivedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback)
clearWidgetClassSelectionReceived :: MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionReceived :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassSelectionReceived WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
592) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassSelectionReceivedFieldInfo
instance AttrInfo WidgetClassSelectionReceivedFieldInfo where
type AttrBaseTypeConstraint WidgetClassSelectionReceivedFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassSelectionReceivedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassSelectionReceivedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback)
type AttrTransferTypeConstraint WidgetClassSelectionReceivedFieldInfo = (~)Gtk.Callbacks.WidgetClassSelectionReceivedFieldCallback
type AttrTransferType WidgetClassSelectionReceivedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassSelectionReceivedFieldCallback)
type AttrGetType WidgetClassSelectionReceivedFieldInfo = Maybe Gtk.Callbacks.WidgetClassSelectionReceivedFieldCallback
type AttrLabel WidgetClassSelectionReceivedFieldInfo = "selection_received"
type AttrOrigin WidgetClassSelectionReceivedFieldInfo = WidgetClass
attrGet = getWidgetClassSelectionReceived
attrSet = setWidgetClassSelectionReceived
attrConstruct = undefined
attrClear = clearWidgetClassSelectionReceived
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassSelectionReceivedFieldCallback (Gtk.Callbacks.wrap_WidgetClassSelectionReceivedFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.selectionReceived"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:selectionReceived"
})
widgetClass_selectionReceived :: AttrLabelProxy "selectionReceived"
widgetClass_selectionReceived = AttrLabelProxy
#endif
getWidgetClassDragBegin :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragBeginFieldCallback)
getWidgetClassDragBegin :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDragBeginFieldCallback)
getWidgetClassDragBegin WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDragBeginFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
600) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)
Maybe WidgetClassDragBeginFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragBeginFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragBeginFieldCallback
val' -> do
let val'' :: WidgetClassDragBeginFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragBeginFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassDragBeginFieldCallback FunPtr C_WidgetClassDragBeginFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragBeginFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragBeginFieldCallback
result
setWidgetClassDragBegin :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragBegin :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragBegin WidgetClass
s FunPtr C_WidgetClassDragBeginFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
600) (FunPtr C_WidgetClassDragBeginFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragBeginFieldCallback)
clearWidgetClassDragBegin :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragBegin :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDragBegin WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
600) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dragBegin"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dragBegin"
})
widgetClass_dragBegin :: AttrLabelProxy "dragBegin"
widgetClass_dragBegin = AttrLabelProxy
#endif
getWidgetClassDragEnd :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragEndFieldCallback)
getWidgetClassDragEnd :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDragBeginFieldCallback)
getWidgetClassDragEnd WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDragBeginFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
608) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)
Maybe WidgetClassDragBeginFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragBeginFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragBeginFieldCallback
val' -> do
let val'' :: WidgetClassDragBeginFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragBeginFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassDragEndFieldCallback FunPtr C_WidgetClassDragBeginFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragBeginFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragBeginFieldCallback
result
setWidgetClassDragEnd :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback -> m ()
setWidgetClassDragEnd :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragEnd WidgetClass
s FunPtr C_WidgetClassDragBeginFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
608) (FunPtr C_WidgetClassDragBeginFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragEndFieldCallback)
clearWidgetClassDragEnd :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragEnd :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDragEnd WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
608) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dragEnd"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dragEnd"
})
widgetClass_dragEnd :: AttrLabelProxy "dragEnd"
widgetClass_dragEnd = AttrLabelProxy
#endif
getWidgetClassDragDataGet :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragDataGetFieldCallback)
getWidgetClassDragDataGet :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDragDataGetFieldCallback)
getWidgetClassDragDataGet WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDragDataGetFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
616) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)
Maybe WidgetClassDragDataGetFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragDataGetFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragDataGetFieldCallback
val' -> do
let val'' :: WidgetClassDragDataGetFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragDataGetFieldCallback
-> a -> b -> SelectionData -> Word32 -> Word32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassDragDataGetFieldCallback FunPtr C_WidgetClassDragDataGetFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragDataGetFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragDataGetFieldCallback
result
setWidgetClassDragDataGet :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback -> m ()
setWidgetClassDragDataGet :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDragDataGetFieldCallback -> m ()
setWidgetClassDragDataGet WidgetClass
s FunPtr C_WidgetClassDragDataGetFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
616) (FunPtr C_WidgetClassDragDataGetFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataGetFieldCallback)
clearWidgetClassDragDataGet :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataGet :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataGet WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
616) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dragDataGet"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dragDataGet"
})
widgetClass_dragDataGet :: AttrLabelProxy "dragDataGet"
widgetClass_dragDataGet = AttrLabelProxy
#endif
getWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragDataDeleteFieldCallback)
getWidgetClassDragDataDelete :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDragBeginFieldCallback)
getWidgetClassDragDataDelete WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDragBeginFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
624) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)
Maybe WidgetClassDragBeginFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragBeginFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragBeginFieldCallback
val' -> do
let val'' :: WidgetClassDragBeginFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragBeginFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassDragDataDeleteFieldCallback FunPtr C_WidgetClassDragBeginFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragBeginFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragBeginFieldCallback
result
setWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback -> m ()
setWidgetClassDragDataDelete :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDragBeginFieldCallback -> m ()
setWidgetClassDragDataDelete WidgetClass
s FunPtr C_WidgetClassDragBeginFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
624) (FunPtr C_WidgetClassDragBeginFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataDeleteFieldCallback)
clearWidgetClassDragDataDelete :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataDelete :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataDelete WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
624) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dragDataDelete"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dragDataDelete"
})
widgetClass_dragDataDelete :: AttrLabelProxy "dragDataDelete"
widgetClass_dragDataDelete = AttrLabelProxy
#endif
getWidgetClassDragLeave :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragLeaveFieldCallback)
getWidgetClassDragLeave :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDragLeaveFieldCallback)
getWidgetClassDragLeave WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDragLeaveFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
632) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)
Maybe WidgetClassDragLeaveFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragLeaveFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragLeaveFieldCallback
val' -> do
let val'' :: WidgetClassDragLeaveFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragLeaveFieldCallback
-> a -> b -> Word32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassDragLeaveFieldCallback FunPtr C_WidgetClassDragLeaveFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragLeaveFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragLeaveFieldCallback
result
setWidgetClassDragLeave :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback -> m ()
setWidgetClassDragLeave :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDragLeaveFieldCallback -> m ()
setWidgetClassDragLeave WidgetClass
s FunPtr C_WidgetClassDragLeaveFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
632) (FunPtr C_WidgetClassDragLeaveFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragLeaveFieldCallback)
clearWidgetClassDragLeave :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragLeave :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDragLeave WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
632) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dragLeave"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dragLeave"
})
widgetClass_dragLeave :: AttrLabelProxy "dragLeave"
widgetClass_dragLeave = AttrLabelProxy
#endif
getWidgetClassDragMotion :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragMotionFieldCallback)
getWidgetClassDragMotion :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDragMotionFieldCallback)
getWidgetClassDragMotion WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDragMotionFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
640) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)
Maybe WidgetClassDragMotionFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragMotionFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragMotionFieldCallback
val' -> do
let val'' :: WidgetClassDragMotionFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragMotionFieldCallback
-> a -> b -> Int32 -> Int32 -> Word32 -> m Bool
Gtk.Callbacks.dynamic_WidgetClassDragMotionFieldCallback FunPtr C_WidgetClassDragMotionFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragMotionFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragMotionFieldCallback
result
setWidgetClassDragMotion :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback -> m ()
setWidgetClassDragMotion :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDragMotionFieldCallback -> m ()
setWidgetClassDragMotion WidgetClass
s FunPtr C_WidgetClassDragMotionFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
640) (FunPtr C_WidgetClassDragMotionFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragMotionFieldCallback)
clearWidgetClassDragMotion :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragMotion :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDragMotion WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
640) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dragMotion"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dragMotion"
})
widgetClass_dragMotion :: AttrLabelProxy "dragMotion"
widgetClass_dragMotion = AttrLabelProxy
#endif
getWidgetClassDragDrop :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragDropFieldCallback)
getWidgetClassDragDrop :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDragMotionFieldCallback)
getWidgetClassDragDrop WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDragMotionFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
648) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)
Maybe WidgetClassDragMotionFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragMotionFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragMotionFieldCallback
val' -> do
let val'' :: WidgetClassDragMotionFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragMotionFieldCallback
-> a -> b -> Int32 -> Int32 -> Word32 -> m Bool
Gtk.Callbacks.dynamic_WidgetClassDragDropFieldCallback FunPtr C_WidgetClassDragMotionFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragMotionFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragMotionFieldCallback
result
setWidgetClassDragDrop :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback -> m ()
setWidgetClassDragDrop :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDragMotionFieldCallback -> m ()
setWidgetClassDragDrop WidgetClass
s FunPtr C_WidgetClassDragMotionFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
648) (FunPtr C_WidgetClassDragMotionFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDropFieldCallback)
clearWidgetClassDragDrop :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDrop :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDrop WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
648) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dragDrop"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dragDrop"
})
widgetClass_dragDrop :: AttrLabelProxy "dragDrop"
widgetClass_dragDrop = AttrLabelProxy
#endif
getWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragDataReceivedFieldCallback)
getWidgetClassDragDataReceived :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDragDataReceivedFieldCallback)
getWidgetClassDragDataReceived WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDragDataReceivedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
656) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)
Maybe WidgetClassDragDataReceivedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragDataReceivedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragDataReceivedFieldCallback
val' -> do
let val'' :: WidgetClassDragDataReceivedFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragDataReceivedFieldCallback
-> a
-> b
-> Int32
-> Int32
-> SelectionData
-> Word32
-> Word32
-> m ()
Gtk.Callbacks.dynamic_WidgetClassDragDataReceivedFieldCallback FunPtr C_WidgetClassDragDataReceivedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragDataReceivedFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragDataReceivedFieldCallback
result
setWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback -> m ()
setWidgetClassDragDataReceived :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassDragDataReceivedFieldCallback -> m ()
setWidgetClassDragDataReceived WidgetClass
s FunPtr C_WidgetClassDragDataReceivedFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
656) (FunPtr C_WidgetClassDragDataReceivedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragDataReceivedFieldCallback)
clearWidgetClassDragDataReceived :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataReceived :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDragDataReceived WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
656) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dragDataReceived"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dragDataReceived"
})
widgetClass_dragDataReceived :: AttrLabelProxy "dragDataReceived"
widgetClass_dragDataReceived = AttrLabelProxy
#endif
getWidgetClassDragFailed :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassDragFailedFieldCallback)
getWidgetClassDragFailed :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDragFailedFieldCallback)
getWidgetClassDragFailed WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDragFailedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
664) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)
Maybe WidgetClassDragFailedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDragFailedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDragFailedFieldCallback
val' -> do
let val'' :: WidgetClassDragFailedFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsDragContext b) =>
FunPtr C_WidgetClassDragFailedFieldCallback
-> a -> b -> DragResult -> m Bool
Gtk.Callbacks.dynamic_WidgetClassDragFailedFieldCallback FunPtr C_WidgetClassDragFailedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDragFailedFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDragFailedFieldCallback
result
setWidgetClassDragFailed :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback -> m ()
setWidgetClassDragFailed :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDragFailedFieldCallback -> m ()
setWidgetClassDragFailed WidgetClass
s FunPtr C_WidgetClassDragFailedFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
664) (FunPtr C_WidgetClassDragFailedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassDragFailedFieldCallback)
clearWidgetClassDragFailed :: MonadIO m => WidgetClass -> m ()
clearWidgetClassDragFailed :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassDragFailed WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
664) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.dragFailed"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:dragFailed"
})
widgetClass_dragFailed :: AttrLabelProxy "dragFailed"
widgetClass_dragFailed = AttrLabelProxy
#endif
getWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassPopupMenuFieldCallback)
WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassPopupMenuFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
672) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)
Maybe WidgetClassPopupMenuFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassPopupMenuFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassPopupMenuFieldCallback
val' -> do
let val'' :: WidgetClassPopupMenuFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassPopupMenuFieldCallback -> a -> m Bool
Gtk.Callbacks.dynamic_WidgetClassPopupMenuFieldCallback FunPtr C_WidgetClassPopupMenuFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassPopupMenuFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassPopupMenuFieldCallback
result
setWidgetClassPopupMenu :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback -> m ()
WidgetClass
s FunPtr C_WidgetClassPopupMenuFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
672) (FunPtr C_WidgetClassPopupMenuFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassPopupMenuFieldCallback)
clearWidgetClassPopupMenu :: MonadIO m => WidgetClass -> m ()
WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
672) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.popupMenu"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:popupMenu"
})
widgetClass_popupMenu :: AttrLabelProxy "popupMenu"
widgetClass_popupMenu = AttrLabelProxy
#endif
getWidgetClassShowHelp :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassShowHelpFieldCallback)
getWidgetClassShowHelp :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassShowHelpFieldCallback)
getWidgetClassShowHelp WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassFocusFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
680) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)
Maybe WidgetClassShowHelpFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassFocusFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassFocusFieldCallback
val' -> do
let val'' :: WidgetClassShowHelpFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassFocusFieldCallback
-> a -> WidgetHelpType -> m Bool
Gtk.Callbacks.dynamic_WidgetClassShowHelpFieldCallback FunPtr C_WidgetClassFocusFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassShowHelpFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassShowHelpFieldCallback
result
setWidgetClassShowHelp :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback -> m ()
setWidgetClassShowHelp :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassFocusFieldCallback -> m ()
setWidgetClassShowHelp WidgetClass
s FunPtr C_WidgetClassFocusFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
680) (FunPtr C_WidgetClassFocusFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)
clearWidgetClassShowHelp :: MonadIO m => WidgetClass -> m ()
clearWidgetClassShowHelp :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassShowHelp WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
680) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassShowHelpFieldInfo
instance AttrInfo WidgetClassShowHelpFieldInfo where
type AttrBaseTypeConstraint WidgetClassShowHelpFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassShowHelpFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassShowHelpFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)
type AttrTransferTypeConstraint WidgetClassShowHelpFieldInfo = (~)Gtk.Callbacks.WidgetClassShowHelpFieldCallback
type AttrTransferType WidgetClassShowHelpFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassShowHelpFieldCallback)
type AttrGetType WidgetClassShowHelpFieldInfo = Maybe Gtk.Callbacks.WidgetClassShowHelpFieldCallback
type AttrLabel WidgetClassShowHelpFieldInfo = "show_help"
type AttrOrigin WidgetClassShowHelpFieldInfo = WidgetClass
attrGet = getWidgetClassShowHelp
attrSet = setWidgetClassShowHelp
attrConstruct = undefined
attrClear = clearWidgetClassShowHelp
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassShowHelpFieldCallback (Gtk.Callbacks.wrap_WidgetClassShowHelpFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.showHelp"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:showHelp"
})
widgetClass_showHelp :: AttrLabelProxy "showHelp"
widgetClass_showHelp = AttrLabelProxy
#endif
getWidgetClassGetAccessible :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetAccessibleFieldCallback)
getWidgetClassGetAccessible :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassGetAccessibleFieldCallback)
getWidgetClassGetAccessible WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassGetAccessibleFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
688) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)
Maybe WidgetClassGetAccessibleFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassGetAccessibleFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassGetAccessibleFieldCallback
val' -> do
let val'' :: WidgetClassGetAccessibleFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassGetAccessibleFieldCallback -> a -> m Object
Gtk.Callbacks.dynamic_WidgetClassGetAccessibleFieldCallback FunPtr C_WidgetClassGetAccessibleFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetAccessibleFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGetAccessibleFieldCallback
result
setWidgetClassGetAccessible :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback -> m ()
setWidgetClassGetAccessible :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassGetAccessibleFieldCallback -> m ()
setWidgetClassGetAccessible WidgetClass
s FunPtr C_WidgetClassGetAccessibleFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
688) (FunPtr C_WidgetClassGetAccessibleFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetAccessibleFieldCallback)
clearWidgetClassGetAccessible :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetAccessible :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGetAccessible WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
688) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.getAccessible"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:getAccessible"
})
widgetClass_getAccessible :: AttrLabelProxy "getAccessible"
widgetClass_getAccessible = AttrLabelProxy
#endif
getWidgetClassScreenChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassScreenChangedFieldCallback)
getWidgetClassScreenChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassScreenChangedFieldCallback)
getWidgetClassScreenChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassScreenChangedFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
696) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)
Maybe WidgetClassScreenChangedFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassScreenChangedFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassScreenChangedFieldCallback
val' -> do
let val'' :: WidgetClassScreenChangedFieldCallback
val'' = forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsWidget a, IsScreen b) =>
FunPtr C_WidgetClassScreenChangedFieldCallback -> a -> b -> m ()
Gtk.Callbacks.dynamic_WidgetClassScreenChangedFieldCallback FunPtr C_WidgetClassScreenChangedFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassScreenChangedFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassScreenChangedFieldCallback
result
setWidgetClassScreenChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback -> m ()
setWidgetClassScreenChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassScreenChangedFieldCallback -> m ()
setWidgetClassScreenChanged WidgetClass
s FunPtr C_WidgetClassScreenChangedFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
696) (FunPtr C_WidgetClassScreenChangedFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)
clearWidgetClassScreenChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassScreenChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassScreenChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
696) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassScreenChangedFieldInfo
instance AttrInfo WidgetClassScreenChangedFieldInfo where
type AttrBaseTypeConstraint WidgetClassScreenChangedFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassScreenChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassScreenChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)
type AttrTransferTypeConstraint WidgetClassScreenChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassScreenChangedFieldCallback
type AttrTransferType WidgetClassScreenChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassScreenChangedFieldCallback)
type AttrGetType WidgetClassScreenChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassScreenChangedFieldCallback
type AttrLabel WidgetClassScreenChangedFieldInfo = "screen_changed"
type AttrOrigin WidgetClassScreenChangedFieldInfo = WidgetClass
attrGet = getWidgetClassScreenChanged
attrSet = setWidgetClassScreenChanged
attrConstruct = undefined
attrClear = clearWidgetClassScreenChanged
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassScreenChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassScreenChangedFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.screenChanged"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:screenChanged"
})
widgetClass_screenChanged :: AttrLabelProxy "screenChanged"
widgetClass_screenChanged = AttrLabelProxy
#endif
getWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassCanActivateAccelFieldCallback)
getWidgetClassCanActivateAccel :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassCanActivateAccelFieldCallback)
getWidgetClassCanActivateAccel WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassCanActivateAccelFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
704) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)
Maybe WidgetClassCanActivateAccelFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassCanActivateAccelFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassCanActivateAccelFieldCallback
val' -> do
let val'' :: WidgetClassCanActivateAccelFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassCanActivateAccelFieldCallback
-> a -> Word32 -> m Bool
Gtk.Callbacks.dynamic_WidgetClassCanActivateAccelFieldCallback FunPtr C_WidgetClassCanActivateAccelFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassCanActivateAccelFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassCanActivateAccelFieldCallback
result
setWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback -> m ()
setWidgetClassCanActivateAccel :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassCanActivateAccelFieldCallback -> m ()
setWidgetClassCanActivateAccel WidgetClass
s FunPtr C_WidgetClassCanActivateAccelFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
704) (FunPtr C_WidgetClassCanActivateAccelFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassCanActivateAccelFieldCallback)
clearWidgetClassCanActivateAccel :: MonadIO m => WidgetClass -> m ()
clearWidgetClassCanActivateAccel :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassCanActivateAccel WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
704) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.canActivateAccel"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:canActivateAccel"
})
widgetClass_canActivateAccel :: AttrLabelProxy "canActivateAccel"
widgetClass_canActivateAccel = AttrLabelProxy
#endif
getWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassCompositedChangedFieldCallback)
getWidgetClassCompositedChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassCompositedChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
712) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassCompositedChangedFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback -> m ()
setWidgetClassCompositedChanged :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassCompositedChanged WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
712) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)
clearWidgetClassCompositedChanged :: MonadIO m => WidgetClass -> m ()
clearWidgetClassCompositedChanged :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassCompositedChanged WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
712) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassCompositedChangedFieldInfo
instance AttrInfo WidgetClassCompositedChangedFieldInfo where
type AttrBaseTypeConstraint WidgetClassCompositedChangedFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassCompositedChangedFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassCompositedChangedFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)
type AttrTransferTypeConstraint WidgetClassCompositedChangedFieldInfo = (~)Gtk.Callbacks.WidgetClassCompositedChangedFieldCallback
type AttrTransferType WidgetClassCompositedChangedFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassCompositedChangedFieldCallback)
type AttrGetType WidgetClassCompositedChangedFieldInfo = Maybe Gtk.Callbacks.WidgetClassCompositedChangedFieldCallback
type AttrLabel WidgetClassCompositedChangedFieldInfo = "composited_changed"
type AttrOrigin WidgetClassCompositedChangedFieldInfo = WidgetClass
attrGet = getWidgetClassCompositedChanged
attrSet = setWidgetClassCompositedChanged
attrConstruct = undefined
attrClear = clearWidgetClassCompositedChanged
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassCompositedChangedFieldCallback (Gtk.Callbacks.wrap_WidgetClassCompositedChangedFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.compositedChanged"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:compositedChanged"
})
widgetClass_compositedChanged :: AttrLabelProxy "compositedChanged"
widgetClass_compositedChanged = AttrLabelProxy
#endif
getWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassQueryTooltipFieldCallback)
getWidgetClassQueryTooltip :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassQueryTooltipFieldCallback)
getWidgetClassQueryTooltip WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassQueryTooltipFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
720) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
Maybe WidgetClassQueryTooltipFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassQueryTooltipFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassQueryTooltipFieldCallback
val' -> do
let val'' :: WidgetClassQueryTooltipFieldCallback
val'' = 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'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassQueryTooltipFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassQueryTooltipFieldCallback
result
setWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback -> m ()
setWidgetClassQueryTooltip :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassQueryTooltipFieldCallback -> m ()
setWidgetClassQueryTooltip WidgetClass
s FunPtr C_WidgetClassQueryTooltipFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
720) (FunPtr C_WidgetClassQueryTooltipFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassQueryTooltipFieldCallback)
clearWidgetClassQueryTooltip :: MonadIO m => WidgetClass -> m ()
clearWidgetClassQueryTooltip :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassQueryTooltip WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
720) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.queryTooltip"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:queryTooltip"
})
widgetClass_queryTooltip :: AttrLabelProxy "queryTooltip"
widgetClass_queryTooltip = AttrLabelProxy
#endif
getWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassComputeExpandFieldCallback)
getWidgetClassComputeExpand :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassComputeExpandFieldCallback)
getWidgetClassComputeExpand WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassComputeExpandFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
728) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
Maybe WidgetClassComputeExpandFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassComputeExpandFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassComputeExpandFieldCallback
val' -> do
let val'' :: WidgetClassComputeExpandFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassComputeExpandFieldCallback
-> a -> Bool -> Bool -> m ()
Gtk.Callbacks.dynamic_WidgetClassComputeExpandFieldCallback FunPtr C_WidgetClassComputeExpandFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassComputeExpandFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassComputeExpandFieldCallback
result
setWidgetClassComputeExpand :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback -> m ()
setWidgetClassComputeExpand :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassComputeExpandFieldCallback -> m ()
setWidgetClassComputeExpand WidgetClass
s FunPtr C_WidgetClassComputeExpandFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
728) (FunPtr C_WidgetClassComputeExpandFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassComputeExpandFieldCallback)
clearWidgetClassComputeExpand :: MonadIO m => WidgetClass -> m ()
clearWidgetClassComputeExpand :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassComputeExpand WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
728) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.computeExpand"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:computeExpand"
})
widgetClass_computeExpand :: AttrLabelProxy "computeExpand"
widgetClass_computeExpand = AttrLabelProxy
#endif
getWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassAdjustSizeRequestFieldCallback)
getWidgetClassAdjustSizeRequest :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassAdjustSizeRequestFieldCallback)
getWidgetClassAdjustSizeRequest WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
736) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback)
Maybe WidgetClassAdjustSizeRequestFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
val' -> do
let val'' :: WidgetClassAdjustSizeRequestFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
-> a -> Orientation -> Int32 -> Int32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassAdjustSizeRequestFieldCallback FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassAdjustSizeRequestFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassAdjustSizeRequestFieldCallback
result
setWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback -> m ()
setWidgetClassAdjustSizeRequest :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassAdjustSizeRequestFieldCallback -> m ()
setWidgetClassAdjustSizeRequest WidgetClass
s FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
736) (FunPtr C_WidgetClassAdjustSizeRequestFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback)
clearWidgetClassAdjustSizeRequest :: MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustSizeRequest :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustSizeRequest WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
736) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassAdjustSizeRequestFieldInfo
instance AttrInfo WidgetClassAdjustSizeRequestFieldInfo where
type AttrBaseTypeConstraint WidgetClassAdjustSizeRequestFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassAdjustSizeRequestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassAdjustSizeRequestFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback)
type AttrTransferTypeConstraint WidgetClassAdjustSizeRequestFieldInfo = (~)Gtk.Callbacks.WidgetClassAdjustSizeRequestFieldCallback
type AttrTransferType WidgetClassAdjustSizeRequestFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeRequestFieldCallback)
type AttrGetType WidgetClassAdjustSizeRequestFieldInfo = Maybe Gtk.Callbacks.WidgetClassAdjustSizeRequestFieldCallback
type AttrLabel WidgetClassAdjustSizeRequestFieldInfo = "adjust_size_request"
type AttrOrigin WidgetClassAdjustSizeRequestFieldInfo = WidgetClass
attrGet = getWidgetClassAdjustSizeRequest
attrSet = setWidgetClassAdjustSizeRequest
attrConstruct = undefined
attrClear = clearWidgetClassAdjustSizeRequest
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassAdjustSizeRequestFieldCallback (Gtk.Callbacks.wrap_WidgetClassAdjustSizeRequestFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.adjustSizeRequest"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:adjustSizeRequest"
})
widgetClass_adjustSizeRequest :: AttrLabelProxy "adjustSizeRequest"
widgetClass_adjustSizeRequest = AttrLabelProxy
#endif
getWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassAdjustSizeAllocationFieldCallback)
getWidgetClassAdjustSizeAllocation :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassAdjustSizeAllocationFieldCallback)
getWidgetClassAdjustSizeAllocation WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
744) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback)
Maybe WidgetClassAdjustSizeAllocationFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
val' -> do
let val'' :: WidgetClassAdjustSizeAllocationFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
-> a -> Orientation -> Int32 -> Int32 -> Int32 -> Int32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassAdjustSizeAllocationFieldCallback FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassAdjustSizeAllocationFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassAdjustSizeAllocationFieldCallback
result
setWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback -> m ()
setWidgetClassAdjustSizeAllocation :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback -> m ()
setWidgetClassAdjustSizeAllocation WidgetClass
s FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
744) (FunPtr C_WidgetClassAdjustSizeAllocationFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback)
clearWidgetClassAdjustSizeAllocation :: MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustSizeAllocation :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustSizeAllocation WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
744) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassAdjustSizeAllocationFieldInfo
instance AttrInfo WidgetClassAdjustSizeAllocationFieldInfo where
type AttrBaseTypeConstraint WidgetClassAdjustSizeAllocationFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassAdjustSizeAllocationFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassAdjustSizeAllocationFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback)
type AttrTransferTypeConstraint WidgetClassAdjustSizeAllocationFieldInfo = (~)Gtk.Callbacks.WidgetClassAdjustSizeAllocationFieldCallback
type AttrTransferType WidgetClassAdjustSizeAllocationFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassAdjustSizeAllocationFieldCallback)
type AttrGetType WidgetClassAdjustSizeAllocationFieldInfo = Maybe Gtk.Callbacks.WidgetClassAdjustSizeAllocationFieldCallback
type AttrLabel WidgetClassAdjustSizeAllocationFieldInfo = "adjust_size_allocation"
type AttrOrigin WidgetClassAdjustSizeAllocationFieldInfo = WidgetClass
attrGet = getWidgetClassAdjustSizeAllocation
attrSet = setWidgetClassAdjustSizeAllocation
attrConstruct = undefined
attrClear = clearWidgetClassAdjustSizeAllocation
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassAdjustSizeAllocationFieldCallback (Gtk.Callbacks.wrap_WidgetClassAdjustSizeAllocationFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.adjustSizeAllocation"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:adjustSizeAllocation"
})
widgetClass_adjustSizeAllocation :: AttrLabelProxy "adjustSizeAllocation"
widgetClass_adjustSizeAllocation = AttrLabelProxy
#endif
getWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassStyleUpdatedFieldCallback)
getWidgetClassStyleUpdated :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassDestroyFieldCallback)
getWidgetClassStyleUpdated WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassDestroyFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
752) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)
Maybe WidgetClassDestroyFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassDestroyFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassDestroyFieldCallback
val' -> do
let val'' :: WidgetClassDestroyFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassDestroyFieldCallback -> a -> m ()
Gtk.Callbacks.dynamic_WidgetClassStyleUpdatedFieldCallback FunPtr C_WidgetClassDestroyFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassDestroyFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassDestroyFieldCallback
result
setWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback -> m ()
setWidgetClassStyleUpdated :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassDestroyFieldCallback -> m ()
setWidgetClassStyleUpdated WidgetClass
s FunPtr C_WidgetClassDestroyFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
752) (FunPtr C_WidgetClassDestroyFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassStyleUpdatedFieldCallback)
clearWidgetClassStyleUpdated :: MonadIO m => WidgetClass -> m ()
clearWidgetClassStyleUpdated :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassStyleUpdated WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
752) (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)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.styleUpdated"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:styleUpdated"
})
widgetClass_styleUpdated :: AttrLabelProxy "styleUpdated"
widgetClass_styleUpdated = AttrLabelProxy
#endif
getWidgetClassTouchEvent :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassTouchEventFieldCallback)
getWidgetClassTouchEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassTouchEventFieldCallback)
getWidgetClassTouchEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassTouchEventFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
760) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback)
Maybe WidgetClassTouchEventFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassTouchEventFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassTouchEventFieldCallback
val' -> do
let val'' :: WidgetClassTouchEventFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassTouchEventFieldCallback
-> a -> EventTouch -> m Bool
Gtk.Callbacks.dynamic_WidgetClassTouchEventFieldCallback FunPtr C_WidgetClassTouchEventFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassTouchEventFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassTouchEventFieldCallback
result
setWidgetClassTouchEvent :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback -> m ()
setWidgetClassTouchEvent :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> FunPtr C_WidgetClassTouchEventFieldCallback -> m ()
setWidgetClassTouchEvent WidgetClass
s FunPtr C_WidgetClassTouchEventFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
760) (FunPtr C_WidgetClassTouchEventFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback)
clearWidgetClassTouchEvent :: MonadIO m => WidgetClass -> m ()
clearWidgetClassTouchEvent :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassTouchEvent WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
760) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassTouchEventFieldInfo
instance AttrInfo WidgetClassTouchEventFieldInfo where
type AttrBaseTypeConstraint WidgetClassTouchEventFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassTouchEventFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassTouchEventFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback)
type AttrTransferTypeConstraint WidgetClassTouchEventFieldInfo = (~)Gtk.Callbacks.WidgetClassTouchEventFieldCallback
type AttrTransferType WidgetClassTouchEventFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassTouchEventFieldCallback)
type AttrGetType WidgetClassTouchEventFieldInfo = Maybe Gtk.Callbacks.WidgetClassTouchEventFieldCallback
type AttrLabel WidgetClassTouchEventFieldInfo = "touch_event"
type AttrOrigin WidgetClassTouchEventFieldInfo = WidgetClass
attrGet = getWidgetClassTouchEvent
attrSet = setWidgetClassTouchEvent
attrConstruct = undefined
attrClear = clearWidgetClassTouchEvent
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassTouchEventFieldCallback (Gtk.Callbacks.wrap_WidgetClassTouchEventFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.touchEvent"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:touchEvent"
})
widgetClass_touchEvent :: AttrLabelProxy "touchEvent"
widgetClass_touchEvent = AttrLabelProxy
#endif
getWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
getWidgetClassGetPreferredHeightAndBaselineForWidth :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe
WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
getWidgetClassGetPreferredHeightAndBaselineForWidth WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr
C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
768) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr
C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr
C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val' -> do
let val'' :: WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr
C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
-> a -> Int32 -> m (Int32, Int32, Int32, Int32)
Gtk.Callbacks.dynamic_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback FunPtr
C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
result
setWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback -> m ()
setWidgetClassGetPreferredHeightAndBaselineForWidth :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr
C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
-> m ()
setWidgetClassGetPreferredHeightAndBaselineForWidth WidgetClass
s FunPtr
C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
768) (FunPtr
C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
clearWidgetClassGetPreferredHeightAndBaselineForWidth :: MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredHeightAndBaselineForWidth :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassGetPreferredHeightAndBaselineForWidth WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
768) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo
instance AttrInfo WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo where
type AttrBaseTypeConstraint WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
type AttrTransferTypeConstraint WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = (~)Gtk.Callbacks.WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
type AttrTransferType WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback)
type AttrGetType WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = Maybe Gtk.Callbacks.WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback
type AttrLabel WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = "get_preferred_height_and_baseline_for_width"
type AttrOrigin WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo = WidgetClass
attrGet = getWidgetClassGetPreferredHeightAndBaselineForWidth
attrSet = setWidgetClassGetPreferredHeightAndBaselineForWidth
attrConstruct = undefined
attrClear = clearWidgetClassGetPreferredHeightAndBaselineForWidth
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback (Gtk.Callbacks.wrap_WidgetClassGetPreferredHeightAndBaselineForWidthFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.getPreferredHeightAndBaselineForWidth"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:getPreferredHeightAndBaselineForWidth"
})
widgetClass_getPreferredHeightAndBaselineForWidth :: AttrLabelProxy "getPreferredHeightAndBaselineForWidth"
widgetClass_getPreferredHeightAndBaselineForWidth = AttrLabelProxy
#endif
getWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassAdjustBaselineRequestFieldCallback)
getWidgetClassAdjustBaselineRequest :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassAdjustBaselineRequestFieldCallback)
getWidgetClassAdjustBaselineRequest WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
776) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback)
Maybe WidgetClassAdjustBaselineRequestFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
val' -> do
let val'' :: WidgetClassAdjustBaselineRequestFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
-> a -> Int32 -> Int32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassAdjustBaselineRequestFieldCallback FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassAdjustBaselineRequestFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassAdjustBaselineRequestFieldCallback
result
setWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback -> m ()
setWidgetClassAdjustBaselineRequest :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback -> m ()
setWidgetClassAdjustBaselineRequest WidgetClass
s FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
776) (FunPtr C_WidgetClassAdjustBaselineRequestFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback)
clearWidgetClassAdjustBaselineRequest :: MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustBaselineRequest :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustBaselineRequest WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
776) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassAdjustBaselineRequestFieldInfo
instance AttrInfo WidgetClassAdjustBaselineRequestFieldInfo where
type AttrBaseTypeConstraint WidgetClassAdjustBaselineRequestFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassAdjustBaselineRequestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassAdjustBaselineRequestFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback)
type AttrTransferTypeConstraint WidgetClassAdjustBaselineRequestFieldInfo = (~)Gtk.Callbacks.WidgetClassAdjustBaselineRequestFieldCallback
type AttrTransferType WidgetClassAdjustBaselineRequestFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineRequestFieldCallback)
type AttrGetType WidgetClassAdjustBaselineRequestFieldInfo = Maybe Gtk.Callbacks.WidgetClassAdjustBaselineRequestFieldCallback
type AttrLabel WidgetClassAdjustBaselineRequestFieldInfo = "adjust_baseline_request"
type AttrOrigin WidgetClassAdjustBaselineRequestFieldInfo = WidgetClass
attrGet = getWidgetClassAdjustBaselineRequest
attrSet = setWidgetClassAdjustBaselineRequest
attrConstruct = undefined
attrClear = clearWidgetClassAdjustBaselineRequest
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassAdjustBaselineRequestFieldCallback (Gtk.Callbacks.wrap_WidgetClassAdjustBaselineRequestFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.adjustBaselineRequest"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:adjustBaselineRequest"
})
widgetClass_adjustBaselineRequest :: AttrLabelProxy "adjustBaselineRequest"
widgetClass_adjustBaselineRequest = AttrLabelProxy
#endif
getWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassAdjustBaselineAllocationFieldCallback)
getWidgetClassAdjustBaselineAllocation :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> m (Maybe WidgetClassAdjustBaselineAllocationFieldCallback)
getWidgetClassAdjustBaselineAllocation WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
784) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback)
Maybe WidgetClassAdjustBaselineAllocationFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
val' -> do
let val'' :: WidgetClassAdjustBaselineAllocationFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
-> a -> Int32 -> m ()
Gtk.Callbacks.dynamic_WidgetClassAdjustBaselineAllocationFieldCallback FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassAdjustBaselineAllocationFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassAdjustBaselineAllocationFieldCallback
result
setWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback -> m ()
setWidgetClassAdjustBaselineAllocation :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
-> m ()
setWidgetClassAdjustBaselineAllocation WidgetClass
s FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
784) (FunPtr C_WidgetClassAdjustBaselineAllocationFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback)
clearWidgetClassAdjustBaselineAllocation :: MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustBaselineAllocation :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassAdjustBaselineAllocation WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
784) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassAdjustBaselineAllocationFieldInfo
instance AttrInfo WidgetClassAdjustBaselineAllocationFieldInfo where
type AttrBaseTypeConstraint WidgetClassAdjustBaselineAllocationFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassAdjustBaselineAllocationFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassAdjustBaselineAllocationFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback)
type AttrTransferTypeConstraint WidgetClassAdjustBaselineAllocationFieldInfo = (~)Gtk.Callbacks.WidgetClassAdjustBaselineAllocationFieldCallback
type AttrTransferType WidgetClassAdjustBaselineAllocationFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassAdjustBaselineAllocationFieldCallback)
type AttrGetType WidgetClassAdjustBaselineAllocationFieldInfo = Maybe Gtk.Callbacks.WidgetClassAdjustBaselineAllocationFieldCallback
type AttrLabel WidgetClassAdjustBaselineAllocationFieldInfo = "adjust_baseline_allocation"
type AttrOrigin WidgetClassAdjustBaselineAllocationFieldInfo = WidgetClass
attrGet = getWidgetClassAdjustBaselineAllocation
attrSet = setWidgetClassAdjustBaselineAllocation
attrConstruct = undefined
attrClear = clearWidgetClassAdjustBaselineAllocation
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassAdjustBaselineAllocationFieldCallback (Gtk.Callbacks.wrap_WidgetClassAdjustBaselineAllocationFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.adjustBaselineAllocation"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:adjustBaselineAllocation"
})
widgetClass_adjustBaselineAllocation :: AttrLabelProxy "adjustBaselineAllocation"
widgetClass_adjustBaselineAllocation = AttrLabelProxy
#endif
getWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> m (Maybe Gtk.Callbacks.WidgetClassQueueDrawRegionFieldCallback)
getWidgetClassQueueDrawRegion :: forall (m :: * -> *).
MonadIO m =>
WidgetClass -> m (Maybe WidgetClassQueueDrawRegionFieldCallback)
getWidgetClassQueueDrawRegion WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
FunPtr C_WidgetClassQueueDrawRegionFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
792) :: IO (FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback)
Maybe WidgetClassQueueDrawRegionFieldCallback
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_WidgetClassQueueDrawRegionFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_WidgetClassQueueDrawRegionFieldCallback
val' -> do
let val'' :: WidgetClassQueueDrawRegionFieldCallback
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWidget a) =>
FunPtr C_WidgetClassQueueDrawRegionFieldCallback
-> a -> Region -> m ()
Gtk.Callbacks.dynamic_WidgetClassQueueDrawRegionFieldCallback FunPtr C_WidgetClassQueueDrawRegionFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return WidgetClassQueueDrawRegionFieldCallback
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe WidgetClassQueueDrawRegionFieldCallback
result
setWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback -> m ()
setWidgetClassQueueDrawRegion :: forall (m :: * -> *).
MonadIO m =>
WidgetClass
-> FunPtr C_WidgetClassQueueDrawRegionFieldCallback -> m ()
setWidgetClassQueueDrawRegion WidgetClass
s FunPtr C_WidgetClassQueueDrawRegionFieldCallback
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
792) (FunPtr C_WidgetClassQueueDrawRegionFieldCallback
val :: FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback)
clearWidgetClassQueueDrawRegion :: MonadIO m => WidgetClass -> m ()
clearWidgetClassQueueDrawRegion :: forall (m :: * -> *). MonadIO m => WidgetClass -> m ()
clearWidgetClassQueueDrawRegion WidgetClass
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr WidgetClass
s forall a b. (a -> b) -> a -> b
$ \Ptr WidgetClass
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr WidgetClass
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
792) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback)
#if defined(ENABLE_OVERLOADING)
data WidgetClassQueueDrawRegionFieldInfo
instance AttrInfo WidgetClassQueueDrawRegionFieldInfo where
type AttrBaseTypeConstraint WidgetClassQueueDrawRegionFieldInfo = (~) WidgetClass
type AttrAllowedOps WidgetClassQueueDrawRegionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint WidgetClassQueueDrawRegionFieldInfo = (~) (FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback)
type AttrTransferTypeConstraint WidgetClassQueueDrawRegionFieldInfo = (~)Gtk.Callbacks.WidgetClassQueueDrawRegionFieldCallback
type AttrTransferType WidgetClassQueueDrawRegionFieldInfo = (FunPtr Gtk.Callbacks.C_WidgetClassQueueDrawRegionFieldCallback)
type AttrGetType WidgetClassQueueDrawRegionFieldInfo = Maybe Gtk.Callbacks.WidgetClassQueueDrawRegionFieldCallback
type AttrLabel WidgetClassQueueDrawRegionFieldInfo = "queue_draw_region"
type AttrOrigin WidgetClassQueueDrawRegionFieldInfo = WidgetClass
attrGet = getWidgetClassQueueDrawRegion
attrSet = setWidgetClassQueueDrawRegion
attrConstruct = undefined
attrClear = clearWidgetClassQueueDrawRegion
attrTransfer _ v = do
Gtk.Callbacks.mk_WidgetClassQueueDrawRegionFieldCallback (Gtk.Callbacks.wrap_WidgetClassQueueDrawRegionFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.queueDrawRegion"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#g:attr:queueDrawRegion"
})
widgetClass_queueDrawRegion :: AttrLabelProxy "queueDrawRegion"
widgetClass_queueDrawRegion = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList WidgetClass
type instance O.AttributeList WidgetClass = WidgetClassAttributeList
type WidgetClassAttributeList = ('[ '("parentClass", WidgetClassParentClassFieldInfo), '("activateSignal", WidgetClassActivateSignalFieldInfo), '("dispatchChildPropertiesChanged", WidgetClassDispatchChildPropertiesChangedFieldInfo), '("destroy", WidgetClassDestroyFieldInfo), '("show", WidgetClassShowFieldInfo), '("showAll", WidgetClassShowAllFieldInfo), '("hide", WidgetClassHideFieldInfo), '("map", WidgetClassMapFieldInfo), '("unmap", WidgetClassUnmapFieldInfo), '("realize", WidgetClassRealizeFieldInfo), '("unrealize", WidgetClassUnrealizeFieldInfo), '("sizeAllocate", WidgetClassSizeAllocateFieldInfo), '("stateChanged", WidgetClassStateChangedFieldInfo), '("stateFlagsChanged", WidgetClassStateFlagsChangedFieldInfo), '("parentSet", WidgetClassParentSetFieldInfo), '("hierarchyChanged", WidgetClassHierarchyChangedFieldInfo), '("styleSet", WidgetClassStyleSetFieldInfo), '("directionChanged", WidgetClassDirectionChangedFieldInfo), '("grabNotify", WidgetClassGrabNotifyFieldInfo), '("childNotify", WidgetClassChildNotifyFieldInfo), '("draw", WidgetClassDrawFieldInfo), '("getRequestMode", WidgetClassGetRequestModeFieldInfo), '("getPreferredHeight", WidgetClassGetPreferredHeightFieldInfo), '("getPreferredWidthForHeight", WidgetClassGetPreferredWidthForHeightFieldInfo), '("getPreferredWidth", WidgetClassGetPreferredWidthFieldInfo), '("getPreferredHeightForWidth", WidgetClassGetPreferredHeightForWidthFieldInfo), '("mnemonicActivate", WidgetClassMnemonicActivateFieldInfo), '("grabFocus", WidgetClassGrabFocusFieldInfo), '("focus", WidgetClassFocusFieldInfo), '("moveFocus", WidgetClassMoveFocusFieldInfo), '("keynavFailed", WidgetClassKeynavFailedFieldInfo), '("event", WidgetClassEventFieldInfo), '("buttonPressEvent", WidgetClassButtonPressEventFieldInfo), '("buttonReleaseEvent", WidgetClassButtonReleaseEventFieldInfo), '("scrollEvent", WidgetClassScrollEventFieldInfo), '("motionNotifyEvent", WidgetClassMotionNotifyEventFieldInfo), '("deleteEvent", WidgetClassDeleteEventFieldInfo), '("destroyEvent", WidgetClassDestroyEventFieldInfo), '("keyPressEvent", WidgetClassKeyPressEventFieldInfo), '("keyReleaseEvent", WidgetClassKeyReleaseEventFieldInfo), '("enterNotifyEvent", WidgetClassEnterNotifyEventFieldInfo), '("leaveNotifyEvent", WidgetClassLeaveNotifyEventFieldInfo), '("configureEvent", WidgetClassConfigureEventFieldInfo), '("focusInEvent", WidgetClassFocusInEventFieldInfo), '("focusOutEvent", WidgetClassFocusOutEventFieldInfo), '("mapEvent", WidgetClassMapEventFieldInfo), '("unmapEvent", WidgetClassUnmapEventFieldInfo), '("propertyNotifyEvent", WidgetClassPropertyNotifyEventFieldInfo), '("selectionClearEvent", WidgetClassSelectionClearEventFieldInfo), '("selectionRequestEvent", WidgetClassSelectionRequestEventFieldInfo), '("selectionNotifyEvent", WidgetClassSelectionNotifyEventFieldInfo), '("proximityInEvent", WidgetClassProximityInEventFieldInfo), '("proximityOutEvent", WidgetClassProximityOutEventFieldInfo), '("visibilityNotifyEvent", WidgetClassVisibilityNotifyEventFieldInfo), '("windowStateEvent", WidgetClassWindowStateEventFieldInfo), '("damageEvent", WidgetClassDamageEventFieldInfo), '("grabBrokenEvent", WidgetClassGrabBrokenEventFieldInfo), '("selectionGet", WidgetClassSelectionGetFieldInfo), '("selectionReceived", WidgetClassSelectionReceivedFieldInfo), '("dragBegin", WidgetClassDragBeginFieldInfo), '("dragEnd", WidgetClassDragEndFieldInfo), '("dragDataGet", WidgetClassDragDataGetFieldInfo), '("dragDataDelete", WidgetClassDragDataDeleteFieldInfo), '("dragLeave", WidgetClassDragLeaveFieldInfo), '("dragMotion", WidgetClassDragMotionFieldInfo), '("dragDrop", WidgetClassDragDropFieldInfo), '("dragDataReceived", WidgetClassDragDataReceivedFieldInfo), '("dragFailed", WidgetClassDragFailedFieldInfo), '("popupMenu", WidgetClassPopupMenuFieldInfo), '("showHelp", WidgetClassShowHelpFieldInfo), '("getAccessible", WidgetClassGetAccessibleFieldInfo), '("screenChanged", WidgetClassScreenChangedFieldInfo), '("canActivateAccel", WidgetClassCanActivateAccelFieldInfo), '("compositedChanged", WidgetClassCompositedChangedFieldInfo), '("queryTooltip", WidgetClassQueryTooltipFieldInfo), '("computeExpand", WidgetClassComputeExpandFieldInfo), '("adjustSizeRequest", WidgetClassAdjustSizeRequestFieldInfo), '("adjustSizeAllocation", WidgetClassAdjustSizeAllocationFieldInfo), '("styleUpdated", WidgetClassStyleUpdatedFieldInfo), '("touchEvent", WidgetClassTouchEventFieldInfo), '("getPreferredHeightAndBaselineForWidth", WidgetClassGetPreferredHeightAndBaselineForWidthFieldInfo), '("adjustBaselineRequest", WidgetClassAdjustBaselineRequestFieldInfo), '("adjustBaselineAllocation", WidgetClassAdjustBaselineAllocationFieldInfo), '("queueDrawRegion", WidgetClassQueueDrawRegionFieldInfo)] :: [(Symbol, DK.Type)])
#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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> IO () -> m ()
widgetClassBindTemplateCallbackFull WidgetClass
widgetClass Text
callbackName IO ()
callbackSymbol = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
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 <- 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 (forall a. a -> Maybe a
Just Ptr (FunPtr (IO ()))
ptrcallbackSymbol) IO ()
callbackSymbol)
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'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
forall a. Ptr a -> IO ()
freeMem CString
callbackName'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data WidgetClassBindTemplateCallbackFullMethodInfo
instance (signature ~ (T.Text -> GObject.Callbacks.Callback -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass signature where
overloadedMethod = widgetClassBindTemplateCallbackFull
instance O.OverloadedMethodInfo WidgetClassBindTemplateCallbackFullMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassBindTemplateCallbackFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> Bool -> Int64 -> m ()
widgetClassBindTemplateChildFull WidgetClass
widgetClass Text
name Bool
internalChild Int64
structOffset = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
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' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.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
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data WidgetClassBindTemplateChildFullMethodInfo
instance (signature ~ (T.Text -> Bool -> Int64 -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassBindTemplateChildFullMethodInfo WidgetClass signature where
overloadedMethod = widgetClassBindTemplateChildFull
instance O.OverloadedMethodInfo WidgetClassBindTemplateChildFullMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassBindTemplateChildFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassBindTemplateChildFull"
})
#endif
foreign import ccall "gtk_widget_class_find_style_property" gtk_widget_class_find_style_property ::
Ptr WidgetClass ->
CString ->
IO (Ptr GParamSpec)
widgetClassFindStyleProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> T.Text
-> m GParamSpec
widgetClassFindStyleProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> m GParamSpec
widgetClassFindStyleProperty WidgetClass
klass Text
propertyName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
klass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
klass
CString
propertyName' <- Text -> IO CString
textToCString Text
propertyName
Ptr GParamSpec
result <- Ptr WidgetClass -> CString -> IO (Ptr GParamSpec)
gtk_widget_class_find_style_property Ptr WidgetClass
klass' CString
propertyName'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"widgetClassFindStyleProperty" Ptr GParamSpec
result
GParamSpec
result' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
klass
forall a. Ptr a -> IO ()
freeMem CString
propertyName'
forall (m :: * -> *) a. Monad m => a -> m a
return GParamSpec
result'
#if defined(ENABLE_OVERLOADING)
data WidgetClassFindStylePropertyMethodInfo
instance (signature ~ (T.Text -> m GParamSpec), MonadIO m) => O.OverloadedMethod WidgetClassFindStylePropertyMethodInfo WidgetClass signature where
overloadedMethod = widgetClassFindStyleProperty
instance O.OverloadedMethodInfo WidgetClassFindStylePropertyMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassFindStyleProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassFindStyleProperty"
})
#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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> m Text
widgetClassGetCssName WidgetClass
widgetClass = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
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'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"widgetClassGetCssName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data WidgetClassGetCssNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.OverloadedMethod WidgetClassGetCssNameMethodInfo WidgetClass signature where
overloadedMethod = widgetClassGetCssName
instance O.OverloadedMethodInfo WidgetClassGetCssNameMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassGetCssName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassGetCssName"
})
#endif
foreign import ccall "gtk_widget_class_install_style_property" gtk_widget_class_install_style_property ::
Ptr WidgetClass ->
Ptr GParamSpec ->
IO ()
widgetClassInstallStyleProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
WidgetClass
-> GParamSpec
-> m ()
widgetClassInstallStyleProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> GParamSpec -> m ()
widgetClassInstallStyleProperty WidgetClass
klass GParamSpec
pspec = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
klass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
klass
Ptr GParamSpec
pspec' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GParamSpec
pspec
Ptr WidgetClass -> Ptr GParamSpec -> IO ()
gtk_widget_class_install_style_property Ptr WidgetClass
klass' Ptr GParamSpec
pspec'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
klass
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GParamSpec
pspec
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data WidgetClassInstallStylePropertyMethodInfo
instance (signature ~ (GParamSpec -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassInstallStylePropertyMethodInfo WidgetClass signature where
overloadedMethod = widgetClassInstallStyleProperty
instance O.OverloadedMethodInfo WidgetClassInstallStylePropertyMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassInstallStyleProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassInstallStyleProperty"
})
#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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Role -> m ()
widgetClassSetAccessibleRole WidgetClass
widgetClass Role
role = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
widgetClass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
let role' :: CUInt
role' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Role
role
Ptr WidgetClass -> CUInt -> IO ()
gtk_widget_class_set_accessible_role Ptr WidgetClass
widgetClass' CUInt
role'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data WidgetClassSetAccessibleRoleMethodInfo
instance (signature ~ (Atk.Enums.Role -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetAccessibleRoleMethodInfo WidgetClass signature where
overloadedMethod = widgetClassSetAccessibleRole
instance O.OverloadedMethodInfo WidgetClassSetAccessibleRoleMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetAccessibleRole",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> GType -> m ()
widgetClassSetAccessibleType WidgetClass
widgetClass GType
type_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
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_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data WidgetClassSetAccessibleTypeMethodInfo
instance (signature ~ (GType -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetAccessibleTypeMethodInfo WidgetClass signature where
overloadedMethod = widgetClassSetAccessibleType
instance O.OverloadedMethodInfo WidgetClassSetAccessibleTypeMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetAccessibleType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> BuilderConnectFunc -> m ()
widgetClassSetConnectFunc WidgetClass
widgetClass BuilderConnectFunc
connectFunc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
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 forall a. Maybe a
Nothing (BuilderConnectFunc -> BuilderConnectFunc_WithClosures
Gtk.Callbacks.drop_closures_BuilderConnectFunc BuilderConnectFunc
connectFunc))
let connectData :: Ptr ()
connectData = forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_BuilderConnectFunc
connectFunc'
let connectDataDestroy :: FunPtr (Ptr a -> IO ())
connectDataDestroy = forall a. FunPtr (Ptr a -> IO ())
SP.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 forall a. FunPtr (Ptr a -> IO ())
connectDataDestroy
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data WidgetClassSetConnectFuncMethodInfo
instance (signature ~ (Gtk.Callbacks.BuilderConnectFunc -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetConnectFuncMethodInfo WidgetClass signature where
overloadedMethod = widgetClassSetConnectFunc
instance O.OverloadedMethodInfo WidgetClassSetConnectFuncMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetConnectFunc",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> m ()
widgetClassSetCssName WidgetClass
widgetClass Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
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'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data WidgetClassSetCssNameMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetCssNameMethodInfo WidgetClass signature where
overloadedMethod = widgetClassSetCssName
instance O.OverloadedMethodInfo WidgetClassSetCssNameMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetCssName",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetCssName"
})
#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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Bytes -> m ()
widgetClassSetTemplate WidgetClass
widgetClass Bytes
templateBytes = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
widgetClass' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr WidgetClass
widgetClass
Ptr Bytes
templateBytes' <- 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'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Bytes
templateBytes
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data WidgetClassSetTemplateMethodInfo
instance (signature ~ (GLib.Bytes.Bytes -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetTemplateMethodInfo WidgetClass signature where
overloadedMethod = widgetClassSetTemplate
instance O.OverloadedMethodInfo WidgetClassSetTemplateMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v: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 :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
WidgetClass -> Text -> m ()
widgetClassSetTemplateFromResource WidgetClass
widgetClass Text
resourceName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr WidgetClass
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'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr WidgetClass
widgetClass
forall a. Ptr a -> IO ()
freeMem CString
resourceName'
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data WidgetClassSetTemplateFromResourceMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod WidgetClassSetTemplateFromResourceMethodInfo WidgetClass signature where
overloadedMethod = widgetClassSetTemplateFromResource
instance O.OverloadedMethodInfo WidgetClassSetTemplateFromResourceMethodInfo WidgetClass where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.WidgetClass.widgetClassSetTemplateFromResource",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-WidgetClass.html#v:widgetClassSetTemplateFromResource"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveWidgetClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveWidgetClassMethod "bindTemplateCallbackFull" o = WidgetClassBindTemplateCallbackFullMethodInfo
ResolveWidgetClassMethod "bindTemplateChildFull" o = WidgetClassBindTemplateChildFullMethodInfo
ResolveWidgetClassMethod "findStyleProperty" o = WidgetClassFindStylePropertyMethodInfo
ResolveWidgetClassMethod "installStyleProperty" o = WidgetClassInstallStylePropertyMethodInfo
ResolveWidgetClassMethod "getCssName" o = WidgetClassGetCssNameMethodInfo
ResolveWidgetClassMethod "setAccessibleRole" o = WidgetClassSetAccessibleRoleMethodInfo
ResolveWidgetClassMethod "setAccessibleType" o = WidgetClassSetAccessibleTypeMethodInfo
ResolveWidgetClassMethod "setConnectFunc" o = WidgetClassSetConnectFuncMethodInfo
ResolveWidgetClassMethod "setCssName" o = WidgetClassSetCssNameMethodInfo
ResolveWidgetClassMethod "setTemplate" o = WidgetClassSetTemplateMethodInfo
ResolveWidgetClassMethod "setTemplateFromResource" o = WidgetClassSetTemplateFromResourceMethodInfo
ResolveWidgetClassMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveWidgetClassMethod t WidgetClass, O.OverloadedMethod info WidgetClass p) => OL.IsLabel t (WidgetClass -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveWidgetClassMethod t WidgetClass, O.OverloadedMethod info WidgetClass p, R.HasField t WidgetClass p) => R.HasField t WidgetClass p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveWidgetClassMethod t WidgetClass, O.OverloadedMethodInfo info WidgetClass) => OL.IsLabel t (O.MethodProxy info WidgetClass) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif