{-# 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


-- ** paramTypes #attr:paramTypes#
-- | The individual parameter types for
--  user callbacks, note that the effective callback signature is:
--  
-- === /C code/
-- >
-- > @return_type callback (#gpointer     data1,
-- > [param_types param_names,]
-- > gpointer     data2);
-- > 

    clearSignalQueryParamTypes              ,
    getSignalQueryParamTypes                ,
    setSignalQueryParamTypes                ,
#if defined(ENABLE_OVERLOADING)
    signalQuery_paramTypes                  ,
#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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified Data.Bits as DB
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags

#else
import {-# SOURCE #-} qualified GI.GObject.Flags as GObject.Flags

#endif

-- | Memory-managed wrapper type.
newtype SignalQuery = SignalQuery (SP.ManagedPtr SignalQuery)
    deriving (SignalQuery -> SignalQuery -> Bool
(SignalQuery -> SignalQuery -> Bool)
-> (SignalQuery -> SignalQuery -> Bool) -> Eq SignalQuery
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SignalQuery -> SignalQuery -> Bool
== :: SignalQuery -> SignalQuery -> Bool
$c/= :: SignalQuery -> SignalQuery -> Bool
/= :: 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 -> SignalQuery
-> (Ptr SignalQuery -> IO SignalQuery) -> IO SignalQuery
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SignalQuery
p (Int -> Ptr SignalQuery -> IO (Ptr SignalQuery)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
56 (Ptr SignalQuery -> IO (Ptr SignalQuery))
-> (Ptr SignalQuery -> IO SignalQuery)
-> Ptr SignalQuery
-> IO SignalQuery
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr SignalQuery -> SignalQuery)
-> Ptr SignalQuery -> IO SignalQuery
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 -> SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr SignalQuery
x Ptr SignalQuery -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr SignalQuery where
    boxedPtrCalloc :: IO (Ptr SignalQuery)
boxedPtrCalloc = Int -> IO (Ptr SignalQuery)
forall a. Int -> IO (Ptr a)
callocBytes Int
56


-- | Construct a t'SignalQuery' struct initialized to zero.
newZeroSignalQuery :: MonadIO m => m SignalQuery
newZeroSignalQuery :: forall (m :: * -> *). MonadIO m => m SignalQuery
newZeroSignalQuery = IO SignalQuery -> m SignalQuery
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalQuery -> m SignalQuery)
-> IO SignalQuery -> m SignalQuery
forall a b. (a -> b) -> a -> b
$ IO (Ptr SignalQuery)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr SignalQuery)
-> (Ptr SignalQuery -> IO SignalQuery) -> IO SignalQuery
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr SignalQuery -> SignalQuery)
-> Ptr SignalQuery -> IO SignalQuery
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
        o <- m SignalQuery
forall (m :: * -> *). MonadIO m => m SignalQuery
newZeroSignalQuery
        GI.Attributes.set o attrs
        return 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 = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO Word32) -> IO Word32)
-> (Ptr SignalQuery -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Word32
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO ()) -> IO ())
-> (Ptr SignalQuery -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr Word32
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 :: forall o.
AttrBaseTypeConstraint SignalQuerySignalIdFieldInfo o =>
o -> IO (AttrGetType SignalQuerySignalIdFieldInfo)
attrGet = o -> IO (AttrGetType SignalQuerySignalIdFieldInfo)
SignalQuery -> IO Word32
forall (m :: * -> *). MonadIO m => SignalQuery -> m Word32
getSignalQuerySignalId
    attrSet :: forall o b.
(AttrBaseTypeConstraint SignalQuerySignalIdFieldInfo o,
 AttrSetTypeConstraint SignalQuerySignalIdFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
SignalQuery -> Word32 -> IO ()
forall (m :: * -> *). MonadIO m => SignalQuery -> Word32 -> m ()
setSignalQuerySignalId
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint SignalQuerySignalIdFieldInfo o,
 AttrSetTypeConstraint SignalQuerySignalIdFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint SignalQuerySignalIdFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint SignalQuerySignalIdFieldInfo o,
 AttrTransferTypeConstraint SignalQuerySignalIdFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType SignalQuerySignalIdFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.SignalQuery.signalId"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-SignalQuery.html#g:attr:signalId"
        })

