{-# 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 ,
noSignalQuery ,
#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags
newtype SignalQuery = SignalQuery (ManagedPtr SignalQuery)
deriving (Eq)
instance WrappedPtr SignalQuery where
wrappedPtrCalloc = callocBytes 56
wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 56 >=> wrapPtr SignalQuery)
wrappedPtrFree = Just ptr_to_g_free
newZeroSignalQuery :: MonadIO m => m SignalQuery
newZeroSignalQuery = liftIO $ wrappedPtrCalloc >>= wrapPtr SignalQuery
instance tag ~ 'AttrSet => Constructible SignalQuery tag where
new _ attrs = do
o <- newZeroSignalQuery
GI.Attributes.set o attrs
return o
noSignalQuery :: Maybe SignalQuery
noSignalQuery = Nothing
getSignalQuerySignalId :: MonadIO m => SignalQuery -> m Word32
getSignalQuerySignalId s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 0) :: IO Word32
return val
setSignalQuerySignalId :: MonadIO m => SignalQuery -> Word32 -> m ()
setSignalQuerySignalId s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 0) (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
signalQuery_signalId :: AttrLabelProxy "signalId"
signalQuery_signalId = AttrLabelProxy
#endif
getSignalQuerySignalName :: MonadIO m => SignalQuery -> m (Maybe T.Text)
getSignalQuerySignalName s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 8) :: IO CString
result <- SP.convertIfNonNull val $ \val' -> do
val'' <- cstringToText val'
return val''
return result
setSignalQuerySignalName :: MonadIO m => SignalQuery -> CString -> m ()
setSignalQuerySignalName s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (val :: CString)
clearSignalQuerySignalName :: MonadIO m => SignalQuery -> m ()
clearSignalQuerySignalName s = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 8) (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
signalQuery_signalName :: AttrLabelProxy "signalName"
signalQuery_signalName = AttrLabelProxy
#endif
getSignalQueryItype :: MonadIO m => SignalQuery -> m GType
getSignalQueryItype s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 16) :: IO CGType
let val' = GType val
return val'
setSignalQueryItype :: MonadIO m => SignalQuery -> GType -> m ()
setSignalQueryItype s val = liftIO $ withManagedPtr s $ \ptr -> do
let val' = gtypeToCGType val
poke (ptr `plusPtr` 16) (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
signalQuery_itype :: AttrLabelProxy "itype"
signalQuery_itype = AttrLabelProxy
#endif
getSignalQuerySignalFlags :: MonadIO m => SignalQuery -> m [GObject.Flags.SignalFlags]
getSignalQuerySignalFlags s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 24) :: IO CUInt
let val' = wordToGFlags val
return val'
setSignalQuerySignalFlags :: MonadIO m => SignalQuery -> [GObject.Flags.SignalFlags] -> m ()
setSignalQuerySignalFlags s val = liftIO $ withManagedPtr s $ \ptr -> do
let val' = gflagsToWord val
poke (ptr `plusPtr` 24) (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
signalQuery_signalFlags :: AttrLabelProxy "signalFlags"
signalQuery_signalFlags = AttrLabelProxy
#endif
getSignalQueryReturnType :: MonadIO m => SignalQuery -> m GType
getSignalQueryReturnType s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 32) :: IO CGType
let val' = GType val
return val'
setSignalQueryReturnType :: MonadIO m => SignalQuery -> GType -> m ()
setSignalQueryReturnType s val = liftIO $ withManagedPtr s $ \ptr -> do
let val' = gtypeToCGType val
poke (ptr `plusPtr` 32) (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
signalQuery_returnType :: AttrLabelProxy "returnType"
signalQuery_returnType = AttrLabelProxy
#endif
getSignalQueryNParams :: MonadIO m => SignalQuery -> m Word32
getSignalQueryNParams s = liftIO $ withManagedPtr s $ \ptr -> do
val <- peek (ptr `plusPtr` 40) :: IO Word32
return val
setSignalQueryNParams :: MonadIO m => SignalQuery -> Word32 -> m ()
setSignalQueryNParams s val = liftIO $ withManagedPtr s $ \ptr -> do
poke (ptr `plusPtr` 40) (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
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, *)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveSignalQueryMethod (t :: Symbol) (o :: *) :: * where
ResolveSignalQueryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveSignalQueryMethod t SignalQuery, O.MethodInfo 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
#endif