{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A structure holding in-depth information for a specific signal.
-- 
-- See also: 'GI.GObject.Functions.signalQuery'

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GObject.Structs.SignalQuery
    ( 

-- * Exported types
    SignalQuery(..)                         ,
    newZeroSignalQuery                      ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveSignalQueryMethod                ,
#endif



 -- * Properties


-- ** itype #attr:itype#
-- | The interface\/instance type that this signal can be emitted for.

    getSignalQueryItype                     ,
    setSignalQueryItype                     ,
#if defined(ENABLE_OVERLOADING)
    signalQuery_itype                       ,
#endif


-- ** nParams #attr:nParams#
-- | The number of parameters that user callbacks take.

    getSignalQueryNParams                   ,
    setSignalQueryNParams                   ,
#if defined(ENABLE_OVERLOADING)
    signalQuery_nParams                     ,
#endif


-- ** returnType #attr:returnType#
-- | The return type for user callbacks.

    getSignalQueryReturnType                ,
    setSignalQueryReturnType                ,
#if defined(ENABLE_OVERLOADING)
    signalQuery_returnType                  ,
#endif


-- ** signalFlags #attr:signalFlags#
-- | The signal flags as passed in to @/g_signal_new()/@.

    getSignalQuerySignalFlags               ,
    setSignalQuerySignalFlags               ,
#if defined(ENABLE_OVERLOADING)
    signalQuery_signalFlags                 ,
#endif


-- ** signalId #attr:signalId#
-- | The signal id of the signal being queried, or 0 if the
--  signal to be queried was unknown.

    getSignalQuerySignalId                  ,
    setSignalQuerySignalId                  ,
#if defined(ENABLE_OVERLOADING)
    signalQuery_signalId                    ,
#endif


-- ** signalName #attr:signalName#
-- | The signal name.

    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

-- | Memory-managed wrapper type.
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
56 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
56


-- | Construct a `SignalQuery` struct initialized to zero.
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


-- | Get the value of the “@signal_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' signalQuery #signalId
-- @
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

-- | Set the value of the “@signal_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' signalQuery [ #signalId 'Data.GI.Base.Attributes.:=' value ]
-- @
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


-- | Get the value of the “@signal_name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' signalQuery #signalName
-- @
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
8) :: 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

-- | Set the value of the “@signal_name@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' signalQuery [ #signalName 'Data.GI.Base.Attributes.:=' value ]
-- @
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
8) (CString
val :: CString)

-- | Set the value of the “@signal_name@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #signalName
-- @
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
8) (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


-- | Get the value of the “@itype@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' signalQuery #itype
-- @
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
    CGType
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' = CGType -> GType
GType CGType
val
    forall (m :: * -> *) a. Monad m => a -> m a
return GType
val'

-- | Set the value of the “@itype@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' signalQuery [ #itype 'Data.GI.Base.Attributes.:=' value ]
-- @
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' :: CGType
val' = GType -> CGType
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) (CGType
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


-- | Get the value of the “@signal_flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' signalQuery #signalFlags
-- @
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
24) :: 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'

-- | Set the value of the “@signal_flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' signalQuery [ #signalFlags 'Data.GI.Base.Attributes.:=' value ]
-- @
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
24) (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


-- | Get the value of the “@return_type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' signalQuery #returnType
-- @
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
    CGType
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CGType
    let val' :: GType
val' = CGType -> GType
GType CGType
val
    forall (m :: * -> *) a. Monad m => a -> m a
return GType
val'

-- | Set the value of the “@return_type@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' signalQuery [ #returnType 'Data.GI.Base.Attributes.:=' value ]
-- @
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' :: CGType
val' = GType -> CGType
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
32) (CGType
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


-- | Get the value of the “@n_params@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' signalQuery #nParams
-- @
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
40) :: IO Word32
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@n_params@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' signalQuery [ #nParams 'Data.GI.Base.Attributes.:=' value ]
-- @
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
40) (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


-- XXX Skipped attribute for "SignalQuery:param_types"
-- Not implemented: Don't know how to unpack C array of type TCArray False (-1) 5 (TBasicType TGType)

#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