signalQuery_signalId :: AttrLabelProxy "signalId"
signalQuery_signalId :: AttrLabelProxy "signalId"
signalQuery_signalId = AttrLabelProxy "signalId"
forall (a :: Symbol). AttrLabelProxy a
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 = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ SignalQuery
-> (Ptr SignalQuery -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr SignalQuery -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CString
    result <- SP.convertIfNonNull val $ \CString
val' -> do
        val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        return val''
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO ()) -> IO ())
-> (Ptr SignalQuery -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr CString
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO ()) -> IO ())
-> (Ptr SignalQuery -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
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 :: forall o.
AttrBaseTypeConstraint SignalQuerySignalNameFieldInfo o =>
o -> IO (AttrGetType SignalQuerySignalNameFieldInfo)
attrGet = o -> IO (AttrGetType SignalQuerySignalNameFieldInfo)
SignalQuery -> IO (Maybe Text)
forall (m :: * -> *). MonadIO m => SignalQuery -> m (Maybe Text)
getSignalQuerySignalName
    attrSet :: forall o b.
(AttrBaseTypeConstraint SignalQuerySignalNameFieldInfo o,
 AttrSetTypeConstraint SignalQuerySignalNameFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
SignalQuery -> CString -> IO ()
forall (m :: * -> *). MonadIO m => SignalQuery -> CString -> m ()
setSignalQuerySignalName
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint SignalQuerySignalNameFieldInfo o,
 AttrSetTypeConstraint SignalQuerySignalNameFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint SignalQuerySignalNameFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
SignalQuery -> IO ()
forall (m :: * -> *). MonadIO m => SignalQuery -> m ()
clearSignalQuerySignalName
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint SignalQuerySignalNameFieldInfo o,
 AttrTransferTypeConstraint SignalQuerySignalNameFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType SignalQuerySignalNameFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.SignalQuery.signalName"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-SignalQuery.html#g:attr:signalName"
        })

signalQuery_signalName :: AttrLabelProxy "signalName"
signalQuery_signalName :: AttrLabelProxy "signalName"
signalQuery_signalName = AttrLabelProxy "signalName"
forall (a :: Symbol). AttrLabelProxy a
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 = IO GType -> m GType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO GType) -> IO GType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO GType) -> IO GType)
-> (Ptr SignalQuery -> IO GType) -> IO GType
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    val <- Ptr CGType -> IO CGType
forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr CGType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CGType
    let val' = CGType -> GType
GType CGType
val
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO ()) -> IO ())
-> (Ptr SignalQuery -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    let val' :: CGType
val' = GType -> CGType
gtypeToCGType GType
val
    Ptr CGType -> CGType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr CGType
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 :: forall o.
AttrBaseTypeConstraint SignalQueryItypeFieldInfo o =>
o -> IO (AttrGetType SignalQueryItypeFieldInfo)
attrGet = o -> IO (AttrGetType SignalQueryItypeFieldInfo)
SignalQuery -> IO GType
forall (m :: * -> *). MonadIO m => SignalQuery -> m GType
getSignalQueryItype
    attrSet :: forall o b.
(AttrBaseTypeConstraint SignalQueryItypeFieldInfo o,
 AttrSetTypeConstraint SignalQueryItypeFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
SignalQuery -> GType -> IO ()
forall (m :: * -> *). MonadIO m => SignalQuery -> GType -> m ()
setSignalQueryItype
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint SignalQueryItypeFieldInfo o,
 AttrSetTypeConstraint SignalQueryItypeFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint SignalQueryItypeFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint SignalQueryItypeFieldInfo o,
 AttrTransferTypeConstraint SignalQueryItypeFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType SignalQueryItypeFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.SignalQuery.itype"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-SignalQuery.html#g:attr:itype"
        })

