-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.Cogl.Callbacks
    ( 

 -- * Signals


-- ** FuncPtr #signal:FuncPtr#

    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


-- callback FuncPtr
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args = []
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type used by cogl for function pointers, note that this type\nis used as a generic catch-all cast for function pointers and the\nactual arguments and return type may be different."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_FuncPtr =
    IO ()

-- Args: []
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_FuncPtr :: FunPtr C_FuncPtr -> C_FuncPtr

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
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 ()

-- | Generate a function pointer callable from C code, from a `C_FuncPtr`.
foreign import ccall "wrapper"
    mk_FuncPtr :: C_FuncPtr -> IO (FunPtr C_FuncPtr)

-- | The type used by cogl for function pointers, note that this type
-- is used as a generic catch-all cast for function pointers and the
-- actual arguments and return type may be different.
type FuncPtr =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `FuncPtr`@.
noFuncPtr :: Maybe FuncPtr
noFuncPtr :: Maybe C_FuncPtr
noFuncPtr = Maybe C_FuncPtr
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
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 a `FuncPtr` into a `C_FuncPtr`.
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