{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.IBus.Objects.Engine
(
Engine(..) ,
IsEngine ,
toEngine ,
#if defined(ENABLE_OVERLOADING)
ResolveEngineMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
EngineCommitTextMethodInfo ,
#endif
engineCommitText ,
#if defined(ENABLE_OVERLOADING)
EngineDeleteSurroundingTextMethodInfo ,
#endif
engineDeleteSurroundingText ,
#if defined(ENABLE_OVERLOADING)
EngineForwardKeyEventMethodInfo ,
#endif
engineForwardKeyEvent ,
#if defined(ENABLE_OVERLOADING)
EngineGetContentTypeMethodInfo ,
#endif
engineGetContentType ,
#if defined(ENABLE_OVERLOADING)
EngineGetNameMethodInfo ,
#endif
engineGetName ,
#if defined(ENABLE_OVERLOADING)
EngineGetSurroundingTextMethodInfo ,
#endif
engineGetSurroundingText ,
#if defined(ENABLE_OVERLOADING)
EngineHideAuxiliaryTextMethodInfo ,
#endif
engineHideAuxiliaryText ,
#if defined(ENABLE_OVERLOADING)
EngineHideLookupTableMethodInfo ,
#endif
engineHideLookupTable ,
#if defined(ENABLE_OVERLOADING)
EngineHidePreeditTextMethodInfo ,
#endif
engineHidePreeditText ,
engineNew ,
engineNewWithType ,
#if defined(ENABLE_OVERLOADING)
EngineRegisterPropertiesMethodInfo ,
#endif
engineRegisterProperties ,
#if defined(ENABLE_OVERLOADING)
EngineShowAuxiliaryTextMethodInfo ,
#endif
engineShowAuxiliaryText ,
#if defined(ENABLE_OVERLOADING)
EngineShowLookupTableMethodInfo ,
#endif
engineShowLookupTable ,
#if defined(ENABLE_OVERLOADING)
EngineShowPreeditTextMethodInfo ,
#endif
engineShowPreeditText ,
#if defined(ENABLE_OVERLOADING)
EngineUpdateAuxiliaryTextMethodInfo ,
#endif
engineUpdateAuxiliaryText ,
#if defined(ENABLE_OVERLOADING)
EngineUpdateLookupTableMethodInfo ,
#endif
engineUpdateLookupTable ,
#if defined(ENABLE_OVERLOADING)
EngineUpdateLookupTableFastMethodInfo ,
#endif
engineUpdateLookupTableFast ,
#if defined(ENABLE_OVERLOADING)
EngineUpdatePreeditTextMethodInfo ,
#endif
engineUpdatePreeditText ,
#if defined(ENABLE_OVERLOADING)
EngineUpdatePreeditTextWithModeMethodInfo,
#endif
engineUpdatePreeditTextWithMode ,
#if defined(ENABLE_OVERLOADING)
EngineUpdatePropertyMethodInfo ,
#endif
engineUpdateProperty ,
#if defined(ENABLE_OVERLOADING)
EngineEngineNamePropertyInfo ,
#endif
constructEngineEngineName ,
#if defined(ENABLE_OVERLOADING)
engineEngineName ,
#endif
getEngineEngineName ,
C_EngineCancelHandWritingCallback ,
EngineCancelHandWritingCallback ,
#if defined(ENABLE_OVERLOADING)
EngineCancelHandWritingSignalInfo ,
#endif
afterEngineCancelHandWriting ,
genClosure_EngineCancelHandWriting ,
mk_EngineCancelHandWritingCallback ,
noEngineCancelHandWritingCallback ,
onEngineCancelHandWriting ,
wrap_EngineCancelHandWritingCallback ,
C_EngineCandidateClickedCallback ,
EngineCandidateClickedCallback ,
#if defined(ENABLE_OVERLOADING)
EngineCandidateClickedSignalInfo ,
#endif
afterEngineCandidateClicked ,
genClosure_EngineCandidateClicked ,
mk_EngineCandidateClickedCallback ,
noEngineCandidateClickedCallback ,
onEngineCandidateClicked ,
wrap_EngineCandidateClickedCallback ,
C_EngineCursorDownCallback ,
EngineCursorDownCallback ,
#if defined(ENABLE_OVERLOADING)
EngineCursorDownSignalInfo ,
#endif
afterEngineCursorDown ,
genClosure_EngineCursorDown ,
mk_EngineCursorDownCallback ,
noEngineCursorDownCallback ,
onEngineCursorDown ,
wrap_EngineCursorDownCallback ,
C_EngineCursorUpCallback ,
EngineCursorUpCallback ,
#if defined(ENABLE_OVERLOADING)
EngineCursorUpSignalInfo ,
#endif
afterEngineCursorUp ,
genClosure_EngineCursorUp ,
mk_EngineCursorUpCallback ,
noEngineCursorUpCallback ,
onEngineCursorUp ,
wrap_EngineCursorUpCallback ,
C_EngineDisableCallback ,
EngineDisableCallback ,
#if defined(ENABLE_OVERLOADING)
EngineDisableSignalInfo ,
#endif
afterEngineDisable ,
genClosure_EngineDisable ,
mk_EngineDisableCallback ,
noEngineDisableCallback ,
onEngineDisable ,
wrap_EngineDisableCallback ,
C_EngineEnableCallback ,
EngineEnableCallback ,
#if defined(ENABLE_OVERLOADING)
EngineEnableSignalInfo ,
#endif
afterEngineEnable ,
genClosure_EngineEnable ,
mk_EngineEnableCallback ,
noEngineEnableCallback ,
onEngineEnable ,
wrap_EngineEnableCallback ,
C_EngineFocusInCallback ,
EngineFocusInCallback ,
#if defined(ENABLE_OVERLOADING)
EngineFocusInSignalInfo ,
#endif
afterEngineFocusIn ,
genClosure_EngineFocusIn ,
mk_EngineFocusInCallback ,
noEngineFocusInCallback ,
onEngineFocusIn ,
wrap_EngineFocusInCallback ,
C_EngineFocusOutCallback ,
EngineFocusOutCallback ,
#if defined(ENABLE_OVERLOADING)
EngineFocusOutSignalInfo ,
#endif
afterEngineFocusOut ,
genClosure_EngineFocusOut ,
mk_EngineFocusOutCallback ,
noEngineFocusOutCallback ,
onEngineFocusOut ,
wrap_EngineFocusOutCallback ,
C_EnginePageDownCallback ,
EnginePageDownCallback ,
#if defined(ENABLE_OVERLOADING)
EnginePageDownSignalInfo ,
#endif
afterEnginePageDown ,
genClosure_EnginePageDown ,
mk_EnginePageDownCallback ,
noEnginePageDownCallback ,
onEnginePageDown ,
wrap_EnginePageDownCallback ,
C_EnginePageUpCallback ,
EnginePageUpCallback ,
#if defined(ENABLE_OVERLOADING)
EnginePageUpSignalInfo ,
#endif
afterEnginePageUp ,
genClosure_EnginePageUp ,
mk_EnginePageUpCallback ,
noEnginePageUpCallback ,
onEnginePageUp ,
wrap_EnginePageUpCallback ,
C_EngineProcessHandWritingEventCallback ,
EngineProcessHandWritingEventCallback ,
#if defined(ENABLE_OVERLOADING)
EngineProcessHandWritingEventSignalInfo ,
#endif
afterEngineProcessHandWritingEvent ,
genClosure_EngineProcessHandWritingEvent,
mk_EngineProcessHandWritingEventCallback,
noEngineProcessHandWritingEventCallback ,
onEngineProcessHandWritingEvent ,
wrap_EngineProcessHandWritingEventCallback,
C_EngineProcessKeyEventCallback ,
EngineProcessKeyEventCallback ,
#if defined(ENABLE_OVERLOADING)
EngineProcessKeyEventSignalInfo ,
#endif
afterEngineProcessKeyEvent ,
genClosure_EngineProcessKeyEvent ,
mk_EngineProcessKeyEventCallback ,
noEngineProcessKeyEventCallback ,
onEngineProcessKeyEvent ,
wrap_EngineProcessKeyEventCallback ,
C_EnginePropertyActivateCallback ,
EnginePropertyActivateCallback ,
#if defined(ENABLE_OVERLOADING)
EnginePropertyActivateSignalInfo ,
#endif
afterEnginePropertyActivate ,
genClosure_EnginePropertyActivate ,
mk_EnginePropertyActivateCallback ,
noEnginePropertyActivateCallback ,
onEnginePropertyActivate ,
wrap_EnginePropertyActivateCallback ,
C_EnginePropertyHideCallback ,
EnginePropertyHideCallback ,
#if defined(ENABLE_OVERLOADING)
EnginePropertyHideSignalInfo ,
#endif
afterEnginePropertyHide ,
genClosure_EnginePropertyHide ,
mk_EnginePropertyHideCallback ,
noEnginePropertyHideCallback ,
onEnginePropertyHide ,
wrap_EnginePropertyHideCallback ,
C_EnginePropertyShowCallback ,
EnginePropertyShowCallback ,
#if defined(ENABLE_OVERLOADING)
EnginePropertyShowSignalInfo ,
#endif
afterEnginePropertyShow ,
genClosure_EnginePropertyShow ,
mk_EnginePropertyShowCallback ,
noEnginePropertyShowCallback ,
onEnginePropertyShow ,
wrap_EnginePropertyShowCallback ,
C_EngineResetCallback ,
EngineResetCallback ,
#if defined(ENABLE_OVERLOADING)
EngineResetSignalInfo ,
#endif
afterEngineReset ,
genClosure_EngineReset ,
mk_EngineResetCallback ,
noEngineResetCallback ,
onEngineReset ,
wrap_EngineResetCallback ,
C_EngineSetCapabilitiesCallback ,
EngineSetCapabilitiesCallback ,
#if defined(ENABLE_OVERLOADING)
EngineSetCapabilitiesSignalInfo ,
#endif
afterEngineSetCapabilities ,
genClosure_EngineSetCapabilities ,
mk_EngineSetCapabilitiesCallback ,
noEngineSetCapabilitiesCallback ,
onEngineSetCapabilities ,
wrap_EngineSetCapabilitiesCallback ,
C_EngineSetContentTypeCallback ,
EngineSetContentTypeCallback ,
#if defined(ENABLE_OVERLOADING)
EngineSetContentTypeSignalInfo ,
#endif
afterEngineSetContentType ,
genClosure_EngineSetContentType ,
mk_EngineSetContentTypeCallback ,
noEngineSetContentTypeCallback ,
onEngineSetContentType ,
wrap_EngineSetContentTypeCallback ,
C_EngineSetCursorLocationCallback ,
EngineSetCursorLocationCallback ,
#if defined(ENABLE_OVERLOADING)
EngineSetCursorLocationSignalInfo ,
#endif
afterEngineSetCursorLocation ,
genClosure_EngineSetCursorLocation ,
mk_EngineSetCursorLocationCallback ,
noEngineSetCursorLocationCallback ,
onEngineSetCursorLocation ,
wrap_EngineSetCursorLocationCallback ,
C_EngineSetSurroundingTextCallback ,
EngineSetSurroundingTextCallback ,
#if defined(ENABLE_OVERLOADING)
EngineSetSurroundingTextSignalInfo ,
#endif
afterEngineSetSurroundingText ,
genClosure_EngineSetSurroundingText ,
mk_EngineSetSurroundingTextCallback ,
noEngineSetSurroundingTextCallback ,
onEngineSetSurroundingText ,
wrap_EngineSetSurroundingTextCallback ,
) 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 qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.IBus.Enums as IBus.Enums
import {-# SOURCE #-} qualified GI.IBus.Objects.LookupTable as IBus.LookupTable
import {-# SOURCE #-} qualified GI.IBus.Objects.Object as IBus.Object
import {-# SOURCE #-} qualified GI.IBus.Objects.PropList as IBus.PropList
import {-# SOURCE #-} qualified GI.IBus.Objects.Property as IBus.Property
import {-# SOURCE #-} qualified GI.IBus.Objects.Service as IBus.Service
import {-# SOURCE #-} qualified GI.IBus.Objects.Text as IBus.Text
newtype Engine = Engine (SP.ManagedPtr Engine)
deriving (Engine -> Engine -> Bool
(Engine -> Engine -> Bool)
-> (Engine -> Engine -> Bool) -> Eq Engine
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Engine -> Engine -> Bool
$c/= :: Engine -> Engine -> Bool
== :: Engine -> Engine -> Bool
$c== :: Engine -> Engine -> Bool
Eq)
instance SP.ManagedPtrNewtype Engine where
toManagedPtr :: Engine -> ManagedPtr Engine
toManagedPtr (Engine ManagedPtr Engine
p) = ManagedPtr Engine
p
foreign import ccall "ibus_engine_get_type"
c_ibus_engine_get_type :: IO B.Types.GType
instance B.Types.TypedObject Engine where
glibType :: IO GType
glibType = IO GType
c_ibus_engine_get_type
instance B.Types.GObject Engine
class (SP.GObject o, O.IsDescendantOf Engine o) => IsEngine o
instance (SP.GObject o, O.IsDescendantOf Engine o) => IsEngine o
instance O.HasParentTypes Engine
type instance O.ParentTypes Engine = '[IBus.Service.Service, IBus.Object.Object, GObject.Object.Object]
toEngine :: (MIO.MonadIO m, IsEngine o) => o -> m Engine
toEngine :: forall (m :: * -> *) o. (MonadIO m, IsEngine o) => o -> m Engine
toEngine = IO Engine -> m Engine
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Engine -> m Engine) -> (o -> IO Engine) -> o -> m Engine
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Engine -> Engine) -> o -> IO Engine
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Engine -> Engine
Engine
instance B.GValue.IsGValue (Maybe Engine) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ibus_engine_get_type
gvalueSet_ :: Ptr GValue -> Maybe Engine -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Engine
P.Nothing = Ptr GValue -> Ptr Engine -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Engine
forall a. Ptr a
FP.nullPtr :: FP.Ptr Engine)
gvalueSet_ Ptr GValue
gv (P.Just Engine
obj) = Engine -> (Ptr Engine -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Engine
obj (Ptr GValue -> Ptr Engine -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Engine)
gvalueGet_ Ptr GValue
gv = do
Ptr Engine
ptr <- Ptr GValue -> IO (Ptr Engine)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Engine)
if Ptr Engine
ptr Ptr Engine -> Ptr Engine -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Engine
forall a. Ptr a
FP.nullPtr
then Engine -> Maybe Engine
forall a. a -> Maybe a
P.Just (Engine -> Maybe Engine) -> IO Engine -> IO (Maybe Engine)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Engine -> Engine) -> Ptr Engine -> IO Engine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Engine -> Engine
Engine Ptr Engine
ptr
else Maybe Engine -> IO (Maybe Engine)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Engine
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveEngineMethod (t :: Symbol) (o :: *) :: * where
ResolveEngineMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveEngineMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveEngineMethod "commitText" o = EngineCommitTextMethodInfo
ResolveEngineMethod "deleteSurroundingText" o = EngineDeleteSurroundingTextMethodInfo
ResolveEngineMethod "destroy" o = IBus.Object.ObjectDestroyMethodInfo
ResolveEngineMethod "emitSignal" o = IBus.Service.ServiceEmitSignalMethodInfo
ResolveEngineMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveEngineMethod "forwardKeyEvent" o = EngineForwardKeyEventMethodInfo
ResolveEngineMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveEngineMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveEngineMethod "hideAuxiliaryText" o = EngineHideAuxiliaryTextMethodInfo
ResolveEngineMethod "hideLookupTable" o = EngineHideLookupTableMethodInfo
ResolveEngineMethod "hidePreeditText" o = EngineHidePreeditTextMethodInfo
ResolveEngineMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveEngineMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveEngineMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveEngineMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveEngineMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveEngineMethod "register" o = IBus.Service.ServiceRegisterMethodInfo
ResolveEngineMethod "registerProperties" o = EngineRegisterPropertiesMethodInfo
ResolveEngineMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveEngineMethod "showAuxiliaryText" o = EngineShowAuxiliaryTextMethodInfo
ResolveEngineMethod "showLookupTable" o = EngineShowLookupTableMethodInfo
ResolveEngineMethod "showPreeditText" o = EngineShowPreeditTextMethodInfo
ResolveEngineMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveEngineMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveEngineMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveEngineMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveEngineMethod "unregister" o = IBus.Service.ServiceUnregisterMethodInfo
ResolveEngineMethod "updateAuxiliaryText" o = EngineUpdateAuxiliaryTextMethodInfo
ResolveEngineMethod "updateLookupTable" o = EngineUpdateLookupTableMethodInfo
ResolveEngineMethod "updateLookupTableFast" o = EngineUpdateLookupTableFastMethodInfo
ResolveEngineMethod "updatePreeditText" o = EngineUpdatePreeditTextMethodInfo
ResolveEngineMethod "updatePreeditTextWithMode" o = EngineUpdatePreeditTextWithModeMethodInfo
ResolveEngineMethod "updateProperty" o = EngineUpdatePropertyMethodInfo
ResolveEngineMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveEngineMethod "getConnection" o = IBus.Service.ServiceGetConnectionMethodInfo
ResolveEngineMethod "getContentType" o = EngineGetContentTypeMethodInfo
ResolveEngineMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveEngineMethod "getName" o = EngineGetNameMethodInfo
ResolveEngineMethod "getObjectPath" o = IBus.Service.ServiceGetObjectPathMethodInfo
ResolveEngineMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveEngineMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveEngineMethod "getSurroundingText" o = EngineGetSurroundingTextMethodInfo
ResolveEngineMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveEngineMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveEngineMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveEngineMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveEngineMethod t Engine, O.OverloadedMethod info Engine p) => OL.IsLabel t (Engine -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveEngineMethod t Engine, O.OverloadedMethod info Engine p, R.HasField t Engine p) => R.HasField t Engine p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveEngineMethod t Engine, O.OverloadedMethodInfo info Engine) => OL.IsLabel t (O.MethodProxy info Engine) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type EngineCancelHandWritingCallback =
Word32
-> IO ()
noEngineCancelHandWritingCallback :: Maybe EngineCancelHandWritingCallback
noEngineCancelHandWritingCallback :: Maybe EngineCancelHandWritingCallback
noEngineCancelHandWritingCallback = Maybe EngineCancelHandWritingCallback
forall a. Maybe a
Nothing
type C_EngineCancelHandWritingCallback =
Ptr () ->
Word32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineCancelHandWritingCallback :: C_EngineCancelHandWritingCallback -> IO (FunPtr C_EngineCancelHandWritingCallback)
genClosure_EngineCancelHandWriting :: MonadIO m => EngineCancelHandWritingCallback -> m (GClosure C_EngineCancelHandWritingCallback)
genClosure_EngineCancelHandWriting :: forall (m :: * -> *).
MonadIO m =>
EngineCancelHandWritingCallback
-> m (GClosure C_EngineCancelHandWritingCallback)
genClosure_EngineCancelHandWriting EngineCancelHandWritingCallback
cb = IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback))
-> IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback EngineCancelHandWritingCallback
cb
C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineCancelHandWritingCallback C_EngineCancelHandWritingCallback
cb' IO (FunPtr C_EngineCancelHandWritingCallback)
-> (FunPtr C_EngineCancelHandWritingCallback
-> IO (GClosure C_EngineCancelHandWritingCallback))
-> IO (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCancelHandWritingCallback
-> IO (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineCancelHandWritingCallback ::
EngineCancelHandWritingCallback ->
C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback :: EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback EngineCancelHandWritingCallback
_cb Ptr ()
_ Word32
nStrokes Ptr ()
_ = do
EngineCancelHandWritingCallback
_cb Word32
nStrokes
onEngineCancelHandWriting :: (IsEngine a, MonadIO m) => a -> EngineCancelHandWritingCallback -> m SignalHandlerId
onEngineCancelHandWriting :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCancelHandWritingCallback -> m SignalHandlerId
onEngineCancelHandWriting a
obj EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback EngineCancelHandWritingCallback
cb
FunPtr C_EngineCancelHandWritingCallback
cb'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineCancelHandWritingCallback C_EngineCancelHandWritingCallback
cb'
a
-> Text
-> FunPtr C_EngineCancelHandWritingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancel-hand-writing" FunPtr C_EngineCancelHandWritingCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineCancelHandWriting :: (IsEngine a, MonadIO m) => a -> EngineCancelHandWritingCallback -> m SignalHandlerId
afterEngineCancelHandWriting :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCancelHandWritingCallback -> m SignalHandlerId
afterEngineCancelHandWriting a
obj EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback EngineCancelHandWritingCallback
cb
FunPtr C_EngineCancelHandWritingCallback
cb'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineCancelHandWritingCallback C_EngineCancelHandWritingCallback
cb'
a
-> Text
-> FunPtr C_EngineCancelHandWritingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancel-hand-writing" FunPtr C_EngineCancelHandWritingCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineCancelHandWritingSignalInfo
instance SignalInfo EngineCancelHandWritingSignalInfo where
type HaskellCallbackType EngineCancelHandWritingSignalInfo = EngineCancelHandWritingCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineCancelHandWritingCallback cb
cb'' <- mk_EngineCancelHandWritingCallback cb'
connectSignalFunPtr obj "cancel-hand-writing" cb'' connectMode detail
#endif
type EngineCandidateClickedCallback =
Word32
-> Word32
-> Word32
-> IO ()
noEngineCandidateClickedCallback :: Maybe EngineCandidateClickedCallback
noEngineCandidateClickedCallback :: Maybe EngineCandidateClickedCallback
noEngineCandidateClickedCallback = Maybe EngineCandidateClickedCallback
forall a. Maybe a
Nothing
type C_EngineCandidateClickedCallback =
Ptr () ->
Word32 ->
Word32 ->
Word32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineCandidateClickedCallback :: C_EngineCandidateClickedCallback -> IO (FunPtr C_EngineCandidateClickedCallback)
genClosure_EngineCandidateClicked :: MonadIO m => EngineCandidateClickedCallback -> m (GClosure C_EngineCandidateClickedCallback)
genClosure_EngineCandidateClicked :: forall (m :: * -> *).
MonadIO m =>
EngineCandidateClickedCallback
-> m (GClosure C_EngineCandidateClickedCallback)
genClosure_EngineCandidateClicked EngineCandidateClickedCallback
cb = IO (GClosure C_EngineCandidateClickedCallback)
-> m (GClosure C_EngineCandidateClickedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCandidateClickedCallback)
-> m (GClosure C_EngineCandidateClickedCallback))
-> IO (GClosure C_EngineCandidateClickedCallback)
-> m (GClosure C_EngineCandidateClickedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCandidateClickedCallback
cb' = EngineCandidateClickedCallback -> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback EngineCandidateClickedCallback
cb
C_EngineCandidateClickedCallback
-> IO (FunPtr C_EngineCandidateClickedCallback)
mk_EngineCandidateClickedCallback C_EngineCandidateClickedCallback
cb' IO (FunPtr C_EngineCandidateClickedCallback)
-> (FunPtr C_EngineCandidateClickedCallback
-> IO (GClosure C_EngineCandidateClickedCallback))
-> IO (GClosure C_EngineCandidateClickedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCandidateClickedCallback
-> IO (GClosure C_EngineCandidateClickedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineCandidateClickedCallback ::
EngineCandidateClickedCallback ->
C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback :: EngineCandidateClickedCallback -> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback EngineCandidateClickedCallback
_cb Ptr ()
_ Word32
index Word32
button Word32
state Ptr ()
_ = do
EngineCandidateClickedCallback
_cb Word32
index Word32
button Word32
state
onEngineCandidateClicked :: (IsEngine a, MonadIO m) => a -> EngineCandidateClickedCallback -> m SignalHandlerId
onEngineCandidateClicked :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCandidateClickedCallback -> m SignalHandlerId
onEngineCandidateClicked a
obj EngineCandidateClickedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCandidateClickedCallback
cb' = EngineCandidateClickedCallback -> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback EngineCandidateClickedCallback
cb
FunPtr C_EngineCandidateClickedCallback
cb'' <- C_EngineCandidateClickedCallback
-> IO (FunPtr C_EngineCandidateClickedCallback)
mk_EngineCandidateClickedCallback C_EngineCandidateClickedCallback
cb'
a
-> Text
-> FunPtr C_EngineCandidateClickedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"candidate-clicked" FunPtr C_EngineCandidateClickedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineCandidateClicked :: (IsEngine a, MonadIO m) => a -> EngineCandidateClickedCallback -> m SignalHandlerId
afterEngineCandidateClicked :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCandidateClickedCallback -> m SignalHandlerId
afterEngineCandidateClicked a
obj EngineCandidateClickedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCandidateClickedCallback
cb' = EngineCandidateClickedCallback -> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback EngineCandidateClickedCallback
cb
FunPtr C_EngineCandidateClickedCallback
cb'' <- C_EngineCandidateClickedCallback
-> IO (FunPtr C_EngineCandidateClickedCallback)
mk_EngineCandidateClickedCallback C_EngineCandidateClickedCallback
cb'
a
-> Text
-> FunPtr C_EngineCandidateClickedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"candidate-clicked" FunPtr C_EngineCandidateClickedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineCandidateClickedSignalInfo
instance SignalInfo EngineCandidateClickedSignalInfo where
type HaskellCallbackType EngineCandidateClickedSignalInfo = EngineCandidateClickedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineCandidateClickedCallback cb
cb'' <- mk_EngineCandidateClickedCallback cb'
connectSignalFunPtr obj "candidate-clicked" cb'' connectMode detail
#endif
type EngineCursorDownCallback =
IO ()
noEngineCursorDownCallback :: Maybe EngineCursorDownCallback
noEngineCursorDownCallback :: Maybe (IO ())
noEngineCursorDownCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EngineCursorDownCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineCursorDownCallback :: C_EngineCursorDownCallback -> IO (FunPtr C_EngineCursorDownCallback)
genClosure_EngineCursorDown :: MonadIO m => EngineCursorDownCallback -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineCursorDown :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineCursorDown IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback IO ()
cb
C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorDownCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineCursorDownCallback ::
EngineCursorDownCallback ->
C_EngineCursorDownCallback
wrap_EngineCursorDownCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onEngineCursorDown :: (IsEngine a, MonadIO m) => a -> EngineCursorDownCallback -> m SignalHandlerId
onEngineCursorDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineCursorDown a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorDownCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-down" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineCursorDown :: (IsEngine a, MonadIO m) => a -> EngineCursorDownCallback -> m SignalHandlerId
afterEngineCursorDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineCursorDown a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorDownCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-down" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineCursorDownSignalInfo
instance SignalInfo EngineCursorDownSignalInfo where
type HaskellCallbackType EngineCursorDownSignalInfo = EngineCursorDownCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineCursorDownCallback cb
cb'' <- mk_EngineCursorDownCallback cb'
connectSignalFunPtr obj "cursor-down" cb'' connectMode detail
#endif
type EngineCursorUpCallback =
IO ()
noEngineCursorUpCallback :: Maybe EngineCursorUpCallback
noEngineCursorUpCallback :: Maybe (IO ())
noEngineCursorUpCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EngineCursorUpCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineCursorUpCallback :: C_EngineCursorUpCallback -> IO (FunPtr C_EngineCursorUpCallback)
genClosure_EngineCursorUp :: MonadIO m => EngineCursorUpCallback -> m (GClosure C_EngineCursorUpCallback)
genClosure_EngineCursorUp :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineCursorUp IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback IO ()
cb
C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorUpCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineCursorUpCallback ::
EngineCursorUpCallback ->
C_EngineCursorUpCallback
wrap_EngineCursorUpCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onEngineCursorUp :: (IsEngine a, MonadIO m) => a -> EngineCursorUpCallback -> m SignalHandlerId
onEngineCursorUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineCursorUp a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorUpCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-up" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineCursorUp :: (IsEngine a, MonadIO m) => a -> EngineCursorUpCallback -> m SignalHandlerId
afterEngineCursorUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineCursorUp a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorUpCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-up" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineCursorUpSignalInfo
instance SignalInfo EngineCursorUpSignalInfo where
type HaskellCallbackType EngineCursorUpSignalInfo = EngineCursorUpCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineCursorUpCallback cb
cb'' <- mk_EngineCursorUpCallback cb'
connectSignalFunPtr obj "cursor-up" cb'' connectMode detail
#endif
type EngineDisableCallback =
IO ()
noEngineDisableCallback :: Maybe EngineDisableCallback
noEngineDisableCallback :: Maybe (IO ())
noEngineDisableCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EngineDisableCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineDisableCallback :: C_EngineDisableCallback -> IO (FunPtr C_EngineDisableCallback)
genClosure_EngineDisable :: MonadIO m => EngineDisableCallback -> m (GClosure C_EngineDisableCallback)
genClosure_EngineDisable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineDisable IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineDisableCallback IO ()
cb
C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineDisableCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineDisableCallback ::
EngineDisableCallback ->
C_EngineDisableCallback
wrap_EngineDisableCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineDisableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onEngineDisable :: (IsEngine a, MonadIO m) => a -> EngineDisableCallback -> m SignalHandlerId
onEngineDisable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineDisable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineDisableCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineDisableCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"disable" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineDisable :: (IsEngine a, MonadIO m) => a -> EngineDisableCallback -> m SignalHandlerId
afterEngineDisable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineDisable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineDisableCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineDisableCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"disable" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineDisableSignalInfo
instance SignalInfo EngineDisableSignalInfo where
type HaskellCallbackType EngineDisableSignalInfo = EngineDisableCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineDisableCallback cb
cb'' <- mk_EngineDisableCallback cb'
connectSignalFunPtr obj "disable" cb'' connectMode detail
#endif
type EngineEnableCallback =
IO ()
noEngineEnableCallback :: Maybe EngineEnableCallback
noEngineEnableCallback :: Maybe (IO ())
noEngineEnableCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EngineEnableCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineEnableCallback :: C_EngineEnableCallback -> IO (FunPtr C_EngineEnableCallback)
genClosure_EngineEnable :: MonadIO m => EngineEnableCallback -> m (GClosure C_EngineEnableCallback)
genClosure_EngineEnable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineEnable IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineEnableCallback IO ()
cb
C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineEnableCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineEnableCallback ::
EngineEnableCallback ->
C_EngineEnableCallback
wrap_EngineEnableCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineEnableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onEngineEnable :: (IsEngine a, MonadIO m) => a -> EngineEnableCallback -> m SignalHandlerId
onEngineEnable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineEnable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineEnableCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineEnableCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enable" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineEnable :: (IsEngine a, MonadIO m) => a -> EngineEnableCallback -> m SignalHandlerId
afterEngineEnable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineEnable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineEnableCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineEnableCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enable" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineEnableSignalInfo
instance SignalInfo EngineEnableSignalInfo where
type HaskellCallbackType EngineEnableSignalInfo = EngineEnableCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineEnableCallback cb
cb'' <- mk_EngineEnableCallback cb'
connectSignalFunPtr obj "enable" cb'' connectMode detail
#endif
type EngineFocusInCallback =
IO ()
noEngineFocusInCallback :: Maybe EngineFocusInCallback
noEngineFocusInCallback :: Maybe (IO ())
noEngineFocusInCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EngineFocusInCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineFocusInCallback :: C_EngineFocusInCallback -> IO (FunPtr C_EngineFocusInCallback)
genClosure_EngineFocusIn :: MonadIO m => EngineFocusInCallback -> m (GClosure C_EngineFocusInCallback)
genClosure_EngineFocusIn :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineFocusIn IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback IO ()
cb
C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusInCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineFocusInCallback ::
EngineFocusInCallback ->
C_EngineFocusInCallback
wrap_EngineFocusInCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onEngineFocusIn :: (IsEngine a, MonadIO m) => a -> EngineFocusInCallback -> m SignalHandlerId
onEngineFocusIn :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineFocusIn a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusInCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-in" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineFocusIn :: (IsEngine a, MonadIO m) => a -> EngineFocusInCallback -> m SignalHandlerId
afterEngineFocusIn :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineFocusIn a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusInCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-in" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineFocusInSignalInfo
instance SignalInfo EngineFocusInSignalInfo where
type HaskellCallbackType EngineFocusInSignalInfo = EngineFocusInCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineFocusInCallback cb
cb'' <- mk_EngineFocusInCallback cb'
connectSignalFunPtr obj "focus-in" cb'' connectMode detail
#endif
type EngineFocusOutCallback =
IO ()
noEngineFocusOutCallback :: Maybe EngineFocusOutCallback
noEngineFocusOutCallback :: Maybe (IO ())
noEngineFocusOutCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EngineFocusOutCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineFocusOutCallback :: C_EngineFocusOutCallback -> IO (FunPtr C_EngineFocusOutCallback)
genClosure_EngineFocusOut :: MonadIO m => EngineFocusOutCallback -> m (GClosure C_EngineFocusOutCallback)
genClosure_EngineFocusOut :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineFocusOut IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback IO ()
cb
C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusOutCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineFocusOutCallback ::
EngineFocusOutCallback ->
C_EngineFocusOutCallback
wrap_EngineFocusOutCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onEngineFocusOut :: (IsEngine a, MonadIO m) => a -> EngineFocusOutCallback -> m SignalHandlerId
onEngineFocusOut :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineFocusOut a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusOutCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-out" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineFocusOut :: (IsEngine a, MonadIO m) => a -> EngineFocusOutCallback -> m SignalHandlerId
afterEngineFocusOut :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineFocusOut a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusOutCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-out" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineFocusOutSignalInfo
instance SignalInfo EngineFocusOutSignalInfo where
type HaskellCallbackType EngineFocusOutSignalInfo = EngineFocusOutCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineFocusOutCallback cb
cb'' <- mk_EngineFocusOutCallback cb'
connectSignalFunPtr obj "focus-out" cb'' connectMode detail
#endif
type EnginePageDownCallback =
IO ()
noEnginePageDownCallback :: Maybe EnginePageDownCallback
noEnginePageDownCallback :: Maybe (IO ())
noEnginePageDownCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EnginePageDownCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EnginePageDownCallback :: C_EnginePageDownCallback -> IO (FunPtr C_EnginePageDownCallback)
genClosure_EnginePageDown :: MonadIO m => EnginePageDownCallback -> m (GClosure C_EnginePageDownCallback)
genClosure_EnginePageDown :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EnginePageDown IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback IO ()
cb
C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageDownCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EnginePageDownCallback ::
EnginePageDownCallback ->
C_EnginePageDownCallback
wrap_EnginePageDownCallback :: IO () -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onEnginePageDown :: (IsEngine a, MonadIO m) => a -> EnginePageDownCallback -> m SignalHandlerId
onEnginePageDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEnginePageDown a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageDownCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-down" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEnginePageDown :: (IsEngine a, MonadIO m) => a -> EnginePageDownCallback -> m SignalHandlerId
afterEnginePageDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEnginePageDown a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageDownCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-down" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EnginePageDownSignalInfo
instance SignalInfo EnginePageDownSignalInfo where
type HaskellCallbackType EnginePageDownSignalInfo = EnginePageDownCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EnginePageDownCallback cb
cb'' <- mk_EnginePageDownCallback cb'
connectSignalFunPtr obj "page-down" cb'' connectMode detail
#endif
type EnginePageUpCallback =
IO ()
noEnginePageUpCallback :: Maybe EnginePageUpCallback
noEnginePageUpCallback :: Maybe (IO ())
noEnginePageUpCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EnginePageUpCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EnginePageUpCallback :: C_EnginePageUpCallback -> IO (FunPtr C_EnginePageUpCallback)
genClosure_EnginePageUp :: MonadIO m => EnginePageUpCallback -> m (GClosure C_EnginePageUpCallback)
genClosure_EnginePageUp :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EnginePageUp IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback IO ()
cb
C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageUpCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EnginePageUpCallback ::
EnginePageUpCallback ->
C_EnginePageUpCallback
wrap_EnginePageUpCallback :: IO () -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onEnginePageUp :: (IsEngine a, MonadIO m) => a -> EnginePageUpCallback -> m SignalHandlerId
onEnginePageUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEnginePageUp a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageUpCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-up" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEnginePageUp :: (IsEngine a, MonadIO m) => a -> EnginePageUpCallback -> m SignalHandlerId
afterEnginePageUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEnginePageUp a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageUpCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-up" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EnginePageUpSignalInfo
instance SignalInfo EnginePageUpSignalInfo where
type HaskellCallbackType EnginePageUpSignalInfo = EnginePageUpCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EnginePageUpCallback cb
cb'' <- mk_EnginePageUpCallback cb'
connectSignalFunPtr obj "page-up" cb'' connectMode detail
#endif
type EngineProcessHandWritingEventCallback =
Ptr ()
-> Word32
-> IO ()
noEngineProcessHandWritingEventCallback :: Maybe EngineProcessHandWritingEventCallback
noEngineProcessHandWritingEventCallback :: Maybe EngineProcessHandWritingEventCallback
noEngineProcessHandWritingEventCallback = Maybe EngineProcessHandWritingEventCallback
forall a. Maybe a
Nothing
type C_EngineProcessHandWritingEventCallback =
Ptr () ->
Ptr () ->
Word32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineProcessHandWritingEventCallback :: C_EngineProcessHandWritingEventCallback -> IO (FunPtr C_EngineProcessHandWritingEventCallback)
genClosure_EngineProcessHandWritingEvent :: MonadIO m => EngineProcessHandWritingEventCallback -> m (GClosure C_EngineProcessHandWritingEventCallback)
genClosure_EngineProcessHandWritingEvent :: forall (m :: * -> *).
MonadIO m =>
EngineProcessHandWritingEventCallback
-> m (GClosure C_EngineProcessHandWritingEventCallback)
genClosure_EngineProcessHandWritingEvent EngineProcessHandWritingEventCallback
cb = IO (GClosure C_EngineProcessHandWritingEventCallback)
-> m (GClosure C_EngineProcessHandWritingEventCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineProcessHandWritingEventCallback)
-> m (GClosure C_EngineProcessHandWritingEventCallback))
-> IO (GClosure C_EngineProcessHandWritingEventCallback)
-> m (GClosure C_EngineProcessHandWritingEventCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineProcessHandWritingEventCallback
cb' = EngineProcessHandWritingEventCallback
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback EngineProcessHandWritingEventCallback
cb
C_EngineProcessHandWritingEventCallback
-> IO (FunPtr C_EngineProcessHandWritingEventCallback)
mk_EngineProcessHandWritingEventCallback C_EngineProcessHandWritingEventCallback
cb' IO (FunPtr C_EngineProcessHandWritingEventCallback)
-> (FunPtr C_EngineProcessHandWritingEventCallback
-> IO (GClosure C_EngineProcessHandWritingEventCallback))
-> IO (GClosure C_EngineProcessHandWritingEventCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineProcessHandWritingEventCallback
-> IO (GClosure C_EngineProcessHandWritingEventCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineProcessHandWritingEventCallback ::
EngineProcessHandWritingEventCallback ->
C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback :: EngineProcessHandWritingEventCallback
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback EngineProcessHandWritingEventCallback
_cb Ptr ()
_ Ptr ()
coordinates Word32
coordinatesLen Ptr ()
_ = do
EngineProcessHandWritingEventCallback
_cb Ptr ()
coordinates Word32
coordinatesLen
onEngineProcessHandWritingEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId
onEngineProcessHandWritingEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId
onEngineProcessHandWritingEvent a
obj EngineProcessHandWritingEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineProcessHandWritingEventCallback
cb' = EngineProcessHandWritingEventCallback
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback EngineProcessHandWritingEventCallback
cb
FunPtr C_EngineProcessHandWritingEventCallback
cb'' <- C_EngineProcessHandWritingEventCallback
-> IO (FunPtr C_EngineProcessHandWritingEventCallback)
mk_EngineProcessHandWritingEventCallback C_EngineProcessHandWritingEventCallback
cb'
a
-> Text
-> FunPtr C_EngineProcessHandWritingEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"process-hand-writing-event" FunPtr C_EngineProcessHandWritingEventCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineProcessHandWritingEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId
afterEngineProcessHandWritingEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId
afterEngineProcessHandWritingEvent a
obj EngineProcessHandWritingEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineProcessHandWritingEventCallback
cb' = EngineProcessHandWritingEventCallback
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback EngineProcessHandWritingEventCallback
cb
FunPtr C_EngineProcessHandWritingEventCallback
cb'' <- C_EngineProcessHandWritingEventCallback
-> IO (FunPtr C_EngineProcessHandWritingEventCallback)
mk_EngineProcessHandWritingEventCallback C_EngineProcessHandWritingEventCallback
cb'
a
-> Text
-> FunPtr C_EngineProcessHandWritingEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"process-hand-writing-event" FunPtr C_EngineProcessHandWritingEventCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineProcessHandWritingEventSignalInfo
instance SignalInfo EngineProcessHandWritingEventSignalInfo where
type HaskellCallbackType EngineProcessHandWritingEventSignalInfo = EngineProcessHandWritingEventCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineProcessHandWritingEventCallback cb
cb'' <- mk_EngineProcessHandWritingEventCallback cb'
connectSignalFunPtr obj "process-hand-writing-event" cb'' connectMode detail
#endif
type EngineProcessKeyEventCallback =
Word32
-> Word32
-> Word32
-> IO Bool
noEngineProcessKeyEventCallback :: Maybe EngineProcessKeyEventCallback
noEngineProcessKeyEventCallback :: Maybe EngineProcessKeyEventCallback
noEngineProcessKeyEventCallback = Maybe EngineProcessKeyEventCallback
forall a. Maybe a
Nothing
type C_EngineProcessKeyEventCallback =
Ptr () ->
Word32 ->
Word32 ->
Word32 ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mk_EngineProcessKeyEventCallback :: C_EngineProcessKeyEventCallback -> IO (FunPtr C_EngineProcessKeyEventCallback)
genClosure_EngineProcessKeyEvent :: MonadIO m => EngineProcessKeyEventCallback -> m (GClosure C_EngineProcessKeyEventCallback)
genClosure_EngineProcessKeyEvent :: forall (m :: * -> *).
MonadIO m =>
EngineProcessKeyEventCallback
-> m (GClosure C_EngineProcessKeyEventCallback)
genClosure_EngineProcessKeyEvent EngineProcessKeyEventCallback
cb = IO (GClosure C_EngineProcessKeyEventCallback)
-> m (GClosure C_EngineProcessKeyEventCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineProcessKeyEventCallback)
-> m (GClosure C_EngineProcessKeyEventCallback))
-> IO (GClosure C_EngineProcessKeyEventCallback)
-> m (GClosure C_EngineProcessKeyEventCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineProcessKeyEventCallback
cb' = EngineProcessKeyEventCallback -> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback EngineProcessKeyEventCallback
cb
C_EngineProcessKeyEventCallback
-> IO (FunPtr C_EngineProcessKeyEventCallback)
mk_EngineProcessKeyEventCallback C_EngineProcessKeyEventCallback
cb' IO (FunPtr C_EngineProcessKeyEventCallback)
-> (FunPtr C_EngineProcessKeyEventCallback
-> IO (GClosure C_EngineProcessKeyEventCallback))
-> IO (GClosure C_EngineProcessKeyEventCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineProcessKeyEventCallback
-> IO (GClosure C_EngineProcessKeyEventCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineProcessKeyEventCallback ::
EngineProcessKeyEventCallback ->
C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback :: EngineProcessKeyEventCallback -> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback EngineProcessKeyEventCallback
_cb Ptr ()
_ Word32
keyval Word32
keycode Word32
state Ptr ()
_ = do
Bool
result <- EngineProcessKeyEventCallback
_cb Word32
keyval Word32
keycode Word32
state
let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'
onEngineProcessKeyEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessKeyEventCallback -> m SignalHandlerId
onEngineProcessKeyEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineProcessKeyEventCallback -> m SignalHandlerId
onEngineProcessKeyEvent a
obj EngineProcessKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineProcessKeyEventCallback
cb' = EngineProcessKeyEventCallback -> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback EngineProcessKeyEventCallback
cb
FunPtr C_EngineProcessKeyEventCallback
cb'' <- C_EngineProcessKeyEventCallback
-> IO (FunPtr C_EngineProcessKeyEventCallback)
mk_EngineProcessKeyEventCallback C_EngineProcessKeyEventCallback
cb'
a
-> Text
-> FunPtr C_EngineProcessKeyEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"process-key-event" FunPtr C_EngineProcessKeyEventCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineProcessKeyEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessKeyEventCallback -> m SignalHandlerId
afterEngineProcessKeyEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineProcessKeyEventCallback -> m SignalHandlerId
afterEngineProcessKeyEvent a
obj EngineProcessKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineProcessKeyEventCallback
cb' = EngineProcessKeyEventCallback -> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback EngineProcessKeyEventCallback
cb
FunPtr C_EngineProcessKeyEventCallback
cb'' <- C_EngineProcessKeyEventCallback
-> IO (FunPtr C_EngineProcessKeyEventCallback)
mk_EngineProcessKeyEventCallback C_EngineProcessKeyEventCallback
cb'
a
-> Text
-> FunPtr C_EngineProcessKeyEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"process-key-event" FunPtr C_EngineProcessKeyEventCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineProcessKeyEventSignalInfo
instance SignalInfo EngineProcessKeyEventSignalInfo where
type HaskellCallbackType EngineProcessKeyEventSignalInfo = EngineProcessKeyEventCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineProcessKeyEventCallback cb
cb'' <- mk_EngineProcessKeyEventCallback cb'
connectSignalFunPtr obj "process-key-event" cb'' connectMode detail
#endif
type EnginePropertyActivateCallback =
T.Text
-> Word32
-> IO ()
noEnginePropertyActivateCallback :: Maybe EnginePropertyActivateCallback
noEnginePropertyActivateCallback :: Maybe EnginePropertyActivateCallback
noEnginePropertyActivateCallback = Maybe EnginePropertyActivateCallback
forall a. Maybe a
Nothing
type C_EnginePropertyActivateCallback =
Ptr () ->
CString ->
Word32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EnginePropertyActivateCallback :: C_EnginePropertyActivateCallback -> IO (FunPtr C_EnginePropertyActivateCallback)
genClosure_EnginePropertyActivate :: MonadIO m => EnginePropertyActivateCallback -> m (GClosure C_EnginePropertyActivateCallback)
genClosure_EnginePropertyActivate :: forall (m :: * -> *).
MonadIO m =>
EnginePropertyActivateCallback
-> m (GClosure C_EnginePropertyActivateCallback)
genClosure_EnginePropertyActivate EnginePropertyActivateCallback
cb = IO (GClosure C_EnginePropertyActivateCallback)
-> m (GClosure C_EnginePropertyActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EnginePropertyActivateCallback)
-> m (GClosure C_EnginePropertyActivateCallback))
-> IO (GClosure C_EnginePropertyActivateCallback)
-> m (GClosure C_EnginePropertyActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EnginePropertyActivateCallback
cb' = EnginePropertyActivateCallback -> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback EnginePropertyActivateCallback
cb
C_EnginePropertyActivateCallback
-> IO (FunPtr C_EnginePropertyActivateCallback)
mk_EnginePropertyActivateCallback C_EnginePropertyActivateCallback
cb' IO (FunPtr C_EnginePropertyActivateCallback)
-> (FunPtr C_EnginePropertyActivateCallback
-> IO (GClosure C_EnginePropertyActivateCallback))
-> IO (GClosure C_EnginePropertyActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EnginePropertyActivateCallback
-> IO (GClosure C_EnginePropertyActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EnginePropertyActivateCallback ::
EnginePropertyActivateCallback ->
C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback :: EnginePropertyActivateCallback -> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback EnginePropertyActivateCallback
_cb Ptr ()
_ CString
name Word32
state Ptr ()
_ = do
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
EnginePropertyActivateCallback
_cb Text
name' Word32
state
onEnginePropertyActivate :: (IsEngine a, MonadIO m) => a -> EnginePropertyActivateCallback -> m SignalHandlerId
onEnginePropertyActivate :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyActivateCallback -> m SignalHandlerId
onEnginePropertyActivate a
obj EnginePropertyActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EnginePropertyActivateCallback
cb' = EnginePropertyActivateCallback -> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback EnginePropertyActivateCallback
cb
FunPtr C_EnginePropertyActivateCallback
cb'' <- C_EnginePropertyActivateCallback
-> IO (FunPtr C_EnginePropertyActivateCallback)
mk_EnginePropertyActivateCallback C_EnginePropertyActivateCallback
cb'
a
-> Text
-> FunPtr C_EnginePropertyActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-activate" FunPtr C_EnginePropertyActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEnginePropertyActivate :: (IsEngine a, MonadIO m) => a -> EnginePropertyActivateCallback -> m SignalHandlerId
afterEnginePropertyActivate :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyActivateCallback -> m SignalHandlerId
afterEnginePropertyActivate a
obj EnginePropertyActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EnginePropertyActivateCallback
cb' = EnginePropertyActivateCallback -> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback EnginePropertyActivateCallback
cb
FunPtr C_EnginePropertyActivateCallback
cb'' <- C_EnginePropertyActivateCallback
-> IO (FunPtr C_EnginePropertyActivateCallback)
mk_EnginePropertyActivateCallback C_EnginePropertyActivateCallback
cb'
a
-> Text
-> FunPtr C_EnginePropertyActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-activate" FunPtr C_EnginePropertyActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EnginePropertyActivateSignalInfo
instance SignalInfo EnginePropertyActivateSignalInfo where
type HaskellCallbackType EnginePropertyActivateSignalInfo = EnginePropertyActivateCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EnginePropertyActivateCallback cb
cb'' <- mk_EnginePropertyActivateCallback cb'
connectSignalFunPtr obj "property-activate" cb'' connectMode detail
#endif
type EnginePropertyHideCallback =
T.Text
-> IO ()
noEnginePropertyHideCallback :: Maybe EnginePropertyHideCallback
noEnginePropertyHideCallback :: Maybe EnginePropertyHideCallback
noEnginePropertyHideCallback = Maybe EnginePropertyHideCallback
forall a. Maybe a
Nothing
type C_EnginePropertyHideCallback =
Ptr () ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EnginePropertyHideCallback :: C_EnginePropertyHideCallback -> IO (FunPtr C_EnginePropertyHideCallback)
genClosure_EnginePropertyHide :: MonadIO m => EnginePropertyHideCallback -> m (GClosure C_EnginePropertyHideCallback)
genClosure_EnginePropertyHide :: forall (m :: * -> *).
MonadIO m =>
EnginePropertyHideCallback
-> m (GClosure C_EnginePropertyHideCallback)
genClosure_EnginePropertyHide EnginePropertyHideCallback
cb = IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback))
-> IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback EnginePropertyHideCallback
cb
C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyHideCallback C_EnginePropertyHideCallback
cb' IO (FunPtr C_EnginePropertyHideCallback)
-> (FunPtr C_EnginePropertyHideCallback
-> IO (GClosure C_EnginePropertyHideCallback))
-> IO (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EnginePropertyHideCallback
-> IO (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EnginePropertyHideCallback ::
EnginePropertyHideCallback ->
C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback :: EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback EnginePropertyHideCallback
_cb Ptr ()
_ CString
name Ptr ()
_ = do
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
EnginePropertyHideCallback
_cb Text
name'
onEnginePropertyHide :: (IsEngine a, MonadIO m) => a -> EnginePropertyHideCallback -> m SignalHandlerId
onEnginePropertyHide :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyHideCallback -> m SignalHandlerId
onEnginePropertyHide a
obj EnginePropertyHideCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback EnginePropertyHideCallback
cb
FunPtr C_EnginePropertyHideCallback
cb'' <- C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyHideCallback C_EnginePropertyHideCallback
cb'
a
-> Text
-> FunPtr C_EnginePropertyHideCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-hide" FunPtr C_EnginePropertyHideCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEnginePropertyHide :: (IsEngine a, MonadIO m) => a -> EnginePropertyHideCallback -> m SignalHandlerId
afterEnginePropertyHide :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyHideCallback -> m SignalHandlerId
afterEnginePropertyHide a
obj EnginePropertyHideCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback EnginePropertyHideCallback
cb
FunPtr C_EnginePropertyHideCallback
cb'' <- C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyHideCallback C_EnginePropertyHideCallback
cb'
a
-> Text
-> FunPtr C_EnginePropertyHideCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-hide" FunPtr C_EnginePropertyHideCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EnginePropertyHideSignalInfo
instance SignalInfo EnginePropertyHideSignalInfo where
type HaskellCallbackType EnginePropertyHideSignalInfo = EnginePropertyHideCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EnginePropertyHideCallback cb
cb'' <- mk_EnginePropertyHideCallback cb'
connectSignalFunPtr obj "property-hide" cb'' connectMode detail
#endif
type EnginePropertyShowCallback =
T.Text
-> IO ()
noEnginePropertyShowCallback :: Maybe EnginePropertyShowCallback
noEnginePropertyShowCallback :: Maybe EnginePropertyHideCallback
noEnginePropertyShowCallback = Maybe EnginePropertyHideCallback
forall a. Maybe a
Nothing
type C_EnginePropertyShowCallback =
Ptr () ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EnginePropertyShowCallback :: C_EnginePropertyShowCallback -> IO (FunPtr C_EnginePropertyShowCallback)
genClosure_EnginePropertyShow :: MonadIO m => EnginePropertyShowCallback -> m (GClosure C_EnginePropertyShowCallback)
genClosure_EnginePropertyShow :: forall (m :: * -> *).
MonadIO m =>
EnginePropertyHideCallback
-> m (GClosure C_EnginePropertyHideCallback)
genClosure_EnginePropertyShow EnginePropertyHideCallback
cb = IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback))
-> IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyShowCallback EnginePropertyHideCallback
cb
C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyShowCallback C_EnginePropertyHideCallback
cb' IO (FunPtr C_EnginePropertyHideCallback)
-> (FunPtr C_EnginePropertyHideCallback
-> IO (GClosure C_EnginePropertyHideCallback))
-> IO (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EnginePropertyHideCallback
-> IO (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EnginePropertyShowCallback ::
EnginePropertyShowCallback ->
C_EnginePropertyShowCallback
wrap_EnginePropertyShowCallback :: EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyShowCallback EnginePropertyHideCallback
_cb Ptr ()
_ CString
name Ptr ()
_ = do
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
EnginePropertyHideCallback
_cb Text
name'
onEnginePropertyShow :: (IsEngine a, MonadIO m) => a -> EnginePropertyShowCallback -> m SignalHandlerId
onEnginePropertyShow :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyHideCallback -> m SignalHandlerId
onEnginePropertyShow a
obj EnginePropertyHideCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyShowCallback EnginePropertyHideCallback
cb
FunPtr C_EnginePropertyHideCallback
cb'' <- C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyShowCallback C_EnginePropertyHideCallback
cb'
a
-> Text
-> FunPtr C_EnginePropertyHideCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-show" FunPtr C_EnginePropertyHideCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEnginePropertyShow :: (IsEngine a, MonadIO m) => a -> EnginePropertyShowCallback -> m SignalHandlerId
afterEnginePropertyShow :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyHideCallback -> m SignalHandlerId
afterEnginePropertyShow a
obj EnginePropertyHideCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyShowCallback EnginePropertyHideCallback
cb
FunPtr C_EnginePropertyHideCallback
cb'' <- C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyShowCallback C_EnginePropertyHideCallback
cb'
a
-> Text
-> FunPtr C_EnginePropertyHideCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-show" FunPtr C_EnginePropertyHideCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EnginePropertyShowSignalInfo
instance SignalInfo EnginePropertyShowSignalInfo where
type HaskellCallbackType EnginePropertyShowSignalInfo = EnginePropertyShowCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EnginePropertyShowCallback cb
cb'' <- mk_EnginePropertyShowCallback cb'
connectSignalFunPtr obj "property-show" cb'' connectMode detail
#endif
type EngineResetCallback =
IO ()
noEngineResetCallback :: Maybe EngineResetCallback
noEngineResetCallback :: Maybe (IO ())
noEngineResetCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_EngineResetCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineResetCallback :: C_EngineResetCallback -> IO (FunPtr C_EngineResetCallback)
genClosure_EngineReset :: MonadIO m => EngineResetCallback -> m (GClosure C_EngineResetCallback)
genClosure_EngineReset :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineReset IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineResetCallback IO ()
cb
C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineResetCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineResetCallback ::
EngineResetCallback ->
C_EngineResetCallback
wrap_EngineResetCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineResetCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onEngineReset :: (IsEngine a, MonadIO m) => a -> EngineResetCallback -> m SignalHandlerId
onEngineReset :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineReset a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineResetCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineResetCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"reset" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineReset :: (IsEngine a, MonadIO m) => a -> EngineResetCallback -> m SignalHandlerId
afterEngineReset :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineReset a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineResetCallback IO ()
cb
FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineResetCallback C_EngineCursorDownCallback
cb'
a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"reset" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineResetSignalInfo
instance SignalInfo EngineResetSignalInfo where
type HaskellCallbackType EngineResetSignalInfo = EngineResetCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineResetCallback cb
cb'' <- mk_EngineResetCallback cb'
connectSignalFunPtr obj "reset" cb'' connectMode detail
#endif
type EngineSetCapabilitiesCallback =
Word32
-> IO ()
noEngineSetCapabilitiesCallback :: Maybe EngineSetCapabilitiesCallback
noEngineSetCapabilitiesCallback :: Maybe EngineCancelHandWritingCallback
noEngineSetCapabilitiesCallback = Maybe EngineCancelHandWritingCallback
forall a. Maybe a
Nothing
type C_EngineSetCapabilitiesCallback =
Ptr () ->
Word32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineSetCapabilitiesCallback :: C_EngineSetCapabilitiesCallback -> IO (FunPtr C_EngineSetCapabilitiesCallback)
genClosure_EngineSetCapabilities :: MonadIO m => EngineSetCapabilitiesCallback -> m (GClosure C_EngineSetCapabilitiesCallback)
genClosure_EngineSetCapabilities :: forall (m :: * -> *).
MonadIO m =>
EngineCancelHandWritingCallback
-> m (GClosure C_EngineCancelHandWritingCallback)
genClosure_EngineSetCapabilities EngineCancelHandWritingCallback
cb = IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback))
-> IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback EngineCancelHandWritingCallback
cb
C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineSetCapabilitiesCallback C_EngineCancelHandWritingCallback
cb' IO (FunPtr C_EngineCancelHandWritingCallback)
-> (FunPtr C_EngineCancelHandWritingCallback
-> IO (GClosure C_EngineCancelHandWritingCallback))
-> IO (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCancelHandWritingCallback
-> IO (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineSetCapabilitiesCallback ::
EngineSetCapabilitiesCallback ->
C_EngineSetCapabilitiesCallback
wrap_EngineSetCapabilitiesCallback :: EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback EngineCancelHandWritingCallback
_cb Ptr ()
_ Word32
caps Ptr ()
_ = do
EngineCancelHandWritingCallback
_cb Word32
caps
onEngineSetCapabilities :: (IsEngine a, MonadIO m) => a -> EngineSetCapabilitiesCallback -> m SignalHandlerId
onEngineSetCapabilities :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCancelHandWritingCallback -> m SignalHandlerId
onEngineSetCapabilities a
obj EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback EngineCancelHandWritingCallback
cb
FunPtr C_EngineCancelHandWritingCallback
cb'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineSetCapabilitiesCallback C_EngineCancelHandWritingCallback
cb'
a
-> Text
-> FunPtr C_EngineCancelHandWritingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-capabilities" FunPtr C_EngineCancelHandWritingCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineSetCapabilities :: (IsEngine a, MonadIO m) => a -> EngineSetCapabilitiesCallback -> m SignalHandlerId
afterEngineSetCapabilities :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCancelHandWritingCallback -> m SignalHandlerId
afterEngineSetCapabilities a
obj EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback EngineCancelHandWritingCallback
cb
FunPtr C_EngineCancelHandWritingCallback
cb'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineSetCapabilitiesCallback C_EngineCancelHandWritingCallback
cb'
a
-> Text
-> FunPtr C_EngineCancelHandWritingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-capabilities" FunPtr C_EngineCancelHandWritingCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineSetCapabilitiesSignalInfo
instance SignalInfo EngineSetCapabilitiesSignalInfo where
type HaskellCallbackType EngineSetCapabilitiesSignalInfo = EngineSetCapabilitiesCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineSetCapabilitiesCallback cb
cb'' <- mk_EngineSetCapabilitiesCallback cb'
connectSignalFunPtr obj "set-capabilities" cb'' connectMode detail
#endif
type EngineSetContentTypeCallback =
Word32
-> Word32
-> IO ()
noEngineSetContentTypeCallback :: Maybe EngineSetContentTypeCallback
noEngineSetContentTypeCallback :: Maybe EngineSetContentTypeCallback
noEngineSetContentTypeCallback = Maybe EngineSetContentTypeCallback
forall a. Maybe a
Nothing
type C_EngineSetContentTypeCallback =
Ptr () ->
Word32 ->
Word32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineSetContentTypeCallback :: C_EngineSetContentTypeCallback -> IO (FunPtr C_EngineSetContentTypeCallback)
genClosure_EngineSetContentType :: MonadIO m => EngineSetContentTypeCallback -> m (GClosure C_EngineSetContentTypeCallback)
genClosure_EngineSetContentType :: forall (m :: * -> *).
MonadIO m =>
EngineSetContentTypeCallback
-> m (GClosure C_EngineSetContentTypeCallback)
genClosure_EngineSetContentType EngineSetContentTypeCallback
cb = IO (GClosure C_EngineSetContentTypeCallback)
-> m (GClosure C_EngineSetContentTypeCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineSetContentTypeCallback)
-> m (GClosure C_EngineSetContentTypeCallback))
-> IO (GClosure C_EngineSetContentTypeCallback)
-> m (GClosure C_EngineSetContentTypeCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineSetContentTypeCallback
cb' = EngineSetContentTypeCallback -> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback EngineSetContentTypeCallback
cb
C_EngineSetContentTypeCallback
-> IO (FunPtr C_EngineSetContentTypeCallback)
mk_EngineSetContentTypeCallback C_EngineSetContentTypeCallback
cb' IO (FunPtr C_EngineSetContentTypeCallback)
-> (FunPtr C_EngineSetContentTypeCallback
-> IO (GClosure C_EngineSetContentTypeCallback))
-> IO (GClosure C_EngineSetContentTypeCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineSetContentTypeCallback
-> IO (GClosure C_EngineSetContentTypeCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineSetContentTypeCallback ::
EngineSetContentTypeCallback ->
C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback :: EngineSetContentTypeCallback -> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback EngineSetContentTypeCallback
_cb Ptr ()
_ Word32
purpose Word32
hints Ptr ()
_ = do
EngineSetContentTypeCallback
_cb Word32
purpose Word32
hints
onEngineSetContentType :: (IsEngine a, MonadIO m) => a -> EngineSetContentTypeCallback -> m SignalHandlerId
onEngineSetContentType :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetContentTypeCallback -> m SignalHandlerId
onEngineSetContentType a
obj EngineSetContentTypeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineSetContentTypeCallback
cb' = EngineSetContentTypeCallback -> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback EngineSetContentTypeCallback
cb
FunPtr C_EngineSetContentTypeCallback
cb'' <- C_EngineSetContentTypeCallback
-> IO (FunPtr C_EngineSetContentTypeCallback)
mk_EngineSetContentTypeCallback C_EngineSetContentTypeCallback
cb'
a
-> Text
-> FunPtr C_EngineSetContentTypeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-content-type" FunPtr C_EngineSetContentTypeCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineSetContentType :: (IsEngine a, MonadIO m) => a -> EngineSetContentTypeCallback -> m SignalHandlerId
afterEngineSetContentType :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetContentTypeCallback -> m SignalHandlerId
afterEngineSetContentType a
obj EngineSetContentTypeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineSetContentTypeCallback
cb' = EngineSetContentTypeCallback -> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback EngineSetContentTypeCallback
cb
FunPtr C_EngineSetContentTypeCallback
cb'' <- C_EngineSetContentTypeCallback
-> IO (FunPtr C_EngineSetContentTypeCallback)
mk_EngineSetContentTypeCallback C_EngineSetContentTypeCallback
cb'
a
-> Text
-> FunPtr C_EngineSetContentTypeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-content-type" FunPtr C_EngineSetContentTypeCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineSetContentTypeSignalInfo
instance SignalInfo EngineSetContentTypeSignalInfo where
type HaskellCallbackType EngineSetContentTypeSignalInfo = EngineSetContentTypeCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineSetContentTypeCallback cb
cb'' <- mk_EngineSetContentTypeCallback cb'
connectSignalFunPtr obj "set-content-type" cb'' connectMode detail
#endif
type EngineSetCursorLocationCallback =
Int32
-> Int32
-> Int32
-> Int32
-> IO ()
noEngineSetCursorLocationCallback :: Maybe EngineSetCursorLocationCallback
noEngineSetCursorLocationCallback :: Maybe EngineSetCursorLocationCallback
noEngineSetCursorLocationCallback = Maybe EngineSetCursorLocationCallback
forall a. Maybe a
Nothing
type C_EngineSetCursorLocationCallback =
Ptr () ->
Int32 ->
Int32 ->
Int32 ->
Int32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineSetCursorLocationCallback :: C_EngineSetCursorLocationCallback -> IO (FunPtr C_EngineSetCursorLocationCallback)
genClosure_EngineSetCursorLocation :: MonadIO m => EngineSetCursorLocationCallback -> m (GClosure C_EngineSetCursorLocationCallback)
genClosure_EngineSetCursorLocation :: forall (m :: * -> *).
MonadIO m =>
EngineSetCursorLocationCallback
-> m (GClosure C_EngineSetCursorLocationCallback)
genClosure_EngineSetCursorLocation EngineSetCursorLocationCallback
cb = IO (GClosure C_EngineSetCursorLocationCallback)
-> m (GClosure C_EngineSetCursorLocationCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineSetCursorLocationCallback)
-> m (GClosure C_EngineSetCursorLocationCallback))
-> IO (GClosure C_EngineSetCursorLocationCallback)
-> m (GClosure C_EngineSetCursorLocationCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineSetCursorLocationCallback
cb' = EngineSetCursorLocationCallback
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback EngineSetCursorLocationCallback
cb
C_EngineSetCursorLocationCallback
-> IO (FunPtr C_EngineSetCursorLocationCallback)
mk_EngineSetCursorLocationCallback C_EngineSetCursorLocationCallback
cb' IO (FunPtr C_EngineSetCursorLocationCallback)
-> (FunPtr C_EngineSetCursorLocationCallback
-> IO (GClosure C_EngineSetCursorLocationCallback))
-> IO (GClosure C_EngineSetCursorLocationCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineSetCursorLocationCallback
-> IO (GClosure C_EngineSetCursorLocationCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineSetCursorLocationCallback ::
EngineSetCursorLocationCallback ->
C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback :: EngineSetCursorLocationCallback
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback EngineSetCursorLocationCallback
_cb Ptr ()
_ Int32
x Int32
y Int32
w Int32
h Ptr ()
_ = do
EngineSetCursorLocationCallback
_cb Int32
x Int32
y Int32
w Int32
h
onEngineSetCursorLocation :: (IsEngine a, MonadIO m) => a -> EngineSetCursorLocationCallback -> m SignalHandlerId
onEngineSetCursorLocation :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetCursorLocationCallback -> m SignalHandlerId
onEngineSetCursorLocation a
obj EngineSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineSetCursorLocationCallback
cb' = EngineSetCursorLocationCallback
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback EngineSetCursorLocationCallback
cb
FunPtr C_EngineSetCursorLocationCallback
cb'' <- C_EngineSetCursorLocationCallback
-> IO (FunPtr C_EngineSetCursorLocationCallback)
mk_EngineSetCursorLocationCallback C_EngineSetCursorLocationCallback
cb'
a
-> Text
-> FunPtr C_EngineSetCursorLocationCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-cursor-location" FunPtr C_EngineSetCursorLocationCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineSetCursorLocation :: (IsEngine a, MonadIO m) => a -> EngineSetCursorLocationCallback -> m SignalHandlerId
afterEngineSetCursorLocation :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetCursorLocationCallback -> m SignalHandlerId
afterEngineSetCursorLocation a
obj EngineSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineSetCursorLocationCallback
cb' = EngineSetCursorLocationCallback
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback EngineSetCursorLocationCallback
cb
FunPtr C_EngineSetCursorLocationCallback
cb'' <- C_EngineSetCursorLocationCallback
-> IO (FunPtr C_EngineSetCursorLocationCallback)
mk_EngineSetCursorLocationCallback C_EngineSetCursorLocationCallback
cb'
a
-> Text
-> FunPtr C_EngineSetCursorLocationCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-cursor-location" FunPtr C_EngineSetCursorLocationCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineSetCursorLocationSignalInfo
instance SignalInfo EngineSetCursorLocationSignalInfo where
type HaskellCallbackType EngineSetCursorLocationSignalInfo = EngineSetCursorLocationCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineSetCursorLocationCallback cb
cb'' <- mk_EngineSetCursorLocationCallback cb'
connectSignalFunPtr obj "set-cursor-location" cb'' connectMode detail
#endif
type EngineSetSurroundingTextCallback =
GObject.Object.Object
-> Word32
-> Word32
-> IO ()
noEngineSetSurroundingTextCallback :: Maybe EngineSetSurroundingTextCallback
noEngineSetSurroundingTextCallback :: Maybe EngineSetSurroundingTextCallback
noEngineSetSurroundingTextCallback = Maybe EngineSetSurroundingTextCallback
forall a. Maybe a
Nothing
type C_EngineSetSurroundingTextCallback =
Ptr () ->
Ptr GObject.Object.Object ->
Word32 ->
Word32 ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_EngineSetSurroundingTextCallback :: C_EngineSetSurroundingTextCallback -> IO (FunPtr C_EngineSetSurroundingTextCallback)
genClosure_EngineSetSurroundingText :: MonadIO m => EngineSetSurroundingTextCallback -> m (GClosure C_EngineSetSurroundingTextCallback)
genClosure_EngineSetSurroundingText :: forall (m :: * -> *).
MonadIO m =>
EngineSetSurroundingTextCallback
-> m (GClosure C_EngineSetSurroundingTextCallback)
genClosure_EngineSetSurroundingText EngineSetSurroundingTextCallback
cb = IO (GClosure C_EngineSetSurroundingTextCallback)
-> m (GClosure C_EngineSetSurroundingTextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineSetSurroundingTextCallback)
-> m (GClosure C_EngineSetSurroundingTextCallback))
-> IO (GClosure C_EngineSetSurroundingTextCallback)
-> m (GClosure C_EngineSetSurroundingTextCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineSetSurroundingTextCallback
cb' = EngineSetSurroundingTextCallback
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback EngineSetSurroundingTextCallback
cb
C_EngineSetSurroundingTextCallback
-> IO (FunPtr C_EngineSetSurroundingTextCallback)
mk_EngineSetSurroundingTextCallback C_EngineSetSurroundingTextCallback
cb' IO (FunPtr C_EngineSetSurroundingTextCallback)
-> (FunPtr C_EngineSetSurroundingTextCallback
-> IO (GClosure C_EngineSetSurroundingTextCallback))
-> IO (GClosure C_EngineSetSurroundingTextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineSetSurroundingTextCallback
-> IO (GClosure C_EngineSetSurroundingTextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_EngineSetSurroundingTextCallback ::
EngineSetSurroundingTextCallback ->
C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback :: EngineSetSurroundingTextCallback
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback EngineSetSurroundingTextCallback
_cb Ptr ()
_ Ptr Object
text Word32
cursorPos Word32
anchorPos Ptr ()
_ = do
Object
text' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
text
EngineSetSurroundingTextCallback
_cb Object
text' Word32
cursorPos Word32
anchorPos
onEngineSetSurroundingText :: (IsEngine a, MonadIO m) => a -> EngineSetSurroundingTextCallback -> m SignalHandlerId
onEngineSetSurroundingText :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetSurroundingTextCallback -> m SignalHandlerId
onEngineSetSurroundingText a
obj EngineSetSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineSetSurroundingTextCallback
cb' = EngineSetSurroundingTextCallback
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback EngineSetSurroundingTextCallback
cb
FunPtr C_EngineSetSurroundingTextCallback
cb'' <- C_EngineSetSurroundingTextCallback
-> IO (FunPtr C_EngineSetSurroundingTextCallback)
mk_EngineSetSurroundingTextCallback C_EngineSetSurroundingTextCallback
cb'
a
-> Text
-> FunPtr C_EngineSetSurroundingTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-surrounding-text" FunPtr C_EngineSetSurroundingTextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterEngineSetSurroundingText :: (IsEngine a, MonadIO m) => a -> EngineSetSurroundingTextCallback -> m SignalHandlerId
afterEngineSetSurroundingText :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetSurroundingTextCallback -> m SignalHandlerId
afterEngineSetSurroundingText a
obj EngineSetSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_EngineSetSurroundingTextCallback
cb' = EngineSetSurroundingTextCallback
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback EngineSetSurroundingTextCallback
cb
FunPtr C_EngineSetSurroundingTextCallback
cb'' <- C_EngineSetSurroundingTextCallback
-> IO (FunPtr C_EngineSetSurroundingTextCallback)
mk_EngineSetSurroundingTextCallback C_EngineSetSurroundingTextCallback
cb'
a
-> Text
-> FunPtr C_EngineSetSurroundingTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-surrounding-text" FunPtr C_EngineSetSurroundingTextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data EngineSetSurroundingTextSignalInfo
instance SignalInfo EngineSetSurroundingTextSignalInfo where
type HaskellCallbackType EngineSetSurroundingTextSignalInfo = EngineSetSurroundingTextCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_EngineSetSurroundingTextCallback cb
cb'' <- mk_EngineSetSurroundingTextCallback cb'
connectSignalFunPtr obj "set-surrounding-text" cb'' connectMode detail
#endif
getEngineEngineName :: (MonadIO m, IsEngine o) => o -> m (Maybe T.Text)
getEngineEngineName :: forall (m :: * -> *) o.
(MonadIO m, IsEngine o) =>
o -> m (Maybe Text)
getEngineEngineName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"engine-name"
constructEngineEngineName :: (IsEngine o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructEngineEngineName :: forall o (m :: * -> *).
(IsEngine o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructEngineEngineName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"engine-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
#if defined(ENABLE_OVERLOADING)
data EngineEngineNamePropertyInfo
instance AttrInfo EngineEngineNamePropertyInfo where
type AttrAllowedOps EngineEngineNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint EngineEngineNamePropertyInfo = IsEngine
type AttrSetTypeConstraint EngineEngineNamePropertyInfo = (~) T.Text
type AttrTransferTypeConstraint EngineEngineNamePropertyInfo = (~) T.Text
type AttrTransferType EngineEngineNamePropertyInfo = T.Text
type AttrGetType EngineEngineNamePropertyInfo = (Maybe T.Text)
type AttrLabel EngineEngineNamePropertyInfo = "engine-name"
type AttrOrigin EngineEngineNamePropertyInfo = Engine
attrGet = getEngineEngineName
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructEngineEngineName
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Engine
type instance O.AttributeList Engine = EngineAttributeList
type EngineAttributeList = ('[ '("connection", IBus.Service.ServiceConnectionPropertyInfo), '("engineName", EngineEngineNamePropertyInfo), '("objectPath", IBus.Service.ServiceObjectPathPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
engineEngineName :: AttrLabelProxy "engineName"
engineEngineName = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Engine = EngineSignalList
type EngineSignalList = ('[ '("cancelHandWriting", EngineCancelHandWritingSignalInfo), '("candidateClicked", EngineCandidateClickedSignalInfo), '("cursorDown", EngineCursorDownSignalInfo), '("cursorUp", EngineCursorUpSignalInfo), '("destroy", IBus.Object.ObjectDestroySignalInfo), '("disable", EngineDisableSignalInfo), '("enable", EngineEnableSignalInfo), '("focusIn", EngineFocusInSignalInfo), '("focusOut", EngineFocusOutSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pageDown", EnginePageDownSignalInfo), '("pageUp", EnginePageUpSignalInfo), '("processHandWritingEvent", EngineProcessHandWritingEventSignalInfo), '("processKeyEvent", EngineProcessKeyEventSignalInfo), '("propertyActivate", EnginePropertyActivateSignalInfo), '("propertyHide", EnginePropertyHideSignalInfo), '("propertyShow", EnginePropertyShowSignalInfo), '("reset", EngineResetSignalInfo), '("setCapabilities", EngineSetCapabilitiesSignalInfo), '("setContentType", EngineSetContentTypeSignalInfo), '("setCursorLocation", EngineSetCursorLocationSignalInfo), '("setSurroundingText", EngineSetSurroundingTextSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "ibus_engine_new" ibus_engine_new ::
CString ->
CString ->
Ptr Gio.DBusConnection.DBusConnection ->
IO (Ptr Engine)
engineNew ::
(B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
T.Text
-> T.Text
-> a
-> m Engine
engineNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
Text -> Text -> a -> m Engine
engineNew Text
engineName Text
objectPath a
connection = IO Engine -> m Engine
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Engine -> m Engine) -> IO Engine -> m Engine
forall a b. (a -> b) -> a -> b
$ do
CString
engineName' <- Text -> IO CString
textToCString Text
engineName
CString
objectPath' <- Text -> IO CString
textToCString Text
objectPath
Ptr DBusConnection
connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
Ptr Engine
result <- CString -> CString -> Ptr DBusConnection -> IO (Ptr Engine)
ibus_engine_new CString
engineName' CString
objectPath' Ptr DBusConnection
connection'
Text -> Ptr Engine -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"engineNew" Ptr Engine
result
Engine
result' <- ((ManagedPtr Engine -> Engine) -> Ptr Engine -> IO Engine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Engine -> Engine
Engine) Ptr Engine
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
engineName'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
objectPath'
Engine -> IO Engine
forall (m :: * -> *) a. Monad m => a -> m a
return Engine
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ibus_engine_new_with_type" ibus_engine_new_with_type ::
CGType ->
CString ->
CString ->
Ptr Gio.DBusConnection.DBusConnection ->
IO (Ptr Engine)
engineNewWithType ::
(B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
GType
-> T.Text
-> T.Text
-> a
-> m Engine
engineNewWithType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
GType -> Text -> Text -> a -> m Engine
engineNewWithType GType
engineType Text
engineName Text
objectPath a
connection = IO Engine -> m Engine
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Engine -> m Engine) -> IO Engine -> m Engine
forall a b. (a -> b) -> a -> b
$ do
let engineType' :: CGType
engineType' = GType -> CGType
gtypeToCGType GType
engineType
CString
engineName' <- Text -> IO CString
textToCString Text
engineName
CString
objectPath' <- Text -> IO CString
textToCString Text
objectPath
Ptr DBusConnection
connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
Ptr Engine
result <- CGType
-> CString -> CString -> Ptr DBusConnection -> IO (Ptr Engine)
ibus_engine_new_with_type CGType
engineType' CString
engineName' CString
objectPath' Ptr DBusConnection
connection'
Text -> Ptr Engine -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"engineNewWithType" Ptr Engine
result
Engine
result' <- ((ManagedPtr Engine -> Engine) -> Ptr Engine -> IO Engine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Engine -> Engine
Engine) Ptr Engine
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
engineName'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
objectPath'
Engine -> IO Engine
forall (m :: * -> *) a. Monad m => a -> m a
return Engine
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "ibus_engine_commit_text" ibus_engine_commit_text ::
Ptr Engine ->
Ptr IBus.Text.Text ->
IO ()
engineCommitText ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Text.IsText b) =>
a
-> b
-> m ()
engineCommitText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsText b) =>
a -> b -> m ()
engineCommitText a
engine b
text = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
Ptr Engine -> Ptr Text -> IO ()
ibus_engine_commit_text Ptr Engine
engine' Ptr Text
text'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineCommitTextMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEngine a, IBus.Text.IsText b) => O.OverloadedMethod EngineCommitTextMethodInfo a signature where
overloadedMethod = engineCommitText
instance O.OverloadedMethodInfo EngineCommitTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineCommitText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineCommitText"
}
#endif
foreign import ccall "ibus_engine_delete_surrounding_text" ibus_engine_delete_surrounding_text ::
Ptr Engine ->
Int32 ->
Word32 ->
IO ()
engineDeleteSurroundingText ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> Int32
-> Word32
-> m ()
engineDeleteSurroundingText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> Int32 -> Word32 -> m ()
engineDeleteSurroundingText a
engine Int32
offset Word32
nchars = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Engine -> Int32 -> EngineCancelHandWritingCallback
ibus_engine_delete_surrounding_text Ptr Engine
engine' Int32
offset Word32
nchars
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineDeleteSurroundingTextMethodInfo
instance (signature ~ (Int32 -> Word32 -> m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineDeleteSurroundingTextMethodInfo a signature where
overloadedMethod = engineDeleteSurroundingText
instance O.OverloadedMethodInfo EngineDeleteSurroundingTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineDeleteSurroundingText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineDeleteSurroundingText"
}
#endif
foreign import ccall "ibus_engine_forward_key_event" ibus_engine_forward_key_event ::
Ptr Engine ->
Word32 ->
Word32 ->
Word32 ->
IO ()
engineForwardKeyEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> Word32
-> Word32
-> Word32
-> m ()
engineForwardKeyEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> Word32 -> Word32 -> Word32 -> m ()
engineForwardKeyEvent a
engine Word32
keyval Word32
keycode Word32
state = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Engine -> EngineCandidateClickedCallback
ibus_engine_forward_key_event Ptr Engine
engine' Word32
keyval Word32
keycode Word32
state
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineForwardKeyEventMethodInfo
instance (signature ~ (Word32 -> Word32 -> Word32 -> m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineForwardKeyEventMethodInfo a signature where
overloadedMethod = engineForwardKeyEvent
instance O.OverloadedMethodInfo EngineForwardKeyEventMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineForwardKeyEvent",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineForwardKeyEvent"
}
#endif
foreign import ccall "ibus_engine_get_content_type" ibus_engine_get_content_type ::
Ptr Engine ->
Ptr Word32 ->
Ptr Word32 ->
IO ()
engineGetContentType ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> m ((Word32, Word32))
engineGetContentType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m (Word32, Word32)
engineGetContentType a
engine = IO (Word32, Word32) -> m (Word32, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word32, Word32) -> m (Word32, Word32))
-> IO (Word32, Word32) -> m (Word32, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Word32
purpose <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Word32
hints <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Engine -> Ptr Word32 -> Ptr Word32 -> IO ()
ibus_engine_get_content_type Ptr Engine
engine' Ptr Word32
purpose Ptr Word32
hints
Word32
purpose' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
purpose
Word32
hints' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
hints
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
purpose
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
hints
(Word32, Word32) -> IO (Word32, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32
purpose', Word32
hints')
#if defined(ENABLE_OVERLOADING)
data EngineGetContentTypeMethodInfo
instance (signature ~ (m ((Word32, Word32))), MonadIO m, IsEngine a) => O.OverloadedMethod EngineGetContentTypeMethodInfo a signature where
overloadedMethod = engineGetContentType
instance O.OverloadedMethodInfo EngineGetContentTypeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineGetContentType",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineGetContentType"
}
#endif
foreign import ccall "ibus_engine_get_name" ibus_engine_get_name ::
Ptr Engine ->
IO CString
engineGetName ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> m T.Text
engineGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m Text
engineGetName a
engine = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
CString
result <- Ptr Engine -> IO CString
ibus_engine_get_name Ptr Engine
engine'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"engineGetName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data EngineGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsEngine a) => O.OverloadedMethod EngineGetNameMethodInfo a signature where
overloadedMethod = engineGetName
instance O.OverloadedMethodInfo EngineGetNameMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineGetName",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineGetName"
}
#endif
foreign import ccall "ibus_engine_get_surrounding_text" ibus_engine_get_surrounding_text ::
Ptr Engine ->
Ptr (Ptr IBus.Text.Text) ->
Ptr Word32 ->
Ptr Word32 ->
IO ()
engineGetSurroundingText ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> m ((IBus.Text.Text, Word32, Word32))
engineGetSurroundingText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m (Text, Word32, Word32)
engineGetSurroundingText a
engine = IO (Text, Word32, Word32) -> m (Text, Word32, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Word32, Word32) -> m (Text, Word32, Word32))
-> IO (Text, Word32, Word32) -> m (Text, Word32, Word32)
forall a b. (a -> b) -> a -> b
$ do
Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr (Ptr Text)
text <- IO (Ptr (Ptr Text))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr IBus.Text.Text))
Ptr Word32
cursorPos <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Word32
anchorPos <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Engine -> Ptr (Ptr Text) -> Ptr Word32 -> Ptr Word32 -> IO ()
ibus_engine_get_surrounding_text Ptr Engine
engine' Ptr (Ptr Text)
text Ptr Word32
cursorPos Ptr Word32
anchorPos
Ptr Text
text' <- Ptr (Ptr Text) -> IO (Ptr Text)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Text)
text
Text
text'' <- ((ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Text -> Text
IBus.Text.Text) Ptr Text
text'
Word32
cursorPos' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
cursorPos
Word32
anchorPos' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
anchorPos
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
Ptr (Ptr Text) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Text)
text
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
cursorPos
Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
anchorPos
(Text, Word32, Word32) -> IO (Text, Word32, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
text'', Word32
cursorPos', Word32
anchorPos')
#if defined(ENABLE_OVERLOADING)
data EngineGetSurroundingTextMethodInfo
instance (signature ~ (m ((IBus.Text.Text, Word32, Word32))), MonadIO m, IsEngine a) => O.OverloadedMethod EngineGetSurroundingTextMethodInfo a signature where
overloadedMethod = engineGetSurroundingText
instance O.OverloadedMethodInfo EngineGetSurroundingTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineGetSurroundingText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineGetSurroundingText"
}
#endif
foreign import ccall "ibus_engine_hide_auxiliary_text" ibus_engine_hide_auxiliary_text ::
Ptr Engine ->
IO ()
engineHideAuxiliaryText ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> m ()
engineHideAuxiliaryText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineHideAuxiliaryText a
engine = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Engine -> IO ()
ibus_engine_hide_auxiliary_text Ptr Engine
engine'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineHideAuxiliaryTextMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineHideAuxiliaryTextMethodInfo a signature where
overloadedMethod = engineHideAuxiliaryText
instance O.OverloadedMethodInfo EngineHideAuxiliaryTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineHideAuxiliaryText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineHideAuxiliaryText"
}
#endif
foreign import ccall "ibus_engine_hide_lookup_table" ibus_engine_hide_lookup_table ::
Ptr Engine ->
IO ()
engineHideLookupTable ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> m ()
engineHideLookupTable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineHideLookupTable a
engine = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Engine -> IO ()
ibus_engine_hide_lookup_table Ptr Engine
engine'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineHideLookupTableMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineHideLookupTableMethodInfo a signature where
overloadedMethod = engineHideLookupTable
instance O.OverloadedMethodInfo EngineHideLookupTableMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineHideLookupTable",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineHideLookupTable"
}
#endif
foreign import ccall "ibus_engine_hide_preedit_text" ibus_engine_hide_preedit_text ::
Ptr Engine ->
IO ()
engineHidePreeditText ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> m ()
engineHidePreeditText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineHidePreeditText a
engine = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Engine -> IO ()
ibus_engine_hide_preedit_text Ptr Engine
engine'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineHidePreeditTextMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineHidePreeditTextMethodInfo a signature where
overloadedMethod = engineHidePreeditText
instance O.OverloadedMethodInfo EngineHidePreeditTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineHidePreeditText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineHidePreeditText"
}
#endif
foreign import ccall "ibus_engine_register_properties" ibus_engine_register_properties ::
Ptr Engine ->
Ptr IBus.PropList.PropList ->
IO ()
engineRegisterProperties ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.PropList.IsPropList b) =>
a
-> b
-> m ()
engineRegisterProperties :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsPropList b) =>
a -> b -> m ()
engineRegisterProperties a
engine b
propList = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr PropList
propList' <- b -> IO (Ptr PropList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
propList
Ptr Engine -> Ptr PropList -> IO ()
ibus_engine_register_properties Ptr Engine
engine' Ptr PropList
propList'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
propList
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineRegisterPropertiesMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEngine a, IBus.PropList.IsPropList b) => O.OverloadedMethod EngineRegisterPropertiesMethodInfo a signature where
overloadedMethod = engineRegisterProperties
instance O.OverloadedMethodInfo EngineRegisterPropertiesMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineRegisterProperties",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineRegisterProperties"
}
#endif
foreign import ccall "ibus_engine_show_auxiliary_text" ibus_engine_show_auxiliary_text ::
Ptr Engine ->
IO ()
engineShowAuxiliaryText ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> m ()
engineShowAuxiliaryText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineShowAuxiliaryText a
engine = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Engine -> IO ()
ibus_engine_show_auxiliary_text Ptr Engine
engine'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineShowAuxiliaryTextMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineShowAuxiliaryTextMethodInfo a signature where
overloadedMethod = engineShowAuxiliaryText
instance O.OverloadedMethodInfo EngineShowAuxiliaryTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineShowAuxiliaryText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineShowAuxiliaryText"
}
#endif
foreign import ccall "ibus_engine_show_lookup_table" ibus_engine_show_lookup_table ::
Ptr Engine ->
IO ()
engineShowLookupTable ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> m ()
engineShowLookupTable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineShowLookupTable a
engine = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Engine -> IO ()
ibus_engine_show_lookup_table Ptr Engine
engine'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineShowLookupTableMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineShowLookupTableMethodInfo a signature where
overloadedMethod = engineShowLookupTable
instance O.OverloadedMethodInfo EngineShowLookupTableMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineShowLookupTable",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineShowLookupTable"
}
#endif
foreign import ccall "ibus_engine_show_preedit_text" ibus_engine_show_preedit_text ::
Ptr Engine ->
IO ()
engineShowPreeditText ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
a
-> m ()
engineShowPreeditText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineShowPreeditText a
engine = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Engine -> IO ()
ibus_engine_show_preedit_text Ptr Engine
engine'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineShowPreeditTextMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineShowPreeditTextMethodInfo a signature where
overloadedMethod = engineShowPreeditText
instance O.OverloadedMethodInfo EngineShowPreeditTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineShowPreeditText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineShowPreeditText"
}
#endif
foreign import ccall "ibus_engine_update_auxiliary_text" ibus_engine_update_auxiliary_text ::
Ptr Engine ->
Ptr IBus.Text.Text ->
CInt ->
IO ()
engineUpdateAuxiliaryText ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Text.IsText b) =>
a
-> b
-> Bool
-> m ()
engineUpdateAuxiliaryText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsText b) =>
a -> b -> Bool -> m ()
engineUpdateAuxiliaryText a
engine b
text Bool
visible = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
Ptr Engine -> Ptr Text -> CInt -> IO ()
ibus_engine_update_auxiliary_text Ptr Engine
engine' Ptr Text
text' CInt
visible'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineUpdateAuxiliaryTextMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsEngine a, IBus.Text.IsText b) => O.OverloadedMethod EngineUpdateAuxiliaryTextMethodInfo a signature where
overloadedMethod = engineUpdateAuxiliaryText
instance O.OverloadedMethodInfo EngineUpdateAuxiliaryTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineUpdateAuxiliaryText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineUpdateAuxiliaryText"
}
#endif
foreign import ccall "ibus_engine_update_lookup_table" ibus_engine_update_lookup_table ::
Ptr Engine ->
Ptr IBus.LookupTable.LookupTable ->
CInt ->
IO ()
engineUpdateLookupTable ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.LookupTable.IsLookupTable b) =>
a
-> b
-> Bool
-> m ()
engineUpdateLookupTable :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsLookupTable b) =>
a -> b -> Bool -> m ()
engineUpdateLookupTable a
engine b
lookupTable Bool
visible = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr LookupTable
lookupTable' <- b -> IO (Ptr LookupTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
lookupTable
let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
Ptr Engine -> Ptr LookupTable -> CInt -> IO ()
ibus_engine_update_lookup_table Ptr Engine
engine' Ptr LookupTable
lookupTable' CInt
visible'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
lookupTable
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineUpdateLookupTableMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsEngine a, IBus.LookupTable.IsLookupTable b) => O.OverloadedMethod EngineUpdateLookupTableMethodInfo a signature where
overloadedMethod = engineUpdateLookupTable
instance O.OverloadedMethodInfo EngineUpdateLookupTableMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineUpdateLookupTable",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineUpdateLookupTable"
}
#endif
foreign import ccall "ibus_engine_update_lookup_table_fast" ibus_engine_update_lookup_table_fast ::
Ptr Engine ->
Ptr IBus.LookupTable.LookupTable ->
CInt ->
IO ()
engineUpdateLookupTableFast ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.LookupTable.IsLookupTable b) =>
a
-> b
-> Bool
-> m ()
engineUpdateLookupTableFast :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsLookupTable b) =>
a -> b -> Bool -> m ()
engineUpdateLookupTableFast a
engine b
lookupTable Bool
visible = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr LookupTable
lookupTable' <- b -> IO (Ptr LookupTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
lookupTable
let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
Ptr Engine -> Ptr LookupTable -> CInt -> IO ()
ibus_engine_update_lookup_table_fast Ptr Engine
engine' Ptr LookupTable
lookupTable' CInt
visible'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
lookupTable
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineUpdateLookupTableFastMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsEngine a, IBus.LookupTable.IsLookupTable b) => O.OverloadedMethod EngineUpdateLookupTableFastMethodInfo a signature where
overloadedMethod = engineUpdateLookupTableFast
instance O.OverloadedMethodInfo EngineUpdateLookupTableFastMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineUpdateLookupTableFast",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineUpdateLookupTableFast"
}
#endif
foreign import ccall "ibus_engine_update_preedit_text" ibus_engine_update_preedit_text ::
Ptr Engine ->
Ptr IBus.Text.Text ->
Word32 ->
CInt ->
IO ()
engineUpdatePreeditText ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Text.IsText b) =>
a
-> b
-> Word32
-> Bool
-> m ()
engineUpdatePreeditText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsText b) =>
a -> b -> Word32 -> Bool -> m ()
engineUpdatePreeditText a
engine b
text Word32
cursorPos Bool
visible = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
Ptr Engine -> Ptr Text -> Word32 -> CInt -> IO ()
ibus_engine_update_preedit_text Ptr Engine
engine' Ptr Text
text' Word32
cursorPos CInt
visible'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineUpdatePreeditTextMethodInfo
instance (signature ~ (b -> Word32 -> Bool -> m ()), MonadIO m, IsEngine a, IBus.Text.IsText b) => O.OverloadedMethod EngineUpdatePreeditTextMethodInfo a signature where
overloadedMethod = engineUpdatePreeditText
instance O.OverloadedMethodInfo EngineUpdatePreeditTextMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineUpdatePreeditText",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineUpdatePreeditText"
}
#endif
foreign import ccall "ibus_engine_update_preedit_text_with_mode" ibus_engine_update_preedit_text_with_mode ::
Ptr Engine ->
Ptr IBus.Text.Text ->
Word32 ->
CInt ->
CUInt ->
IO ()
engineUpdatePreeditTextWithMode ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Text.IsText b) =>
a
-> b
-> Word32
-> Bool
-> IBus.Enums.PreeditFocusMode
-> m ()
engineUpdatePreeditTextWithMode :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsText b) =>
a -> b -> Word32 -> Bool -> PreeditFocusMode -> m ()
engineUpdatePreeditTextWithMode a
engine b
text Word32
cursorPos Bool
visible PreeditFocusMode
mode = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (PreeditFocusMode -> Int) -> PreeditFocusMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PreeditFocusMode -> Int
forall a. Enum a => a -> Int
fromEnum) PreeditFocusMode
mode
Ptr Engine -> Ptr Text -> Word32 -> CInt -> CUInt -> IO ()
ibus_engine_update_preedit_text_with_mode Ptr Engine
engine' Ptr Text
text' Word32
cursorPos CInt
visible' CUInt
mode'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineUpdatePreeditTextWithModeMethodInfo
instance (signature ~ (b -> Word32 -> Bool -> IBus.Enums.PreeditFocusMode -> m ()), MonadIO m, IsEngine a, IBus.Text.IsText b) => O.OverloadedMethod EngineUpdatePreeditTextWithModeMethodInfo a signature where
overloadedMethod = engineUpdatePreeditTextWithMode
instance O.OverloadedMethodInfo EngineUpdatePreeditTextWithModeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineUpdatePreeditTextWithMode",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineUpdatePreeditTextWithMode"
}
#endif
foreign import ccall "ibus_engine_update_property" ibus_engine_update_property ::
Ptr Engine ->
Ptr IBus.Property.Property ->
IO ()
engineUpdateProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Property.IsProperty b) =>
a
-> b
-> m ()
engineUpdateProperty :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsProperty b) =>
a -> b -> m ()
engineUpdateProperty a
engine b
prop = 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 Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
Ptr Property
prop' <- b -> IO (Ptr Property)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
prop
Ptr Engine -> Ptr Property -> IO ()
ibus_engine_update_property Ptr Engine
engine' Ptr Property
prop'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
prop
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data EngineUpdatePropertyMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEngine a, IBus.Property.IsProperty b) => O.OverloadedMethod EngineUpdatePropertyMethodInfo a signature where
overloadedMethod = engineUpdateProperty
instance O.OverloadedMethodInfo EngineUpdatePropertyMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.IBus.Objects.Engine.engineUpdateProperty",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-Engine.html#v:engineUpdateProperty"
}
#endif