module GI.Atk.Callbacks
(
EventListener ,
EventListenerC ,
eventListenerClosure ,
eventListenerWrapper ,
mkEventListener ,
noEventListener ,
EventListenerInit ,
EventListenerInitC ,
eventListenerInitClosure ,
eventListenerInitWrapper ,
mkEventListenerInit ,
noEventListenerInit ,
FocusHandler ,
FocusHandlerC ,
focusHandlerClosure ,
focusHandlerWrapper ,
mkFocusHandler ,
noFocusHandler ,
Function ,
FunctionC ,
functionClosure ,
functionWrapper ,
mkFunction ,
noFunction ,
KeySnoopFunc ,
KeySnoopFuncC ,
keySnoopFuncClosure ,
keySnoopFuncWrapper ,
mkKeySnoopFunc ,
noKeySnoopFunc ,
PropertyChangeHandler ,
PropertyChangeHandlerC ,
mkPropertyChangeHandler ,
noPropertyChangeHandler ,
propertyChangeHandlerClosure ,
propertyChangeHandlerWrapper ,
) where
import Prelude ()
import Data.GI.Base.ShortPrelude
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import GI.Atk.Types
propertyChangeHandlerClosure :: PropertyChangeHandler -> IO Closure
propertyChangeHandlerClosure cb = newCClosure =<< mkPropertyChangeHandler wrapped
where wrapped = propertyChangeHandlerWrapper Nothing cb
type PropertyChangeHandlerC =
Ptr Object ->
Ptr PropertyValues ->
IO ()
foreign import ccall "wrapper"
mkPropertyChangeHandler :: PropertyChangeHandlerC -> IO (FunPtr PropertyChangeHandlerC)
type PropertyChangeHandler =
Object ->
PropertyValues ->
IO ()
noPropertyChangeHandler :: Maybe PropertyChangeHandler
noPropertyChangeHandler = Nothing
propertyChangeHandlerWrapper ::
Maybe (Ptr (FunPtr (PropertyChangeHandlerC))) ->
PropertyChangeHandler ->
Ptr Object ->
Ptr PropertyValues ->
IO ()
propertyChangeHandlerWrapper funptrptr _cb obj vals = do
obj' <- (newObject Object) obj
vals' <- (newPtr 56 PropertyValues) vals
_cb obj' vals'
maybeReleaseFunPtr funptrptr
keySnoopFuncClosure :: KeySnoopFunc -> IO Closure
keySnoopFuncClosure cb = newCClosure =<< mkKeySnoopFunc wrapped
where wrapped = keySnoopFuncWrapper Nothing cb
type KeySnoopFuncC =
Ptr KeyEventStruct ->
Ptr () ->
IO Int32
foreign import ccall "wrapper"
mkKeySnoopFunc :: KeySnoopFuncC -> IO (FunPtr KeySnoopFuncC)
type KeySnoopFunc =
KeyEventStruct ->
IO Int32
noKeySnoopFunc :: Maybe KeySnoopFunc
noKeySnoopFunc = Nothing
keySnoopFuncWrapper ::
Maybe (Ptr (FunPtr (KeySnoopFuncC))) ->
KeySnoopFunc ->
Ptr KeyEventStruct ->
Ptr () ->
IO Int32
keySnoopFuncWrapper funptrptr _cb event _ = do
event' <- (newPtr 32 KeyEventStruct) event
result <- _cb event'
maybeReleaseFunPtr funptrptr
return result
functionClosure :: Function -> IO Closure
functionClosure cb = newCClosure =<< mkFunction wrapped
where wrapped = functionWrapper Nothing cb
type FunctionC =
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkFunction :: FunctionC -> IO (FunPtr FunctionC)
type Function =
IO Bool
noFunction :: Maybe Function
noFunction = Nothing
functionWrapper ::
Maybe (Ptr (FunPtr (FunctionC))) ->
Function ->
Ptr () ->
IO CInt
functionWrapper funptrptr _cb _ = do
result <- _cb
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
focusHandlerClosure :: FocusHandler -> IO Closure
focusHandlerClosure cb = newCClosure =<< mkFocusHandler wrapped
where wrapped = focusHandlerWrapper Nothing cb
type FocusHandlerC =
Ptr Object ->
CInt ->
IO ()
foreign import ccall "wrapper"
mkFocusHandler :: FocusHandlerC -> IO (FunPtr FocusHandlerC)
type FocusHandler =
Object ->
Bool ->
IO ()
noFocusHandler :: Maybe FocusHandler
noFocusHandler = Nothing
focusHandlerWrapper ::
Maybe (Ptr (FunPtr (FocusHandlerC))) ->
FocusHandler ->
Ptr Object ->
CInt ->
IO ()
focusHandlerWrapper funptrptr _cb object focus_in = do
object' <- (newObject Object) object
let focus_in' = (/= 0) focus_in
_cb object' focus_in'
maybeReleaseFunPtr funptrptr
eventListenerInitClosure :: EventListenerInit -> IO Closure
eventListenerInitClosure cb = newCClosure =<< mkEventListenerInit wrapped
where wrapped = eventListenerInitWrapper Nothing cb
type EventListenerInitC =
IO ()
foreign import ccall "wrapper"
mkEventListenerInit :: EventListenerInitC -> IO (FunPtr EventListenerInitC)
type EventListenerInit =
IO ()
noEventListenerInit :: Maybe EventListenerInit
noEventListenerInit = Nothing
eventListenerInitWrapper ::
Maybe (Ptr (FunPtr (EventListenerInitC))) ->
EventListenerInit ->
IO ()
eventListenerInitWrapper funptrptr _cb = do
_cb
maybeReleaseFunPtr funptrptr
eventListenerClosure :: EventListener -> IO Closure
eventListenerClosure cb = newCClosure =<< mkEventListener wrapped
where wrapped = eventListenerWrapper Nothing cb
type EventListenerC =
Ptr Object ->
IO ()
foreign import ccall "wrapper"
mkEventListener :: EventListenerC -> IO (FunPtr EventListenerC)
type EventListener =
Object ->
IO ()
noEventListener :: Maybe EventListener
noEventListener = Nothing
eventListenerWrapper ::
Maybe (Ptr (FunPtr (EventListenerC))) ->
EventListener ->
Ptr Object ->
IO ()
eventListenerWrapper funptrptr _cb obj = do
obj' <- (newObject Object) obj
_cb obj'
maybeReleaseFunPtr funptrptr