signalQuery_itype :: AttrLabelProxy "itype"
signalQuery_itype :: AttrLabelProxy "itype"
signalQuery_itype = AttrLabelProxy "itype"
forall (a :: Symbol). AttrLabelProxy a
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 = IO [SignalFlags] -> m [SignalFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [SignalFlags] -> m [SignalFlags])
-> IO [SignalFlags] -> m [SignalFlags]
forall a b. (a -> b) -> a -> b
$ SignalQuery
-> (Ptr SignalQuery -> IO [SignalFlags]) -> IO [SignalFlags]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO [SignalFlags]) -> IO [SignalFlags])
-> (Ptr SignalQuery -> IO [SignalFlags]) -> IO [SignalFlags]
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CUInt
    let val' = CUInt -> [SignalFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO ()) -> IO ())
-> (Ptr SignalQuery -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    let val' :: CUInt
val' = [SignalFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [SignalFlags]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr CUInt
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 :: forall o.
AttrBaseTypeConstraint SignalQuerySignalFlagsFieldInfo o =>
o -> IO (AttrGetType SignalQuerySignalFlagsFieldInfo)
attrGet = o -> IO (AttrGetType SignalQuerySignalFlagsFieldInfo)
SignalQuery -> IO [SignalFlags]
forall (m :: * -> *). MonadIO m => SignalQuery -> m [SignalFlags]
getSignalQuerySignalFlags
    attrSet :: forall o b.
(AttrBaseTypeConstraint SignalQuerySignalFlagsFieldInfo o,
 AttrSetTypeConstraint SignalQuerySignalFlagsFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
SignalQuery -> [SignalFlags] -> IO ()
forall (m :: * -> *).
MonadIO m =>
SignalQuery -> [SignalFlags] -> m ()
setSignalQuerySignalFlags
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint SignalQuerySignalFlagsFieldInfo o,
 AttrSetTypeConstraint SignalQuerySignalFlagsFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint SignalQuerySignalFlagsFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint SignalQuerySignalFlagsFieldInfo o,
 AttrTransferTypeConstraint SignalQuerySignalFlagsFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType SignalQuerySignalFlagsFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.SignalQuery.signalFlags"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-SignalQuery.html#g:attr:signalFlags"
        })

signalQuery_signalFlags :: AttrLabelProxy "signalFlags"
signalQuery_signalFlags :: AttrLabelProxy "signalFlags"
signalQuery_signalFlags = AttrLabelProxy "signalFlags"
forall (a :: Symbol). AttrLabelProxy a
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 = IO GType -> m GType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO GType) -> IO GType
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO GType) -> IO GType)
-> (Ptr SignalQuery -> IO GType) -> IO GType
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    val <- Ptr CGType -> IO CGType
forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr CGType
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CGType
    let val' = CGType -> GType
GType CGType
val
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO ()) -> IO ())
-> (Ptr SignalQuery -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    let val' :: CGType
val' = GType -> CGType
gtypeToCGType GType
val
    Ptr CGType -> CGType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr CGType
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 :: forall o.
AttrBaseTypeConstraint SignalQueryReturnTypeFieldInfo o =>
o -> IO (AttrGetType SignalQueryReturnTypeFieldInfo)
attrGet = o -> IO (AttrGetType SignalQueryReturnTypeFieldInfo)
SignalQuery -> IO GType
forall (m :: * -> *). MonadIO m => SignalQuery -> m GType
getSignalQueryReturnType
    attrSet :: forall o b.
(AttrBaseTypeConstraint SignalQueryReturnTypeFieldInfo o,
 AttrSetTypeConstraint SignalQueryReturnTypeFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
SignalQuery -> GType -> IO ()
forall (m :: * -> *). MonadIO m => SignalQuery -> GType -> m ()
setSignalQueryReturnType
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint SignalQueryReturnTypeFieldInfo o,
 AttrSetTypeConstraint SignalQueryReturnTypeFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint SignalQueryReturnTypeFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint SignalQueryReturnTypeFieldInfo o,
 AttrTransferTypeConstraint SignalQueryReturnTypeFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType SignalQueryReturnTypeFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.SignalQuery.returnType"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-SignalQuery.html#g:attr:returnType"
        })

signalQuery_returnType :: AttrLabelProxy "returnType"
signalQuery_returnType :: AttrLabelProxy "returnType"
signalQuery_returnType = AttrLabelProxy "returnType"
forall (a :: Symbol). AttrLabelProxy a
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 = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO Word32) -> IO Word32)
-> (Ptr SignalQuery -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO Word32
    return 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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO ()) -> IO ())
-> (Ptr SignalQuery -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr Word32
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 :: forall o.
AttrBaseTypeConstraint SignalQueryNParamsFieldInfo o =>
o -> IO (AttrGetType SignalQueryNParamsFieldInfo)
attrGet = o -> IO (AttrGetType SignalQueryNParamsFieldInfo)
SignalQuery -> IO Word32
forall (m :: * -> *). MonadIO m => SignalQuery -> m Word32
getSignalQueryNParams
    attrSet :: forall o b.
(AttrBaseTypeConstraint SignalQueryNParamsFieldInfo o,
 AttrSetTypeConstraint SignalQueryNParamsFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
SignalQuery -> Word32 -> IO ()
forall (m :: * -> *). MonadIO m => SignalQuery -> Word32 -> m ()
setSignalQueryNParams
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint SignalQueryNParamsFieldInfo o,
 AttrSetTypeConstraint SignalQueryNParamsFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint SignalQueryNParamsFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
forall a. HasCallStack => a
undefined
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint SignalQueryNParamsFieldInfo o,
 AttrTransferTypeConstraint SignalQueryNParamsFieldInfo b) =>
Proxy o -> b -> IO (AttrTransferType SignalQueryNParamsFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.SignalQuery.nParams"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-SignalQuery.html#g:attr:nParams"
        })

signalQuery_nParams :: AttrLabelProxy "nParams"
signalQuery_nParams :: AttrLabelProxy "nParams"
signalQuery_nParams = AttrLabelProxy "nParams"
forall (a :: Symbol). AttrLabelProxy a
AttrLabelProxy

#endif


