GI.IBus.Objects.InputContext

An IBusInputContext is a proxy object of BusInputContext, which manages the context for input methods that supports text input in various natural languages.

Clients call the IBusInputContext to invoke BusInputContext, through which invokes IBusEngine.

Exported types

newtype InputContext

Memory-managed wrapper type.

Constructors

InputContext (ManagedPtr InputContext)

Instances

Eq InputContext

Defined in GI.IBus.Objects.InputContext

Methods

(==) :: InputContext -> InputContext -> Bool

(/=) :: InputContext -> InputContext -> Bool

GObject InputContext

Defined in GI.IBus.Objects.InputContext

ManagedPtrNewtype InputContext

Defined in GI.IBus.Objects.InputContext

Methods

toManagedPtr :: InputContext -> ManagedPtr InputContext

TypedObject InputContext

Defined in GI.IBus.Objects.InputContext

Methods

glibType :: IO GType

HasParentTypes InputContext

Defined in GI.IBus.Objects.InputContext

IsGValue (Maybe InputContext)

Convert InputContext to and from GValue. See toGValue and fromGValue.

Defined in GI.IBus.Objects.InputContext

Methods

gvalueGType_ :: IO GType

gvalueSet_ :: Ptr GValue -> Maybe InputContext -> IO ()

gvalueGet_ :: Ptr GValue -> IO (Maybe InputContext)

type ParentTypes InputContext

Defined in GI.IBus.Objects.InputContext

type ParentTypes InputContext = '[Proxy, DBusProxy, Object, AsyncInitable, DBusInterface, Initable]

class (GObject o, IsDescendantOf InputContext o) => IsInputContext o

Type class for types which can be safely cast to InputContext, for instance with toInputContext.

Instances

(GObject o, IsDescendantOf InputContext o) => IsInputContext o

Defined in GI.IBus.Objects.InputContext

toInputContext :: (MonadIO m, IsInputContext o) => o -> m InputContext

Cast to InputContext, for types for which this is known to be safe. For general casts, use castTo.

Methods

Click to display all available methods, including inherited ones

Methods

bindProperty, bindPropertyFull, call, callFinish, callSync, callWithUnixFdList, callWithUnixFdListFinish, callWithUnixFdListSync, cancelHandWriting, destroy, focusIn, focusOut, forceFloating, freezeNotify, getv, init, initAsync, initFinish, isFloating, needsSurroundingText, notify, notifyByPspec, processHandWritingEvent, processKeyEvent, processKeyEventAsync, processKeyEventAsyncFinish, propertyActivate, ref, refSink, reset, runDispose, stealData, stealQdata, thawNotify, unref, watchClosure.

Getters

getCachedProperty, getCachedPropertyNames, getConnection, getData, getDefaultTimeout, getEngine, getEngineAsync, getEngineAsyncFinish, getFlags, getInfo, getInterfaceInfo, getInterfaceName, getName, getNameOwner, getObject, getObjectPath, getProperty, getQdata.

Setters

setCachedProperty, setCapabilities, setClientCommitPreedit, setContentType, setCursorLocation, setCursorLocationRelative, setData, setDataFull, setDefaultTimeout, setEngine, setInterfaceInfo, setObject, setProperty, setSurroundingText.

cancelHandWriting

inputContextCancelHandWriting

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An IBusInputContext.

-> Word32

nStrokes: The number of strokes to be removed. Pass 0 to remove all.

-> m ()

Clear handwriting stroke(s) in the current input method engine.

see_also: cancelHandWriting

focusIn

inputContextFocusIn

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> m ()

Invoked when the client application get focus. An asynchronous IPC will be performed.

see_also: Engine::focus_in.

focusOut

inputContextFocusOut

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> m ()

Invoked when the client application get focus. An asynchronous IPC will be performed.

see_also: Engine::focus_out.

getEngine

inputContextGetEngine

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> m EngineDesc

Returns: An IME engine description for the context, or NULL.

Gets an IME engine description for the context. A synchronous IPC will be performed.

getEngineAsync

inputContextGetEngineAsync

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a, IsCancellable b)

=> a

context: An InputContext.

-> Int32

timeoutMsec: The timeout in milliseconds or -1 to use the default timeout.

-> Maybe b

cancellable: A Cancellable or Nothing.

-> Maybe AsyncReadyCallback

callback: A AsyncReadyCallback to call when the request is satisfied or Nothing if you don't care about the result of the method invocation.

-> m ()

An asynchronous IPC will be performed.

getEngineAsyncFinish

inputContextGetEngineAsyncFinish

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a, IsAsyncResult b)

=> a

context: An InputContext.

-> b

res: A AsyncResult obtained from the AsyncReadyCallback passed to inputContextGetEngineAsync.

-> m EngineDesc

Returns: An IME engine description for the context, or Nothing. (Can throw GError)

Finishes an operation started with inputContextGetEngineAsync.

getInputContext

inputContextGetInputContext

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)

=> Text

path: The path to the object that emitting the signal.

-> a

connection: A GDBusConnection.

-> m InputContext

Returns: An existing InputContext.

Gets an existing IBusInputContext.

getInputContextAsync

inputContextGetInputContextAsync

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a, IsCancellable b)

=> Text

path: The path to the object that emitting the signal.

-> a

connection: A DBusConnection.

-> Maybe b

cancellable: A Cancellable or Nothing.

-> Maybe AsyncReadyCallback

callback: A AsyncReadyCallback to call when the request is satisfied. The callback should not be Nothing.

-> m ()

Gets an existing InputContext asynchronously.

getInputContextAsyncFinish

inputContextGetInputContextAsyncFinish

Arguments

:: (HasCallStack, MonadIO m, IsAsyncResult a)

=> a

