-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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.Gdk.Callbacks
    ( 

 -- * Signals


-- ** ContentDeserializeFunc #signal:ContentDeserializeFunc#

    C_ContentDeserializeFunc                ,
    ContentDeserializeFunc                  ,
    dynamic_ContentDeserializeFunc          ,
    genClosure_ContentDeserializeFunc       ,
    mk_ContentDeserializeFunc               ,
    noContentDeserializeFunc                ,
    wrap_ContentDeserializeFunc             ,


-- ** ContentSerializeFunc #signal:ContentSerializeFunc#

    C_ContentSerializeFunc                  ,
    ContentSerializeFunc                    ,
    dynamic_ContentSerializeFunc            ,
    genClosure_ContentSerializeFunc         ,
    mk_ContentSerializeFunc                 ,
    noContentSerializeFunc                  ,
    wrap_ContentSerializeFunc               ,




    ) 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.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.Text as T
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.Gdk.Objects.ContentDeserializer as Gdk.ContentDeserializer
import {-# SOURCE #-} qualified GI.Gdk.Objects.ContentSerializer as Gdk.ContentSerializer

-- callback ContentSerializeFunc
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "serializer"
          , argType =
              TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GdkContentSerializer"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type of a function that can be registered with gdk_content_register_serializer().\nWhen the function gets called to operate on content, it can call functions on the\n@serializer object to obtain the mime type, output stream, user data, etc. for its\noperation."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_ContentSerializeFunc =
    Ptr Gdk.ContentSerializer.ContentSerializer ->
    IO ()

-- Args: [ Arg
--           { argCName = "serializer"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "ContentSerializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentSerializer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ContentSerializeFunc :: FunPtr C_ContentSerializeFunc -> C_ContentSerializeFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ContentSerializeFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gdk.ContentSerializer.IsContentSerializer a) =>
    FunPtr C_ContentSerializeFunc
    -> a
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> m ()
dynamic_ContentSerializeFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentSerializer a) =>
FunPtr C_ContentSerializeFunc -> a -> m ()
dynamic_ContentSerializeFunc FunPtr C_ContentSerializeFunc
__funPtr a
serializer = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ContentSerializer
serializer' <- a -> IO (Ptr ContentSerializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
serializer
    (FunPtr C_ContentSerializeFunc -> C_ContentSerializeFunc
__dynamic_C_ContentSerializeFunc FunPtr C_ContentSerializeFunc
__funPtr) Ptr ContentSerializer
serializer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
serializer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | The type of a function that can be registered with 'GI.Gdk.Functions.contentRegisterSerializer'.
-- When the function gets called to operate on content, it can call functions on the
-- /@serializer@/ object to obtain the mime type, output stream, user data, etc. for its
-- operation.
type ContentSerializeFunc =
    Gdk.ContentSerializer.ContentSerializer
    -- ^ /@serializer@/: a t'GI.Gdk.Objects.ContentSerializer.ContentSerializer'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ContentSerializeFunc`@.
noContentSerializeFunc :: Maybe ContentSerializeFunc
noContentSerializeFunc :: Maybe ContentSerializeFunc
noContentSerializeFunc = Maybe ContentSerializeFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ContentSerializeFunc :: MonadIO m => ContentSerializeFunc -> m (GClosure C_ContentSerializeFunc)
genClosure_ContentSerializeFunc :: forall (m :: * -> *).
MonadIO m =>
ContentSerializeFunc -> m (GClosure C_ContentSerializeFunc)
genClosure_ContentSerializeFunc ContentSerializeFunc
cb = IO (GClosure C_ContentSerializeFunc)
-> m (GClosure C_ContentSerializeFunc)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ContentSerializeFunc)
 -> m (GClosure C_ContentSerializeFunc))
-> IO (GClosure C_ContentSerializeFunc)
-> m (GClosure C_ContentSerializeFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ContentSerializeFunc
cb' = Maybe (Ptr (FunPtr C_ContentSerializeFunc))
-> ContentSerializeFunc -> C_ContentSerializeFunc
wrap_ContentSerializeFunc Maybe (Ptr (FunPtr C_ContentSerializeFunc))
forall a. Maybe a
Nothing ContentSerializeFunc
cb
    C_ContentSerializeFunc -> IO (FunPtr C_ContentSerializeFunc)
mk_ContentSerializeFunc C_ContentSerializeFunc
cb' IO (FunPtr C_ContentSerializeFunc)
-> (FunPtr C_ContentSerializeFunc
    -> IO (GClosure C_ContentSerializeFunc))
-> IO (GClosure C_ContentSerializeFunc)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ContentSerializeFunc
-> IO (GClosure C_ContentSerializeFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ContentSerializeFunc` into a `C_ContentSerializeFunc`.
wrap_ContentSerializeFunc ::
    Maybe (Ptr (FunPtr C_ContentSerializeFunc)) ->
    ContentSerializeFunc ->
    C_ContentSerializeFunc
wrap_ContentSerializeFunc :: Maybe (Ptr (FunPtr C_ContentSerializeFunc))
-> ContentSerializeFunc -> C_ContentSerializeFunc
wrap_ContentSerializeFunc Maybe (Ptr (FunPtr C_ContentSerializeFunc))
funptrptr ContentSerializeFunc
_cb Ptr ContentSerializer
serializer = do
    ContentSerializer
serializer' <- ((ManagedPtr ContentSerializer -> ContentSerializer)
-> Ptr ContentSerializer -> IO ContentSerializer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ContentSerializer -> ContentSerializer
Gdk.ContentSerializer.ContentSerializer) Ptr ContentSerializer
serializer
    ContentSerializeFunc
_cb  ContentSerializer
serializer'
    Maybe (Ptr (FunPtr C_ContentSerializeFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ContentSerializeFunc))
funptrptr


-- callback ContentDeserializeFunc
{- Callable
  { returnType = Nothing
  , returnMayBeNull = False
  , returnTransfer = TransferNothing
  , returnDocumentation =
      Documentation { rawDocText = Nothing , sinceVersion = Nothing }
  , args =
      [ Arg
          { argCName = "deserializer"
          , argType =
              TInterface
                Name { namespace = "Gdk" , name = "ContentDeserializer" }
          , direction = DirectionIn
          , mayBeNull = False
          , argDoc =
              Documentation
                { rawDocText = Just "a #GdkContentDeserializer"
                , sinceVersion = Nothing
                }
          , argScope = ScopeTypeInvalid
          , argClosure = -1
          , argDestroy = -1
          , argCallerAllocates = False
          , transfer = TransferNothing
          }
      ]
  , skipReturn = False
  , callableThrows = False
  , callableDeprecated = Nothing
  , callableDocumentation =
      Documentation
        { rawDocText =
            Just
              "The type of a function that can be registered with gdk_content_register_deserializer().\nWhen the function gets called to operate on content, it can call functions on the\n@deserializer object to obtain the mime type, input stream, user data, etc. for its\noperation."
        , sinceVersion = Nothing
        }
  , callableResolvable = Nothing
  }
-}
-- | Type for the callback on the (unwrapped) C side.
type C_ContentDeserializeFunc =
    Ptr Gdk.ContentDeserializer.ContentDeserializer ->
    IO ()

-- Args: [ Arg
--           { argCName = "deserializer"
--           , argType =
--               TInterface
--                 Name { namespace = "Gdk" , name = "ContentDeserializer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GdkContentDeserializer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_ContentDeserializeFunc :: FunPtr C_ContentDeserializeFunc -> C_ContentDeserializeFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_ContentDeserializeFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gdk.ContentDeserializer.IsContentDeserializer a) =>
    FunPtr C_ContentDeserializeFunc
    -> a
    -- ^ /@deserializer@/: a t'GI.Gdk.Objects.ContentDeserializer.ContentDeserializer'
    -> m ()
dynamic_ContentDeserializeFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsContentDeserializer a) =>
FunPtr C_ContentDeserializeFunc -> a -> m ()
dynamic_ContentDeserializeFunc FunPtr C_ContentDeserializeFunc
__funPtr a
deserializer = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ContentDeserializer
deserializer' <- a -> IO (Ptr ContentDeserializer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
deserializer
    (FunPtr C_ContentDeserializeFunc -> C_ContentDeserializeFunc
__dynamic_C_ContentDeserializeFunc FunPtr C_ContentDeserializeFunc
__funPtr) Ptr ContentDeserializer
deserializer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
deserializer
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | The type of a function that can be registered with 'GI.Gdk.Functions.contentRegisterDeserializer'.
-- When the function gets called to operate on content, it can call functions on the
-- /@deserializer@/ object to obtain the mime type, input stream, user data, etc. for its
-- operation.
type ContentDeserializeFunc =
    Gdk.ContentDeserializer.ContentDeserializer
    -- ^ /@deserializer@/: a t'GI.Gdk.Objects.ContentDeserializer.ContentDeserializer'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ContentDeserializeFunc`@.
noContentDeserializeFunc :: Maybe ContentDeserializeFunc
noContentDeserializeFunc :: Maybe ContentDeserializeFunc
noContentDeserializeFunc = Maybe ContentDeserializeFunc
forall a. Maybe a
Nothing

-- | Wrap the callback into a `GClosure`.
genClosure_ContentDeserializeFunc :: MonadIO m => ContentDeserializeFunc -> m (GClosure C_ContentDeserializeFunc)
genClosure_ContentDeserializeFunc :: forall (m :: * -> *).
MonadIO m =>
ContentDeserializeFunc -> m (GClosure C_ContentDeserializeFunc)
genClosure_ContentDeserializeFunc ContentDeserializeFunc
cb = IO (GClosure C_ContentDeserializeFunc)
-> m (GClosure C_ContentDeserializeFunc)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ContentDeserializeFunc)
 -> m (GClosure C_ContentDeserializeFunc))
-> IO (GClosure C_ContentDeserializeFunc)
-> m (GClosure C_ContentDeserializeFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ContentDeserializeFunc
cb' = Maybe (Ptr (FunPtr C_ContentDeserializeFunc))
-> ContentDeserializeFunc -> C_ContentDeserializeFunc
wrap_ContentDeserializeFunc Maybe (Ptr (FunPtr C_ContentDeserializeFunc))
forall a. Maybe a
Nothing ContentDeserializeFunc
cb
    C_ContentDeserializeFunc -> IO (FunPtr C_ContentDeserializeFunc)
mk_ContentDeserializeFunc C_ContentDeserializeFunc
cb' IO (FunPtr C_ContentDeserializeFunc)
-> (FunPtr C_ContentDeserializeFunc
    -> IO (GClosure C_ContentDeserializeFunc))
-> IO (GClosure C_ContentDeserializeFunc)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ContentDeserializeFunc
-> IO (GClosure C_ContentDeserializeFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `ContentDeserializeFunc` into a `C_ContentDeserializeFunc`.
wrap_ContentDeserializeFunc ::
    Maybe (Ptr (FunPtr C_ContentDeserializeFunc)) ->
    ContentDeserializeFunc ->
    C_ContentDeserializeFunc
wrap_ContentDeserializeFunc :: Maybe (Ptr (FunPtr C_ContentDeserializeFunc))
-> ContentDeserializeFunc -> C_ContentDeserializeFunc
wrap_ContentDeserializeFunc Maybe (Ptr (FunPtr C_ContentDeserializeFunc))
funptrptr ContentDeserializeFunc
_cb Ptr ContentDeserializer
deserializer = do
    ContentDeserializer
deserializer' <- ((ManagedPtr ContentDeserializer -> ContentDeserializer)
-> Ptr ContentDeserializer -> IO ContentDeserializer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ContentDeserializer -> ContentDeserializer
Gdk.ContentDeserializer.ContentDeserializer) Ptr ContentDeserializer
deserializer
    ContentDeserializeFunc
_cb  ContentDeserializer
deserializer'
    Maybe (Ptr (FunPtr C_ContentDeserializeFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_ContentDeserializeFunc))
funptrptr