gi-ibus-1.5.4: IBus bindings
CopyrightWill Thompson and Iñaki García Etxebarria
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria
Safe HaskellSafe-Inferred
LanguageHaskell2010

GI.IBus.Objects.Engine

Description

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

see_also: Component, EngineDesc

Synopsis

Exported types

newtype Engine Source #

Memory-managed wrapper type.

Constructors

Engine (ManagedPtr Engine) 

Instances

Instances details
Eq Engine Source # 
Instance details

Defined in GI.IBus.Objects.Engine

Methods

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

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

GObject Engine Source # 
Instance details

Defined in GI.IBus.Objects.Engine

ManagedPtrNewtype Engine Source # 
Instance details

Defined in GI.IBus.Objects.Engine

TypedObject Engine Source # 
Instance details

Defined in GI.IBus.Objects.Engine

Methods

glibType :: IO GType #

HasParentTypes Engine Source # 
Instance details

Defined in GI.IBus.Objects.Engine

IsGValue (Maybe Engine) Source #

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

Instance details

Defined in GI.IBus.Objects.Engine

type ParentTypes Engine Source # 
Instance details

Defined in GI.IBus.Objects.Engine

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

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

Instances

Instances details
(GObject o, IsDescendantOf Engine o) => IsEngine o Source # 
Instance details

Defined in GI.IBus.Objects.Engine

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

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

Methods

commitText

engineCommitText Source #

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 Source #

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 Source #

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 Source #

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 Source #

Arguments

:: (HasCallStack, MonadIO m, IsEngine a) 
=> a

engine: An IBusEngine.

-> m Text

Returns: Name of Engine.

Return the name of Engine.

getSurroundingText

engineGetSurroundingText Source #

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 Source #

Arguments

:: (HasCallStack, MonadIO m, IsEngine a) 
=> a

engine: An IBusEngine.

-> m () 

Hide the auxiliary bar.

hideLookupTable

engineHideLookupTable Source #

Arguments

:: (HasCallStack, MonadIO m, IsEngine a) 
=> a

engine: An IBusEngine.

-> m () 

Hide the lookup table.

hidePreeditText

engineHidePreeditText Source #

Arguments

:: (HasCallStack, MonadIO m, IsEngine a) 
=> a

engine: An IBusEngine.

-> m () 

Hide the pre-edit buffer.

new

engineNew Source #

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 Source #

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 Source #

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 Source #

Arguments

:: (HasCallStack, MonadIO m, IsEngine a) 
=> a

engine: An IBusEngine.

-> m () 

Show the auxiliary bar.

showLookupTable

engineShowLookupTable Source #

Arguments

:: (HasCallStack, MonadIO m, IsEngine a) 
=> a

engine: An IBusEngine.

-> m () 

Show the lookup table.

showPreeditText

engineShowPreeditText Source #

Arguments

:: (HasCallStack, MonadIO m, IsEngine a) 
=> a

engine: An IBusEngine.

-> m () 

Show the pre-edit buffer.

updateAuxiliaryText

engineUpdateAuxiliaryText Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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) Source #

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) Source #

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

get engine #engineName

Signals

cancelHandWriting

type EngineCancelHandWritingCallback Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 () Source #

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 Source #

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 Source #

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 () Source #

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 Source #

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 Source #

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 () Source #

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 Source #

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 Source #

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 () Source #

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 Source #

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 Source #

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 () Source #

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 Source #

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 Source #

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 () Source #

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 Source #

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 Source #

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 () Source #

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 Source #

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 Source #

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 () Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 () Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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 Source #

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