res: A AsyncResult obtained from the AsyncReadyCallback pass to inputContextGetInputContextAsync.

-> m InputContext

Returns: An existing InputContext. (Can throw GError)

Finishes an operation started with inputContextGetInputContextAsync.

needsSurroundingText

inputContextNeedsSurroundingText

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> m Bool

Returns: True if surrounding-text is needed by the current engine; False otherwise.

Check whether the current engine requires surrounding-text.

new

inputContextNew

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a, IsCancellable b)

=> Text

path: The path to the object that emitting the signal.

-> a

connection: A DBusConnection.

-> Maybe b

cancellable: A Cancellable or Nothing.

-> m InputContext

Returns: A newly allocated InputContext. (Can throw GError)

Creates a new InputContext.

newAsync

inputContextNewAsync

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a, IsCancellable b)

=> Text

path: The path to the object that emitting the signal.

-> a

connection: A DBusConnection.

-> Maybe b

cancellable: A Cancellable or Nothing.

-> Maybe AsyncReadyCallback

callback: A AsyncReadyCallback to call when the request is satisfied. The callback should not be Nothing.

-> m ()

Creates a new InputContext asynchronously.

newAsyncFinish

inputContextNewAsyncFinish

Arguments

:: (HasCallStack, MonadIO m, IsAsyncResult a)

=> a

res: A AsyncResult obtained from the AsyncReadyCallback pass to inputContextNewAsync.

-> m InputContext

Returns: A newly allocated InputContext. (Can throw GError)

Finishes an operation started with inputContextNewAsync.

processHandWritingEvent

inputContextProcessHandWritingEvent

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An IBusInputContext.

-> Double

coordinates: An array of gdouble (0.0 to 1.0) which represents a stroke (i.e. [x1, y1, x2, y2, x3, y3, ...]).

-> Word32

coordinatesLen: The number of elements in the array. The number should be even and >= 4.

-> m ()

Pass a handwriting stroke to an input method engine.

In this API, a coordinate (0.0, 0.0) represents the top-left corner of an area for handwriting, and (1.0, 1.0) does the bottom-right. Therefore, for example, if a user writes a character 'L', the array would be something like [0.0, 0.0, 0.0, 1.0, 1.0, 1.0] and coordinates_len would be 6.

The function is usually called when a user releases the mouse button in a hand writing area.

see_also: processHandWritingEvent

processKeyEvent

inputContextProcessKeyEvent

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> Word32

keyval: Key symbol of a key event.

-> Word32

keycode: Keycode of a key event.

-> Word32

state: Key modifier flags.

-> m Bool

Returns: True for successfully process the key; False otherwise.

See also: inputContextProcessKeyEventAsync

Pass the key event to input method engine and wait for the reply from ibus (i.e. synchronous IPC).

processKeyEventAsync

inputContextProcessKeyEventAsync

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a, IsCancellable b)

=> a

context: An IBusInputContext.

-> Word32

keyval: Key symbol of a key event.

-> Word32

keycode: Keycode of a key event.

-> Word32

state: Key modifier flags.

-> Int32

timeoutMsec: The timeout in milliseconds or -1 to use the default timeout.

-> Maybe b

cancellable: A GCancellable or NULL.

-> Maybe AsyncReadyCallback

callback: A GAsyncReadyCallback to call when the request is satisfied or NULL if you don't care about the result of the method invocation.

-> m ()

Pass the key event to input method engine.

Key symbols are characters/symbols produced by key press, for example, pressing "s" generates key symbol "s"; pressing shift-"s" generates key symbol "S". Same key on keyboard may produce different key symbols on different keyboard layout. e.g., "s" key on QWERTY keyboard produces "o" in DVORAK layout.

Unlike key symbol, keycode is only determined by the location of the key, and irrelevant of the keyboard layout.

Briefly speaking, input methods that expect certain keyboard layout should use keycode; otherwise keyval is sufficient. For example, Chewing, Cangjie, Wubi expect an en-US QWERTY keyboard, these should use keycode; while pinyin can rely on keyval only, as it is less sensitive to the keyboard layout change, DVORAK users can still use DVORAK layout to input pinyin.

Use keymapLookupKeysym to convert keycode to keysym in given keyboard layout.

see_also: processKeyEvent

processKeyEventAsyncFinish

inputContextProcessKeyEventAsyncFinish

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a, IsAsyncResult b)

=> a

context: An InputContext.

-> b

res: A AsyncResult obtained from the AsyncReadyCallback passed to inputContextProcessKeyEventAsync.

-> m ()

(Can throw GError)

Finishes an operation started with inputContextProcessKeyEventAsync.

propertyActivate

inputContextPropertyActivate

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> Text

propName: A property name (e.g. "InputMode.WideLatin")

-> Word32

state: A status of the property (e.g. PROP_STATE_CHECKED)

-> m ()

Activate the property asynchronously.

See also: Engine::property_activate

reset

inputContextReset

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> m ()

Invoked when the IME is reset. An asynchronous IPC will be performed.

see_also: reset

setCapabilities

inputContextSetCapabilities

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An IBusInputContext.

-> Word32

capabilities: Capabilities flags of IBusEngine, see Capabilite

-> m ()

Set the capabilities flags of client application asynchronously. When IBUS_CAP_FOCUS is not set, IBUS_CAP_PREEDIT_TEXT, IBUS_CAP_AUXILIARY_TEXT, IBUS_CAP_LOOKUP_TABLE, and IBUS_CAP_PROPERTY have to be all set. The panel component does nothing for an application that doesn't support focus.

see_also: setCapabilities

setClientCommitPreedit

inputContextSetClientCommitPreedit

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> Bool

