#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Wnck.Callbacks
(
C_LoadSurfaceFunction ,
LoadSurfaceFunction ,
dynamic_LoadSurfaceFunction ,
genClosure_LoadSurfaceFunction ,
mk_LoadSurfaceFunction ,
noLoadSurfaceFunction ,
wrap_LoadSurfaceFunction ,
) 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
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
type C_LoadSurfaceFunction =
CString ->
Int32 ->
Word32 ->
Ptr () ->
IO (Ptr Cairo.Surface.Surface)
foreign import ccall "dynamic" __dynamic_C_LoadSurfaceFunction :: FunPtr C_LoadSurfaceFunction -> C_LoadSurfaceFunction
dynamic_LoadSurfaceFunction ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_LoadSurfaceFunction
-> T.Text
-> Int32
-> Word32
-> Ptr ()
-> m Cairo.Surface.Surface
dynamic_LoadSurfaceFunction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_LoadSurfaceFunction
-> Text -> Int32 -> Word32 -> Ptr () -> m Surface
dynamic_LoadSurfaceFunction FunPtr C_LoadSurfaceFunction
__funPtr Text
iconName Int32
size Word32
flags Ptr ()
data_ = IO Surface -> m Surface
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Surface -> m Surface) -> IO Surface -> m Surface
forall a b. (a -> b) -> a -> b
$ do
CString
iconName' <- Text -> IO CString
textToCString Text
iconName
Ptr Surface
result <- (FunPtr C_LoadSurfaceFunction -> C_LoadSurfaceFunction
__dynamic_C_LoadSurfaceFunction FunPtr C_LoadSurfaceFunction
__funPtr) CString
iconName' Int32
size Word32
flags Ptr ()
data_
Text -> Ptr Surface -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"loadSurfaceFunction" Ptr Surface
result
Surface
result' <- ((ManagedPtr Surface -> Surface) -> Ptr Surface -> IO Surface
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Surface -> Surface
Cairo.Surface.Surface) Ptr Surface
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
iconName'
Surface -> IO Surface
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Surface
result'
foreign import ccall "wrapper"
mk_LoadSurfaceFunction :: C_LoadSurfaceFunction -> IO (FunPtr C_LoadSurfaceFunction)
type LoadSurfaceFunction =
T.Text
-> Int32
-> Word32
-> Ptr ()
-> IO Cairo.Surface.Surface
noLoadSurfaceFunction :: Maybe LoadSurfaceFunction
noLoadSurfaceFunction :: Maybe LoadSurfaceFunction
noLoadSurfaceFunction = Maybe LoadSurfaceFunction
forall a. Maybe a
Nothing
genClosure_LoadSurfaceFunction :: MonadIO m => LoadSurfaceFunction -> m (GClosure C_LoadSurfaceFunction)
genClosure_LoadSurfaceFunction :: forall (m :: * -> *).
MonadIO m =>
LoadSurfaceFunction -> m (GClosure C_LoadSurfaceFunction)
genClosure_LoadSurfaceFunction LoadSurfaceFunction
cb = IO (GClosure C_LoadSurfaceFunction)
-> m (GClosure C_LoadSurfaceFunction)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_LoadSurfaceFunction)
-> m (GClosure C_LoadSurfaceFunction))
-> IO (GClosure C_LoadSurfaceFunction)
-> m (GClosure C_LoadSurfaceFunction)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_LoadSurfaceFunction
cb' = Maybe (Ptr (FunPtr C_LoadSurfaceFunction))
-> LoadSurfaceFunction -> C_LoadSurfaceFunction
wrap_LoadSurfaceFunction Maybe (Ptr (FunPtr C_LoadSurfaceFunction))
forall a. Maybe a
Nothing LoadSurfaceFunction
cb
C_LoadSurfaceFunction -> IO (FunPtr C_LoadSurfaceFunction)
mk_LoadSurfaceFunction C_LoadSurfaceFunction
cb' IO (FunPtr C_LoadSurfaceFunction)
-> (FunPtr C_LoadSurfaceFunction
-> IO (GClosure C_LoadSurfaceFunction))
-> IO (GClosure C_LoadSurfaceFunction)
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_LoadSurfaceFunction -> IO (GClosure C_LoadSurfaceFunction)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_LoadSurfaceFunction ::
Maybe (Ptr (FunPtr C_LoadSurfaceFunction)) ->
LoadSurfaceFunction ->
C_LoadSurfaceFunction
wrap_LoadSurfaceFunction :: Maybe (Ptr (FunPtr C_LoadSurfaceFunction))
-> LoadSurfaceFunction -> C_LoadSurfaceFunction
wrap_LoadSurfaceFunction Maybe (Ptr (FunPtr C_LoadSurfaceFunction))
gi'funptrptr LoadSurfaceFunction
gi'cb CString
iconName Int32
size Word32
flags Ptr ()
data_ = do
Text
iconName' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
iconName
Surface
result <- LoadSurfaceFunction
gi'cb Text
iconName' Int32
size Word32
flags Ptr ()
data_
Maybe (Ptr (FunPtr C_LoadSurfaceFunction)) -> IO ()
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_LoadSurfaceFunction))
gi'funptrptr
Ptr Surface
result' <- Surface -> IO (Ptr Surface)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Surface
result
Ptr Surface -> IO (Ptr Surface)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Surface
result'