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

HasParentTypes Engine

Defined in GI.IBus.Objects.Engine

IsGValue (Maybe Engine)

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

Defined in GI.IBus.Objects.Engine

Methods

gvalueGType_ :: IO GType

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

gvalueGet_ :: Ptr GValue -> IO (Maybe 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

Click to display all available methods, including inherited ones

Methods

bindProperty, bindPropertyFull, commitText, deleteSurroundingText, destroy, emitSignal, forceFloating, forwardKeyEvent, freezeNotify, getv, hideAuxiliaryText, hideLookupTable, hidePreeditText, isFloating, notify, notifyByPspec, ref, refSink, register, registerProperties, runDispose, showAuxiliaryText, showLookupTable, showPreeditText, stealData, stealQdata, thawNotify, unref, unregister, updateAuxiliaryText, updateLookupTable, updateLookupTableFast, updatePreeditText, updatePreeditTextWithMode, updateProperty, watchClosure.

Getters

getConnection, getContentType, getData, getName, getObjectPath, getProperty, getQdata, getSurroundingText.

Setters

setData, setDataFull, setProperty.

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 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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineCancelHandWriting :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

candidateClicked

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineCandidateClicked :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

cursorDown

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineCursorDown :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

cursorUp

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineCursorUp :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

disable

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineDisable :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

enable

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineEnable :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

focusIn

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineFocusIn :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

focusOut

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineFocusOut :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

pageDown

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEnginePageDown :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

pageUp

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEnginePageUp :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

processHandWritingEvent

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineProcessHandWritingEvent :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

processKeyEvent

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineProcessKeyEvent :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

propertyActivate

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEnginePropertyActivate :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

propertyHide

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEnginePropertyHide :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

propertyShow

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEnginePropertyShow :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

reset

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineReset :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

setCapabilities

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineSetCapabilities :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

setContentType

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineSetContentType :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

setCursorLocation

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineSetCursorLocation :: (IsEngine a, MonadIO m) => a -> ((?self :: 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

setSurroundingText

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 -> ((?self :: 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

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

onEngineSetSurroundingText :: (IsEngine a, MonadIO m) => a -> ((?self :: 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