clientCommit: True if your input context commits pre-edit texts with Space or Enter key events or mouse click events. False if ibus-daemon commits pre-edit texts with those events. The default is False. The behavior is decided with engineUpdatePreeditTextWithMode to commit, clear or keep the pre-edit text and this API is important in ibus-hangul.

-> m ()

Set whether InputContext commits pre-edit texts or not. If True, 'update-preedit-text-with-mode' signal is emitted instead of 'update-preedit-text' signal. If your client receives the 'update-preedit-text-with-mode' signal, the client needs to implement commit_text() of pre-edit text when GtkIMContextClass.focus_out() is called in case an IME desires that behavior but it depends on each IME.

See also engineUpdatePreeditTextWithMode.

setContentType

inputContextSetContentType

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> Word32

purpose: Primary purpose of the input context, as an InputPurpose.

-> Word32

hints: Hints that augment purpose, as an InputHints.

-> m ()

Set content-type (primary purpose and hints) of the context. This information is particularly useful to implement intelligent behavior in engines, such as automatic input-mode switch and text prediction. For example, to restrict input to numbers, the client can call this function with purpose set to IBUS_INPUT_PURPOSE_NUMBER.

See also: setContentType

setCursorLocation

inputContextSetCursorLocation

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An IBusInputContext.

-> Int32

x: X coordinate of the cursor.

-> Int32

y: Y coordinate of the cursor.

-> Int32

w: Width of the cursor.

-> Int32

h: Height of the cursor.

-> m ()

Set the cursor location of IBus input context asynchronously.

see_also: setCursorLocation

setCursorLocationRelative

inputContextSetCursorLocationRelative

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An IBusInputContext.

-> Int32

x: X coordinate of the cursor.

-> Int32

y: Y coordinate of the cursor.

-> Int32

w: Width of the cursor.

-> Int32

h: Height of the cursor.

-> m ()

Set the relative cursor location of IBus input context asynchronously.

setEngine

inputContextSetEngine

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a)

=> a

context: An InputContext.

-> Text

name: A name of the engine.

-> m ()

Invoked when the IME engine is changed. An asynchronous IPC will be performed.

setSurroundingText

inputContextSetSurroundingText

Arguments

:: (HasCallStack, MonadIO m, IsInputContext a, IsText b)

=> a

context: An InputContext.

-> b

text: An Text surrounding the current cursor on the application.

-> Word32

cursorPos: Current cursor position in characters in text.

-> Word32

anchorPos: Anchor position of selection in text.

-> m ()

No description available in the introspection data.

Signals

commitText

type C_InputContextCommitTextCallback = Ptr () -> Ptr Text -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextCommitTextCallback

Arguments

 = Text

text: Text to be committed.

-> IO ()

Emitted when the text is going to be committed.

(Note: The text object is floating, and it will be released after the signal. If signal handler wants to keep the object, the handler should use objectRefSink to get the ownership of the object.)

afterInputContextCommitText :: (IsInputContext a, MonadIO m) => a -> InputContextCommitTextCallback -> m SignalHandlerId

Connect a signal handler for the commitText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #commitText callback

genClosure_InputContextCommitText :: MonadIO m => InputContextCommitTextCallback -> m (GClosure C_InputContextCommitTextCallback)

Wrap the callback into a GClosure.

mk_InputContextCommitTextCallback :: C_InputContextCommitTextCallback -> IO (FunPtr C_InputContextCommitTextCallback)

Generate a function pointer callable from C code, from a C_InputContextCommitTextCallback.

noInputContextCommitTextCallback :: Maybe InputContextCommitTextCallback

A convenience synonym for Nothing :: Maybe InputContextCommitTextCallback.

onInputContextCommitText :: (IsInputContext a, MonadIO m) => a -> InputContextCommitTextCallback -> m SignalHandlerId

Connect a signal handler for the commitText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #commitText callback

wrap_InputContextCommitTextCallback :: InputContextCommitTextCallback -> C_InputContextCommitTextCallback

Wrap a InputContextCommitTextCallback into a C_InputContextCommitTextCallback.

cursorDownLookupTable

type C_InputContextCursorDownLookupTableCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextCursorDownLookupTableCallback = IO ()

Emitted to select next candidate of lookup table.

afterInputContextCursorDownLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextCursorDownLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the cursorDownLookupTable signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #cursorDownLookupTable callback

genClosure_InputContextCursorDownLookupTable :: MonadIO m => InputContextCursorDownLookupTableCallback -> m (GClosure C_InputContextCursorDownLookupTableCallback)

Wrap the callback into a GClosure.

mk_InputContextCursorDownLookupTableCallback :: C_InputContextCursorDownLookupTableCallback -> IO (FunPtr C_InputContextCursorDownLookupTableCallback)

Generate a function pointer callable from C code, from a C_InputContextCursorDownLookupTableCallback.

noInputContextCursorDownLookupTableCallback :: Maybe InputContextCursorDownLookupTableCallback

A convenience synonym for Nothing :: Maybe InputContextCursorDownLookupTableCallback.

onInputContextCursorDownLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextCursorDownLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the cursorDownLookupTable signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #cursorDownLookupTable callback

wrap_InputContextCursorDownLookupTableCallback :: InputContextCursorDownLookupTableCallback -> C_InputContextCursorDownLookupTableCallback

Wrap a InputContextCursorDownLookupTableCallback into a C_InputContextCursorDownLookupTableCallback.

cursorUpLookupTable

type C_InputContextCursorUpLookupTableCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextCursorUpLookupTableCallback = IO ()

Emitted to select previous candidate of lookup table.

afterInputContextCursorUpLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextCursorUpLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the cursorUpLookupTable signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #cursorUpLookupTable callback

genClosure_InputContextCursorUpLookupTable :: MonadIO m => InputContextCursorUpLookupTableCallback -> m (GClosure C_InputContextCursorUpLookupTableCallback)

