gi-ibus-1.5.2: IBus bindings
CopyrightWill Thompson Iñaki García Etxebarria and Jonas Platte
LicenseLGPL-2.1
MaintainerIñaki García Etxebarria
Safe HaskellNone
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

Methods

toManagedPtr :: Engine -> ManagedPtr Engine

TypedObject Engine Source # 
Instance details

Defined in GI.IBus.Objects.Engine

Methods

glibType :: IO GType

IsGValue Engine Source #

Convert Engine to and from GValue with toGValue and fromGValue.

Instance details

Defined in GI.IBus.Objects.Engine

Methods

toGValue :: Engine -> IO GValue

fromGValue :: GValue -> IO Engine

HasParentTypes Engine Source # 
Instance details

Defined in GI.IBus.Objects.Engine

type ParentTypes Engine Source # 
Instance details

Defined in GI.IBus.Objects.Engine

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

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

Overloaded 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 C_EngineCancelHandWritingCallback = Ptr () -> Word32 -> Ptr () -> IO () Source #

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

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

onEngineCancelHandWriting :: (IsEngine a, MonadIO m) => 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 C_EngineCandidateClickedCallback = Ptr () -> Word32 -> Word32 -> Word32 -> Ptr () -> IO () Source #

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

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

onEngineCandidateClicked :: (IsEngine a, MonadIO m) => 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 C_EngineCursorDownCallback = Ptr () -> Ptr () -> IO () Source #

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

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

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

Wrap the callback into a GClosure.

mk_EngineCursorDownCallback :: C_EngineCursorDownCallback -> IO (FunPtr C_EngineCursorDownCallback) Source #

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

noEngineCursorDownCallback :: Maybe EngineCursorDownCallback Source #

A convenience synonym for Nothing :: Maybe EngineCursorDownCallback.

onEngineCursorDown :: (IsEngine a, MonadIO m) => 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 C_EngineCursorUpCallback = Ptr () -> Ptr () -> IO () Source #

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

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

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

Wrap the callback into a GClosure.

mk_EngineCursorUpCallback :: C_EngineCursorUpCallback -> IO (FunPtr C_EngineCursorUpCallback) Source #

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

noEngineCursorUpCallback :: Maybe EngineCursorUpCallback Source #

A convenience synonym for Nothing :: Maybe EngineCursorUpCallback.

onEngineCursorUp :: (IsEngine a, MonadIO m) => 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 C_EngineDisableCallback = Ptr () -> Ptr () -> IO () Source #

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

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

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

Wrap the callback into a GClosure.

mk_EngineDisableCallback :: C_EngineDisableCallback -> IO (FunPtr C_EngineDisableCallback) Source #

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

noEngineDisableCallback :: Maybe EngineDisableCallback Source #

A convenience synonym for Nothing :: Maybe EngineDisableCallback.

onEngineDisable :: (IsEngine a, MonadIO m) => 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 C_EngineEnableCallback = Ptr () -> Ptr () -> IO () Source #

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

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

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

Wrap the callback into a GClosure.

mk_EngineEnableCallback :: C_EngineEnableCallback -> IO (FunPtr C_EngineEnableCallback) Source #

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

noEngineEnableCallback :: Maybe EngineEnableCallback Source #

A convenience synonym for Nothing :: Maybe EngineEnableCallback.

onEngineEnable :: (IsEngine a, MonadIO m) => 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 C_EngineFocusInCallback = Ptr () -> Ptr () -> IO () Source #

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

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

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

Wrap the callback into a GClosure.

mk_EngineFocusInCallback :: C_EngineFocusInCallback -> IO (FunPtr C_EngineFocusInCallback) Source #

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

noEngineFocusInCallback :: Maybe EngineFocusInCallback Source #

A convenience synonym for Nothing :: Maybe EngineFocusInCallback.

onEngineFocusIn :: (IsEngine a, MonadIO m) => 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 C_EngineFocusOutCallback = Ptr () -> Ptr () -> IO () Source #

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

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

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

Wrap the callback into a GClosure.

