#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Callbacks
(
C_EventFunc ,
EventFunc ,
EventFunc_WithClosures ,
drop_closures_EventFunc ,
dynamic_EventFunc ,
genClosure_EventFunc ,
mk_EventFunc ,
noEventFunc ,
noEventFunc_WithClosures ,
wrap_EventFunc ,
C_FilterFunc ,
FilterFunc ,
FilterFunc_WithClosures ,
drop_closures_FilterFunc ,
dynamic_FilterFunc ,
genClosure_FilterFunc ,
mk_FilterFunc ,
noFilterFunc ,
noFilterFunc_WithClosures ,
wrap_FilterFunc ,
C_SeatGrabPrepareFunc ,
SeatGrabPrepareFunc ,
SeatGrabPrepareFunc_WithClosures ,
drop_closures_SeatGrabPrepareFunc ,
dynamic_SeatGrabPrepareFunc ,
genClosure_SeatGrabPrepareFunc ,
mk_SeatGrabPrepareFunc ,
noSeatGrabPrepareFunc ,
noSeatGrabPrepareFunc_WithClosures ,
wrap_SeatGrabPrepareFunc ,
C_WindowChildFunc ,
WindowChildFunc ,
WindowChildFunc_WithClosures ,
drop_closures_WindowChildFunc ,
dynamic_WindowChildFunc ,
genClosure_WindowChildFunc ,
mk_WindowChildFunc ,
noWindowChildFunc ,
noWindowChildFunc_WithClosures ,
wrap_WindowChildFunc ,
C_WindowInvalidateHandlerFunc ,
WindowInvalidateHandlerFunc ,
dynamic_WindowInvalidateHandlerFunc ,
genClosure_WindowInvalidateHandlerFunc ,
mk_WindowInvalidateHandlerFunc ,
noWindowInvalidateHandlerFunc ,
wrap_WindowInvalidateHandlerFunc ,
) 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.Region as Cairo.Region
import {-# SOURCE #-} qualified GI.Gdk.Enums as Gdk.Enums
import {-# SOURCE #-} qualified GI.Gdk.Objects.Seat as Gdk.Seat
import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
import {-# SOURCE #-} qualified GI.Gdk.Unions.Event as Gdk.Event
type C_WindowInvalidateHandlerFunc =
Ptr Gdk.Window.Window ->
Ptr Cairo.Region.Region ->
IO ()
foreign import ccall "dynamic" __dynamic_C_WindowInvalidateHandlerFunc :: FunPtr C_WindowInvalidateHandlerFunc -> C_WindowInvalidateHandlerFunc
dynamic_WindowInvalidateHandlerFunc ::
(B.CallStack.HasCallStack, MonadIO m, Gdk.Window.IsWindow a) =>
FunPtr C_WindowInvalidateHandlerFunc
-> a
-> Cairo.Region.Region
-> m ()
dynamic_WindowInvalidateHandlerFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
FunPtr C_WindowInvalidateHandlerFunc -> a -> Region -> m ()
dynamic_WindowInvalidateHandlerFunc FunPtr C_WindowInvalidateHandlerFunc
__funPtr a
window Region
region = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Window
window' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
Ptr Region
region' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Region
region
(FunPtr C_WindowInvalidateHandlerFunc
-> C_WindowInvalidateHandlerFunc
__dynamic_C_WindowInvalidateHandlerFunc FunPtr C_WindowInvalidateHandlerFunc
__funPtr) Ptr Window
window' Ptr Region
region'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Region
region
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_WindowInvalidateHandlerFunc :: C_WindowInvalidateHandlerFunc -> IO (FunPtr C_WindowInvalidateHandlerFunc)
type WindowInvalidateHandlerFunc =
Gdk.Window.Window
-> Cairo.Region.Region
-> IO ()
noWindowInvalidateHandlerFunc :: Maybe WindowInvalidateHandlerFunc
noWindowInvalidateHandlerFunc :: Maybe WindowInvalidateHandlerFunc
noWindowInvalidateHandlerFunc = forall a. Maybe a
Nothing
genClosure_WindowInvalidateHandlerFunc :: MonadIO m => WindowInvalidateHandlerFunc -> m (GClosure C_WindowInvalidateHandlerFunc)
genClosure_WindowInvalidateHandlerFunc :: forall (m :: * -> *).
MonadIO m =>
WindowInvalidateHandlerFunc
-> m (GClosure C_WindowInvalidateHandlerFunc)
genClosure_WindowInvalidateHandlerFunc WindowInvalidateHandlerFunc
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_WindowInvalidateHandlerFunc
cb' = Maybe (Ptr (FunPtr C_WindowInvalidateHandlerFunc))
-> WindowInvalidateHandlerFunc -> C_WindowInvalidateHandlerFunc
wrap_WindowInvalidateHandlerFunc forall a. Maybe a
Nothing WindowInvalidateHandlerFunc
cb
C_WindowInvalidateHandlerFunc
-> IO (FunPtr C_WindowInvalidateHandlerFunc)
mk_WindowInvalidateHandlerFunc C_WindowInvalidateHandlerFunc
cb' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_WindowInvalidateHandlerFunc ::
Maybe (Ptr (FunPtr C_WindowInvalidateHandlerFunc)) ->
WindowInvalidateHandlerFunc ->
C_WindowInvalidateHandlerFunc
wrap_WindowInvalidateHandlerFunc :: Maybe (Ptr (FunPtr C_WindowInvalidateHandlerFunc))
-> WindowInvalidateHandlerFunc -> C_WindowInvalidateHandlerFunc
wrap_WindowInvalidateHandlerFunc Maybe (Ptr (FunPtr C_WindowInvalidateHandlerFunc))
gi'funptrptr WindowInvalidateHandlerFunc
gi'cb Ptr Window
window Ptr Region
region = do
Window
window' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Window -> Window
Gdk.Window.Window) Ptr Window
window
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Region
region forall a b. (a -> b) -> a -> b
$ \Region
region' -> do
WindowInvalidateHandlerFunc
gi'cb Window
window' Region
region'
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_WindowInvalidateHandlerFunc))
gi'funptrptr
type C_WindowChildFunc =
Ptr Gdk.Window.Window ->
Ptr () ->
IO CInt
foreign import ccall "dynamic" __dynamic_C_WindowChildFunc :: FunPtr C_WindowChildFunc -> C_WindowChildFunc
dynamic_WindowChildFunc ::
(B.CallStack.HasCallStack, MonadIO m, Gdk.Window.IsWindow a) =>
FunPtr C_WindowChildFunc
-> a
-> Ptr ()
-> m Bool
dynamic_WindowChildFunc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsWindow a) =>
FunPtr C_WindowChildFunc -> a -> Ptr () -> m Bool
dynamic_WindowChildFunc FunPtr C_WindowChildFunc
__funPtr a
window Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Window
window' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
window
CInt
result <- (FunPtr C_WindowChildFunc -> C_WindowChildFunc
__dynamic_C_WindowChildFunc FunPtr C_WindowChildFunc
__funPtr) Ptr Window
window' Ptr ()
userData
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
window
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "wrapper"
mk_WindowChildFunc :: C_WindowChildFunc -> IO (FunPtr C_WindowChildFunc)
type WindowChildFunc =
Gdk.Window.Window
-> IO Bool
noWindowChildFunc :: Maybe WindowChildFunc
noWindowChildFunc :: Maybe WindowChildFunc
noWindowChildFunc = forall a. Maybe a
Nothing
type WindowChildFunc_WithClosures =
Gdk.Window.Window
-> Ptr ()
-> IO Bool
noWindowChildFunc_WithClosures :: Maybe WindowChildFunc_WithClosures
noWindowChildFunc_WithClosures :: Maybe WindowChildFunc_WithClosures
noWindowChildFunc_WithClosures = forall a. Maybe a
Nothing
drop_closures_WindowChildFunc :: WindowChildFunc -> WindowChildFunc_WithClosures
drop_closures_WindowChildFunc :: WindowChildFunc -> WindowChildFunc_WithClosures
drop_closures_WindowChildFunc WindowChildFunc
_f Window
window Ptr ()
_ = WindowChildFunc
_f Window
window
genClosure_WindowChildFunc :: MonadIO m => WindowChildFunc -> m (GClosure C_WindowChildFunc)
genClosure_WindowChildFunc :: forall (m :: * -> *).
MonadIO m =>
WindowChildFunc -> m (GClosure C_WindowChildFunc)
genClosure_WindowChildFunc WindowChildFunc
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: WindowChildFunc_WithClosures
cb' = WindowChildFunc -> WindowChildFunc_WithClosures
drop_closures_WindowChildFunc WindowChildFunc
cb
let cb'' :: C_WindowChildFunc
cb'' = Maybe (Ptr (FunPtr C_WindowChildFunc))
-> WindowChildFunc_WithClosures -> C_WindowChildFunc
wrap_WindowChildFunc forall a. Maybe a
Nothing WindowChildFunc_WithClosures
cb'
C_WindowChildFunc -> IO (FunPtr C_WindowChildFunc)
mk_WindowChildFunc C_WindowChildFunc
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_WindowChildFunc ::
Maybe (Ptr (FunPtr C_WindowChildFunc)) ->
WindowChildFunc_WithClosures ->
C_WindowChildFunc
wrap_WindowChildFunc :: Maybe (Ptr (FunPtr C_WindowChildFunc))
-> WindowChildFunc_WithClosures -> C_WindowChildFunc
wrap_WindowChildFunc Maybe (Ptr (FunPtr C_WindowChildFunc))
gi'funptrptr WindowChildFunc_WithClosures
gi'cb Ptr Window
window Ptr ()
userData = do
Window
window' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Window -> Window
Gdk.Window.Window) Ptr Window
window
Bool
result <- WindowChildFunc_WithClosures
gi'cb Window
window' Ptr ()
userData
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_WindowChildFunc))
gi'funptrptr
let result' :: CInt
result' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
result
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
type C_SeatGrabPrepareFunc =
Ptr Gdk.Seat.Seat ->
Ptr Gdk.Window.Window ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_SeatGrabPrepareFunc :: FunPtr C_SeatGrabPrepareFunc -> C_SeatGrabPrepareFunc
dynamic_SeatGrabPrepareFunc ::
(B.CallStack.HasCallStack, MonadIO m, Gdk.Seat.IsSeat a, Gdk.Window.IsWindow b) =>
FunPtr C_SeatGrabPrepareFunc
-> a
-> b
-> Ptr ()
-> m ()
dynamic_SeatGrabPrepareFunc :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsSeat a, IsWindow b) =>
FunPtr C_SeatGrabPrepareFunc -> a -> b -> Ptr () -> m ()
dynamic_SeatGrabPrepareFunc FunPtr C_SeatGrabPrepareFunc
__funPtr a
seat b
window Ptr ()
userData = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Seat
seat' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
seat
Ptr Window
window' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
window
(FunPtr C_SeatGrabPrepareFunc -> C_SeatGrabPrepareFunc
__dynamic_C_SeatGrabPrepareFunc FunPtr C_SeatGrabPrepareFunc
__funPtr) Ptr Seat
seat' Ptr Window
window' Ptr ()
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
seat
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
window
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_SeatGrabPrepareFunc :: C_SeatGrabPrepareFunc -> IO (FunPtr C_SeatGrabPrepareFunc)
type SeatGrabPrepareFunc =
Gdk.Seat.Seat
-> Gdk.Window.Window
-> IO ()
noSeatGrabPrepareFunc :: Maybe SeatGrabPrepareFunc
noSeatGrabPrepareFunc :: Maybe SeatGrabPrepareFunc
noSeatGrabPrepareFunc = forall a. Maybe a
Nothing
type SeatGrabPrepareFunc_WithClosures =
Gdk.Seat.Seat
-> Gdk.Window.Window
-> Ptr ()
-> IO ()
noSeatGrabPrepareFunc_WithClosures :: Maybe SeatGrabPrepareFunc_WithClosures
noSeatGrabPrepareFunc_WithClosures :: Maybe SeatGrabPrepareFunc_WithClosures
noSeatGrabPrepareFunc_WithClosures = forall a. Maybe a
Nothing
drop_closures_SeatGrabPrepareFunc :: SeatGrabPrepareFunc -> SeatGrabPrepareFunc_WithClosures
drop_closures_SeatGrabPrepareFunc :: SeatGrabPrepareFunc -> SeatGrabPrepareFunc_WithClosures
drop_closures_SeatGrabPrepareFunc SeatGrabPrepareFunc
_f Seat
seat Window
window Ptr ()
_ = SeatGrabPrepareFunc
_f Seat
seat Window
window
genClosure_SeatGrabPrepareFunc :: MonadIO m => SeatGrabPrepareFunc -> m (GClosure C_SeatGrabPrepareFunc)
genClosure_SeatGrabPrepareFunc :: forall (m :: * -> *).
MonadIO m =>
SeatGrabPrepareFunc -> m (GClosure C_SeatGrabPrepareFunc)
genClosure_SeatGrabPrepareFunc SeatGrabPrepareFunc
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO 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 forall a. Maybe a
Nothing SeatGrabPrepareFunc_WithClosures
cb'
C_SeatGrabPrepareFunc -> IO (FunPtr C_SeatGrabPrepareFunc)
mk_SeatGrabPrepareFunc C_SeatGrabPrepareFunc
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_SeatGrabPrepareFunc ::
Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc)) ->
SeatGrabPrepareFunc_WithClosures ->
C_SeatGrabPrepareFunc
wrap_SeatGrabPrepareFunc :: Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
-> SeatGrabPrepareFunc_WithClosures -> C_SeatGrabPrepareFunc
wrap_SeatGrabPrepareFunc Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
gi'funptrptr SeatGrabPrepareFunc_WithClosures
gi'cb Ptr Seat
seat Ptr Window
window Ptr ()
userData = do
Seat
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
Window
window' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Window -> Window
Gdk.Window.Window) Ptr Window
window
SeatGrabPrepareFunc_WithClosures
gi'cb Seat
seat' Window
window' Ptr ()
userData
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_SeatGrabPrepareFunc))
gi'funptrptr
type C_FilterFunc =
Ptr () ->
Ptr Gdk.Event.Event ->
Ptr () ->
IO CUInt
foreign import ccall "dynamic" __dynamic_C_FilterFunc :: FunPtr C_FilterFunc -> C_FilterFunc
dynamic_FilterFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_FilterFunc
-> Ptr ()
-> Gdk.Event.Event
-> Ptr ()
-> m Gdk.Enums.FilterReturn
dynamic_FilterFunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_FilterFunc -> Ptr () -> Event -> Ptr () -> m FilterReturn
dynamic_FilterFunc FunPtr C_FilterFunc
__funPtr Ptr ()
xevent Event
event Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CUInt
result <- (FunPtr C_FilterFunc -> C_FilterFunc
__dynamic_C_FilterFunc FunPtr C_FilterFunc
__funPtr) Ptr ()
xevent Ptr Event
event' Ptr ()
data_
let result' :: FilterReturn
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
forall (m :: * -> *) a. Monad m => a -> m a
return FilterReturn
result'
foreign import ccall "wrapper"
mk_FilterFunc :: C_FilterFunc -> IO (FunPtr C_FilterFunc)
type FilterFunc =
Ptr ()
-> Gdk.Event.Event
-> IO Gdk.Enums.FilterReturn
noFilterFunc :: Maybe FilterFunc
noFilterFunc :: Maybe FilterFunc
noFilterFunc = forall a. Maybe a
Nothing
type FilterFunc_WithClosures =
Ptr ()
-> Gdk.Event.Event
-> Ptr ()
-> IO Gdk.Enums.FilterReturn
noFilterFunc_WithClosures :: Maybe FilterFunc_WithClosures
noFilterFunc_WithClosures :: Maybe FilterFunc_WithClosures
noFilterFunc_WithClosures = forall a. Maybe a
Nothing
drop_closures_FilterFunc :: FilterFunc -> FilterFunc_WithClosures
drop_closures_FilterFunc :: FilterFunc -> FilterFunc_WithClosures
drop_closures_FilterFunc FilterFunc
_f Ptr ()
xevent Event
event Ptr ()
_ = FilterFunc
_f Ptr ()
xevent Event
event
genClosure_FilterFunc :: MonadIO m => FilterFunc -> m (GClosure C_FilterFunc)
genClosure_FilterFunc :: forall (m :: * -> *).
MonadIO m =>
FilterFunc -> m (GClosure C_FilterFunc)
genClosure_FilterFunc FilterFunc
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: FilterFunc_WithClosures
cb' = FilterFunc -> FilterFunc_WithClosures
drop_closures_FilterFunc FilterFunc
cb
let cb'' :: C_FilterFunc
cb'' = Maybe (Ptr (FunPtr C_FilterFunc))
-> FilterFunc_WithClosures -> C_FilterFunc
wrap_FilterFunc forall a. Maybe a
Nothing FilterFunc_WithClosures
cb'
C_FilterFunc -> IO (FunPtr C_FilterFunc)
mk_FilterFunc C_FilterFunc
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_FilterFunc ::
Maybe (Ptr (FunPtr C_FilterFunc)) ->
FilterFunc_WithClosures ->
C_FilterFunc
wrap_FilterFunc :: Maybe (Ptr (FunPtr C_FilterFunc))
-> FilterFunc_WithClosures -> C_FilterFunc
wrap_FilterFunc Maybe (Ptr (FunPtr C_FilterFunc))
gi'funptrptr FilterFunc_WithClosures
gi'cb Ptr ()
xevent Ptr Event
event Ptr ()
data_ = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Event
event forall a b. (a -> b) -> a -> b
$ \Event
event' -> do
FilterReturn
result <- FilterFunc_WithClosures
gi'cb Ptr ()
xevent Event
event' Ptr ()
data_
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_FilterFunc))
gi'funptrptr
let result' :: CUInt
result' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) FilterReturn
result
forall (m :: * -> *) a. Monad m => a -> m a
return CUInt
result'
type C_EventFunc =
Ptr Gdk.Event.Event ->
Ptr () ->
IO ()
foreign import ccall "dynamic" __dynamic_C_EventFunc :: FunPtr C_EventFunc -> C_EventFunc
dynamic_EventFunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
FunPtr C_EventFunc
-> Gdk.Event.Event
-> Ptr ()
-> m ()
dynamic_EventFunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_EventFunc -> Event -> Ptr () -> m ()
dynamic_EventFunc FunPtr C_EventFunc
__funPtr Event
event Ptr ()
data_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr Event
event' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
(FunPtr C_EventFunc -> C_EventFunc
__dynamic_C_EventFunc FunPtr C_EventFunc
__funPtr) Ptr Event
event' Ptr ()
data_
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "wrapper"
mk_EventFunc :: C_EventFunc -> IO (FunPtr C_EventFunc)
type EventFunc =
Gdk.Event.Event
-> IO ()
noEventFunc :: Maybe EventFunc
noEventFunc :: Maybe EventFunc
noEventFunc = forall a. Maybe a
Nothing
type EventFunc_WithClosures =
Gdk.Event.Event
-> Ptr ()
-> IO ()
noEventFunc_WithClosures :: Maybe EventFunc_WithClosures
noEventFunc_WithClosures :: Maybe EventFunc_WithClosures
noEventFunc_WithClosures = forall a. Maybe a
Nothing
drop_closures_EventFunc :: EventFunc -> EventFunc_WithClosures
drop_closures_EventFunc :: EventFunc -> EventFunc_WithClosures
drop_closures_EventFunc EventFunc
_f Event
event Ptr ()
_ = EventFunc
_f Event
event
genClosure_EventFunc :: MonadIO m => EventFunc -> m (GClosure C_EventFunc)
genClosure_EventFunc :: forall (m :: * -> *).
MonadIO m =>
EventFunc -> m (GClosure C_EventFunc)
genClosure_EventFunc EventFunc
cb = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let cb' :: EventFunc_WithClosures
cb' = EventFunc -> EventFunc_WithClosures
drop_closures_EventFunc EventFunc
cb
let cb'' :: C_EventFunc
cb'' = Maybe (Ptr (FunPtr C_EventFunc))
-> EventFunc_WithClosures -> C_EventFunc
wrap_EventFunc forall a. Maybe a
Nothing EventFunc_WithClosures
cb'
C_EventFunc -> IO (FunPtr C_EventFunc)
mk_EventFunc C_EventFunc
cb'' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EventFunc ::
Maybe (Ptr (FunPtr C_EventFunc)) ->
EventFunc_WithClosures ->
C_EventFunc
wrap_EventFunc :: Maybe (Ptr (FunPtr C_EventFunc))
-> EventFunc_WithClosures -> C_EventFunc
wrap_EventFunc Maybe (Ptr (FunPtr C_EventFunc))
gi'funptrptr EventFunc_WithClosures
gi'cb Ptr Event
event Ptr ()
data_ = do
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Event
event forall a b. (a -> b) -> a -> b
$ \Event
event' -> do
EventFunc_WithClosures
gi'cb Event
event' Ptr ()
data_
forall a. Maybe (Ptr (FunPtr a)) -> IO ()
maybeReleaseFunPtr Maybe (Ptr (FunPtr C_EventFunc))
gi'funptrptr