GI.IBus.Objects.PanelService

An IBusPanelService is a base class for UI services. Developers can "extend" this class for panel UI development.

Exported types

newtype PanelService

Memory-managed wrapper type.

Constructors

PanelService (ManagedPtr PanelService)

Instances

Eq PanelService

Defined in GI.IBus.Objects.PanelService

Methods

(==) :: PanelService -> PanelService -> Bool

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

GObject PanelService

Defined in GI.IBus.Objects.PanelService

ManagedPtrNewtype PanelService

Defined in GI.IBus.Objects.PanelService

Methods

toManagedPtr :: PanelService -> ManagedPtr PanelService

TypedObject PanelService

Defined in GI.IBus.Objects.PanelService

Methods

glibType :: IO GType

HasParentTypes PanelService

Defined in GI.IBus.Objects.PanelService

IsGValue (Maybe PanelService)

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

Defined in GI.IBus.Objects.PanelService

Methods

gvalueGType_ :: IO GType

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

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

type ParentTypes PanelService

Defined in GI.IBus.Objects.PanelService

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

class (GObject o, IsDescendantOf PanelService o) => IsPanelService o

Type class for types which can be safely cast to PanelService, for instance with toPanelService.

Instances

(GObject o, IsDescendantOf PanelService o) => IsPanelService o

Defined in GI.IBus.Objects.PanelService

toPanelService :: (MonadIO m, IsPanelService o) => o -> m PanelService

Cast to PanelService, 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, candidateClicked, commitText, cursorDown, cursorUp, destroy, emitSignal, forceFloating, freezeNotify, getv, hidePreeditTextReceived, isFloating, notify, notifyByPspec, pageDown, pageUp, panelExtension, propertyActivate, propertyHide, propertyShow, ref, refSink, register, runDispose, showPreeditTextReceived, stealData, stealQdata, thawNotify, unref, unregister, updateAuxiliaryTextReceived, updateLookupTableReceived, updatePreeditTextReceived, watchClosure.

Getters

getConnection, getData, getObjectPath, getProperty, getQdata.

Setters

setData, setDataFull, setProperty.

candidateClicked

panelServiceCandidateClicked

Arguments

:: (HasCallStack, MonadIO m, IsPanelService a)

=> a

panel: An IBusPanelService

-> Word32

index: Index in the Lookup table

-> Word32

