GI.IBus.Objects.Engine

An IBusEngine provides infrastructure for input method engine. Developers can "extend" this class for input method engine development.

see_also: Component, EngineDesc

Exported types

newtype Engine

Memory-managed wrapper type.

Constructors

Engine (ManagedPtr Engine)

Instances

Eq Engine

Defined in GI.IBus.Objects.Engine

Methods

(==) :: Engine -> Engine -> Bool

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

GObject Engine

Defined in GI.IBus.Objects.Engine

ManagedPtrNewtype Engine

Defined in GI.IBus.Objects.Engine

Methods

toManagedPtr :: Engine -> ManagedPtr Engine

TypedObject Engine

Defined in GI.IBus.Objects.Engine

Methods

glibType :: IO GType

IsGValue Engine

Convert Engine to and from GValue with toGValue and fromGValue.

Defined in GI.IBus.Objects.Engine

Methods

toGValue :: Engine -> IO GValue

fromGValue :: GValue -> IO Engine

HasParentTypes Engine

Defined in GI.IBus.Objects.Engine

type ParentTypes Engine

Defined in GI.IBus.Objects.Engine

type ParentTypes Engine = '[Service, Object, Object]

class (GObject o, IsDescendantOf Engine o) => IsEngine o

Type class for types which can be safely cast to Engine, for instance with toEngine.

Instances

(GObject o, IsDescendantOf Engine o) => IsEngine o

Defined in GI.IBus.Objects.Engine

toEngine :: (MonadIO m, IsEngine o) => o -> m Engine

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

Methods

Overloaded methods

commitText

engineCommitText

Arguments

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

=> a

engine: An IBusEngine.

-> b

text: String commit to IBusEngine.

-> m ()

Commit output of input method to IBus client.

(Note: The text object will be released, if it is floating. If caller want to keep the object, caller should make the object sink by g_object_ref_sink.)

deleteSurroundingText

engineDeleteSurroundingText

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> Int32

offset: The offset of the first char.

-> Word32

nchars: Number of chars to be deleted.

-> m ()

Delete surrounding text.

forwardKeyEvent

engineForwardKeyEvent

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> Word32

keyval: KeySym.

-> Word32

keycode: keyboard scancode.

-> Word32

state: Key modifier flags.

-> m ()

Forward the key event.

getContentType

engineGetContentType

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An Engine.

-> m (Word32, Word32)

Get content-type (primary purpose and hints) of the current input context.

See also: setContentType

getName

engineGetName

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> m Text

Returns: Name of Engine.

Return the name of Engine.

getSurroundingText

engineGetSurroundingText

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> m (Text, Word32, Word32)

Get surrounding text.

It is also used to tell the input-context that the engine will utilize surrounding-text. In that case, it must be called in enable handler, with both text and cursor set to Nothing.

See also: setSurroundingText

hideAuxiliaryText

engineHideAuxiliaryText

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> m ()

Hide the auxiliary bar.

hideLookupTable

engineHideLookupTable

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> m ()

Hide the lookup table.

hidePreeditText

engineHidePreeditText

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> m ()

Hide the pre-edit buffer.

new

engineNew

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)

=> Text

engineName: Name of the IBusObject.

-> Text

objectPath: Path for IBusService.

-> a

connection: An opened GDBusConnection.

-> m Engine

Returns: A newly allocated IBusEngine.

Create a new Engine.

newWithType

engineNewWithType

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)

=> GType

engineType: GType of Engine.

-> Text

engineName: Name of the IBusObject.

-> Text

objectPath: Path for IBusService.

-> a

connection: An opened GDBusConnection.

-> m Engine

Returns: A newly allocated IBusEngine.

Create a new Engine.

registerProperties

engineRegisterProperties

Arguments

:: (HasCallStack, MonadIO m, IsEngine a, IsPropList b)

=> a

engine: An IBusEngine.

-> b

propList: Property List.

-> m ()

Register and show properties in language bar.

(Note: The prop_list object will be released, if it is floating. If caller want to keep the object, caller should make the object sink by g_object_ref_sink.)

showAuxiliaryText

engineShowAuxiliaryText

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> m ()

Show the auxiliary bar.

showLookupTable

engineShowLookupTable

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> m ()

Show the lookup table.

showPreeditText

engineShowPreeditText

Arguments

:: (HasCallStack, MonadIO m, IsEngine a)

=> a

engine: An IBusEngine.

-> m ()

Show the pre-edit buffer.

updateAuxiliaryText