mk_EngineFocusOutCallback :: C_EngineFocusOutCallback -> IO (FunPtr C_EngineFocusOutCallback) Source #

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

noEngineFocusOutCallback :: Maybe EngineFocusOutCallback Source #

A convenience synonym for Nothing :: Maybe EngineFocusOutCallback.

onEngineFocusOut :: (IsEngine a, MonadIO m) => 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 C_EnginePageDownCallback = Ptr () -> Ptr () -> IO () Source #

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

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

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

Wrap the callback into a GClosure.

mk_EnginePageDownCallback :: C_EnginePageDownCallback -> IO (FunPtr C_EnginePageDownCallback) Source #

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

noEnginePageDownCallback :: Maybe EnginePageDownCallback Source #

A convenience synonym for Nothing :: Maybe EnginePageDownCallback.

onEnginePageDown :: (IsEngine a, MonadIO m) => 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 C_EnginePageUpCallback = Ptr () -> Ptr () -> IO () Source #

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

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

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

Wrap the callback into a GClosure.

mk_EnginePageUpCallback :: C_EnginePageUpCallback -> IO (FunPtr C_EnginePageUpCallback) Source #

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

noEnginePageUpCallback :: Maybe EnginePageUpCallback Source #

A convenience synonym for Nothing :: Maybe EnginePageUpCallback.

onEnginePageUp :: (IsEngine a, MonadIO m) => 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 C_EngineProcessHandWritingEventCallback = Ptr () -> Ptr () -> Word32 -> Ptr () -> IO () Source #

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

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

onEngineProcessHandWritingEvent :: (IsEngine a, MonadIO m) => 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 C_EngineProcessKeyEventCallback = Ptr () -> Word32 -> Word32 -> Word32 -> Ptr () -> IO CInt Source #

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

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

onEngineProcessKeyEvent :: (IsEngine a, MonadIO m) => 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 C_EnginePropertyActivateCallback = Ptr () -> CString -> Word32 -> Ptr () -> IO () Source #

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

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

onEnginePropertyActivate :: (IsEngine a, MonadIO m) => 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 C_EnginePropertyHideCallback = Ptr () -> CString -> Ptr () -> IO () Source #

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

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

mk_EnginePropertyHideCallback :: C_EnginePropertyHideCallback -> IO (FunPtr C_EnginePropertyHideCallback) Source #

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

onEnginePropertyHide :: (IsEngine a, MonadIO m) => 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 C_EnginePropertyShowCallback = Ptr () -> CString -> Ptr () -> IO () Source #

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

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

mk_EnginePropertyShowCallback :: C_EnginePropertyShowCallback -> IO (FunPtr C_EnginePropertyShowCallback) Source #

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

onEnginePropertyShow :: (IsEngine a, MonadIO m) => 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 C_EngineResetCallback = Ptr () -> Ptr () -> IO () Source #

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

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

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

Wrap the callback into a GClosure.

mk_EngineResetCallback :: C_EngineResetCallback -> IO (FunPtr C_EngineResetCallback) Source #

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

noEngineResetCallback :: Maybe EngineResetCallback Source #

A convenience synonym for Nothing :: Maybe EngineResetCallback.

onEngineReset :: (IsEngine a, MonadIO m) => 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 C_EngineSetCapabilitiesCallback = Ptr () -> Word32 -> Ptr () -> IO () Source #

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

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

onEngineSetCapabilities :: (IsEngine a, MonadIO m) => 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 C_EngineSetContentTypeCallback = Ptr () -> Word32 -> Word32 -> Ptr () -> IO () Source #

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

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

onEngineSetContentType :: (IsEngine a, MonadIO m) => 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 C_EngineSetCursorLocationCallback = Ptr () -> Int32 -> Int32 -> Int32 -> Int32 -> Ptr () -> IO () Source #

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

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

onEngineSetCursorLocation :: (IsEngine a, MonadIO m) => 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 C_EngineSetSurroundingTextCallback = Ptr () -> Ptr Object -> Word32 -> Word32 -> Ptr () -> IO () Source #

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

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

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