Wrap the callback into a GClosure.

mk_InputContextCursorUpLookupTableCallback :: C_InputContextCursorUpLookupTableCallback -> IO (FunPtr C_InputContextCursorUpLookupTableCallback)

Generate a function pointer callable from C code, from a C_InputContextCursorUpLookupTableCallback.

noInputContextCursorUpLookupTableCallback :: Maybe InputContextCursorUpLookupTableCallback

A convenience synonym for Nothing :: Maybe InputContextCursorUpLookupTableCallback.

onInputContextCursorUpLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextCursorUpLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the cursorUpLookupTable signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #cursorUpLookupTable callback

wrap_InputContextCursorUpLookupTableCallback :: InputContextCursorUpLookupTableCallback -> C_InputContextCursorUpLookupTableCallback

Wrap a InputContextCursorUpLookupTableCallback into a C_InputContextCursorUpLookupTableCallback.

deleteSurroundingText

type C_InputContextDeleteSurroundingTextCallback = Ptr () -> Int32 -> Word32 -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextDeleteSurroundingTextCallback

Arguments

 = Int32

offset: the character offset from the cursor position of the text to be deleted. A negative value indicates a position before the cursor.

-> Word32

nChars: the number of characters to be deleted.

-> IO ()

Emitted to delete surrounding text event from IME to client of IME.

afterInputContextDeleteSurroundingText :: (IsInputContext a, MonadIO m) => a -> InputContextDeleteSurroundingTextCallback -> m SignalHandlerId

Connect a signal handler for the deleteSurroundingText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #deleteSurroundingText callback

genClosure_InputContextDeleteSurroundingText :: MonadIO m => InputContextDeleteSurroundingTextCallback -> m (GClosure C_InputContextDeleteSurroundingTextCallback)

Wrap the callback into a GClosure.

mk_InputContextDeleteSurroundingTextCallback :: C_InputContextDeleteSurroundingTextCallback -> IO (FunPtr C_InputContextDeleteSurroundingTextCallback)

Generate a function pointer callable from C code, from a C_InputContextDeleteSurroundingTextCallback.

noInputContextDeleteSurroundingTextCallback :: Maybe InputContextDeleteSurroundingTextCallback

A convenience synonym for Nothing :: Maybe InputContextDeleteSurroundingTextCallback.

onInputContextDeleteSurroundingText :: (IsInputContext a, MonadIO m) => a -> InputContextDeleteSurroundingTextCallback -> m SignalHandlerId

Connect a signal handler for the deleteSurroundingText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #deleteSurroundingText callback

wrap_InputContextDeleteSurroundingTextCallback :: InputContextDeleteSurroundingTextCallback -> C_InputContextDeleteSurroundingTextCallback

Wrap a InputContextDeleteSurroundingTextCallback into a C_InputContextDeleteSurroundingTextCallback.

disabled

type C_InputContextDisabledCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextDisabledCallback = IO ()

Emitted when an IME is disabled.

afterInputContextDisabled :: (IsInputContext a, MonadIO m) => a -> InputContextDisabledCallback -> m SignalHandlerId

Connect a signal handler for the disabled signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #disabled callback

genClosure_InputContextDisabled :: MonadIO m => InputContextDisabledCallback -> m (GClosure C_InputContextDisabledCallback)

Wrap the callback into a GClosure.

mk_InputContextDisabledCallback :: C_InputContextDisabledCallback -> IO (FunPtr C_InputContextDisabledCallback)

Generate a function pointer callable from C code, from a C_InputContextDisabledCallback.

noInputContextDisabledCallback :: Maybe InputContextDisabledCallback

A convenience synonym for Nothing :: Maybe InputContextDisabledCallback.

onInputContextDisabled :: (IsInputContext a, MonadIO m) => a -> InputContextDisabledCallback -> m SignalHandlerId

Connect a signal handler for the disabled signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #disabled callback

wrap_InputContextDisabledCallback :: InputContextDisabledCallback -> C_InputContextDisabledCallback

Wrap a InputContextDisabledCallback into a C_InputContextDisabledCallback.

enabled

type C_InputContextEnabledCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextEnabledCallback = IO ()

Emitted when an IME is enabled.

afterInputContextEnabled :: (IsInputContext a, MonadIO m) => a -> InputContextEnabledCallback -> m SignalHandlerId

Connect a signal handler for the enabled signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #enabled callback

genClosure_InputContextEnabled :: MonadIO m => InputContextEnabledCallback -> m (GClosure C_InputContextEnabledCallback)

Wrap the callback into a GClosure.

mk_InputContextEnabledCallback :: C_InputContextEnabledCallback -> IO (FunPtr C_InputContextEnabledCallback)

Generate a function pointer callable from C code, from a C_InputContextEnabledCallback.

noInputContextEnabledCallback :: Maybe InputContextEnabledCallback

A convenience synonym for Nothing :: Maybe InputContextEnabledCallback.

onInputContextEnabled :: (IsInputContext a, MonadIO m) => a -> InputContextEnabledCallback -> m SignalHandlerId

Connect a signal handler for the enabled signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #enabled callback

wrap_InputContextEnabledCallback :: InputContextEnabledCallback -> C_InputContextEnabledCallback

Wrap a InputContextEnabledCallback into a C_InputContextEnabledCallback.

forwardKeyEvent

type C_InputContextForwardKeyEventCallback = Ptr () -> Word32 -> Word32 -> Word32 -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextForwardKeyEventCallback

Arguments

 = Word32

keyval: Key symbol of the keyboard event.

-> Word32

keycode: Key symbol of the keyboard event.

-> Word32

modifiers: Key modifier flags.

-> IO ()

Emitted to forward key event from IME to client of IME.

afterInputContextForwardKeyEvent :: (IsInputContext a, MonadIO m) => a -> InputContextForwardKeyEventCallback -> m SignalHandlerId

Connect a signal handler for the forwardKeyEvent signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #forwardKeyEvent callback

genClosure_InputContextForwardKeyEvent :: MonadIO m => InputContextForwardKeyEventCallback -> m (GClosure C_InputContextForwardKeyEventCallback)

Wrap the callback into a GClosure.

mk_InputContextForwardKeyEventCallback :: C_InputContextForwardKeyEventCallback -> IO (FunPtr C_InputContextForwardKeyEventCallback)

Generate a function pointer callable from C code, from a C_InputContextForwardKeyEventCallback.

noInputContextForwardKeyEventCallback :: Maybe InputContextForwardKeyEventCallback

A convenience synonym for Nothing :: Maybe InputContextForwardKeyEventCallback.

onInputContextForwardKeyEvent :: (IsInputContext a, MonadIO m) => a -> InputContextForwardKeyEventCallback -> m SignalHandlerId

Connect a signal handler for the forwardKeyEvent signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #forwardKeyEvent callback

wrap_InputContextForwardKeyEventCallback :: InputContextForwardKeyEventCallback -> C_InputContextForwardKeyEventCallback

Wrap a InputContextForwardKeyEventCallback into a C_InputContextForwardKeyEventCallback.

hideAuxiliaryText

type C_InputContextHideAuxiliaryTextCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextHideAuxiliaryTextCallback = IO ()

Emitted to hide auxiliary text.

afterInputContextHideAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextHideAuxiliaryTextCallback -> m SignalHandlerId

Connect a signal handler for the hideAuxiliaryText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #hideAuxiliaryText callback

genClosure_InputContextHideAuxiliaryText :: MonadIO m => InputContextHideAuxiliaryTextCallback -> m (GClosure C_InputContextHideAuxiliaryTextCallback)

Wrap the callback into a GClosure.

mk_InputContextHideAuxiliaryTextCallback :: C_InputContextHideAuxiliaryTextCallback -> IO (FunPtr C_InputContextHideAuxiliaryTextCallback)

Generate a function pointer callable from C code, from a C_InputContextHideAuxiliaryTextCallback.

noInputContextHideAuxiliaryTextCallback :: Maybe InputContextHideAuxiliaryTextCallback

A convenience synonym for Nothing :: Maybe InputContextHideAuxiliaryTextCallback.

onInputContextHideAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextHideAuxiliaryTextCallback -> m SignalHandlerId

Connect a signal handler for the hideAuxiliaryText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #hideAuxiliaryText callback

wrap_InputContextHideAuxiliaryTextCallback :: InputContextHideAuxiliaryTextCallback -> C_InputContextHideAuxiliaryTextCallback

Wrap a InputContextHideAuxiliaryTextCallback into a C_InputContextHideAuxiliaryTextCallback.

hideLookupTable

type C_InputContextHideLookupTableCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextHideLookupTableCallback = IO ()

Emitted to hide lookup table.

afterInputContextHideLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextHideLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the hideLookupTable signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #hideLookupTable callback

genClosure_InputContextHideLookupTable :: MonadIO m => InputContextHideLookupTableCallback -> m (GClosure C_InputContextHideLookupTableCallback)

Wrap the callback into a GClosure.

mk_InputContextHideLookupTableCallback :: C_InputContextHideLookupTableCallback -> IO (FunPtr C_InputContextHideLookupTableCallback)

Generate a function pointer callable from C code, from a C_InputContextHideLookupTableCallback.

noInputContextHideLookupTableCallback :: Maybe InputContextHideLookupTableCallback

A convenience synonym for Nothing :: Maybe InputContextHideLookupTableCallback.

onInputContextHideLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextHideLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the hideLookupTable signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #hideLookupTable callback

wrap_InputContextHideLookupTableCallback :: InputContextHideLookupTableCallback -> C_InputContextHideLookupTableCallback

Wrap a InputContextHideLookupTableCallback into a C_InputContextHideLookupTableCallback.

hidePreeditText

type C_InputContextHidePreeditTextCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextHidePreeditTextCallback = IO ()

Emitted to hide preedit text.

afterInputContextHidePreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextHidePreeditTextCallback -> m SignalHandlerId

Connect a signal handler for the hidePreeditText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #hidePreeditText callback

genClosure_InputContextHidePreeditText :: MonadIO m => InputContextHidePreeditTextCallback -> m (GClosure C_InputContextHidePreeditTextCallback)

Wrap the callback into a GClosure.

mk_InputContextHidePreeditTextCallback :: C_InputContextHidePreeditTextCallback -> IO (FunPtr C_InputContextHidePreeditTextCallback)

Generate a function pointer callable from C code, from a C_InputContextHidePreeditTextCallback.

noInputContextHidePreeditTextCallback :: Maybe InputContextHidePreeditTextCallback

A convenience synonym for Nothing :: Maybe InputContextHidePreeditTextCallback.

onInputContextHidePreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextHidePreeditTextCallback -> m SignalHandlerId

Connect a signal handler for the hidePreeditText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #hidePreeditText callback

wrap_InputContextHidePreeditTextCallback :: InputContextHidePreeditTextCallback -> C_InputContextHidePreeditTextCallback

Wrap a InputContextHidePreeditTextCallback into a C_InputContextHidePreeditTextCallback.

pageDownLookupTable

type C_InputContextPageDownLookupTableCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextPageDownLookupTableCallback = IO ()

Emitted to view the next page of lookup table.

afterInputContextPageDownLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextPageDownLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the pageDownLookupTable signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #pageDownLookupTable callback