button: GdkEventButton[button](#g:signal:button) (1: left button, etc.)

-> Word32

state: GdkEventButton[state](#g:signal:state) (key modifier flags)

-> m ()

Notify that a candidate is clicked by sending a "CandidateClicked" to IBus service.

commitText

panelServiceCommitText

Arguments

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

=> a

panel: An PanelService

-> b

text: An Text

-> m ()

Notify that a text is sent by sending a "CommitText" message to IBus service.

cursorDown

panelServiceCursorDown

Arguments

:: (HasCallStack, MonadIO m, IsPanelService a)

=> a

panel: An IBusPanelService

-> m ()

Notify that the cursor is down by sending a "CursorDown" to IBus service.

cursorUp

panelServiceCursorUp

Arguments

:: (HasCallStack, MonadIO m, IsPanelService a)

=> a

panel: An IBusPanelService

-> m ()

Notify that the cursor is up by sending a "CursorUp" to IBus service.

new

panelServiceNew

Arguments

:: (HasCallStack, MonadIO m, IsDBusConnection a)

=> a

connection: An GDBusConnection.

-> m PanelService

Returns: A newly allocated PanelService.

Creates a new PanelService from an DBusConnection.

pageDown

panelServicePageDown

Arguments

:: (HasCallStack, MonadIO m, IsPanelService a)

=> a

panel: An IBusPanelService

-> m ()

Notify that the page is down by sending a "PageDown" to IBus service.

pageUp

panelServicePageUp

Arguments

:: (HasCallStack, MonadIO m, IsPanelService a)

=> a

panel: An IBusPanelService

-> m ()

Notify that the page is up by sending a "PageUp" to IBus service.

panelExtension

panelServicePanelExtension

Arguments

:: (HasCallStack, MonadIO m, IsPanelService a, IsExtensionEvent b)

=> a

panel: An PanelService

-> b

event: A PanelExtensionEvent which is sent to a panel extension.

-> m ()

Enable or disable a panel extension with ExtensionEvent. Notify that a data is sent by sending a "PanelExtension" message to IBus panel extension service.

propertyActivate

panelServicePropertyActivate

Arguments

:: (HasCallStack, MonadIO m, IsPanelService a)

=> a

panel: An IBusPanelService

-> Text

propName: A property name

-> Word32

propState: State of the property

-> m ()

Notify that a property is active by sending a "PropertyActivate" message to IBus service.

propertyHide

panelServicePropertyHide

Arguments

:: (HasCallStack, MonadIO m, IsPanelService a)

=> a

panel: An IBusPanelService

-> Text

propName: A property name

-> m ()

Notify that a property is hidden by sending a "ValueChanged" message to IBus service.

propertyShow

panelServicePropertyShow

Arguments

:: (HasCallStack, MonadIO m, IsPanelService a)

=> a

panel: An IBusPanelService

-> Text

propName: A property name

-> m ()

Notify that a property is shown by sending a "ValueChanged" message to IBus service.

updateAuxiliaryTextReceived

panelServiceUpdateAuxiliaryTextReceived

Arguments

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

=> a

panel: An PanelService

-> b

text: An Text

-> Bool

visible: Whether the auxilirary text is visible.

-> m ()

Notify that the auxilirary is updated by the panel extension.

(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.)

updateLookupTableReceived

panelServiceUpdateLookupTableReceived

Arguments

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

=> a

panel: An PanelService

-> b

table: An LookupTable

-> Bool

visible: Whether the lookup table is visible.

-> m ()

Notify that the lookup table is updated by the panel extension.

(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.)

updatePreeditTextReceived

panelServiceUpdatePreeditTextReceived

Arguments

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

=> a

panel: An PanelService

-> b

text: Update content.

-> Word32

cursorPos: Current position of cursor

-> Bool

visible: Whether the pre-edit buffer is visible.

-> m ()

Notify that the preedit is updated by the panel extension

(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.)

Signals

candidateClickedLookupTable

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

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

type PanelServiceCandidateClickedLookupTableCallback = Word32 -> Word32 -> Word32 -> IO ()

No description available in the introspection data.

afterPanelServiceCandidateClickedLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceCandidateClickedLookupTableCallback -> m SignalHandlerId

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

after panelService #candidateClickedLookupTable callback

genClosure_PanelServiceCandidateClickedLookupTable :: MonadIO m => PanelServiceCandidateClickedLookupTableCallback -> m (GClosure C_PanelServiceCandidateClickedLookupTableCallback)

Wrap the callback into a GClosure.

mk_PanelServiceCandidateClickedLookupTableCallback :: C_PanelServiceCandidateClickedLookupTableCallback -> IO (FunPtr C_PanelServiceCandidateClickedLookupTableCallback)

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

noPanelServiceCandidateClickedLookupTableCallback :: Maybe PanelServiceCandidateClickedLookupTableCallback

A convenience synonym for Nothing :: Maybe PanelServiceCandidateClickedLookupTableCallback.

onPanelServiceCandidateClickedLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceCandidateClickedLookupTableCallback -> m SignalHandlerId

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

on panelService #candidateClickedLookupTable callback

wrap_PanelServiceCandidateClickedLookupTableCallback :: PanelServiceCandidateClickedLookupTableCallback -> C_PanelServiceCandidateClickedLookupTableCallback

Wrap a PanelServiceCandidateClickedLookupTableCallback into a C_PanelServiceCandidateClickedLookupTableCallback.

commitTextReceived

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

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

type PanelServiceCommitTextReceivedCallback

Arguments

 = Text

text: A Text

-> IO ()

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

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

afterPanelServiceCommitTextReceived :: (IsPanelService a, MonadIO m) => a -> PanelServiceCommitTextReceivedCallback -> m SignalHandlerId

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

after panelService #commitTextReceived callback

genClosure_PanelServiceCommitTextReceived :: MonadIO m => PanelServiceCommitTextReceivedCallback -> m (GClosure C_PanelServiceCommitTextReceivedCallback)

Wrap the callback into a GClosure.

mk_PanelServiceCommitTextReceivedCallback :: C_PanelServiceCommitTextReceivedCallback -> IO (FunPtr C_PanelServiceCommitTextReceivedCallback)

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

noPanelServiceCommitTextReceivedCallback :: Maybe PanelServiceCommitTextReceivedCallback

A convenience synonym for Nothing :: Maybe PanelServiceCommitTextReceivedCallback.

onPanelServiceCommitTextReceived :: (IsPanelService a, MonadIO m) => a -> PanelServiceCommitTextReceivedCallback -> m SignalHandlerId

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

on panelService #commitTextReceived callback

wrap_PanelServiceCommitTextReceivedCallback :: PanelServiceCommitTextReceivedCallback -> C_PanelServiceCommitTextReceivedCallback

Wrap a PanelServiceCommitTextReceivedCallback into a C_PanelServiceCommitTextReceivedCallback.

cursorDownLookupTable

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

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

type PanelServiceCursorDownLookupTableCallback = IO ()

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

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

afterPanelServiceCursorDownLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceCursorDownLookupTableCallback -> m SignalHandlerId

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

after panelService #cursorDownLookupTable callback

genClosure_PanelServiceCursorDownLookupTable :: MonadIO m => PanelServiceCursorDownLookupTableCallback -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)

Wrap the callback into a GClosure.

mk_PanelServiceCursorDownLookupTableCallback :: C_PanelServiceCursorDownLookupTableCallback -> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)

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

noPanelServiceCursorDownLookupTableCallback :: Maybe PanelServiceCursorDownLookupTableCallback

A convenience synonym for Nothing :: Maybe PanelServiceCursorDownLookupTableCallback.

onPanelServiceCursorDownLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceCursorDownLookupTableCallback -> m SignalHandlerId

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

on panelService #cursorDownLookupTable callback

wrap_PanelServiceCursorDownLookupTableCallback :: PanelServiceCursorDownLookupTableCallback -> C_PanelServiceCursorDownLookupTableCallback

Wrap a PanelServiceCursorDownLookupTableCallback into a C_PanelServiceCursorDownLookupTableCallback.

cursorUpLookupTable

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

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

type PanelServiceCursorUpLookupTableCallback = IO ()

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

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

afterPanelServiceCursorUpLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceCursorUpLookupTableCallback -> m SignalHandlerId

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

after panelService #cursorUpLookupTable callback

genClosure_PanelServiceCursorUpLookupTable :: MonadIO m => PanelServiceCursorUpLookupTableCallback -> m (GClosure C_PanelServiceCursorUpLookupTableCallback)

Wrap the callback into a GClosure.

mk_PanelServiceCursorUpLookupTableCallback :: C_PanelServiceCursorUpLookupTableCallback -> IO (FunPtr C_PanelServiceCursorUpLookupTableCallback)

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

noPanelServiceCursorUpLookupTableCallback :: Maybe PanelServiceCursorUpLookupTableCallback

A convenience synonym for Nothing :: Maybe PanelServiceCursorUpLookupTableCallback.

onPanelServiceCursorUpLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceCursorUpLookupTableCallback -> m SignalHandlerId

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

on panelService #cursorUpLookupTable callback

wrap_PanelServiceCursorUpLookupTableCallback :: PanelServiceCursorUpLookupTableCallback -> C_PanelServiceCursorUpLookupTableCallback

Wrap a PanelServiceCursorUpLookupTableCallback into a C_PanelServiceCursorUpLookupTableCallback.

destroyContext

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

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

type PanelServiceDestroyContextCallback

Arguments

 = Text

inputContextPath: Object path of InputContext.

-> IO ()

Emitted when the client application destroys. Implement the member function IBusPanelServiceClass[destroy_context](#g:signal:destroy_context) in extended class to receive this signal.

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

afterPanelServiceDestroyContext :: (IsPanelService a, MonadIO m) => a -> PanelServiceDestroyContextCallback -> m SignalHandlerId

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

after panelService #destroyContext callback

genClosure_PanelServiceDestroyContext :: MonadIO m => PanelServiceDestroyContextCallback -> m (GClosure C_PanelServiceDestroyContextCallback)

Wrap the callback into a GClosure.

mk_PanelServiceDestroyContextCallback :: C_PanelServiceDestroyContextCallback -> IO (FunPtr C_PanelServiceDestroyContextCallback)

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

noPanelServiceDestroyContextCallback :: Maybe PanelServiceDestroyContextCallback

A convenience synonym for Nothing :: Maybe PanelServiceDestroyContextCallback.

onPanelServiceDestroyContext :: (IsPanelService a, MonadIO m) => a -> PanelServiceDestroyContextCallback -> m SignalHandlerId

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

on panelService #destroyContext callback

wrap_PanelServiceDestroyContextCallback :: PanelServiceDestroyContextCallback -> C_PanelServiceDestroyContextCallback

Wrap a PanelServiceDestroyContextCallback into a C_PanelServiceDestroyContextCallback.

focusIn

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

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

type PanelServiceFocusInCallback

Arguments

 = Text

inputContextPath: Object path of InputContext.

-> IO ()

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

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

afterPanelServiceFocusIn :: (IsPanelService a, MonadIO m) => a -> PanelServiceFocusInCallback -> 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 panelService #focusIn callback

genClosure_PanelServiceFocusIn :: MonadIO m => PanelServiceFocusInCallback -> m (GClosure C_PanelServiceFocusInCallback)

Wrap the callback into a GClosure.

mk_PanelServiceFocusInCallback :: C_PanelServiceFocusInCallback -> IO (FunPtr C_PanelServiceFocusInCallback)

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

noPanelServiceFocusInCallback :: Maybe PanelServiceFocusInCallback

A convenience synonym for Nothing :: Maybe PanelServiceFocusInCallback.

onPanelServiceFocusIn :: (IsPanelService a, MonadIO m) => a -> PanelServiceFocusInCallback -> 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 panelService #focusIn callback

wrap_PanelServiceFocusInCallback :: PanelServiceFocusInCallback -> C_PanelServiceFocusInCallback

Wrap a PanelServiceFocusInCallback into a C_PanelServiceFocusInCallback.

focusOut

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

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

type PanelServiceFocusOutCallback

Arguments

 = Text

inputContextPath: Object path of InputContext.

-> IO ()

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

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

afterPanelServiceFocusOut :: (IsPanelService a, MonadIO m) => a -> PanelServiceFocusOutCallback -> 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 panelService #focusOut callback

genClosure_PanelServiceFocusOut :: MonadIO m => PanelServiceFocusOutCallback -> m (GClosure C_PanelServiceFocusOutCallback)

Wrap the callback into a GClosure.

mk_PanelServiceFocusOutCallback :: C_PanelServiceFocusOutCallback -> IO (FunPtr C_PanelServiceFocusOutCallback)

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

noPanelServiceFocusOutCallback :: Maybe PanelServiceFocusOutCallback

A convenience synonym for Nothing :: Maybe PanelServiceFocusOutCallback.

onPanelServiceFocusOut :: (IsPanelService a, MonadIO m) => a -> PanelServiceFocusOutCallback -> 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 panelService #focusOut callback

wrap_PanelServiceFocusOutCallback :: PanelServiceFocusOutCallback -> C_PanelServiceFocusOutCallback

Wrap a PanelServiceFocusOutCallback into a C_PanelServiceFocusOutCallback.

hideAuxiliaryText

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

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

type PanelServiceHideAuxiliaryTextCallback = IO ()

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

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

afterPanelServiceHideAuxiliaryText :: (IsPanelService a, MonadIO m) => a -> PanelServiceHideAuxiliaryTextCallback -> m SignalHandlerId

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

after panelService #hideAuxiliaryText callback

genClosure_PanelServiceHideAuxiliaryText :: MonadIO m => PanelServiceHideAuxiliaryTextCallback -> m (GClosure C_PanelServiceHideAuxiliaryTextCallback)

Wrap the callback into a GClosure.

mk_PanelServiceHideAuxiliaryTextCallback :: C_PanelServiceHideAuxiliaryTextCallback -> IO (FunPtr C_PanelServiceHideAuxiliaryTextCallback)

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

noPanelServiceHideAuxiliaryTextCallback :: Maybe PanelServiceHideAuxiliaryTextCallback

A convenience synonym for Nothing :: Maybe PanelServiceHideAuxiliaryTextCallback.

onPanelServiceHideAuxiliaryText :: (IsPanelService a, MonadIO m) => a -> PanelServiceHideAuxiliaryTextCallback -> m SignalHandlerId

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

on panelService #hideAuxiliaryText callback

wrap_PanelServiceHideAuxiliaryTextCallback :: PanelServiceHideAuxiliaryTextCallback -> C_PanelServiceHideAuxiliaryTextCallback

Wrap a PanelServiceHideAuxiliaryTextCallback into a C_PanelServiceHideAuxiliaryTextCallback.

hideLanguageBar

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

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

type PanelServiceHideLanguageBarCallback = IO ()

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

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

afterPanelServiceHideLanguageBar :: (IsPanelService a, MonadIO m) => a -> PanelServiceHideLanguageBarCallback -> m SignalHandlerId

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

after panelService #hideLanguageBar callback

genClosure_PanelServiceHideLanguageBar :: MonadIO m => PanelServiceHideLanguageBarCallback -> m (GClosure C_PanelServiceHideLanguageBarCallback)

Wrap the callback into a GClosure.

mk_PanelServiceHideLanguageBarCallback :: C_PanelServiceHideLanguageBarCallback -> IO (FunPtr C_PanelServiceHideLanguageBarCallback)

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

noPanelServiceHideLanguageBarCallback :: Maybe PanelServiceHideLanguageBarCallback

A convenience synonym for Nothing :: Maybe PanelServiceHideLanguageBarCallback.

onPanelServiceHideLanguageBar :: (IsPanelService a, MonadIO m) => a -> PanelServiceHideLanguageBarCallback -> m SignalHandlerId

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

on panelService #hideLanguageBar callback

wrap_PanelServiceHideLanguageBarCallback :: PanelServiceHideLanguageBarCallback -> C_PanelServiceHideLanguageBarCallback

Wrap a PanelServiceHideLanguageBarCallback into a C_PanelServiceHideLanguageBarCallback.

hideLookupTable

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

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

type PanelServiceHideLookupTableCallback = IO ()

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

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

afterPanelServiceHideLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceHideLookupTableCallback -> m SignalHandlerId

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

after panelService #hideLookupTable callback

genClosure_PanelServiceHideLookupTable :: MonadIO m => PanelServiceHideLookupTableCallback -> m (GClosure C_PanelServiceHideLookupTableCallback)

Wrap the callback into a GClosure.

mk_PanelServiceHideLookupTableCallback :: C_PanelServiceHideLookupTableCallback -> IO (FunPtr C_PanelServiceHideLookupTableCallback)

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

noPanelServiceHideLookupTableCallback :: Maybe PanelServiceHideLookupTableCallback

A convenience synonym for Nothing :: Maybe PanelServiceHideLookupTableCallback.

onPanelServiceHideLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceHideLookupTableCallback -> m SignalHandlerId

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

on panelService #hideLookupTable callback

wrap_PanelServiceHideLookupTableCallback :: PanelServiceHideLookupTableCallback -> C_PanelServiceHideLookupTableCallback

Wrap a PanelServiceHideLookupTableCallback into a C_PanelServiceHideLookupTableCallback.

hidePreeditText

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

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

type PanelServiceHidePreeditTextCallback = IO ()

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

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

afterPanelServiceHidePreeditText :: (IsPanelService a, MonadIO m) => a -> PanelServiceHidePreeditTextCallback -> m SignalHandlerId

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

after panelService #hidePreeditText callback

genClosure_PanelServiceHidePreeditText :: MonadIO m => PanelServiceHidePreeditTextCallback -> m (GClosure C_PanelServiceHidePreeditTextCallback)

Wrap the callback into a GClosure.

mk_PanelServiceHidePreeditTextCallback :: C_PanelServiceHidePreeditTextCallback -> IO (FunPtr C_PanelServiceHidePreeditTextCallback)

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

noPanelServiceHidePreeditTextCallback :: Maybe PanelServiceHidePreeditTextCallback

A convenience synonym for Nothing :: Maybe PanelServiceHidePreeditTextCallback.

onPanelServiceHidePreeditText :: (IsPanelService a, MonadIO m) => a -> PanelServiceHidePreeditTextCallback -> m SignalHandlerId

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

on panelService #hidePreeditText callback

wrap_PanelServiceHidePreeditTextCallback :: PanelServiceHidePreeditTextCallback -> C_PanelServiceHidePreeditTextCallback

Wrap a PanelServiceHidePreeditTextCallback into a C_PanelServiceHidePreeditTextCallback.

pageDownLookupTable

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

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

type PanelServicePageDownLookupTableCallback = IO ()

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

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

afterPanelServicePageDownLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServicePageDownLookupTableCallback -> m SignalHandlerId

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

after panelService #pageDownLookupTable callback

genClosure_PanelServicePageDownLookupTable :: MonadIO m => PanelServicePageDownLookupTableCallback -> m (GClosure C_PanelServicePageDownLookupTableCallback)

Wrap the callback into a GClosure.

mk_PanelServicePageDownLookupTableCallback :: C_PanelServicePageDownLookupTableCallback -> IO (FunPtr C_PanelServicePageDownLookupTableCallback)

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

noPanelServicePageDownLookupTableCallback :: Maybe PanelServicePageDownLookupTableCallback

A convenience synonym for Nothing :: Maybe PanelServicePageDownLookupTableCallback.

onPanelServicePageDownLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServicePageDownLookupTableCallback -> m SignalHandlerId

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

on panelService #pageDownLookupTable callback

wrap_PanelServicePageDownLookupTableCallback :: PanelServicePageDownLookupTableCallback -> C_PanelServicePageDownLookupTableCallback

Wrap a PanelServicePageDownLookupTableCallback into a C_PanelServicePageDownLookupTableCallback.

pageUpLookupTable

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

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

type PanelServicePageUpLookupTableCallback = IO ()

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

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

afterPanelServicePageUpLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServicePageUpLookupTableCallback -> m SignalHandlerId

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

after panelService #pageUpLookupTable callback

genClosure_PanelServicePageUpLookupTable :: MonadIO m => PanelServicePageUpLookupTableCallback -> m (GClosure C_PanelServicePageUpLookupTableCallback)

Wrap the callback into a GClosure.

mk_PanelServicePageUpLookupTableCallback :: C_PanelServicePageUpLookupTableCallback -> IO (FunPtr C_PanelServicePageUpLookupTableCallback)

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

noPanelServicePageUpLookupTableCallback :: Maybe PanelServicePageUpLookupTableCallback

A convenience synonym for Nothing :: Maybe PanelServicePageUpLookupTableCallback.

onPanelServicePageUpLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServicePageUpLookupTableCallback -> m SignalHandlerId

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

on panelService #pageUpLookupTable callback

wrap_PanelServicePageUpLookupTableCallback :: PanelServicePageUpLookupTableCallback -> C_PanelServicePageUpLookupTableCallback

Wrap a PanelServicePageUpLookupTableCallback into a C_PanelServicePageUpLookupTableCallback.

panelExtensionReceived

type C_PanelServicePanelExtensionReceivedCallback = Ptr () -> Ptr ExtensionEvent -> Ptr () -> IO ()

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

type PanelServicePanelExtensionReceivedCallback

Arguments

 = ExtensionEvent

data: A GVariant

-> IO ()

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

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

afterPanelServicePanelExtensionReceived :: (IsPanelService a, MonadIO m) => a -> PanelServicePanelExtensionReceivedCallback -> m SignalHandlerId

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

after panelService #panelExtensionReceived callback

genClosure_PanelServicePanelExtensionReceived :: MonadIO m => PanelServicePanelExtensionReceivedCallback -> m (GClosure C_PanelServicePanelExtensionReceivedCallback)

Wrap the callback into a GClosure.

mk_PanelServicePanelExtensionReceivedCallback :: C_PanelServicePanelExtensionReceivedCallback -> IO (FunPtr C_PanelServicePanelExtensionReceivedCallback)

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

noPanelServicePanelExtensionReceivedCallback :: Maybe PanelServicePanelExtensionReceivedCallback

A convenience synonym for Nothing :: Maybe PanelServicePanelExtensionReceivedCallback.

onPanelServicePanelExtensionReceived :: (IsPanelService a, MonadIO m) => a -> PanelServicePanelExtensionReceivedCallback -> m SignalHandlerId

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

on panelService #panelExtensionReceived callback

wrap_PanelServicePanelExtensionReceivedCallback :: PanelServicePanelExtensionReceivedCallback -> C_PanelServicePanelExtensionReceivedCallback

Wrap a PanelServicePanelExtensionReceivedCallback into a C_PanelServicePanelExtensionReceivedCallback.

processKeyEvent

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

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

type PanelServiceProcessKeyEventCallback

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 IBusPanelServiceClass[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.

afterPanelServiceProcessKeyEvent :: (IsPanelService a, MonadIO m) => a -> PanelServiceProcessKeyEventCallback -> 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 panelService #processKeyEvent callback

genClosure_PanelServiceProcessKeyEvent :: MonadIO m => PanelServiceProcessKeyEventCallback -> m (GClosure C_PanelServiceProcessKeyEventCallback)

Wrap the callback into a GClosure.

mk_PanelServiceProcessKeyEventCallback :: C_PanelServiceProcessKeyEventCallback -> IO (FunPtr C_PanelServiceProcessKeyEventCallback)

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

noPanelServiceProcessKeyEventCallback :: Maybe PanelServiceProcessKeyEventCallback

A convenience synonym for Nothing :: Maybe PanelServiceProcessKeyEventCallback.

onPanelServiceProcessKeyEvent :: (IsPanelService a, MonadIO m) => a -> PanelServiceProcessKeyEventCallback -> 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 panelService #processKeyEvent callback

wrap_PanelServiceProcessKeyEventCallback :: PanelServiceProcessKeyEventCallback -> C_PanelServiceProcessKeyEventCallback

Wrap a PanelServiceProcessKeyEventCallback into a C_PanelServiceProcessKeyEventCallback.

registerProperties

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

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

type PanelServiceRegisterPropertiesCallback

Arguments

 = PropList

propList: An IBusPropList that contains properties.

-> IO ()

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

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

afterPanelServiceRegisterProperties :: (IsPanelService a, MonadIO m) => a -> PanelServiceRegisterPropertiesCallback -> m SignalHandlerId

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

after panelService #registerProperties callback

genClosure_PanelServiceRegisterProperties :: MonadIO m => PanelServiceRegisterPropertiesCallback -> m (GClosure C_PanelServiceRegisterPropertiesCallback)

Wrap the callback into a GClosure.

mk_PanelServiceRegisterPropertiesCallback :: C_PanelServiceRegisterPropertiesCallback -> IO (FunPtr C_PanelServiceRegisterPropertiesCallback)

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

noPanelServiceRegisterPropertiesCallback :: Maybe PanelServiceRegisterPropertiesCallback

A convenience synonym for Nothing :: Maybe PanelServiceRegisterPropertiesCallback.

onPanelServiceRegisterProperties :: (IsPanelService a, MonadIO m) => a -> PanelServiceRegisterPropertiesCallback -> m SignalHandlerId

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

on panelService #registerProperties callback

wrap_PanelServiceRegisterPropertiesCallback :: PanelServiceRegisterPropertiesCallback -> C_PanelServiceRegisterPropertiesCallback

Wrap a PanelServiceRegisterPropertiesCallback into a C_PanelServiceRegisterPropertiesCallback.

reset

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

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

type PanelServiceResetCallback = IO ()

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

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

afterPanelServiceReset :: (IsPanelService a, MonadIO m) => a -> PanelServiceResetCallback -> 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 panelService #reset callback

genClosure_PanelServiceReset :: MonadIO m => PanelServiceResetCallback -> m (GClosure C_PanelServiceResetCallback)

Wrap the callback into a GClosure.

mk_PanelServiceResetCallback :: C_PanelServiceResetCallback -> IO (FunPtr C_PanelServiceResetCallback)

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

noPanelServiceResetCallback :: Maybe PanelServiceResetCallback

A convenience synonym for Nothing :: Maybe PanelServiceResetCallback.

onPanelServiceReset :: (IsPanelService a, MonadIO m) => a -> PanelServiceResetCallback -> 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 panelService #reset callback

wrap_PanelServiceResetCallback :: PanelServiceResetCallback -> C_PanelServiceResetCallback

Wrap a PanelServiceResetCallback into a C_PanelServiceResetCallback.

setContentType

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

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

type PanelServiceSetContentTypeCallback

Arguments

 = Word32

purpose: Input purpose.

-> Word32

hints: Input hints.

-> IO ()

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

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

afterPanelServiceSetContentType :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetContentTypeCallback -> 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 panelService #setContentType callback

genClosure_PanelServiceSetContentType :: MonadIO m => PanelServiceSetContentTypeCallback -> m (GClosure C_PanelServiceSetContentTypeCallback)

Wrap the callback into a GClosure.

mk_PanelServiceSetContentTypeCallback :: C_PanelServiceSetContentTypeCallback -> IO (FunPtr C_PanelServiceSetContentTypeCallback)

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

noPanelServiceSetContentTypeCallback :: Maybe PanelServiceSetContentTypeCallback

A convenience synonym for Nothing :: Maybe PanelServiceSetContentTypeCallback.

onPanelServiceSetContentType :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetContentTypeCallback -> 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 panelService #setContentType callback

wrap_PanelServiceSetContentTypeCallback :: PanelServiceSetContentTypeCallback -> C_PanelServiceSetContentTypeCallback

Wrap a PanelServiceSetContentTypeCallback into a C_PanelServiceSetContentTypeCallback.

setCursorLocation

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

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

type PanelServiceSetCursorLocationCallback

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 client application get the setCursorLocation. Implement the member function IBusPanelServiceClass[set_cursor_location](#g:signal:set_cursor_location) in extended class to receive this signal.

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

afterPanelServiceSetCursorLocation :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetCursorLocationCallback -> 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 panelService #setCursorLocation callback

genClosure_PanelServiceSetCursorLocation :: MonadIO m => PanelServiceSetCursorLocationCallback -> m (GClosure C_PanelServiceSetCursorLocationCallback)

Wrap the callback into a GClosure.

mk_PanelServiceSetCursorLocationCallback :: C_PanelServiceSetCursorLocationCallback -> IO (FunPtr C_PanelServiceSetCursorLocationCallback)

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

noPanelServiceSetCursorLocationCallback :: Maybe PanelServiceSetCursorLocationCallback

A convenience synonym for Nothing :: Maybe PanelServiceSetCursorLocationCallback.

onPanelServiceSetCursorLocation :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetCursorLocationCallback -> 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 panelService #setCursorLocation callback

wrap_PanelServiceSetCursorLocationCallback :: PanelServiceSetCursorLocationCallback -> C_PanelServiceSetCursorLocationCallback

Wrap a PanelServiceSetCursorLocationCallback into a C_PanelServiceSetCursorLocationCallback.

setCursorLocationRelative

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

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

type PanelServiceSetCursorLocationRelativeCallback

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 client application get the set-cursor-location-relative. Implement the member function set_cursor_location_relative() in extended class to receive this signal.

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

afterPanelServiceSetCursorLocationRelative :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetCursorLocationRelativeCallback -> m SignalHandlerId

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

after panelService #setCursorLocationRelative callback

genClosure_PanelServiceSetCursorLocationRelative :: MonadIO m => PanelServiceSetCursorLocationRelativeCallback -> m (GClosure C_PanelServiceSetCursorLocationRelativeCallback)

Wrap the callback into a GClosure.

mk_PanelServiceSetCursorLocationRelativeCallback :: C_PanelServiceSetCursorLocationRelativeCallback -> IO (FunPtr C_PanelServiceSetCursorLocationRelativeCallback)

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

noPanelServiceSetCursorLocationRelativeCallback :: Maybe PanelServiceSetCursorLocationRelativeCallback

A convenience synonym for Nothing :: Maybe PanelServiceSetCursorLocationRelativeCallback.

onPanelServiceSetCursorLocationRelative :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetCursorLocationRelativeCallback -> m SignalHandlerId

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

on panelService #setCursorLocationRelative callback

wrap_PanelServiceSetCursorLocationRelativeCallback :: PanelServiceSetCursorLocationRelativeCallback -> C_PanelServiceSetCursorLocationRelativeCallback

Wrap a PanelServiceSetCursorLocationRelativeCallback into a C_PanelServiceSetCursorLocationRelativeCallback.

showAuxiliaryText

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

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

type PanelServiceShowAuxiliaryTextCallback = IO ()

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

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

afterPanelServiceShowAuxiliaryText :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowAuxiliaryTextCallback -> m SignalHandlerId

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

after panelService #showAuxiliaryText callback

genClosure_PanelServiceShowAuxiliaryText :: MonadIO m => PanelServiceShowAuxiliaryTextCallback -> m (GClosure C_PanelServiceShowAuxiliaryTextCallback)

Wrap the callback into a GClosure.

mk_PanelServiceShowAuxiliaryTextCallback :: C_PanelServiceShowAuxiliaryTextCallback -> IO (FunPtr C_PanelServiceShowAuxiliaryTextCallback)

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

noPanelServiceShowAuxiliaryTextCallback :: Maybe PanelServiceShowAuxiliaryTextCallback

A convenience synonym for Nothing :: Maybe PanelServiceShowAuxiliaryTextCallback.

onPanelServiceShowAuxiliaryText :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowAuxiliaryTextCallback -> m SignalHandlerId

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

on panelService #showAuxiliaryText callback

wrap_PanelServiceShowAuxiliaryTextCallback :: PanelServiceShowAuxiliaryTextCallback -> C_PanelServiceShowAuxiliaryTextCallback

Wrap a PanelServiceShowAuxiliaryTextCallback into a C_PanelServiceShowAuxiliaryTextCallback.

showLanguageBar

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

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

type PanelServiceShowLanguageBarCallback = IO ()

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

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

afterPanelServiceShowLanguageBar :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowLanguageBarCallback -> m SignalHandlerId

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

after panelService #showLanguageBar callback

genClosure_PanelServiceShowLanguageBar :: MonadIO m => PanelServiceShowLanguageBarCallback -> m (GClosure C_PanelServiceShowLanguageBarCallback)

Wrap the callback into a GClosure.

mk_PanelServiceShowLanguageBarCallback :: C_PanelServiceShowLanguageBarCallback -> IO (FunPtr C_PanelServiceShowLanguageBarCallback)

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

noPanelServiceShowLanguageBarCallback :: Maybe PanelServiceShowLanguageBarCallback

A convenience synonym for Nothing :: Maybe PanelServiceShowLanguageBarCallback.

onPanelServiceShowLanguageBar :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowLanguageBarCallback -> m SignalHandlerId

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

on panelService #showLanguageBar callback

wrap_PanelServiceShowLanguageBarCallback :: PanelServiceShowLanguageBarCallback -> C_PanelServiceShowLanguageBarCallback

Wrap a PanelServiceShowLanguageBarCallback into a C_PanelServiceShowLanguageBarCallback.

showLookupTable

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

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

type PanelServiceShowLookupTableCallback = IO ()

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

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

afterPanelServiceShowLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowLookupTableCallback -> m SignalHandlerId

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

after panelService #showLookupTable callback

genClosure_PanelServiceShowLookupTable :: MonadIO m => PanelServiceShowLookupTableCallback -> m (GClosure C_PanelServiceShowLookupTableCallback)

Wrap the callback into a GClosure.

mk_PanelServiceShowLookupTableCallback :: C_PanelServiceShowLookupTableCallback -> IO (FunPtr C_PanelServiceShowLookupTableCallback)

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

noPanelServiceShowLookupTableCallback :: Maybe PanelServiceShowLookupTableCallback

A convenience synonym for Nothing :: Maybe PanelServiceShowLookupTableCallback.

onPanelServiceShowLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowLookupTableCallback -> m SignalHandlerId

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

on panelService #showLookupTable callback

wrap_PanelServiceShowLookupTableCallback :: PanelServiceShowLookupTableCallback -> C_PanelServiceShowLookupTableCallback

Wrap a PanelServiceShowLookupTableCallback into a C_PanelServiceShowLookupTableCallback.

showPreeditText

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

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

type PanelServiceShowPreeditTextCallback = IO ()

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

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

afterPanelServiceShowPreeditText :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowPreeditTextCallback -> m SignalHandlerId

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

after panelService #showPreeditText callback

genClosure_PanelServiceShowPreeditText :: MonadIO m => PanelServiceShowPreeditTextCallback -> m (GClosure C_PanelServiceShowPreeditTextCallback)

Wrap the callback into a GClosure.

mk_PanelServiceShowPreeditTextCallback :: C_PanelServiceShowPreeditTextCallback -> IO (FunPtr C_PanelServiceShowPreeditTextCallback)

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

noPanelServiceShowPreeditTextCallback :: Maybe PanelServiceShowPreeditTextCallback

A convenience synonym for Nothing :: Maybe PanelServiceShowPreeditTextCallback.

onPanelServiceShowPreeditText :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowPreeditTextCallback -> m SignalHandlerId

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

on panelService #showPreeditText callback

wrap_PanelServiceShowPreeditTextCallback :: PanelServiceShowPreeditTextCallback -> C_PanelServiceShowPreeditTextCallback

Wrap a PanelServiceShowPreeditTextCallback into a C_PanelServiceShowPreeditTextCallback.

startSetup

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

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

type PanelServiceStartSetupCallback = IO ()

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

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

afterPanelServiceStartSetup :: (IsPanelService a, MonadIO m) => a -> PanelServiceStartSetupCallback -> m SignalHandlerId

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

after panelService #startSetup callback

genClosure_PanelServiceStartSetup :: MonadIO m => PanelServiceStartSetupCallback -> m (GClosure C_PanelServiceStartSetupCallback)

Wrap the callback into a GClosure.

mk_PanelServiceStartSetupCallback :: C_PanelServiceStartSetupCallback -> IO (FunPtr C_PanelServiceStartSetupCallback)

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

noPanelServiceStartSetupCallback :: Maybe PanelServiceStartSetupCallback

A convenience synonym for Nothing :: Maybe PanelServiceStartSetupCallback.

onPanelServiceStartSetup :: (IsPanelService a, MonadIO m) => a -> PanelServiceStartSetupCallback -> m SignalHandlerId

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

on panelService #startSetup callback

wrap_PanelServiceStartSetupCallback :: PanelServiceStartSetupCallback -> C_PanelServiceStartSetupCallback

Wrap a PanelServiceStartSetupCallback into a C_PanelServiceStartSetupCallback.

stateChanged

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

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

type PanelServiceStateChangedCallback = IO ()

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

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

afterPanelServiceStateChanged :: (IsPanelService a, MonadIO m) => a -> PanelServiceStateChangedCallback -> m SignalHandlerId

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

after panelService #stateChanged callback

genClosure_PanelServiceStateChanged :: MonadIO m => PanelServiceStateChangedCallback -> m (GClosure C_PanelServiceStateChangedCallback)

Wrap the callback into a GClosure.

mk_PanelServiceStateChangedCallback :: C_PanelServiceStateChangedCallback -> IO (FunPtr C_PanelServiceStateChangedCallback)

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

noPanelServiceStateChangedCallback :: Maybe PanelServiceStateChangedCallback

A convenience synonym for Nothing :: Maybe PanelServiceStateChangedCallback.

onPanelServiceStateChanged :: (IsPanelService a, MonadIO m) => a -> PanelServiceStateChangedCallback -> m SignalHandlerId

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

on panelService #stateChanged callback

wrap_PanelServiceStateChangedCallback :: PanelServiceStateChangedCallback -> C_PanelServiceStateChangedCallback

Wrap a PanelServiceStateChangedCallback into a C_PanelServiceStateChangedCallback.

updateAuxiliaryText

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

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

type PanelServiceUpdateAuxiliaryTextCallback

Arguments

 = Text

text: A preedit text to be updated.

-> Bool

visible: Whether the update is visible.

-> IO ()

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

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

afterPanelServiceUpdateAuxiliaryText :: (IsPanelService a, MonadIO m) => a -> PanelServiceUpdateAuxiliaryTextCallback -> m SignalHandlerId

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

after panelService #updateAuxiliaryText callback

genClosure_PanelServiceUpdateAuxiliaryText :: MonadIO m => PanelServiceUpdateAuxiliaryTextCallback -> m (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)

Wrap the callback into a GClosure.

mk_PanelServiceUpdateAuxiliaryTextCallback :: C_PanelServiceUpdateAuxiliaryTextCallback -> IO (FunPtr C_PanelServiceUpdateAuxiliaryTextCallback)

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

noPanelServiceUpdateAuxiliaryTextCallback :: Maybe PanelServiceUpdateAuxiliaryTextCallback

A convenience synonym for Nothing :: Maybe PanelServiceUpdateAuxiliaryTextCallback.

onPanelServiceUpdateAuxiliaryText :: (IsPanelService a, MonadIO m) => a -> PanelServiceUpdateAuxiliaryTextCallback -> m SignalHandlerId

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

on panelService #updateAuxiliaryText callback

wrap_PanelServiceUpdateAuxiliaryTextCallback :: PanelServiceUpdateAuxiliaryTextCallback -> C_PanelServiceUpdateAuxiliaryTextCallback

Wrap a PanelServiceUpdateAuxiliaryTextCallback into a C_PanelServiceUpdateAuxiliaryTextCallback.

updateLookupTable

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

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

type PanelServiceUpdateLookupTableCallback

Arguments

 = LookupTable

lookupTable: A lookup table to be updated.

-> Bool

visible: Whether the update is visible.

-> IO ()

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

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

afterPanelServiceUpdateLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceUpdateLookupTableCallback -> m SignalHandlerId

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

after panelService #updateLookupTable callback

genClosure_PanelServiceUpdateLookupTable :: MonadIO m => PanelServiceUpdateLookupTableCallback -> m (GClosure C_PanelServiceUpdateLookupTableCallback)

Wrap the callback into a GClosure.

mk_PanelServiceUpdateLookupTableCallback :: C_PanelServiceUpdateLookupTableCallback -> IO (FunPtr C_PanelServiceUpdateLookupTableCallback)

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

noPanelServiceUpdateLookupTableCallback :: Maybe PanelServiceUpdateLookupTableCallback

A convenience synonym for Nothing :: Maybe PanelServiceUpdateLookupTableCallback.

onPanelServiceUpdateLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceUpdateLookupTableCallback -> m SignalHandlerId

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

on panelService #updateLookupTable callback

wrap_PanelServiceUpdateLookupTableCallback :: PanelServiceUpdateLookupTableCallback -> C_PanelServiceUpdateLookupTableCallback

Wrap a PanelServiceUpdateLookupTableCallback into a C_PanelServiceUpdateLookupTableCallback.

updatePreeditText

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

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

type PanelServiceUpdatePreeditTextCallback

Arguments

 = Text

text: A preedit text to be updated.

-> Word32

cursorPos: The cursor position of the text.

-> Bool

visible: Whether the update is visible.

-> IO ()

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

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

afterPanelServiceUpdatePreeditText :: (IsPanelService a, MonadIO m) => a -> PanelServiceUpdatePreeditTextCallback -> m SignalHandlerId

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

after panelService #updatePreeditText callback

genClosure_PanelServiceUpdatePreeditText :: MonadIO m => PanelServiceUpdatePreeditTextCallback -> m (GClosure C_PanelServiceUpdatePreeditTextCallback)

Wrap the callback into a GClosure.

mk_PanelServiceUpdatePreeditTextCallback :: C_PanelServiceUpdatePreeditTextCallback -> IO (FunPtr C_PanelServiceUpdatePreeditTextCallback)

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

noPanelServiceUpdatePreeditTextCallback :: Maybe PanelServiceUpdatePreeditTextCallback

A convenience synonym for Nothing :: Maybe PanelServiceUpdatePreeditTextCallback.

onPanelServiceUpdatePreeditText :: (IsPanelService a, MonadIO m) => a -> PanelServiceUpdatePreeditTextCallback -> m SignalHandlerId

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

on panelService #updatePreeditText callback

wrap_PanelServiceUpdatePreeditTextCallback :: PanelServiceUpdatePreeditTextCallback -> C_PanelServiceUpdatePreeditTextCallback

Wrap a PanelServiceUpdatePreeditTextCallback into a C_PanelServiceUpdatePreeditTextCallback.

updateProperty

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

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

type PanelServiceUpdatePropertyCallback

Arguments

 = Property

prop: The IBusProperty to be updated.

-> IO ()

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

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

afterPanelServiceUpdateProperty :: (IsPanelService a, MonadIO m) => a -> PanelServiceUpdatePropertyCallback -> m SignalHandlerId

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

after panelService #updateProperty callback

genClosure_PanelServiceUpdateProperty :: MonadIO m => PanelServiceUpdatePropertyCallback -> m (GClosure C_PanelServiceUpdatePropertyCallback)

Wrap the callback into a GClosure.

mk_PanelServiceUpdatePropertyCallback :: C_PanelServiceUpdatePropertyCallback -> IO (FunPtr C_PanelServiceUpdatePropertyCallback)

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

noPanelServiceUpdatePropertyCallback :: Maybe PanelServiceUpdatePropertyCallback

A convenience synonym for Nothing :: Maybe PanelServiceUpdatePropertyCallback.

onPanelServiceUpdateProperty :: (IsPanelService a, MonadIO m) => a -> PanelServiceUpdatePropertyCallback -> m SignalHandlerId

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

on panelService #updateProperty callback

wrap_PanelServiceUpdatePropertyCallback :: PanelServiceUpdatePropertyCallback -> C_PanelServiceUpdatePropertyCallback

Wrap a PanelServiceUpdatePropertyCallback into a C_PanelServiceUpdatePropertyCallback.