{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Structs.BindingSignal
(
BindingSignal(..) ,
newZeroBindingSignal ,
#if defined(ENABLE_OVERLOADING)
ResolveBindingSignalMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
bindingSignal_nArgs ,
#endif
getBindingSignalNArgs ,
setBindingSignalNArgs ,
#if defined(ENABLE_OVERLOADING)
bindingSignal_next ,
#endif
clearBindingSignalNext ,
getBindingSignalNext ,
setBindingSignalNext ,
#if defined(ENABLE_OVERLOADING)
bindingSignal_signalName ,
#endif
clearBindingSignalSignalName ,
getBindingSignalSignalName ,
setBindingSignalSignalName ,
) 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
newtype BindingSignal = BindingSignal (SP.ManagedPtr BindingSignal)
deriving (BindingSignal -> BindingSignal -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BindingSignal -> BindingSignal -> Bool
$c/= :: BindingSignal -> BindingSignal -> Bool
== :: BindingSignal -> BindingSignal -> Bool
$c== :: BindingSignal -> BindingSignal -> Bool
Eq)
instance SP.ManagedPtrNewtype BindingSignal where
toManagedPtr :: BindingSignal -> ManagedPtr BindingSignal
toManagedPtr (BindingSignal ManagedPtr BindingSignal
p) = ManagedPtr BindingSignal
p
instance BoxedPtr BindingSignal where
boxedPtrCopy :: BindingSignal -> IO BindingSignal
boxedPtrCopy = \BindingSignal
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BindingSignal
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
32 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 BindingSignal -> BindingSignal
BindingSignal)
boxedPtrFree :: BindingSignal -> IO ()
boxedPtrFree = \BindingSignal
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr BindingSignal
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr BindingSignal where
boxedPtrCalloc :: IO (Ptr BindingSignal)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
32
newZeroBindingSignal :: MonadIO m => m BindingSignal
newZeroBindingSignal :: forall (m :: * -> *). MonadIO m => m BindingSignal
newZeroBindingSignal = 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 BindingSignal -> BindingSignal
BindingSignal
instance tag ~ 'AttrSet => Constructible BindingSignal tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr BindingSignal -> BindingSignal)
-> [AttrOp BindingSignal tag] -> m BindingSignal
new ManagedPtr BindingSignal -> BindingSignal
_ [AttrOp BindingSignal tag]
attrs = do
BindingSignal
o <- forall (m :: * -> *). MonadIO m => m BindingSignal
newZeroBindingSignal
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set BindingSignal
o [AttrOp BindingSignal tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return BindingSignal
o
getBindingSignalNext :: MonadIO m => BindingSignal -> m (Maybe BindingSignal)
getBindingSignalNext :: forall (m :: * -> *).
MonadIO m =>
BindingSignal -> m (Maybe BindingSignal)
getBindingSignalNext BindingSignal
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 BindingSignal
s forall a b. (a -> b) -> a -> b
$ \Ptr BindingSignal
ptr -> do
Ptr BindingSignal
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingSignal
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr BindingSignal)
Maybe BindingSignal
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr BindingSignal
val forall a b. (a -> b) -> a -> b
$ \Ptr BindingSignal
val' -> do
BindingSignal
val'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr BindingSignal -> BindingSignal
BindingSignal) Ptr BindingSignal
val'
forall (m :: * -> *) a. Monad m => a -> m a
return BindingSignal
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BindingSignal
result
setBindingSignalNext :: MonadIO m => BindingSignal -> Ptr BindingSignal -> m ()
setBindingSignalNext :: forall (m :: * -> *).
MonadIO m =>
BindingSignal -> Ptr BindingSignal -> m ()
setBindingSignalNext BindingSignal
s Ptr BindingSignal
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 BindingSignal
s forall a b. (a -> b) -> a -> b
$ \Ptr BindingSignal
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingSignal
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr BindingSignal
val :: Ptr BindingSignal)
clearBindingSignalNext :: MonadIO m => BindingSignal -> m ()
clearBindingSignalNext :: forall (m :: * -> *). MonadIO m => BindingSignal -> m ()
clearBindingSignalNext BindingSignal
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 BindingSignal
s forall a b. (a -> b) -> a -> b
$ \Ptr BindingSignal
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingSignal
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: Ptr BindingSignal)
#if defined(ENABLE_OVERLOADING)
data BindingSignalNextFieldInfo
instance AttrInfo BindingSignalNextFieldInfo where
type AttrBaseTypeConstraint BindingSignalNextFieldInfo = (~) BindingSignal
type AttrAllowedOps BindingSignalNextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint BindingSignalNextFieldInfo = (~) (Ptr BindingSignal)
type AttrTransferTypeConstraint BindingSignalNextFieldInfo = (~)(Ptr BindingSignal)
type AttrTransferType BindingSignalNextFieldInfo = (Ptr BindingSignal)
type AttrGetType BindingSignalNextFieldInfo = Maybe BindingSignal
type AttrLabel BindingSignalNextFieldInfo = "next"
type AttrOrigin BindingSignalNextFieldInfo = BindingSignal
attrGet = getBindingSignalNext
attrSet = setBindingSignalNext
attrConstruct = undefined
attrClear = clearBindingSignalNext
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.BindingSignal.next"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-BindingSignal.html#g:attr:next"
})
bindingSignal_next :: AttrLabelProxy "next"
bindingSignal_next = AttrLabelProxy
#endif
getBindingSignalSignalName :: MonadIO m => BindingSignal -> m (Maybe T.Text)
getBindingSignalSignalName :: forall (m :: * -> *). MonadIO m => BindingSignal -> m (Maybe Text)
getBindingSignalSignalName BindingSignal
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 BindingSignal
s forall a b. (a -> b) -> a -> b
$ \Ptr BindingSignal
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingSignal
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
setBindingSignalSignalName :: MonadIO m => BindingSignal -> CString -> m ()
setBindingSignalSignalName :: forall (m :: * -> *). MonadIO m => BindingSignal -> CString -> m ()
setBindingSignalSignalName BindingSignal
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 BindingSignal
s forall a b. (a -> b) -> a -> b
$ \Ptr BindingSignal
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingSignal
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CString
val :: CString)
clearBindingSignalSignalName :: MonadIO m => BindingSignal -> m ()
clearBindingSignalSignalName :: forall (m :: * -> *). MonadIO m => BindingSignal -> m ()
clearBindingSignalSignalName BindingSignal
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 BindingSignal
s forall a b. (a -> b) -> a -> b
$ \Ptr BindingSignal
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingSignal
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data BindingSignalSignalNameFieldInfo
instance AttrInfo BindingSignalSignalNameFieldInfo where
type AttrBaseTypeConstraint BindingSignalSignalNameFieldInfo = (~) BindingSignal
type AttrAllowedOps BindingSignalSignalNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint BindingSignalSignalNameFieldInfo = (~) CString
type AttrTransferTypeConstraint BindingSignalSignalNameFieldInfo = (~)CString
type AttrTransferType BindingSignalSignalNameFieldInfo = CString
type AttrGetType BindingSignalSignalNameFieldInfo = Maybe T.Text
type AttrLabel BindingSignalSignalNameFieldInfo = "signal_name"
type AttrOrigin BindingSignalSignalNameFieldInfo = BindingSignal
attrGet = getBindingSignalSignalName
attrSet = setBindingSignalSignalName
attrConstruct = undefined
attrClear = clearBindingSignalSignalName
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.BindingSignal.signalName"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-BindingSignal.html#g:attr:signalName"
})
bindingSignal_signalName :: AttrLabelProxy "signalName"
bindingSignal_signalName = AttrLabelProxy
#endif
getBindingSignalNArgs :: MonadIO m => BindingSignal -> m Word32
getBindingSignalNArgs :: forall (m :: * -> *). MonadIO m => BindingSignal -> m Word32
getBindingSignalNArgs BindingSignal
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 BindingSignal
s forall a b. (a -> b) -> a -> b
$ \Ptr BindingSignal
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr BindingSignal
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setBindingSignalNArgs :: MonadIO m => BindingSignal -> Word32 -> m ()
setBindingSignalNArgs :: forall (m :: * -> *). MonadIO m => BindingSignal -> Word32 -> m ()
setBindingSignalNArgs BindingSignal
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 BindingSignal
s forall a b. (a -> b) -> a -> b
$ \Ptr BindingSignal
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr BindingSignal
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data BindingSignalNArgsFieldInfo
instance AttrInfo BindingSignalNArgsFieldInfo where
type AttrBaseTypeConstraint BindingSignalNArgsFieldInfo = (~) BindingSignal
type AttrAllowedOps BindingSignalNArgsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint BindingSignalNArgsFieldInfo = (~) Word32
type AttrTransferTypeConstraint BindingSignalNArgsFieldInfo = (~)Word32
type AttrTransferType BindingSignalNArgsFieldInfo = Word32
type AttrGetType BindingSignalNArgsFieldInfo = Word32
type AttrLabel BindingSignalNArgsFieldInfo = "n_args"
type AttrOrigin BindingSignalNArgsFieldInfo = BindingSignal
attrGet = getBindingSignalNArgs
attrSet = setBindingSignalNArgs
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gtk.Structs.BindingSignal.nArgs"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtk-3.0.39/docs/GI-Gtk-Structs-BindingSignal.html#g:attr:nArgs"
})
bindingSignal_nArgs :: AttrLabelProxy "nArgs"
bindingSignal_nArgs = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BindingSignal
type instance O.AttributeList BindingSignal = BindingSignalAttributeList
type BindingSignalAttributeList = ('[ '("next", BindingSignalNextFieldInfo), '("signalName", BindingSignalSignalNameFieldInfo), '("nArgs", BindingSignalNArgsFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveBindingSignalMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveBindingSignalMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBindingSignalMethod t BindingSignal, O.OverloadedMethod info BindingSignal p) => OL.IsLabel t (BindingSignal -> 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 ~ ResolveBindingSignalMethod t BindingSignal, O.OverloadedMethod info BindingSignal p, R.HasField t BindingSignal p) => R.HasField t BindingSignal p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveBindingSignalMethod t BindingSignal, O.OverloadedMethodInfo info BindingSignal) => OL.IsLabel t (O.MethodProxy info BindingSignal) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif