{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GObject.Structs.SignalQuery
(
SignalQuery(..) ,
newZeroSignalQuery ,
#if defined(ENABLE_OVERLOADING)
ResolveSignalQueryMethod ,
#endif
getSignalQueryItype ,
setSignalQueryItype ,
#if defined(ENABLE_OVERLOADING)
signalQuery_itype ,
#endif
getSignalQueryNParams ,
setSignalQueryNParams ,
#if defined(ENABLE_OVERLOADING)
signalQuery_nParams ,
#endif
getSignalQueryReturnType ,
setSignalQueryReturnType ,
#if defined(ENABLE_OVERLOADING)
signalQuery_returnType ,
#endif
getSignalQuerySignalFlags ,
setSignalQuerySignalFlags ,
#if defined(ENABLE_OVERLOADING)
signalQuery_signalFlags ,
#endif
getSignalQuerySignalId ,
setSignalQuerySignalId ,
#if defined(ENABLE_OVERLOADING)
signalQuery_signalId ,
#endif
clearSignalQuerySignalName ,
getSignalQuerySignalName ,
setSignalQuerySignalName ,
#if defined(ENABLE_OVERLOADING)
signalQuery_signalName ,
#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 {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags
newtype SignalQuery = SignalQuery (SP.ManagedPtr SignalQuery)
deriving (SignalQuery -> SignalQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SignalQuery -> SignalQuery -> Bool
$c/= :: SignalQuery -> SignalQuery -> Bool
== :: SignalQuery -> SignalQuery -> Bool
$c== :: SignalQuery -> SignalQuery -> Bool
Eq)
instance SP.ManagedPtrNewtype SignalQuery where
toManagedPtr :: SignalQuery -> ManagedPtr SignalQuery
toManagedPtr (SignalQuery ManagedPtr SignalQuery
p) = ManagedPtr SignalQuery
p
instance BoxedPtr SignalQuery where
boxedPtrCopy :: SignalQuery -> IO SignalQuery
boxedPtrCopy = \SignalQuery
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SignalQuery
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
28 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 SignalQuery -> SignalQuery
SignalQuery)
boxedPtrFree :: SignalQuery -> IO ()
boxedPtrFree = \SignalQuery
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr SignalQuery
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr SignalQuery where
boxedPtrCalloc :: IO (Ptr SignalQuery)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
28
newZeroSignalQuery :: MonadIO m => m SignalQuery
newZeroSignalQuery :: forall (m :: * -> *). MonadIO m => m SignalQuery
newZeroSignalQuery = 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 SignalQuery -> SignalQuery
SignalQuery
instance tag ~ 'AttrSet => Constructible SignalQuery tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr SignalQuery -> SignalQuery)
-> [AttrOp SignalQuery tag] -> m SignalQuery
new ManagedPtr SignalQuery -> SignalQuery
_ [AttrOp SignalQuery tag]
attrs = do
SignalQuery
o <- forall (m :: * -> *). MonadIO m => m SignalQuery
newZeroSignalQuery
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set SignalQuery
o [AttrOp SignalQuery tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return SignalQuery
o
getSignalQuerySignalId :: MonadIO m => SignalQuery -> m Word32
getSignalQuerySignalId :: forall (m :: * -> *). MonadIO m => SignalQuery -> m Word32
getSignalQuerySignalId SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setSignalQuerySignalId :: MonadIO m => SignalQuery -> Word32 -> m ()
setSignalQuerySignalId :: forall (m :: * -> *). MonadIO m => SignalQuery -> Word32 -> m ()
setSignalQuerySignalId SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data SignalQuerySignalIdFieldInfo
instance AttrInfo SignalQuerySignalIdFieldInfo where
type AttrBaseTypeConstraint SignalQuerySignalIdFieldInfo = (~) SignalQuery
type AttrAllowedOps SignalQuerySignalIdFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SignalQuerySignalIdFieldInfo = (~) Word32
type AttrTransferTypeConstraint SignalQuerySignalIdFieldInfo = (~)Word32
type AttrTransferType SignalQuerySignalIdFieldInfo = Word32
type AttrGetType SignalQuerySignalIdFieldInfo = Word32
type AttrLabel SignalQuerySignalIdFieldInfo = "signal_id"
type AttrOrigin SignalQuerySignalIdFieldInfo = SignalQuery
attrGet = getSignalQuerySignalId
attrSet = setSignalQuerySignalId
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.signalId"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-SignalQuery.html#g:attr:signalId"
})
signalQuery_signalId :: AttrLabelProxy "signalId"
signalQuery_signalId = AttrLabelProxy
#endif
getSignalQuerySignalName :: MonadIO m => SignalQuery -> m (Maybe T.Text)
getSignalQuerySignalName :: forall (m :: * -> *). MonadIO m => SignalQuery -> m (Maybe Text)
getSignalQuerySignalName SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: 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
setSignalQuerySignalName :: MonadIO m => SignalQuery -> CString -> m ()
setSignalQuerySignalName :: forall (m :: * -> *). MonadIO m => SignalQuery -> CString -> m ()
setSignalQuerySignalName SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CString
val :: CString)
clearSignalQuerySignalName :: MonadIO m => SignalQuery -> m ()
clearSignalQuerySignalName :: forall (m :: * -> *). MonadIO m => SignalQuery -> m ()
clearSignalQuerySignalName SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data SignalQuerySignalNameFieldInfo
instance AttrInfo SignalQuerySignalNameFieldInfo where
type AttrBaseTypeConstraint SignalQuerySignalNameFieldInfo = (~) SignalQuery
type AttrAllowedOps SignalQuerySignalNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint SignalQuerySignalNameFieldInfo = (~) CString
type AttrTransferTypeConstraint SignalQuerySignalNameFieldInfo = (~)CString
type AttrTransferType SignalQuerySignalNameFieldInfo = CString
type AttrGetType SignalQuerySignalNameFieldInfo = Maybe T.Text
type AttrLabel SignalQuerySignalNameFieldInfo = "signal_name"
type AttrOrigin SignalQuerySignalNameFieldInfo = SignalQuery
attrGet = getSignalQuerySignalName
attrSet = setSignalQuerySignalName
attrConstruct = undefined
attrClear = clearSignalQuerySignalName
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.signalName"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-SignalQuery.html#g:attr:signalName"
})
signalQuery_signalName :: AttrLabelProxy "signalName"
signalQuery_signalName = AttrLabelProxy
#endif
getSignalQueryItype :: MonadIO m => SignalQuery -> m GType
getSignalQueryItype :: forall (m :: * -> *). MonadIO m => SignalQuery -> m GType
getSignalQueryItype SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CGType
let val' :: GType
val' = Word32 -> GType
GType Word32
val
forall (m :: * -> *) a. Monad m => a -> m a
return GType
val'
setSignalQueryItype :: MonadIO m => SignalQuery -> GType -> m ()
setSignalQueryItype :: forall (m :: * -> *). MonadIO m => SignalQuery -> GType -> m ()
setSignalQueryItype SignalQuery
s GType
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
let val' :: Word32
val' = GType -> Word32
gtypeToCGType GType
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val' :: CGType)
#if defined(ENABLE_OVERLOADING)
data SignalQueryItypeFieldInfo
instance AttrInfo SignalQueryItypeFieldInfo where
type AttrBaseTypeConstraint SignalQueryItypeFieldInfo = (~) SignalQuery
type AttrAllowedOps SignalQueryItypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SignalQueryItypeFieldInfo = (~) GType
type AttrTransferTypeConstraint SignalQueryItypeFieldInfo = (~)GType
type AttrTransferType SignalQueryItypeFieldInfo = GType
type AttrGetType SignalQueryItypeFieldInfo = GType
type AttrLabel SignalQueryItypeFieldInfo = "itype"
type AttrOrigin SignalQueryItypeFieldInfo = SignalQuery
attrGet = getSignalQueryItype
attrSet = setSignalQueryItype
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.itype"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-SignalQuery.html#g:attr:itype"
})
signalQuery_itype :: AttrLabelProxy "itype"
signalQuery_itype = AttrLabelProxy
#endif
getSignalQuerySignalFlags :: MonadIO m => SignalQuery -> m [GObject.Flags.SignalFlags]
getSignalQuerySignalFlags :: forall (m :: * -> *). MonadIO m => SignalQuery -> m [SignalFlags]
getSignalQuerySignalFlags SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
CUInt
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO CUInt
let val' :: [SignalFlags]
val' = forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
forall (m :: * -> *) a. Monad m => a -> m a
return [SignalFlags]
val'
setSignalQuerySignalFlags :: MonadIO m => SignalQuery -> [GObject.Flags.SignalFlags] -> m ()
setSignalQuerySignalFlags :: forall (m :: * -> *).
MonadIO m =>
SignalQuery -> [SignalFlags] -> m ()
setSignalQuerySignalFlags SignalQuery
s [SignalFlags]
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
let val' :: CUInt
val' = forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SignalFlags]
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (CUInt
val' :: CUInt)
#if defined(ENABLE_OVERLOADING)
data SignalQuerySignalFlagsFieldInfo
instance AttrInfo SignalQuerySignalFlagsFieldInfo where
type AttrBaseTypeConstraint SignalQuerySignalFlagsFieldInfo = (~) SignalQuery
type AttrAllowedOps SignalQuerySignalFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SignalQuerySignalFlagsFieldInfo = (~) [GObject.Flags.SignalFlags]
type AttrTransferTypeConstraint SignalQuerySignalFlagsFieldInfo = (~)[GObject.Flags.SignalFlags]
type AttrTransferType SignalQuerySignalFlagsFieldInfo = [GObject.Flags.SignalFlags]
type AttrGetType SignalQuerySignalFlagsFieldInfo = [GObject.Flags.SignalFlags]
type AttrLabel SignalQuerySignalFlagsFieldInfo = "signal_flags"
type AttrOrigin SignalQuerySignalFlagsFieldInfo = SignalQuery
attrGet = getSignalQuerySignalFlags
attrSet = setSignalQuerySignalFlags
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.signalFlags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-SignalQuery.html#g:attr:signalFlags"
})
signalQuery_signalFlags :: AttrLabelProxy "signalFlags"
signalQuery_signalFlags = AttrLabelProxy
#endif
getSignalQueryReturnType :: MonadIO m => SignalQuery -> m GType
getSignalQueryReturnType :: forall (m :: * -> *). MonadIO m => SignalQuery -> m GType
getSignalQueryReturnType SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CGType
let val' :: GType
val' = Word32 -> GType
GType Word32
val
forall (m :: * -> *) a. Monad m => a -> m a
return GType
val'
setSignalQueryReturnType :: MonadIO m => SignalQuery -> GType -> m ()
setSignalQueryReturnType :: forall (m :: * -> *). MonadIO m => SignalQuery -> GType -> m ()
setSignalQueryReturnType SignalQuery
s GType
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
let val' :: Word32
val' = GType -> Word32
gtypeToCGType GType
val
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Word32
val' :: CGType)
#if defined(ENABLE_OVERLOADING)
data SignalQueryReturnTypeFieldInfo
instance AttrInfo SignalQueryReturnTypeFieldInfo where
type AttrBaseTypeConstraint SignalQueryReturnTypeFieldInfo = (~) SignalQuery
type AttrAllowedOps SignalQueryReturnTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SignalQueryReturnTypeFieldInfo = (~) GType
type AttrTransferTypeConstraint SignalQueryReturnTypeFieldInfo = (~)GType
type AttrTransferType SignalQueryReturnTypeFieldInfo = GType
type AttrGetType SignalQueryReturnTypeFieldInfo = GType
type AttrLabel SignalQueryReturnTypeFieldInfo = "return_type"
type AttrOrigin SignalQueryReturnTypeFieldInfo = SignalQuery
attrGet = getSignalQueryReturnType
attrSet = setSignalQueryReturnType
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.returnType"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-SignalQuery.html#g:attr:returnType"
})
signalQuery_returnType :: AttrLabelProxy "returnType"
signalQuery_returnType = AttrLabelProxy
#endif
getSignalQueryNParams :: MonadIO m => SignalQuery -> m Word32
getSignalQueryNParams :: forall (m :: * -> *). MonadIO m => SignalQuery -> m Word32
getSignalQueryNParams SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setSignalQueryNParams :: MonadIO m => SignalQuery -> Word32 -> m ()
setSignalQueryNParams :: forall (m :: * -> *). MonadIO m => SignalQuery -> Word32 -> m ()
setSignalQueryNParams SignalQuery
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 SignalQuery
s forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data SignalQueryNParamsFieldInfo
instance AttrInfo SignalQueryNParamsFieldInfo where
type AttrBaseTypeConstraint SignalQueryNParamsFieldInfo = (~) SignalQuery
type AttrAllowedOps SignalQueryNParamsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint SignalQueryNParamsFieldInfo = (~) Word32
type AttrTransferTypeConstraint SignalQueryNParamsFieldInfo = (~)Word32
type AttrTransferType SignalQueryNParamsFieldInfo = Word32
type AttrGetType SignalQueryNParamsFieldInfo = Word32
type AttrLabel SignalQueryNParamsFieldInfo = "n_params"
type AttrOrigin SignalQueryNParamsFieldInfo = SignalQuery
attrGet = getSignalQueryNParams
attrSet = setSignalQueryNParams
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.SignalQuery.nParams"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-SignalQuery.html#g:attr:nParams"
})
signalQuery_nParams :: AttrLabelProxy "nParams"
signalQuery_nParams = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SignalQuery
type instance O.AttributeList SignalQuery = SignalQueryAttributeList
type SignalQueryAttributeList = ('[ '("signalId", SignalQuerySignalIdFieldInfo), '("signalName", SignalQuerySignalNameFieldInfo), '("itype", SignalQueryItypeFieldInfo), '("signalFlags", SignalQuerySignalFlagsFieldInfo), '("returnType", SignalQueryReturnTypeFieldInfo), '("nParams", SignalQueryNParamsFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveSignalQueryMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveSignalQueryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSignalQueryMethod t SignalQuery, O.OverloadedMethod info SignalQuery p) => OL.IsLabel t (SignalQuery -> 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 ~ ResolveSignalQueryMethod t SignalQuery, O.OverloadedMethod info SignalQuery p, R.HasField t SignalQuery p) => R.HasField t SignalQuery p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveSignalQueryMethod t SignalQuery, O.OverloadedMethodInfo info SignalQuery) => OL.IsLabel t (O.MethodProxy info SignalQuery) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif