-- | 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               ,


-- ** SeatGrabPrepareFunc #signal:SeatGrabPrepareFunc#

    C_SeatGrabPrepareFunc                   ,
    SeatGrabPrepareFunc                     ,
    SeatGrabPrepareFunc_WithClosures        ,
    drop_closures_SeatGrabPrepareFunc       ,
    dynamic_SeatGrabPrepareFunc             ,
    genClosure_SeatGrabPrepareFunc          ,
    mk_SeatGrabPrepareFunc                  ,
    noSeatGrabPrepareFunc                   ,
    noSeatGrabPrepareFunc_WithClosures      ,
    wrap_SeatGrabPrepareFunc                ,




    ) 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.ManagedPtr as B.ManagedPtr
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 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 {-# SOURCE #-} qualified GI.Gdk.Objects.ContentDeserializer as Gdk.ContentDeserializer
import {-# SOURCE #-} qualified GI.Gdk.Objects.ContentSerializer as Gdk.ContentSerializer
import {-# SOURCE #-} qualified GI.Gdk.Objects.Seat as Gdk.Seat
import {-# SOURCE #-} qualified GI.Gdk.Objects.Surface as Gdk.Surface

-- callback SeatGrabPrepareFunc
--          -> Callable {returnType = Nothing, returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, args = [Arg {argCName = "seat", argType = TInterface (Name {namespace = "Gdk", name = "Seat"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkSeat being grabbed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "surface", argType = TInterface (Name {namespace = "Gdk", name = "Surface"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkSurface being grabbed", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed in gdk_seat_grab()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = False, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Type of the callback used to set up @surface so it can be\ngrabbed. A typical action would be ensuring the surface is\nvisible, although there's room for other initialization\nactions.", sinceVersion = Nothing}}
-- | Type for the callback on the (unwrapped) C side.
type C_SeatGrabPrepareFunc =
    Ptr Gdk.Seat.Seat ->
    Ptr Gdk.Surface.Surface ->
    Ptr () ->
    IO ()

-- Args: [ Arg
--           { argCName = "seat"
--           , argType = TInterface Name { namespace = "Gdk" , name = "Seat" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GdkSeat being grabbed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "surface"
--           , argType =
--               TInterface Name { namespace = "Gdk" , name = "Surface" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GdkSurface being grabbed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "user data passed in gdk_seat_grab()"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "dynamic" __dynamic_C_SeatGrabPrepareFunc :: FunPtr C_SeatGrabPrepareFunc -> C_SeatGrabPrepareFunc

-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell.
dynamic_SeatGrabPrepareFunc ::
    (B.CallStack.HasCallStack, MonadIO m, Gdk.Seat.IsSeat a, Gdk.Surface.IsSurface b) =>
    FunPtr C_SeatGrabPrepareFunc
    -> a
    -- ^ /@seat@/: the t'GI.Gdk.Objects.Seat.Seat' being grabbed
    -> b
    -- ^ /@surface@/: the t'GI.Gdk.Objects.Surface.Surface' being grabbed
    -> Ptr ()
    -- ^ /@userData@/: user data passed in 'GI.Gdk.Objects.Seat.seatGrab'
    -> m ()
dynamic_SeatGrabPrepareFunc :: FunPtr C_SeatGrabPrepareFunc -> a -> b -> Ptr () -> m ()
dynamic_SeatGrabPrepareFunc __funPtr :: FunPtr C_SeatGrabPrepareFunc
__funPtr seat :: a
seat surface :: b
surface userData :: Ptr ()
userData = 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 Seat
seat' <- a -> IO (Ptr Seat)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seat
    Ptr Surface
surface' <- b -> IO (Ptr Surface)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
surface
    (FunPtr C_SeatGrabPrepareFunc -> C_SeatGrabPrepareFunc
__dynamic_C_SeatGrabPrepareFunc FunPtr C_SeatGrabPrepareFunc
__funPtr) Ptr Seat
seat' Ptr Surface
surface' Ptr ()
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
seat
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
surface
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

-- | Type of the callback used to set up /@surface@/ so it can be
-- grabbed. A typical action would be ensuring the surface is
-- visible, although there\'s room for other initialization
-- actions.
type SeatGrabPrepareFunc =
    Gdk.Seat.Seat
    -- ^ /@seat@/: the t'GI.Gdk.Objects.Seat.Seat' being grabbed
    -> Gdk.Surface.Surface
    -- ^ /@surface@/: the t'GI.Gdk.Objects.Surface.Surface' being grabbed
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SeatGrabPrepareFunc`@.
noSeatGrabPrepareFunc :: Maybe SeatGrabPrepareFunc
noSeatGrabPrepareFunc :: Maybe SeatGrabPrepareFunc
noSeatGrabPrepareFunc = Maybe SeatGrabPrepareFunc
forall a. Maybe a
Nothing

-- | Type of the callback used to set up /@surface@/ so it can be
-- grabbed. A typical action would be ensuring the surface is
-- visible, although there\'s room for other initialization
-- actions.
type SeatGrabPrepareFunc_WithClosures =
    Gdk.Seat.Seat
    -- ^ /@seat@/: the t'GI.Gdk.Objects.Seat.Seat' being grabbed
    -> Gdk.Surface.Surface
    -- ^ /@surface@/: the t'GI.Gdk.Objects.Surface.Surface' being grabbed
    -> Ptr ()
    -- ^ /@userData@/: user data passed in 'GI.Gdk.Objects.Seat.seatGrab'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `SeatGrabPrepareFunc_WithClosures`@.
noSeatGrabPrepareFunc_WithClosures :: Maybe SeatGrabPrepareFunc_WithClosures
noSeatGrabPrepareFunc_WithClosures :: Maybe SeatGrabPrepareFunc_WithClosures
noSeatGrabPrepareFunc_WithClosures = Maybe SeatGrabPrepareFunc_WithClosures
forall a. Maybe a
Nothing

-- | A simple wrapper that ignores the closure arguments.
drop_closures_SeatGrabPrepareFunc :: SeatGrabPrepareFunc -> SeatGrabPrepareFunc_WithClosures
drop_closures_SeatGrabPrepareFunc :: SeatGrabPrepareFunc -> SeatGrabPrepareFunc_WithClosures
drop_closures_SeatGrabPrepareFunc _f :: SeatGrabPrepareFunc
_f seat :: Seat
seat surface :: Surface
surface _ = SeatGrabPrepareFunc
_f Seat
seat Surface
surface

-- | Wrap the callback into a `GClosure`.
genClosure_SeatGrabPrepareFunc :: MonadIO m => SeatGrabPrepareFunc -> m (GClosure C_SeatGrabPrepareFunc)
genClosure_SeatGrabPrepareFunc :: SeatGrabPrepareFunc -> m (GClosure C_SeatGrabPrepareFunc)
genClosure_SeatGrabPrepareFunc cb :: SeatGrabPrepareFunc
cb = IO (GClosure C_SeatGrabPrepareFunc)
-> m (GClosure C_SeatGrabPrepareFunc)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_SeatGrabPrepareFunc)
 -> m (GClosure C_SeatGrabPrepareFunc))
-> IO (GClosure C_SeatGrabPrepareFunc)
-> m (GClosure C_SeatGrabPrepareFunc)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: SeatGrabPrepareFunc_WithClosures
cb' = SeatGrabPrepareFunc -> SeatGrabPrepareFunc_WithClosures
drop_closures_SeatGrabPrepareFunc SeatGrabPrepareFunc
cb
    let cb'' :: C_SeatGrabPrepareFunc
cb'' = Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
-> SeatGrabPrepareFunc_WithClosures -> C_SeatGrabPrepareFunc
wrap_SeatGrabPrepareFunc Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
forall a. Maybe a
Nothing SeatGrabPrepareFunc_WithClosures
cb'
    C_SeatGrabPrepareFunc -> IO (FunPtr C_SeatGrabPrepareFunc)
mk_SeatGrabPrepareFunc C_SeatGrabPrepareFunc
cb'' IO (FunPtr C_SeatGrabPrepareFunc)
-> (FunPtr C_SeatGrabPrepareFunc
    -> IO (GClosure C_SeatGrabPrepareFunc))
-> IO (GClosure C_SeatGrabPrepareFunc)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_SeatGrabPrepareFunc -> IO (GClosure C_SeatGrabPrepareFunc)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `SeatGrabPrepareFunc` into a `C_SeatGrabPrepareFunc`.
wrap_SeatGrabPrepareFunc ::
    Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc)) ->
    SeatGrabPrepareFunc_WithClosures ->
    C_SeatGrabPrepareFunc
wrap_SeatGrabPrepareFunc :: Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
-> SeatGrabPrepareFunc_WithClosures -> C_SeatGrabPrepareFunc
wrap_SeatGrabPrepareFunc funptrptr :: Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
funptrptr _cb :: SeatGrabPrepareFunc_WithClosures
_cb seat :: Ptr Seat
seat surface :: Ptr Surface
surface userData :: Ptr ()
userData = do
    Seat
seat' <- ((ManagedPtr Seat -> Seat) -> Ptr Seat -> IO Seat
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Seat -> Seat
Gdk.Seat.Seat) Ptr Seat
seat
    Surface
surface' <- ((ManagedPtr Surface -> Surface) -> Ptr Surface -> IO Surface
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Surface -> Surface
Gdk.Surface.Surface) Ptr Surface
surface
    SeatGrabPrepareFunc_WithClosures
_cb  Seat
seat' Surface
surface' Ptr ()
userData
    Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
funptrptr


-- 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}}
-- | 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 :: FunPtr C_ContentSerializeFunc -> a -> m ()
dynamic_ContentSerializeFunc __funPtr :: FunPtr C_ContentSerializeFunc
__funPtr serializer :: 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 :: ContentSerializeFunc -> m (GClosure C_ContentSerializeFunc)
genClosure_ContentSerializeFunc cb :: 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 funptrptr :: Maybe (Ptr (FunPtr C_ContentSerializeFunc))
funptrptr _cb :: ContentSerializeFunc
_cb serializer :: 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}}
-- | 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 :: FunPtr C_ContentDeserializeFunc -> a -> m ()
dynamic_ContentDeserializeFunc __funPtr :: FunPtr C_ContentDeserializeFunc
__funPtr deserializer :: 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 :: ContentDeserializeFunc -> m (GClosure C_ContentDeserializeFunc)
genClosure_ContentDeserializeFunc cb :: 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 funptrptr :: Maybe (Ptr (FunPtr C_ContentDeserializeFunc))
funptrptr _cb :: ContentDeserializeFunc
_cb deserializer :: 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