engineUpdateAuxiliaryText

Arguments

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

=> a

engine: An IBusEngine.

-> b

text: Update content.

-> Bool

visible: Whether the auxiliary text bar is visible.

-> m ()

Update the auxiliary bar.

(Note: The text object will be released, if it is floating. If caller want to keep the object, caller should make the object sink by g_object_ref_sink.)

updateLookupTable

engineUpdateLookupTable

Arguments

:: (HasCallStack, MonadIO m, IsEngine a, IsLookupTable b)

=> a

engine: An IBusEngine.

-> b

lookupTable: An lookup_table.

-> Bool

visible: Whether the lookup_table is visible.

-> m ()

Update the lookup table.

(Note: The table object will be released, if it is floating. If caller want to keep the object, caller should make the object sink by g_object_ref_sink.)

updateLookupTableFast

engineUpdateLookupTableFast

Arguments

:: (HasCallStack, MonadIO m, IsEngine a, IsLookupTable b)

=> a

engine: An IBusEngine.

-> b

lookupTable: An lookup_table.

-> Bool

visible: Whether the lookup_table is visible.

-> m ()

Fast update for big lookup table.

If size of lookup table is not over table page size *4, then it calls engineUpdateLookupTable.

(Note: The table object will be released, if it is floating. If caller want to keep the object, caller should make the object sink by g_object_ref_sink.)

updatePreeditText

engineUpdatePreeditText

Arguments

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

=> a

engine: An IBusEngine.

-> b

text: Update content.

-> Word32

cursorPos: Current position of cursor

-> Bool

visible: Whether the pre-edit buffer is visible.

-> m ()

Update the pre-edit buffer.

(Note: The text object will be released, if it is floating. If caller want to keep the object, caller should make the object sink by g_object_ref_sink.)

updatePreeditTextWithMode

engineUpdatePreeditTextWithMode

Arguments

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

=> a

engine: An IBusEngine.

-> b

text: Update content.

-> Word32

cursorPos: Current position of cursor

-> Bool

visible: Whether the pre-edit buffer is visible.

-> PreeditFocusMode

mode: Pre-edit commit mode when the focus is lost.

-> m ()

Update the pre-edit buffer with commit mode. Similar to engineUpdatePreeditText, this function allows users to specify the behavior on focus out when the pre-edit buffer is visible.

If mode is IBUS_ENGINE_PREEDIT_COMMIT, contents of the pre-edit buffer will be committed and cleared. If mode is IBUS_ENGINE_PREEDIT_CLEAR, contents of the pre-edit buffer will be cleared only.

(Note: The text object will be released, if it is floating. If caller want to keep the object, caller should make the object sink by g_object_ref_sink.)

updateProperty

engineUpdateProperty

Arguments

:: (HasCallStack, MonadIO m, IsEngine a, IsProperty b)

=> a

engine: An IBusEngine.

-> b

prop: IBusProperty to be updated.

-> m ()

Update the state displayed in language bar.

(Note: The prop object will be released, if it is floating. If caller want to keep the object, caller should make the object sink by g_object_ref_sink.)

Properties

engineName

No description available in the introspection data.

constructEngineEngineName :: (IsEngine o, MonadIO m) => Text -> m (GValueConstruct o)

Construct a GValueConstruct with valid value for the “engine-name” property. This is rarely needed directly, but it is used by new.

getEngineEngineName :: (MonadIO m, IsEngine o) => o -> m (Maybe Text)

Get the value of the “engine-name” property. When overloading is enabled, this is equivalent to

get engine #engineName

Signals

cancelHandWriting

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

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

type EngineCancelHandWritingCallback

Arguments

 = Word32

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

-> IO ()