-- | Get the value of the “@param_types@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' signalQuery #paramTypes
-- @
getSignalQueryParamTypes :: MonadIO m => SignalQuery -> m (Maybe [GType])
getSignalQueryParamTypes :: forall (m :: * -> *). MonadIO m => SignalQuery -> m (Maybe [GType])
getSignalQueryParamTypes SignalQuery
s = IO (Maybe [GType]) -> m (Maybe [GType])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [GType]) -> m (Maybe [GType]))
-> IO (Maybe [GType]) -> m (Maybe [GType])
forall a b. (a -> b) -> a -> b
$ SignalQuery
-> (Ptr SignalQuery -> IO (Maybe [GType])) -> IO (Maybe [GType])
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO (Maybe [GType])) -> IO (Maybe [GType]))
-> (Ptr SignalQuery -> IO (Maybe [GType])) -> IO (Maybe [GType])
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    val <- Ptr (Ptr CGType) -> IO (Ptr CGType)
forall a. Storable a => Ptr a -> IO a
peek (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr (Ptr CGType)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO (Ptr CGType)
    len <- peek (ptr `plusPtr` 40) :: IO Word32
    result <- SP.convertIfNonNull val $ \Ptr CGType
val' -> do
        val'' <- ((CGType -> GType) -> Word32 -> Ptr CGType -> IO [GType]
forall a b c.
(Integral a, Storable b) =>
(b -> c) -> a -> Ptr b -> IO [c]
unpackMapStorableArrayWithLength CGType -> GType
GType Word32
len) Ptr CGType
val'
        return val''
    return result

-- | Set the value of the “@param_types@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' signalQuery [ #paramTypes 'Data.GI.Base.Attributes.:=' value ]
-- @
setSignalQueryParamTypes :: MonadIO m => SignalQuery -> Ptr CGType -> m ()
setSignalQueryParamTypes :: forall (m :: * -> *).
MonadIO m =>
SignalQuery -> Ptr CGType -> m ()
setSignalQueryParamTypes SignalQuery
s Ptr CGType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO ()) -> IO ())
-> (Ptr SignalQuery -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    Ptr (Ptr CGType) -> Ptr CGType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr (Ptr CGType)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (Ptr CGType
val :: Ptr CGType)

-- | Set the value of the “@param_types@” 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' #paramTypes
-- @
clearSignalQueryParamTypes :: MonadIO m => SignalQuery -> m ()
clearSignalQueryParamTypes :: forall (m :: * -> *). MonadIO m => SignalQuery -> m ()
clearSignalQueryParamTypes SignalQuery
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SignalQuery -> (Ptr SignalQuery -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SignalQuery
s ((Ptr SignalQuery -> IO ()) -> IO ())
-> (Ptr SignalQuery -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SignalQuery
ptr -> do
    Ptr (Ptr CGType) -> Ptr CGType -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SignalQuery
ptr Ptr SignalQuery -> Int -> Ptr (Ptr CGType)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (Ptr CGType
forall a. Ptr a
FP.nullPtr :: Ptr CGType)

#if defined(ENABLE_OVERLOADING)
data SignalQueryParamTypesFieldInfo
instance AttrInfo SignalQueryParamTypesFieldInfo where
    type AttrBaseTypeConstraint SignalQueryParamTypesFieldInfo = (~) SignalQuery
    type AttrAllowedOps SignalQueryParamTypesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint SignalQueryParamTypesFieldInfo = (~) (Ptr CGType)
    type AttrTransferTypeConstraint SignalQueryParamTypesFieldInfo = (~)(Ptr CGType)
    type AttrTransferType SignalQueryParamTypesFieldInfo = (Ptr CGType)
    type AttrGetType SignalQueryParamTypesFieldInfo = Maybe [GType]
    type AttrLabel SignalQueryParamTypesFieldInfo = "param_types"
    type AttrOrigin SignalQueryParamTypesFieldInfo = SignalQuery
    attrGet :: forall o.
AttrBaseTypeConstraint SignalQueryParamTypesFieldInfo o =>
o -> IO (AttrGetType SignalQueryParamTypesFieldInfo)
attrGet = o -> IO (AttrGetType SignalQueryParamTypesFieldInfo)
SignalQuery -> IO (Maybe [GType])
forall (m :: * -> *). MonadIO m => SignalQuery -> m (Maybe [GType])
getSignalQueryParamTypes
    attrSet :: forall o b.
(AttrBaseTypeConstraint SignalQueryParamTypesFieldInfo o,
 AttrSetTypeConstraint SignalQueryParamTypesFieldInfo b) =>
o -> b -> IO ()
attrSet = o -> b -> IO ()
SignalQuery -> Ptr CGType -> IO ()
forall (m :: * -> *).
MonadIO m =>
SignalQuery -> Ptr CGType -> m ()
setSignalQueryParamTypes
    attrConstruct :: forall o b.
(AttrBaseTypeConstraint SignalQueryParamTypesFieldInfo o,
 AttrSetTypeConstraint SignalQueryParamTypesFieldInfo b) =>
b -> IO (GValueConstruct o)
attrConstruct = b -> IO (GValueConstruct o)
forall a. HasCallStack => a
undefined
    attrClear :: forall o.
AttrBaseTypeConstraint SignalQueryParamTypesFieldInfo o =>
o -> IO ()
attrClear = o -> IO ()
SignalQuery -> IO ()
forall (m :: * -> *). MonadIO m => SignalQuery -> m ()
clearSignalQueryParamTypes
    attrTransfer :: forall o b.
(AttrBaseTypeConstraint SignalQueryParamTypesFieldInfo o,
 AttrTransferTypeConstraint SignalQueryParamTypesFieldInfo b) =>
Proxy o
-> b -> IO (AttrTransferType SignalQueryParamTypesFieldInfo)
attrTransfer Proxy o
_ b
v = do
        b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
v
    dbgAttrInfo :: Maybe ResolvedSymbolInfo
dbgAttrInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
        resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GObject.Structs.SignalQuery.paramTypes"
        , resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-gobject-2.0.32/docs/GI-GObject-Structs-SignalQuery.html#g:attr:paramTypes"
        })

signalQuery_paramTypes :: AttrLabelProxy "paramTypes"
signalQuery_paramTypes :: AttrLabelProxy "paramTypes"
signalQuery_paramTypes = AttrLabelProxy "paramTypes"
forall (a :: Symbol). AttrLabelProxy a
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), '("paramTypes", SignalQueryParamTypesFieldInfo)] :: [(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 :: SignalQuery -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
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 :: SignalQuery -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
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 :: MethodProxy info SignalQuery
fromLabel = MethodProxy info SignalQuery
forall info obj. MethodProxy info obj
O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif