#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Cogl.Callbacks
(
C_FuncPtr ,
FuncPtr ,
dynamic_FuncPtr ,
genClosure_FuncPtr ,
mk_FuncPtr ,
noFuncPtr ,
wrap_FuncPtr ,
) 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
type C_FuncPtr =
IO ()
foreign import ccall "dynamic" __dynamic_C_FuncPtr :: FunPtr C_FuncPtr -> C_FuncPtr
dynamic_FuncPtr ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_FuncPtr
-> m ()
dynamic_FuncPtr :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_FuncPtr -> m ()
dynamic_FuncPtr FunPtr C_FuncPtr
__funPtr = C_FuncPtr -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (C_FuncPtr -> m ()) -> C_FuncPtr -> m ()
forall a b. (a -> b) -> a -> b
$ do
(FunPtr C_FuncPtr -> C_FuncPtr
__dynamic_C_FuncPtr FunPtr C_FuncPtr
__funPtr)
() -> C_FuncPtr
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_FuncPtr :: C_FuncPtr -> IO (FunPtr C_FuncPtr)
type FuncPtr =
IO ()
noFuncPtr :: Maybe FuncPtr
noFuncPtr :: Maybe C_FuncPtr
noFuncPtr = Maybe C_FuncPtr
forall a. Maybe a
Nothing
genClosure_FuncPtr :: MonadIO m => FuncPtr -> m (GClosure C_FuncPtr)
genClosure_FuncPtr :: forall (m :: * -> *).
MonadIO m =>
C_FuncPtr -> m (GClosure C_FuncPtr)
genClosure_FuncPtr C_FuncPtr
cb = IO (GClosure C_FuncPtr) -> m (GClosure C_FuncPtr)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_FuncPtr) -> m (GClosure C_FuncPtr))
-> IO (GClosure C_FuncPtr) -> m (GClosure C_FuncPtr)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_FuncPtr
cb' = Maybe (Ptr (FunPtr C_FuncPtr)) -> C_FuncPtr -> C_FuncPtr
wrap_FuncPtr Maybe (Ptr (FunPtr C_FuncPtr))
forall a. Maybe a
Nothing C_FuncPtr
cb
C_FuncPtr -> IO (FunPtr C_FuncPtr)
mk_FuncPtr C_FuncPtr
cb' IO (FunPtr C_FuncPtr)
-> (FunPtr C_FuncPtr -> IO (GClosure C_FuncPtr))
-> IO (GClosure C_FuncPtr)
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_FuncPtr -> IO (GClosure C_FuncPtr)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_FuncPtr ::
Maybe (Ptr (FunPtr C_FuncPtr)) ->
FuncPtr ->
C_FuncPtr
wrap_FuncPtr :: Maybe (Ptr (FunPtr C_FuncPtr)) -> C_FuncPtr -> C_FuncPtr
wrap_FuncPtr Maybe (Ptr (FunPtr C_FuncPtr))
gi'funptrptr C_FuncPtr
gi'cb = do
C_FuncPtr
gi'cb
Maybe (Ptr (FunPtr C_FuncPtr)) -> C_FuncPtr
forall a. Maybe (Ptr (FunPtr a)) -> C_FuncPtr
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_FuncPtr))
gi'funptrptr