Emitted when a hand writing operation is cancelled. Implement the member function IBusEngineClass[cancel_hand_writing](#g:signal:cancel_hand_writing) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEngineCancelHandWriting :: (IsEngine a, MonadIO m) => a -> EngineCancelHandWritingCallback -> m SignalHandlerId

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

after engine #cancelHandWriting callback

genClosure_EngineCancelHandWriting :: MonadIO m => EngineCancelHandWritingCallback -> m (GClosure C_EngineCancelHandWritingCallback)

Wrap the callback into a GClosure.

mk_EngineCancelHandWritingCallback :: C_EngineCancelHandWritingCallback -> IO (FunPtr C_EngineCancelHandWritingCallback)

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

noEngineCancelHandWritingCallback :: Maybe EngineCancelHandWritingCallback

A convenience synonym for Nothing :: Maybe EngineCancelHandWritingCallback.

onEngineCancelHandWriting :: (IsEngine a, MonadIO m) => a -> EngineCancelHandWritingCallback -> m SignalHandlerId

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

on engine #cancelHandWriting callback

wrap_EngineCancelHandWritingCallback :: EngineCancelHandWritingCallback -> C_EngineCancelHandWritingCallback

Wrap a EngineCancelHandWritingCallback into a C_EngineCancelHandWritingCallback.

candidateClicked

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

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

type EngineCandidateClickedCallback

Arguments

 = Word32

index: Index of candidate be clicked.

-> Word32

button: Mouse button.

-> Word32

state: Keyboard state.

-> IO ()

Emitted when candidate on lookup table is clicked. Implement the member function IBusEngineClass[candidate_clicked](#g:signal:candidate_clicked) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEngineCandidateClicked :: (IsEngine a, MonadIO m) => a -> EngineCandidateClickedCallback -> m SignalHandlerId

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

after engine #candidateClicked callback

genClosure_EngineCandidateClicked :: MonadIO m => EngineCandidateClickedCallback -> m (GClosure C_EngineCandidateClickedCallback)

Wrap the callback into a GClosure.

mk_EngineCandidateClickedCallback :: C_EngineCandidateClickedCallback -> IO (FunPtr C_EngineCandidateClickedCallback)

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

noEngineCandidateClickedCallback :: Maybe EngineCandidateClickedCallback

A convenience synonym for Nothing :: Maybe EngineCandidateClickedCallback.

onEngineCandidateClicked :: (IsEngine a, MonadIO m) => a -> EngineCandidateClickedCallback -> m SignalHandlerId

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

on engine #candidateClicked callback

wrap_EngineCandidateClickedCallback :: EngineCandidateClickedCallback -> C_EngineCandidateClickedCallback

Wrap a EngineCandidateClickedCallback into a C_EngineCandidateClickedCallback.

cursorDown

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

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

type EngineCursorDownCallback = IO ()

Emitted when the down cursor button is pressed. Implement the member function IBusEngineClass[cursor_down](#g:signal:cursor_down) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEngineCursorDown :: (IsEngine a, MonadIO m) => a -> EngineCursorDownCallback -> m SignalHandlerId

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

after engine #cursorDown callback

genClosure_EngineCursorDown :: MonadIO m => EngineCursorDownCallback -> m (GClosure C_EngineCursorDownCallback)

Wrap the callback into a GClosure.

mk_EngineCursorDownCallback :: C_EngineCursorDownCallback -> IO (FunPtr C_EngineCursorDownCallback)

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

noEngineCursorDownCallback :: Maybe EngineCursorDownCallback

A convenience synonym for Nothing :: Maybe EngineCursorDownCallback.

onEngineCursorDown :: (IsEngine a, MonadIO m) => a -> EngineCursorDownCallback -> m SignalHandlerId

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

on engine #cursorDown callback

wrap_EngineCursorDownCallback :: EngineCursorDownCallback -> C_EngineCursorDownCallback

Wrap a EngineCursorDownCallback into a C_EngineCursorDownCallback.

cursorUp

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

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

type EngineCursorUpCallback = IO ()

Emitted when the up cursor button is pressed. Implement the member function IBusEngineClass[cursor_up](#g:signal:cursor_up) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEngineCursorUp :: (IsEngine a, MonadIO m) => a -> EngineCursorUpCallback -> m SignalHandlerId

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

after engine #cursorUp callback

genClosure_EngineCursorUp :: MonadIO m => EngineCursorUpCallback -> m (GClosure C_EngineCursorUpCallback)

Wrap the callback into a GClosure.

mk_EngineCursorUpCallback :: C_EngineCursorUpCallback -> IO (FunPtr C_EngineCursorUpCallback)

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

noEngineCursorUpCallback :: Maybe EngineCursorUpCallback

A convenience synonym for Nothing :: Maybe EngineCursorUpCallback.

onEngineCursorUp :: (IsEngine a, MonadIO m) => a -> EngineCursorUpCallback -> m SignalHandlerId

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

on engine #cursorUp callback

wrap_EngineCursorUpCallback :: EngineCursorUpCallback -> C_EngineCursorUpCallback

Wrap a EngineCursorUpCallback into a C_EngineCursorUpCallback.

disable

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

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

type EngineDisableCallback = IO ()

Emitted when the IME is disabled. Implement the member function IBusEngineClass[disable](#g:signal:disable) in extended class to receive this signal.

See also: busSetGlobalEngine. <note><para>Argument userData is ignored in this function.</para></note>

afterEngineDisable :: (IsEngine a, MonadIO m) => a -> EngineDisableCallback -> m SignalHandlerId

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

after engine #disable callback

genClosure_EngineDisable :: MonadIO m => EngineDisableCallback -> m (GClosure C_EngineDisableCallback)

Wrap the callback into a GClosure.

mk_EngineDisableCallback :: C_EngineDisableCallback -> IO (FunPtr C_EngineDisableCallback)

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

noEngineDisableCallback :: Maybe EngineDisableCallback

A convenience synonym for Nothing :: Maybe EngineDisableCallback.

onEngineDisable :: (IsEngine a, MonadIO m) => a -> EngineDisableCallback -> m SignalHandlerId

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

on engine #disable callback

wrap_EngineDisableCallback :: EngineDisableCallback -> C_EngineDisableCallback

Wrap a EngineDisableCallback into a C_EngineDisableCallback.

enable

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

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

type EngineEnableCallback = IO ()

Emitted when the IME is enabled. Implement the member function IBusEngineClass[enable](#g:signal:enable) in extended class to receive this signal.

See also: busSetGlobalEngine. <note><para>Argument userData is ignored in this function.</para></note>

afterEngineEnable :: (IsEngine a, MonadIO m) => a -> EngineEnableCallback -> m SignalHandlerId

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

after engine #enable callback

genClosure_EngineEnable :: MonadIO m => EngineEnableCallback -> m (GClosure C_EngineEnableCallback)

Wrap the callback into a GClosure.

mk_EngineEnableCallback :: C_EngineEnableCallback -> IO (FunPtr C_EngineEnableCallback)

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

noEngineEnableCallback :: Maybe EngineEnableCallback

A convenience synonym for Nothing :: Maybe EngineEnableCallback.

onEngineEnable :: (IsEngine a, MonadIO m) => a -> EngineEnableCallback -> m SignalHandlerId

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

on engine #enable callback

wrap_EngineEnableCallback :: EngineEnableCallback -> C_EngineEnableCallback

Wrap a EngineEnableCallback into a C_EngineEnableCallback.

focusIn

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

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

type EngineFocusInCallback = IO ()

Emitted when the client application get the focus. Implement the member function IBusEngineClass[focus_in](#g:signal:focus_in) in extended class to receive this signal.

See also: inputContextFocusIn <note><para>Argument userData is ignored in this function.</para></note>

afterEngineFocusIn :: (IsEngine a, MonadIO m) => a -> EngineFocusInCallback -> m SignalHandlerId

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

after engine #focusIn callback

genClosure_EngineFocusIn :: MonadIO m => EngineFocusInCallback -> m (GClosure C_EngineFocusInCallback)

Wrap the callback into a GClosure.

mk_EngineFocusInCallback :: C_EngineFocusInCallback -> IO (FunPtr C_EngineFocusInCallback)

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

noEngineFocusInCallback :: Maybe EngineFocusInCallback

A convenience synonym for Nothing :: Maybe EngineFocusInCallback.

onEngineFocusIn :: (IsEngine a, MonadIO m) => a -> EngineFocusInCallback -> m SignalHandlerId

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

on engine #focusIn callback

wrap_EngineFocusInCallback :: EngineFocusInCallback -> C_EngineFocusInCallback

Wrap a EngineFocusInCallback into a C_EngineFocusInCallback.

focusOut

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

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

type EngineFocusOutCallback = IO ()

Emitted when the client application lost the focus. Implement the member function IBusEngineClass[focus_out](#g:signal:focus_out) in extended class to receive this signal.

See also: inputContextFocusOut <note><para>Argument userData is ignored in this function.</para></note>

afterEngineFocusOut :: (IsEngine a, MonadIO m) => a -> EngineFocusOutCallback -> m SignalHandlerId

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

after engine #focusOut callback

genClosure_EngineFocusOut :: MonadIO m => EngineFocusOutCallback -> m (GClosure C_EngineFocusOutCallback)

Wrap the callback into a GClosure.

mk_EngineFocusOutCallback :: C_EngineFocusOutCallback -> IO (FunPtr C_EngineFocusOutCallback)

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

noEngineFocusOutCallback :: Maybe EngineFocusOutCallback

A convenience synonym for Nothing :: Maybe EngineFocusOutCallback.

onEngineFocusOut :: (IsEngine a, MonadIO m) => a -> EngineFocusOutCallback -> m SignalHandlerId

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

on engine #focusOut callback

wrap_EngineFocusOutCallback :: EngineFocusOutCallback -> C_EngineFocusOutCallback

Wrap a EngineFocusOutCallback into a C_EngineFocusOutCallback.

pageDown

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

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

type EnginePageDownCallback = IO ()

Emitted when the page-down button is pressed. Implement the member function IBusEngineClass[page_down](#g:signal:page_down) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEnginePageDown :: (IsEngine a, MonadIO m) => a -> EnginePageDownCallback -> m SignalHandlerId

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

after engine #pageDown callback

genClosure_EnginePageDown :: MonadIO m => EnginePageDownCallback -> m (GClosure C_EnginePageDownCallback)

Wrap the callback into a GClosure.

mk_EnginePageDownCallback :: C_EnginePageDownCallback -> IO (FunPtr C_EnginePageDownCallback)

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

noEnginePageDownCallback :: Maybe EnginePageDownCallback

A convenience synonym for Nothing :: Maybe EnginePageDownCallback.

onEnginePageDown :: (IsEngine a, MonadIO m) => a -> EnginePageDownCallback -> m SignalHandlerId

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

on engine #pageDown callback

wrap_EnginePageDownCallback :: EnginePageDownCallback -> C_EnginePageDownCallback

Wrap a EnginePageDownCallback into a C_EnginePageDownCallback.

pageUp

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

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

type EnginePageUpCallback = IO ()

Emitted when the page-up button is pressed. Implement the member function IBusEngineClass[page_up](#g:signal:page_up) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEnginePageUp :: (IsEngine a, MonadIO m) => a -> EnginePageUpCallback -> m SignalHandlerId

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

after engine #pageUp callback

genClosure_EnginePageUp :: MonadIO m => EnginePageUpCallback -> m (GClosure C_EnginePageUpCallback)

Wrap the callback into a GClosure.

mk_EnginePageUpCallback :: C_EnginePageUpCallback -> IO (FunPtr C_EnginePageUpCallback)

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

noEnginePageUpCallback :: Maybe EnginePageUpCallback

A convenience synonym for Nothing :: Maybe EnginePageUpCallback.

onEnginePageUp :: (IsEngine a, MonadIO m) => a -> EnginePageUpCallback -> m SignalHandlerId

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

on engine #pageUp callback

wrap_EnginePageUpCallback :: EnginePageUpCallback -> C_EnginePageUpCallback

Wrap a EnginePageUpCallback into a C_EnginePageUpCallback.

processHandWritingEvent

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

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

type EngineProcessHandWritingEventCallback

Arguments

 = Ptr ()

coordinates: An array of double (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.

-> IO ()

Emitted when a hand writing operation is cancelled. Implement the member function IBusEngineClass[cancel_hand_writing](#g:signal:cancel_hand_writing) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEngineProcessHandWritingEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId

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

after engine #processHandWritingEvent callback

genClosure_EngineProcessHandWritingEvent :: MonadIO m => EngineProcessHandWritingEventCallback -> m (GClosure C_EngineProcessHandWritingEventCallback)

Wrap the callback into a GClosure.

mk_EngineProcessHandWritingEventCallback :: C_EngineProcessHandWritingEventCallback -> IO (FunPtr C_EngineProcessHandWritingEventCallback)

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

noEngineProcessHandWritingEventCallback :: Maybe EngineProcessHandWritingEventCallback

A convenience synonym for Nothing :: Maybe EngineProcessHandWritingEventCallback.

onEngineProcessHandWritingEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId

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

on engine #processHandWritingEvent callback

wrap_EngineProcessHandWritingEventCallback :: EngineProcessHandWritingEventCallback -> C_EngineProcessHandWritingEventCallback

Wrap a EngineProcessHandWritingEventCallback into a C_EngineProcessHandWritingEventCallback.

processKeyEvent

type C_EngineProcessKeyEventCallback = Ptr () -> Word32 -> Word32 -> Word32 -> Ptr () -> IO CInt

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

type EngineProcessKeyEventCallback

Arguments

 = Word32

keyval: Key symbol of the key press.

-> Word32

keycode: KeyCode of the key press.

-> Word32

state: Key modifier flags.

-> IO Bool

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

<note><para>Argument userData is ignored in this function.</para></note>

Emitted when a key event is received. Implement the member function IBusEngineClass[process_key_event](#g:signal:process_key_event) in extended class to receive this signal. Both the key symbol and keycode are passed to the member function. See inputContextProcessKeyEvent for further explanation of key symbol, keycode and which to use.

afterEngineProcessKeyEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessKeyEventCallback -> m SignalHandlerId

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

after engine #processKeyEvent callback

genClosure_EngineProcessKeyEvent :: MonadIO m => EngineProcessKeyEventCallback -> m (GClosure C_EngineProcessKeyEventCallback)

Wrap the callback into a GClosure.

mk_EngineProcessKeyEventCallback :: C_EngineProcessKeyEventCallback -> IO (FunPtr C_EngineProcessKeyEventCallback)

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

noEngineProcessKeyEventCallback :: Maybe EngineProcessKeyEventCallback

A convenience synonym for Nothing :: Maybe EngineProcessKeyEventCallback.

onEngineProcessKeyEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessKeyEventCallback -> m SignalHandlerId

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

on engine #processKeyEvent callback

wrap_EngineProcessKeyEventCallback :: EngineProcessKeyEventCallback -> C_EngineProcessKeyEventCallback

Wrap a EngineProcessKeyEventCallback into a C_EngineProcessKeyEventCallback.

propertyActivate

type C_EnginePropertyActivateCallback = Ptr () -> CString -> Word32 -> Ptr () -> IO ()

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

type EnginePropertyActivateCallback

Arguments

 = Text

name: Property name.

-> Word32

state: Property state.

-> IO ()

Emitted when a property is activated or change changed. Implement the member function IBusEngineClass[property_activate](#g:signal:property_activate) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEnginePropertyActivate :: (IsEngine a, MonadIO m) => a -> EnginePropertyActivateCallback -> m SignalHandlerId

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

after engine #propertyActivate callback

genClosure_EnginePropertyActivate :: MonadIO m => EnginePropertyActivateCallback -> m (GClosure C_EnginePropertyActivateCallback)

Wrap the callback into a GClosure.

mk_EnginePropertyActivateCallback :: C_EnginePropertyActivateCallback -> IO (FunPtr C_EnginePropertyActivateCallback)

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

noEnginePropertyActivateCallback :: Maybe EnginePropertyActivateCallback

A convenience synonym for Nothing :: Maybe EnginePropertyActivateCallback.

onEnginePropertyActivate :: (IsEngine a, MonadIO m) => a -> EnginePropertyActivateCallback -> m SignalHandlerId

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

on engine #propertyActivate callback

wrap_EnginePropertyActivateCallback :: EnginePropertyActivateCallback -> C_EnginePropertyActivateCallback

Wrap a EnginePropertyActivateCallback into a C_EnginePropertyActivateCallback.

propertyHide

type C_EnginePropertyHideCallback = Ptr () -> CString -> Ptr () -> IO ()

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

type EnginePropertyHideCallback

Arguments

 = Text

name: Property name.

-> IO ()

Emitted when a property is hidden. Implement the member function IBusEngineClass[property_hide](#g:signal:property_hide) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEnginePropertyHide :: (IsEngine a, MonadIO m) => a -> EnginePropertyHideCallback -> m SignalHandlerId

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

after engine #propertyHide callback

genClosure_EnginePropertyHide :: MonadIO m => EnginePropertyHideCallback -> m (GClosure C_EnginePropertyHideCallback)

Wrap the callback into a GClosure.

mk_EnginePropertyHideCallback :: C_EnginePropertyHideCallback -> IO (FunPtr C_EnginePropertyHideCallback)

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

noEnginePropertyHideCallback :: Maybe EnginePropertyHideCallback

A convenience synonym for Nothing :: Maybe EnginePropertyHideCallback.

onEnginePropertyHide :: (IsEngine a, MonadIO m) => a -> EnginePropertyHideCallback -> m SignalHandlerId

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

on engine #propertyHide callback

wrap_EnginePropertyHideCallback :: EnginePropertyHideCallback -> C_EnginePropertyHideCallback

Wrap a EnginePropertyHideCallback into a C_EnginePropertyHideCallback.

propertyShow

type C_EnginePropertyShowCallback = Ptr () -> CString -> Ptr () -> IO ()

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

type EnginePropertyShowCallback

Arguments

 = Text

name: Property name.

-> IO ()

Emitted when a property is shown. Implement the member function IBusEngineClass[property_side](#g:signal:property_side) in extended class to receive this signal.

<note><para>Argument userData is ignored in this function.</para></note>

afterEnginePropertyShow :: (IsEngine a, MonadIO m) => a -> EnginePropertyShowCallback -> m SignalHandlerId

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

after engine #propertyShow callback

genClosure_EnginePropertyShow :: MonadIO m => EnginePropertyShowCallback -> m (GClosure C_EnginePropertyShowCallback)

Wrap the callback into a GClosure.

mk_EnginePropertyShowCallback :: C_EnginePropertyShowCallback -> IO (FunPtr C_EnginePropertyShowCallback)

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

noEnginePropertyShowCallback :: Maybe EnginePropertyShowCallback

A convenience synonym for Nothing :: Maybe EnginePropertyShowCallback.

onEnginePropertyShow :: (IsEngine a, MonadIO m) => a -> EnginePropertyShowCallback -> m SignalHandlerId

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

on engine #propertyShow callback

wrap_EnginePropertyShowCallback :: EnginePropertyShowCallback -> C_EnginePropertyShowCallback

Wrap a EnginePropertyShowCallback into a C_EnginePropertyShowCallback.

reset

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

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

type EngineResetCallback = IO ()

Emitted when the IME is reset. Implement the member function IBusEngineClass[reset](#g:signal:reset) in extended class to receive this signal.

See also: inputContextReset. <note><para>Argument userData is ignored in this function.</para></note>

afterEngineReset :: (IsEngine a, MonadIO m) => a -> EngineResetCallback -> m SignalHandlerId

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

after engine #reset callback

genClosure_EngineReset :: MonadIO m => EngineResetCallback -> m (GClosure C_EngineResetCallback)

Wrap the callback into a GClosure.

mk_EngineResetCallback :: C_EngineResetCallback -> IO (FunPtr C_EngineResetCallback)

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

noEngineResetCallback :: Maybe EngineResetCallback

A convenience synonym for Nothing :: Maybe EngineResetCallback.

onEngineReset :: (IsEngine a, MonadIO m) => a -> EngineResetCallback -> m SignalHandlerId

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

on engine #reset callback

wrap_EngineResetCallback :: EngineResetCallback -> C_EngineResetCallback

Wrap a EngineResetCallback into a C_EngineResetCallback.

setCapabilities

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

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

type EngineSetCapabilitiesCallback

Arguments

 = Word32

caps: Capabilities flags of IBusEngine, see Capabilite

-> IO ()

Emitted when the client application capabilities is set. Implement the member function IBusEngineClass[set_capabilities](#g:signal:set_capabilities) in extended class to receive this signal.

See also: inputContextSetCapabilities. <note><para>Argument userData is ignored in this function.</para></note>

afterEngineSetCapabilities :: (IsEngine a, MonadIO m) => a -> EngineSetCapabilitiesCallback -> m SignalHandlerId

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

after engine #setCapabilities callback

genClosure_EngineSetCapabilities :: MonadIO m => EngineSetCapabilitiesCallback -> m (GClosure C_EngineSetCapabilitiesCallback)

Wrap the callback into a GClosure.

mk_EngineSetCapabilitiesCallback :: C_EngineSetCapabilitiesCallback -> IO (FunPtr C_EngineSetCapabilitiesCallback)

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

noEngineSetCapabilitiesCallback :: Maybe EngineSetCapabilitiesCallback

A convenience synonym for Nothing :: Maybe EngineSetCapabilitiesCallback.

onEngineSetCapabilities :: (IsEngine a, MonadIO m) => a -> EngineSetCapabilitiesCallback -> m SignalHandlerId

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

on engine #setCapabilities callback

wrap_EngineSetCapabilitiesCallback :: EngineSetCapabilitiesCallback -> C_EngineSetCapabilitiesCallback

Wrap a EngineSetCapabilitiesCallback into a C_EngineSetCapabilitiesCallback.

setContentType

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

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

type EngineSetContentTypeCallback

Arguments

 = Word32

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

-> Word32

hints: Hints that augment purpose, as an InputHints.

-> IO ()

Emitted when the client application content-type (primary purpose and hints) is set. The engine could change the behavior according to the content-type. Implement the member function IBusEngineClass[set_content_type](#g:signal:set_content_type) in extended class to receive this signal.

For example, if the client application wants to restrict input to numbers, this signal will be emitted with purpose set to IBUS_INPUT_PURPOSE_NUMBER, so the engine can switch the input mode to latin.

<note><para>Argument userData is ignored in this function.</para></note>

afterEngineSetContentType :: (IsEngine a, MonadIO m) => a -> EngineSetContentTypeCallback -> m SignalHandlerId

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

after engine #setContentType callback

genClosure_EngineSetContentType :: MonadIO m => EngineSetContentTypeCallback -> m (GClosure C_EngineSetContentTypeCallback)

Wrap the callback into a GClosure.

mk_EngineSetContentTypeCallback :: C_EngineSetContentTypeCallback -> IO (FunPtr C_EngineSetContentTypeCallback)

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

noEngineSetContentTypeCallback :: Maybe EngineSetContentTypeCallback

A convenience synonym for Nothing :: Maybe EngineSetContentTypeCallback.

onEngineSetContentType :: (IsEngine a, MonadIO m) => a -> EngineSetContentTypeCallback -> m SignalHandlerId

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

on engine #setContentType callback

wrap_EngineSetContentTypeCallback :: EngineSetContentTypeCallback -> C_EngineSetContentTypeCallback

Wrap a EngineSetContentTypeCallback into a C_EngineSetContentTypeCallback.

setCursorLocation

type C_EngineSetCursorLocationCallback = Ptr () -> Int32 -> Int32 -> Int32 -> Int32 -> Ptr () -> IO ()

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

type EngineSetCursorLocationCallback

Arguments

 = 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.

-> IO ()

Emitted when the location of IME is set. Implement the member function IBusEngineClass[set_cursor_location](#g:signal:set_cursor_location) in extended class to receive this signal.

See also: inputContextSetCursorLocation. <note><para>Argument userData is ignored in this function.</para></note>

afterEngineSetCursorLocation :: (IsEngine a, MonadIO m) => a -> EngineSetCursorLocationCallback -> m SignalHandlerId

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

after engine #setCursorLocation callback

genClosure_EngineSetCursorLocation :: MonadIO m => EngineSetCursorLocationCallback -> m (GClosure C_EngineSetCursorLocationCallback)

Wrap the callback into a GClosure.

mk_EngineSetCursorLocationCallback :: C_EngineSetCursorLocationCallback -> IO (FunPtr C_EngineSetCursorLocationCallback)

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

noEngineSetCursorLocationCallback :: Maybe EngineSetCursorLocationCallback

A convenience synonym for Nothing :: Maybe EngineSetCursorLocationCallback.

onEngineSetCursorLocation :: (IsEngine a, MonadIO m) => a -> EngineSetCursorLocationCallback -> m SignalHandlerId

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

on engine #setCursorLocation callback

wrap_EngineSetCursorLocationCallback :: EngineSetCursorLocationCallback -> C_EngineSetCursorLocationCallback

Wrap a EngineSetCursorLocationCallback into a C_EngineSetCursorLocationCallback.

setSurroundingText

type C_EngineSetSurroundingTextCallback = Ptr () -> Ptr Object -> Word32 -> Word32 -> Ptr () -> IO ()

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

type EngineSetSurroundingTextCallback

Arguments

 = Object

text: The surrounding text.

-> Word32

cursorPos: The cursor position on surrounding text.

-> Word32

anchorPos: The anchor position on selection area.

-> IO ()

Emitted when a surrounding text is set. Implement the member function IBusEngineClass[set_surrounding_text](#g:signal:set_surrounding_text) in extended class to receive this signal. If anchor_pos equals to cursor_pos, it means "there are no selection" or "does not support selection retrival".

<note><para>Argument userData is ignored in this function.</para></note>

afterEngineSetSurroundingText :: (IsEngine a, MonadIO m) => a -> EngineSetSurroundingTextCallback -> m SignalHandlerId

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

after engine #setSurroundingText callback

genClosure_EngineSetSurroundingText :: MonadIO m => EngineSetSurroundingTextCallback -> m (GClosure C_EngineSetSurroundingTextCallback)

Wrap the callback into a GClosure.

mk_EngineSetSurroundingTextCallback :: C_EngineSetSurroundingTextCallback -> IO (FunPtr C_EngineSetSurroundingTextCallback)

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

noEngineSetSurroundingTextCallback :: Maybe EngineSetSurroundingTextCallback

A convenience synonym for Nothing :: Maybe EngineSetSurroundingTextCallback.

onEngineSetSurroundingText :: (IsEngine a, MonadIO m) => a -> EngineSetSurroundingTextCallback -> m SignalHandlerId

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

on engine #setSurroundingText callback

wrap_EngineSetSurroundingTextCallback :: EngineSetSurroundingTextCallback -> C_EngineSetSurroundingTextCallback

Wrap a EngineSetSurroundingTextCallback into a C_EngineSetSurroundingTextCallback.