genClosure_InputContextPageDownLookupTable :: MonadIO m => InputContextPageDownLookupTableCallback -> m (GClosure C_InputContextPageDownLookupTableCallback)

Wrap the callback into a GClosure.

mk_InputContextPageDownLookupTableCallback :: C_InputContextPageDownLookupTableCallback -> IO (FunPtr C_InputContextPageDownLookupTableCallback)

Generate a function pointer callable from C code, from a C_InputContextPageDownLookupTableCallback.

noInputContextPageDownLookupTableCallback :: Maybe InputContextPageDownLookupTableCallback

A convenience synonym for Nothing :: Maybe InputContextPageDownLookupTableCallback.

onInputContextPageDownLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextPageDownLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the pageDownLookupTable signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #pageDownLookupTable callback

wrap_InputContextPageDownLookupTableCallback :: InputContextPageDownLookupTableCallback -> C_InputContextPageDownLookupTableCallback

Wrap a InputContextPageDownLookupTableCallback into a C_InputContextPageDownLookupTableCallback.

pageUpLookupTable

type C_InputContextPageUpLookupTableCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextPageUpLookupTableCallback = IO ()

Emitted to view the previous page of lookup table.

afterInputContextPageUpLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextPageUpLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the pageUpLookupTable signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #pageUpLookupTable callback

genClosure_InputContextPageUpLookupTable :: MonadIO m => InputContextPageUpLookupTableCallback -> m (GClosure C_InputContextPageUpLookupTableCallback)

Wrap the callback into a GClosure.

mk_InputContextPageUpLookupTableCallback :: C_InputContextPageUpLookupTableCallback -> IO (FunPtr C_InputContextPageUpLookupTableCallback)

Generate a function pointer callable from C code, from a C_InputContextPageUpLookupTableCallback.

noInputContextPageUpLookupTableCallback :: Maybe InputContextPageUpLookupTableCallback

A convenience synonym for Nothing :: Maybe InputContextPageUpLookupTableCallback.

onInputContextPageUpLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextPageUpLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the pageUpLookupTable signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #pageUpLookupTable callback

wrap_InputContextPageUpLookupTableCallback :: InputContextPageUpLookupTableCallback -> C_InputContextPageUpLookupTableCallback

Wrap a InputContextPageUpLookupTableCallback into a C_InputContextPageUpLookupTableCallback.

registerProperties

type C_InputContextRegisterPropertiesCallback = Ptr () -> Ptr PropList -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextRegisterPropertiesCallback

Arguments

 = PropList

props: An IBusPropList that contains properties.

-> IO ()

Emitted to register the properties in props.

(Note: The props object is floating, and it will be released after the signal. If signal handler wants to keep the object, the handler should use objectRefSink to get the ownership of the object.)

afterInputContextRegisterProperties :: (IsInputContext a, MonadIO m) => a -> InputContextRegisterPropertiesCallback -> m SignalHandlerId

Connect a signal handler for the registerProperties signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #registerProperties callback

genClosure_InputContextRegisterProperties :: MonadIO m => InputContextRegisterPropertiesCallback -> m (GClosure C_InputContextRegisterPropertiesCallback)

Wrap the callback into a GClosure.

mk_InputContextRegisterPropertiesCallback :: C_InputContextRegisterPropertiesCallback -> IO (FunPtr C_InputContextRegisterPropertiesCallback)

Generate a function pointer callable from C code, from a C_InputContextRegisterPropertiesCallback.

noInputContextRegisterPropertiesCallback :: Maybe InputContextRegisterPropertiesCallback

A convenience synonym for Nothing :: Maybe InputContextRegisterPropertiesCallback.

onInputContextRegisterProperties :: (IsInputContext a, MonadIO m) => a -> InputContextRegisterPropertiesCallback -> m SignalHandlerId

Connect a signal handler for the registerProperties signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #registerProperties callback

wrap_InputContextRegisterPropertiesCallback :: InputContextRegisterPropertiesCallback -> C_InputContextRegisterPropertiesCallback

Wrap a InputContextRegisterPropertiesCallback into a C_InputContextRegisterPropertiesCallback.

showAuxiliaryText

type C_InputContextShowAuxiliaryTextCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextShowAuxiliaryTextCallback = IO ()

Emitted to show auxiliary text.

afterInputContextShowAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextShowAuxiliaryTextCallback -> m SignalHandlerId

Connect a signal handler for the showAuxiliaryText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #showAuxiliaryText callback

genClosure_InputContextShowAuxiliaryText :: MonadIO m => InputContextShowAuxiliaryTextCallback -> m (GClosure C_InputContextShowAuxiliaryTextCallback)

Wrap the callback into a GClosure.

mk_InputContextShowAuxiliaryTextCallback :: C_InputContextShowAuxiliaryTextCallback -> IO (FunPtr C_InputContextShowAuxiliaryTextCallback)

Generate a function pointer callable from C code, from a C_InputContextShowAuxiliaryTextCallback.

noInputContextShowAuxiliaryTextCallback :: Maybe InputContextShowAuxiliaryTextCallback

A convenience synonym for Nothing :: Maybe InputContextShowAuxiliaryTextCallback.

onInputContextShowAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextShowAuxiliaryTextCallback -> m SignalHandlerId

Connect a signal handler for the showAuxiliaryText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #showAuxiliaryText callback

wrap_InputContextShowAuxiliaryTextCallback :: InputContextShowAuxiliaryTextCallback -> C_InputContextShowAuxiliaryTextCallback

Wrap a InputContextShowAuxiliaryTextCallback into a C_InputContextShowAuxiliaryTextCallback.

showLookupTable

type C_InputContextShowLookupTableCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextShowLookupTableCallback = IO ()

Emitted to show lookup table.

afterInputContextShowLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextShowLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the showLookupTable signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #showLookupTable callback

genClosure_InputContextShowLookupTable :: MonadIO m => InputContextShowLookupTableCallback -> m (GClosure C_InputContextShowLookupTableCallback)

Wrap the callback into a GClosure.

mk_InputContextShowLookupTableCallback :: C_InputContextShowLookupTableCallback -> IO (FunPtr C_InputContextShowLookupTableCallback)

Generate a function pointer callable from C code, from a C_InputContextShowLookupTableCallback.

noInputContextShowLookupTableCallback :: Maybe InputContextShowLookupTableCallback

A convenience synonym for Nothing :: Maybe InputContextShowLookupTableCallback.

onInputContextShowLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextShowLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the showLookupTable signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #showLookupTable callback

wrap_InputContextShowLookupTableCallback :: InputContextShowLookupTableCallback -> C_InputContextShowLookupTableCallback

Wrap a InputContextShowLookupTableCallback into a C_InputContextShowLookupTableCallback.

showPreeditText

type C_InputContextShowPreeditTextCallback = Ptr () -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextShowPreeditTextCallback = IO ()

Emitted to show preedit text.

afterInputContextShowPreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextShowPreeditTextCallback -> m SignalHandlerId

Connect a signal handler for the showPreeditText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #showPreeditText callback

genClosure_InputContextShowPreeditText :: MonadIO m => InputContextShowPreeditTextCallback -> m (GClosure C_InputContextShowPreeditTextCallback)

Wrap the callback into a GClosure.

mk_InputContextShowPreeditTextCallback :: C_InputContextShowPreeditTextCallback -> IO (FunPtr C_InputContextShowPreeditTextCallback)

Generate a function pointer callable from C code, from a C_InputContextShowPreeditTextCallback.

noInputContextShowPreeditTextCallback :: Maybe InputContextShowPreeditTextCallback

A convenience synonym for Nothing :: Maybe InputContextShowPreeditTextCallback.

onInputContextShowPreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextShowPreeditTextCallback -> m SignalHandlerId

Connect a signal handler for the showPreeditText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #showPreeditText callback

wrap_InputContextShowPreeditTextCallback :: InputContextShowPreeditTextCallback -> C_InputContextShowPreeditTextCallback

Wrap a InputContextShowPreeditTextCallback into a C_InputContextShowPreeditTextCallback.

updateAuxiliaryText

type C_InputContextUpdateAuxiliaryTextCallback = Ptr () -> Ptr Text -> CInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextUpdateAuxiliaryTextCallback

Arguments

 = Text

text: An auxiliary text

-> Bool

visible: The visibility of text

-> IO ()

Emitted to hide auxilary text.

(Note: The text object is floating, and it will be released after the signal. If signal handler wants to keep the object, the handler should use objectRefSink to get the ownership of the object.)

afterInputContextUpdateAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextUpdateAuxiliaryTextCallback -> m SignalHandlerId

Connect a signal handler for the updateAuxiliaryText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #updateAuxiliaryText callback

genClosure_InputContextUpdateAuxiliaryText :: MonadIO m => InputContextUpdateAuxiliaryTextCallback -> m (GClosure C_InputContextUpdateAuxiliaryTextCallback)

Wrap the callback into a GClosure.

mk_InputContextUpdateAuxiliaryTextCallback :: C_InputContextUpdateAuxiliaryTextCallback -> IO (FunPtr C_InputContextUpdateAuxiliaryTextCallback)

Generate a function pointer callable from C code, from a C_InputContextUpdateAuxiliaryTextCallback.

noInputContextUpdateAuxiliaryTextCallback :: Maybe InputContextUpdateAuxiliaryTextCallback

A convenience synonym for Nothing :: Maybe InputContextUpdateAuxiliaryTextCallback.

onInputContextUpdateAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextUpdateAuxiliaryTextCallback -> m SignalHandlerId

Connect a signal handler for the updateAuxiliaryText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #updateAuxiliaryText callback

wrap_InputContextUpdateAuxiliaryTextCallback :: InputContextUpdateAuxiliaryTextCallback -> C_InputContextUpdateAuxiliaryTextCallback

Wrap a InputContextUpdateAuxiliaryTextCallback into a C_InputContextUpdateAuxiliaryTextCallback.

updateLookupTable

type C_InputContextUpdateLookupTableCallback = Ptr () -> Ptr LookupTable -> CInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextUpdateLookupTableCallback

Arguments

 = LookupTable

table: An IBusLookupTable to be updated.

-> Bool

visible: Whether the table should be visible.

-> IO ()

Emitted to update lookup table.

(Note: The table object is floating, and it will be released after the signal. If signal handler wants to keep the object, the handler should use objectRefSink to get the ownership of the object.)

afterInputContextUpdateLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextUpdateLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the updateLookupTable signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #updateLookupTable callback

genClosure_InputContextUpdateLookupTable :: MonadIO m => InputContextUpdateLookupTableCallback -> m (GClosure C_InputContextUpdateLookupTableCallback)

Wrap the callback into a GClosure.

mk_InputContextUpdateLookupTableCallback :: C_InputContextUpdateLookupTableCallback -> IO (FunPtr C_InputContextUpdateLookupTableCallback)

Generate a function pointer callable from C code, from a C_InputContextUpdateLookupTableCallback.

noInputContextUpdateLookupTableCallback :: Maybe InputContextUpdateLookupTableCallback

A convenience synonym for Nothing :: Maybe InputContextUpdateLookupTableCallback.

onInputContextUpdateLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextUpdateLookupTableCallback -> m SignalHandlerId

Connect a signal handler for the updateLookupTable signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #updateLookupTable callback

wrap_InputContextUpdateLookupTableCallback :: InputContextUpdateLookupTableCallback -> C_InputContextUpdateLookupTableCallback

Wrap a InputContextUpdateLookupTableCallback into a C_InputContextUpdateLookupTableCallback.

updatePreeditText

type C_InputContextUpdatePreeditTextCallback = Ptr () -> Ptr Text -> Word32 -> CInt -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextUpdatePreeditTextCallback

Arguments

 = Text

text: Text to be updated.

-> Word32

cursorPos: Cursor position.

-> Bool

visible: Whether the update is visible.

-> IO ()

Emitted to update preedit text.

(Note: The text object is floating, and it will be released after the signal. If signal handler wants to keep the object, the handler should use objectRefSink to get the ownership of the object.)

afterInputContextUpdatePreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePreeditTextCallback -> m SignalHandlerId

Connect a signal handler for the updatePreeditText signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #updatePreeditText callback

genClosure_InputContextUpdatePreeditText :: MonadIO m => InputContextUpdatePreeditTextCallback -> m (GClosure C_InputContextUpdatePreeditTextCallback)

Wrap the callback into a GClosure.

mk_InputContextUpdatePreeditTextCallback :: C_InputContextUpdatePreeditTextCallback -> IO (FunPtr C_InputContextUpdatePreeditTextCallback)

Generate a function pointer callable from C code, from a C_InputContextUpdatePreeditTextCallback.

noInputContextUpdatePreeditTextCallback :: Maybe InputContextUpdatePreeditTextCallback

A convenience synonym for Nothing :: Maybe InputContextUpdatePreeditTextCallback.

onInputContextUpdatePreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePreeditTextCallback -> m SignalHandlerId

Connect a signal handler for the updatePreeditText signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #updatePreeditText callback

wrap_InputContextUpdatePreeditTextCallback :: InputContextUpdatePreeditTextCallback -> C_InputContextUpdatePreeditTextCallback

Wrap a InputContextUpdatePreeditTextCallback into a C_InputContextUpdatePreeditTextCallback.

updatePreeditTextWithMode

type C_InputContextUpdatePreeditTextWithModeCallback = Ptr () -> Ptr Text -> Word32 -> CInt -> Word32 -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextUpdatePreeditTextWithModeCallback

Arguments

 = Text

text: Text to be updated.

-> Word32

cursorPos: Cursor position.

-> Bool

visible: Whether the update is visible.

-> Word32

mode: Preedit mode.

-> IO ()

Emitted to update preedit text with the mode.

(Note: The text object is floating, and it will be released after the signal. If signal handler wants to keep the object, the handler should use objectRefSink to get the ownership of the object.)

afterInputContextUpdatePreeditTextWithMode :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePreeditTextWithModeCallback -> m SignalHandlerId

Connect a signal handler for the updatePreeditTextWithMode signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #updatePreeditTextWithMode callback

genClosure_InputContextUpdatePreeditTextWithMode :: MonadIO m => InputContextUpdatePreeditTextWithModeCallback -> m (GClosure C_InputContextUpdatePreeditTextWithModeCallback)

Wrap the callback into a GClosure.

mk_InputContextUpdatePreeditTextWithModeCallback :: C_InputContextUpdatePreeditTextWithModeCallback -> IO (FunPtr C_InputContextUpdatePreeditTextWithModeCallback)

Generate a function pointer callable from C code, from a C_InputContextUpdatePreeditTextWithModeCallback.

noInputContextUpdatePreeditTextWithModeCallback :: Maybe InputContextUpdatePreeditTextWithModeCallback

A convenience synonym for Nothing :: Maybe InputContextUpdatePreeditTextWithModeCallback.

onInputContextUpdatePreeditTextWithMode :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePreeditTextWithModeCallback -> m SignalHandlerId

Connect a signal handler for the updatePreeditTextWithMode signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #updatePreeditTextWithMode callback

wrap_InputContextUpdatePreeditTextWithModeCallback :: InputContextUpdatePreeditTextWithModeCallback -> C_InputContextUpdatePreeditTextWithModeCallback

Wrap a InputContextUpdatePreeditTextWithModeCallback into a C_InputContextUpdatePreeditTextWithModeCallback.

updateProperty

type C_InputContextUpdatePropertyCallback = Ptr () -> Ptr Property -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type InputContextUpdatePropertyCallback

Arguments

 = Property

prop: The IBusProperty to be updated.

-> IO ()

Emitted to update the property prop.

(Note: The prop object is floating, and it will be released after the signal. If signal handler wants to keep the object, the handler should use objectRefSink to get the ownership of the object.)

afterInputContextUpdateProperty :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePropertyCallback -> m SignalHandlerId

Connect a signal handler for the updateProperty signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after inputContext #updateProperty callback

genClosure_InputContextUpdateProperty :: MonadIO m => InputContextUpdatePropertyCallback -> m (GClosure C_InputContextUpdatePropertyCallback)

Wrap the callback into a GClosure.

mk_InputContextUpdatePropertyCallback :: C_InputContextUpdatePropertyCallback -> IO (FunPtr C_InputContextUpdatePropertyCallback)

Generate a function pointer callable from C code, from a C_InputContextUpdatePropertyCallback.

noInputContextUpdatePropertyCallback :: Maybe InputContextUpdatePropertyCallback

A convenience synonym for Nothing :: Maybe InputContextUpdatePropertyCallback.

onInputContextUpdateProperty :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePropertyCallback -> m SignalHandlerId

Connect a signal handler for the updateProperty signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on inputContext #updateProperty callback

wrap_InputContextUpdatePropertyCallback :: InputContextUpdatePropertyCallback -> C_InputContextUpdatePropertyCallback

Wrap a InputContextUpdatePropertyCallback into a C_InputContextUpdatePropertyCallback.