{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Structs.ActionEntry
(
ActionEntry(..) ,
newZeroActionEntry ,
#if defined(ENABLE_OVERLOADING)
ResolveActionEntryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
actionEntry_activate ,
#endif
clearActionEntryActivate ,
getActionEntryActivate ,
setActionEntryActivate ,
#if defined(ENABLE_OVERLOADING)
actionEntry_changeState ,
#endif
clearActionEntryChangeState ,
getActionEntryChangeState ,
setActionEntryChangeState ,
#if defined(ENABLE_OVERLOADING)
actionEntry_name ,
#endif
clearActionEntryName ,
getActionEntryName ,
setActionEntryName ,
#if defined(ENABLE_OVERLOADING)
actionEntry_parameterType ,
#endif
clearActionEntryParameterType ,
getActionEntryParameterType ,
setActionEntryParameterType ,
#if defined(ENABLE_OVERLOADING)
actionEntry_state ,
#endif
clearActionEntryState ,
getActionEntryState ,
setActionEntryState ,
) 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.Gio.Callbacks as Gio.Callbacks
newtype ActionEntry = ActionEntry (SP.ManagedPtr ActionEntry)
deriving (ActionEntry -> ActionEntry -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ActionEntry -> ActionEntry -> Bool
$c/= :: ActionEntry -> ActionEntry -> Bool
== :: ActionEntry -> ActionEntry -> Bool
$c== :: ActionEntry -> ActionEntry -> Bool
Eq)
instance SP.ManagedPtrNewtype ActionEntry where
toManagedPtr :: ActionEntry -> ManagedPtr ActionEntry
toManagedPtr (ActionEntry ManagedPtr ActionEntry
p) = ManagedPtr ActionEntry
p
instance BoxedPtr ActionEntry where
boxedPtrCopy :: ActionEntry -> IO ActionEntry
boxedPtrCopy = \ActionEntry
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ActionEntry
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 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 ActionEntry -> ActionEntry
ActionEntry)
boxedPtrFree :: ActionEntry -> IO ()
boxedPtrFree = \ActionEntry
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr ActionEntry
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr ActionEntry where
boxedPtrCalloc :: IO (Ptr ActionEntry)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
64
newZeroActionEntry :: MonadIO m => m ActionEntry
newZeroActionEntry :: forall (m :: * -> *). MonadIO m => m ActionEntry
newZeroActionEntry = 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 ActionEntry -> ActionEntry
ActionEntry
instance tag ~ 'AttrSet => Constructible ActionEntry tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr ActionEntry -> ActionEntry)
-> [AttrOp ActionEntry tag] -> m ActionEntry
new ManagedPtr ActionEntry -> ActionEntry
_ [AttrOp ActionEntry tag]
attrs = do
ActionEntry
o <- forall (m :: * -> *). MonadIO m => m ActionEntry
newZeroActionEntry
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ActionEntry
o [AttrOp ActionEntry tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return ActionEntry
o
getActionEntryName :: MonadIO m => ActionEntry -> m (Maybe T.Text)
getActionEntryName :: forall (m :: * -> *). MonadIO m => ActionEntry -> m (Maybe Text)
getActionEntryName ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setActionEntryName :: MonadIO m => ActionEntry -> CString -> m ()
setActionEntryName :: forall (m :: * -> *). MonadIO m => ActionEntry -> CString -> m ()
setActionEntryName ActionEntry
s CString
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)
clearActionEntryName :: MonadIO m => ActionEntry -> m ()
clearActionEntryName :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryName ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data ActionEntryNameFieldInfo
instance AttrInfo ActionEntryNameFieldInfo where
type AttrBaseTypeConstraint ActionEntryNameFieldInfo = (~) ActionEntry
type AttrAllowedOps ActionEntryNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ActionEntryNameFieldInfo = (~) CString
type AttrTransferTypeConstraint ActionEntryNameFieldInfo = (~)CString
type AttrTransferType ActionEntryNameFieldInfo = CString
type AttrGetType ActionEntryNameFieldInfo = Maybe T.Text
type AttrLabel ActionEntryNameFieldInfo = "name"
type AttrOrigin ActionEntryNameFieldInfo = ActionEntry
attrGet = getActionEntryName
attrSet = setActionEntryName
attrConstruct = undefined
attrClear = clearActionEntryName
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.name"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-ActionEntry.html#g:attr:name"
})
actionEntry_name :: AttrLabelProxy "name"
actionEntry_name = AttrLabelProxy
#endif
getActionEntryActivate :: MonadIO m => ActionEntry -> m (Maybe Gio.Callbacks.ActionEntryActivateFieldCallback_WithClosures)
getActionEntryActivate :: forall (m :: * -> *).
MonadIO m =>
ActionEntry
-> m (Maybe ActionEntryActivateFieldCallback_WithClosures)
getActionEntryActivate ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
FunPtr C_ActionEntryActivateFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
Maybe ActionEntryActivateFieldCallback_WithClosures
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ActionEntryActivateFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ActionEntryActivateFieldCallback
val' -> do
let val'' :: ActionEntryActivateFieldCallback_WithClosures
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSimpleAction a) =>
FunPtr C_ActionEntryActivateFieldCallback
-> a -> Maybe GVariant -> Ptr () -> m ()
Gio.Callbacks.dynamic_ActionEntryActivateFieldCallback FunPtr C_ActionEntryActivateFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ActionEntryActivateFieldCallback_WithClosures
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ActionEntryActivateFieldCallback_WithClosures
result
setActionEntryActivate :: MonadIO m => ActionEntry -> FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback -> m ()
setActionEntryActivate :: forall (m :: * -> *).
MonadIO m =>
ActionEntry -> FunPtr C_ActionEntryActivateFieldCallback -> m ()
setActionEntryActivate ActionEntry
s FunPtr C_ActionEntryActivateFieldCallback
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (FunPtr C_ActionEntryActivateFieldCallback
val :: FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
clearActionEntryActivate :: MonadIO m => ActionEntry -> m ()
clearActionEntryActivate :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryActivate ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ActionEntryActivateFieldInfo
instance AttrInfo ActionEntryActivateFieldInfo where
type AttrBaseTypeConstraint ActionEntryActivateFieldInfo = (~) ActionEntry
type AttrAllowedOps ActionEntryActivateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ActionEntryActivateFieldInfo = (~) (FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
type AttrTransferTypeConstraint ActionEntryActivateFieldInfo = (~)Gio.Callbacks.ActionEntryActivateFieldCallback_WithClosures
type AttrTransferType ActionEntryActivateFieldInfo = (FunPtr Gio.Callbacks.C_ActionEntryActivateFieldCallback)
type AttrGetType ActionEntryActivateFieldInfo = Maybe Gio.Callbacks.ActionEntryActivateFieldCallback_WithClosures
type AttrLabel ActionEntryActivateFieldInfo = "activate"
type AttrOrigin ActionEntryActivateFieldInfo = ActionEntry
attrGet = getActionEntryActivate
attrSet = setActionEntryActivate
attrConstruct = undefined
attrClear = clearActionEntryActivate
attrTransfer _ v = do
Gio.Callbacks.mk_ActionEntryActivateFieldCallback (Gio.Callbacks.wrap_ActionEntryActivateFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.activate"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-ActionEntry.html#g:attr:activate"
})
actionEntry_activate :: AttrLabelProxy "activate"
actionEntry_activate = AttrLabelProxy
#endif
getActionEntryParameterType :: MonadIO m => ActionEntry -> m (Maybe T.Text)
getActionEntryParameterType :: forall (m :: * -> *). MonadIO m => ActionEntry -> m (Maybe Text)
getActionEntryParameterType ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setActionEntryParameterType :: MonadIO m => ActionEntry -> CString -> m ()
setActionEntryParameterType :: forall (m :: * -> *). MonadIO m => ActionEntry -> CString -> m ()
setActionEntryParameterType ActionEntry
s CString
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CString
val :: CString)
clearActionEntryParameterType :: MonadIO m => ActionEntry -> m ()
clearActionEntryParameterType :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryParameterType ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data ActionEntryParameterTypeFieldInfo
instance AttrInfo ActionEntryParameterTypeFieldInfo where
type AttrBaseTypeConstraint ActionEntryParameterTypeFieldInfo = (~) ActionEntry
type AttrAllowedOps ActionEntryParameterTypeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ActionEntryParameterTypeFieldInfo = (~) CString
type AttrTransferTypeConstraint ActionEntryParameterTypeFieldInfo = (~)CString
type AttrTransferType ActionEntryParameterTypeFieldInfo = CString
type AttrGetType ActionEntryParameterTypeFieldInfo = Maybe T.Text
type AttrLabel ActionEntryParameterTypeFieldInfo = "parameter_type"
type AttrOrigin ActionEntryParameterTypeFieldInfo = ActionEntry
attrGet = getActionEntryParameterType
attrSet = setActionEntryParameterType
attrConstruct = undefined
attrClear = clearActionEntryParameterType
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.parameterType"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-ActionEntry.html#g:attr:parameterType"
})
actionEntry_parameterType :: AttrLabelProxy "parameterType"
actionEntry_parameterType = AttrLabelProxy
#endif
getActionEntryState :: MonadIO m => ActionEntry -> m (Maybe T.Text)
getActionEntryState :: forall (m :: * -> *). MonadIO m => ActionEntry -> m (Maybe Text)
getActionEntryState ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setActionEntryState :: MonadIO m => ActionEntry -> CString -> m ()
setActionEntryState :: forall (m :: * -> *). MonadIO m => ActionEntry -> CString -> m ()
setActionEntryState ActionEntry
s CString
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CString
val :: CString)
clearActionEntryState :: MonadIO m => ActionEntry -> m ()
clearActionEntryState :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryState ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data ActionEntryStateFieldInfo
instance AttrInfo ActionEntryStateFieldInfo where
type AttrBaseTypeConstraint ActionEntryStateFieldInfo = (~) ActionEntry
type AttrAllowedOps ActionEntryStateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ActionEntryStateFieldInfo = (~) CString
type AttrTransferTypeConstraint ActionEntryStateFieldInfo = (~)CString
type AttrTransferType ActionEntryStateFieldInfo = CString
type AttrGetType ActionEntryStateFieldInfo = Maybe T.Text
type AttrLabel ActionEntryStateFieldInfo = "state"
type AttrOrigin ActionEntryStateFieldInfo = ActionEntry
attrGet = getActionEntryState
attrSet = setActionEntryState
attrConstruct = undefined
attrClear = clearActionEntryState
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.state"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-ActionEntry.html#g:attr:state"
})
actionEntry_state :: AttrLabelProxy "state"
actionEntry_state = AttrLabelProxy
#endif
getActionEntryChangeState :: MonadIO m => ActionEntry -> m (Maybe Gio.Callbacks.ActionEntryChangeStateFieldCallback_WithClosures)
getActionEntryChangeState :: forall (m :: * -> *).
MonadIO m =>
ActionEntry
-> m (Maybe ActionEntryChangeStateFieldCallback_WithClosures)
getActionEntryChangeState ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
FunPtr C_ActionEntryActivateFieldCallback
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
Maybe ActionEntryChangeStateFieldCallback_WithClosures
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ActionEntryActivateFieldCallback
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ActionEntryActivateFieldCallback
val' -> do
let val'' :: ActionEntryChangeStateFieldCallback_WithClosures
val'' = forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsSimpleAction a) =>
FunPtr C_ActionEntryActivateFieldCallback
-> a -> GVariant -> Ptr () -> m ()
Gio.Callbacks.dynamic_ActionEntryChangeStateFieldCallback FunPtr C_ActionEntryActivateFieldCallback
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ActionEntryChangeStateFieldCallback_WithClosures
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ActionEntryChangeStateFieldCallback_WithClosures
result
setActionEntryChangeState :: MonadIO m => ActionEntry -> FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback -> m ()
setActionEntryChangeState :: forall (m :: * -> *).
MonadIO m =>
ActionEntry -> FunPtr C_ActionEntryActivateFieldCallback -> m ()
setActionEntryChangeState ActionEntry
s FunPtr C_ActionEntryActivateFieldCallback
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (FunPtr C_ActionEntryActivateFieldCallback
val :: FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
clearActionEntryChangeState :: MonadIO m => ActionEntry -> m ()
clearActionEntryChangeState :: forall (m :: * -> *). MonadIO m => ActionEntry -> m ()
clearActionEntryChangeState ActionEntry
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 ActionEntry
s forall a b. (a -> b) -> a -> b
$ \Ptr ActionEntry
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ActionEntry
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
#if defined(ENABLE_OVERLOADING)
data ActionEntryChangeStateFieldInfo
instance AttrInfo ActionEntryChangeStateFieldInfo where
type AttrBaseTypeConstraint ActionEntryChangeStateFieldInfo = (~) ActionEntry
type AttrAllowedOps ActionEntryChangeStateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint ActionEntryChangeStateFieldInfo = (~) (FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
type AttrTransferTypeConstraint ActionEntryChangeStateFieldInfo = (~)Gio.Callbacks.ActionEntryChangeStateFieldCallback_WithClosures
type AttrTransferType ActionEntryChangeStateFieldInfo = (FunPtr Gio.Callbacks.C_ActionEntryChangeStateFieldCallback)
type AttrGetType ActionEntryChangeStateFieldInfo = Maybe Gio.Callbacks.ActionEntryChangeStateFieldCallback_WithClosures
type AttrLabel ActionEntryChangeStateFieldInfo = "change_state"
type AttrOrigin ActionEntryChangeStateFieldInfo = ActionEntry
attrGet = getActionEntryChangeState
attrSet = setActionEntryChangeState
attrConstruct = undefined
attrClear = clearActionEntryChangeState
attrTransfer _ v = do
Gio.Callbacks.mk_ActionEntryChangeStateFieldCallback (Gio.Callbacks.wrap_ActionEntryChangeStateFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.ActionEntry.changeState"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-ActionEntry.html#g:attr:changeState"
})
actionEntry_changeState :: AttrLabelProxy "changeState"
actionEntry_changeState = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ActionEntry
type instance O.AttributeList ActionEntry = ActionEntryAttributeList
type ActionEntryAttributeList = ('[ '("name", ActionEntryNameFieldInfo), '("activate", ActionEntryActivateFieldInfo), '("parameterType", ActionEntryParameterTypeFieldInfo), '("state", ActionEntryStateFieldInfo), '("changeState", ActionEntryChangeStateFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveActionEntryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveActionEntryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveActionEntryMethod t ActionEntry, O.OverloadedMethod info ActionEntry p) => OL.IsLabel t (ActionEntry -> 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 ~ ResolveActionEntryMethod t ActionEntry, O.OverloadedMethod info ActionEntry p, R.HasField t ActionEntry p) => R.HasField t ActionEntry p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveActionEntryMethod t ActionEntry, O.OverloadedMethodInfo info ActionEntry) => OL.IsLabel t (O.MethodProxy info ActionEntry) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif