{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An IBusInputContext is a proxy object of BusInputContext,
-- which manages the context for input methods that supports
-- text input in various natural languages.
-- 
-- Clients call the IBusInputContext to invoke BusInputContext,
-- through which invokes IBusEngine.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.IBus.Objects.InputContext
    ( 

-- * Exported types
    InputContext(..)                        ,
    IsInputContext                          ,
    toInputContext                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [call]("GI.Gio.Objects.DBusProxy#g:method:call"), [callFinish]("GI.Gio.Objects.DBusProxy#g:method:callFinish"), [callSync]("GI.Gio.Objects.DBusProxy#g:method:callSync"), [callWithUnixFdList]("GI.Gio.Objects.DBusProxy#g:method:callWithUnixFdList"), [callWithUnixFdListFinish]("GI.Gio.Objects.DBusProxy#g:method:callWithUnixFdListFinish"), [callWithUnixFdListSync]("GI.Gio.Objects.DBusProxy#g:method:callWithUnixFdListSync"), [cancelHandWriting]("GI.IBus.Objects.InputContext#g:method:cancelHandWriting"), [destroy]("GI.IBus.Objects.Proxy#g:method:destroy"), [focusIn]("GI.IBus.Objects.InputContext#g:method:focusIn"), [focusOut]("GI.IBus.Objects.InputContext#g:method:focusOut"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [init]("GI.Gio.Interfaces.Initable#g:method:init"), [initAsync]("GI.Gio.Interfaces.AsyncInitable#g:method:initAsync"), [initFinish]("GI.Gio.Interfaces.AsyncInitable#g:method:initFinish"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [needsSurroundingText]("GI.IBus.Objects.InputContext#g:method:needsSurroundingText"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [processHandWritingEvent]("GI.IBus.Objects.InputContext#g:method:processHandWritingEvent"), [processKeyEvent]("GI.IBus.Objects.InputContext#g:method:processKeyEvent"), [processKeyEventAsync]("GI.IBus.Objects.InputContext#g:method:processKeyEventAsync"), [processKeyEventAsyncFinish]("GI.IBus.Objects.InputContext#g:method:processKeyEventAsyncFinish"), [propertyActivate]("GI.IBus.Objects.InputContext#g:method:propertyActivate"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [reset]("GI.IBus.Objects.InputContext#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getCachedProperty]("GI.Gio.Objects.DBusProxy#g:method:getCachedProperty"), [getCachedPropertyNames]("GI.Gio.Objects.DBusProxy#g:method:getCachedPropertyNames"), [getConnection]("GI.Gio.Objects.DBusProxy#g:method:getConnection"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDefaultTimeout]("GI.Gio.Objects.DBusProxy#g:method:getDefaultTimeout"), [getEngine]("GI.IBus.Objects.InputContext#g:method:getEngine"), [getEngineAsync]("GI.IBus.Objects.InputContext#g:method:getEngineAsync"), [getEngineAsyncFinish]("GI.IBus.Objects.InputContext#g:method:getEngineAsyncFinish"), [getFlags]("GI.Gio.Objects.DBusProxy#g:method:getFlags"), [getInfo]("GI.Gio.Interfaces.DBusInterface#g:method:getInfo"), [getInterfaceInfo]("GI.Gio.Objects.DBusProxy#g:method:getInterfaceInfo"), [getInterfaceName]("GI.Gio.Objects.DBusProxy#g:method:getInterfaceName"), [getName]("GI.Gio.Objects.DBusProxy#g:method:getName"), [getNameOwner]("GI.Gio.Objects.DBusProxy#g:method:getNameOwner"), [getObject]("GI.Gio.Interfaces.DBusInterface#g:method:getObject"), [getObjectPath]("GI.Gio.Objects.DBusProxy#g:method:getObjectPath"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setCachedProperty]("GI.Gio.Objects.DBusProxy#g:method:setCachedProperty"), [setCapabilities]("GI.IBus.Objects.InputContext#g:method:setCapabilities"), [setClientCommitPreedit]("GI.IBus.Objects.InputContext#g:method:setClientCommitPreedit"), [setContentType]("GI.IBus.Objects.InputContext#g:method:setContentType"), [setCursorLocation]("GI.IBus.Objects.InputContext#g:method:setCursorLocation"), [setCursorLocationRelative]("GI.IBus.Objects.InputContext#g:method:setCursorLocationRelative"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDefaultTimeout]("GI.Gio.Objects.DBusProxy#g:method:setDefaultTimeout"), [setEngine]("GI.IBus.Objects.InputContext#g:method:setEngine"), [setInterfaceInfo]("GI.Gio.Objects.DBusProxy#g:method:setInterfaceInfo"), [setObject]("GI.Gio.Interfaces.DBusInterface#g:method:setObject"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setSurroundingText]("GI.IBus.Objects.InputContext#g:method:setSurroundingText").

#if defined(ENABLE_OVERLOADING)
    ResolveInputContextMethod               ,
#endif

-- ** cancelHandWriting #method:cancelHandWriting#

#if defined(ENABLE_OVERLOADING)
    InputContextCancelHandWritingMethodInfo ,
#endif
    inputContextCancelHandWriting           ,


-- ** focusIn #method:focusIn#

#if defined(ENABLE_OVERLOADING)
    InputContextFocusInMethodInfo           ,
#endif
    inputContextFocusIn                     ,


-- ** focusOut #method:focusOut#

#if defined(ENABLE_OVERLOADING)
    InputContextFocusOutMethodInfo          ,
#endif
    inputContextFocusOut                    ,


-- ** getEngine #method:getEngine#

#if defined(ENABLE_OVERLOADING)
    InputContextGetEngineMethodInfo         ,
#endif
    inputContextGetEngine                   ,


-- ** getEngineAsync #method:getEngineAsync#

#if defined(ENABLE_OVERLOADING)
    InputContextGetEngineAsyncMethodInfo    ,
#endif
    inputContextGetEngineAsync              ,


-- ** getEngineAsyncFinish #method:getEngineAsyncFinish#

#if defined(ENABLE_OVERLOADING)
    InputContextGetEngineAsyncFinishMethodInfo,
#endif
    inputContextGetEngineAsyncFinish        ,


-- ** getInputContext #method:getInputContext#

    inputContextGetInputContext             ,


-- ** getInputContextAsync #method:getInputContextAsync#

    inputContextGetInputContextAsync        ,


-- ** getInputContextAsyncFinish #method:getInputContextAsyncFinish#

    inputContextGetInputContextAsyncFinish  ,


-- ** needsSurroundingText #method:needsSurroundingText#

#if defined(ENABLE_OVERLOADING)
    InputContextNeedsSurroundingTextMethodInfo,
#endif
    inputContextNeedsSurroundingText        ,


-- ** new #method:new#

    inputContextNew                         ,


-- ** newAsync #method:newAsync#

    inputContextNewAsync                    ,


-- ** newAsyncFinish #method:newAsyncFinish#

    inputContextNewAsyncFinish              ,


-- ** processHandWritingEvent #method:processHandWritingEvent#

#if defined(ENABLE_OVERLOADING)
    InputContextProcessHandWritingEventMethodInfo,
#endif
    inputContextProcessHandWritingEvent     ,


-- ** processKeyEvent #method:processKeyEvent#

#if defined(ENABLE_OVERLOADING)
    InputContextProcessKeyEventMethodInfo   ,
#endif
    inputContextProcessKeyEvent             ,


-- ** processKeyEventAsync #method:processKeyEventAsync#

#if defined(ENABLE_OVERLOADING)
    InputContextProcessKeyEventAsyncMethodInfo,
#endif
    inputContextProcessKeyEventAsync        ,


-- ** processKeyEventAsyncFinish #method:processKeyEventAsyncFinish#

#if defined(ENABLE_OVERLOADING)
    InputContextProcessKeyEventAsyncFinishMethodInfo,
#endif
    inputContextProcessKeyEventAsyncFinish  ,


-- ** propertyActivate #method:propertyActivate#

#if defined(ENABLE_OVERLOADING)
    InputContextPropertyActivateMethodInfo  ,
#endif
    inputContextPropertyActivate            ,


-- ** reset #method:reset#

#if defined(ENABLE_OVERLOADING)
    InputContextResetMethodInfo             ,
#endif
    inputContextReset                       ,


-- ** setCapabilities #method:setCapabilities#

#if defined(ENABLE_OVERLOADING)
    InputContextSetCapabilitiesMethodInfo   ,
#endif
    inputContextSetCapabilities             ,


-- ** setClientCommitPreedit #method:setClientCommitPreedit#

#if defined(ENABLE_OVERLOADING)
    InputContextSetClientCommitPreeditMethodInfo,
#endif
    inputContextSetClientCommitPreedit      ,


-- ** setContentType #method:setContentType#

#if defined(ENABLE_OVERLOADING)
    InputContextSetContentTypeMethodInfo    ,
#endif
    inputContextSetContentType              ,


-- ** setCursorLocation #method:setCursorLocation#

#if defined(ENABLE_OVERLOADING)
    InputContextSetCursorLocationMethodInfo ,
#endif
    inputContextSetCursorLocation           ,


-- ** setCursorLocationRelative #method:setCursorLocationRelative#

#if defined(ENABLE_OVERLOADING)
    InputContextSetCursorLocationRelativeMethodInfo,
#endif
    inputContextSetCursorLocationRelative   ,


-- ** setEngine #method:setEngine#

#if defined(ENABLE_OVERLOADING)
    InputContextSetEngineMethodInfo         ,
#endif
    inputContextSetEngine                   ,


-- ** setSurroundingText #method:setSurroundingText#

#if defined(ENABLE_OVERLOADING)
    InputContextSetSurroundingTextMethodInfo,
#endif
    inputContextSetSurroundingText          ,




 -- * Signals


-- ** commitText #signal:commitText#

    C_InputContextCommitTextCallback        ,
    InputContextCommitTextCallback          ,
#if defined(ENABLE_OVERLOADING)
    InputContextCommitTextSignalInfo        ,
#endif
    afterInputContextCommitText             ,
    genClosure_InputContextCommitText       ,
    mk_InputContextCommitTextCallback       ,
    noInputContextCommitTextCallback        ,
    onInputContextCommitText                ,
    wrap_InputContextCommitTextCallback     ,


-- ** cursorDownLookupTable #signal:cursorDownLookupTable#

    C_InputContextCursorDownLookupTableCallback,
    InputContextCursorDownLookupTableCallback,
#if defined(ENABLE_OVERLOADING)
    InputContextCursorDownLookupTableSignalInfo,
#endif
    afterInputContextCursorDownLookupTable  ,
    genClosure_InputContextCursorDownLookupTable,
    mk_InputContextCursorDownLookupTableCallback,
    noInputContextCursorDownLookupTableCallback,
    onInputContextCursorDownLookupTable     ,
    wrap_InputContextCursorDownLookupTableCallback,


-- ** cursorUpLookupTable #signal:cursorUpLookupTable#

    C_InputContextCursorUpLookupTableCallback,
    InputContextCursorUpLookupTableCallback ,
#if defined(ENABLE_OVERLOADING)
    InputContextCursorUpLookupTableSignalInfo,
#endif
    afterInputContextCursorUpLookupTable    ,
    genClosure_InputContextCursorUpLookupTable,
    mk_InputContextCursorUpLookupTableCallback,
    noInputContextCursorUpLookupTableCallback,
    onInputContextCursorUpLookupTable       ,
    wrap_InputContextCursorUpLookupTableCallback,


-- ** deleteSurroundingText #signal:deleteSurroundingText#

    C_InputContextDeleteSurroundingTextCallback,
    InputContextDeleteSurroundingTextCallback,
#if defined(ENABLE_OVERLOADING)
    InputContextDeleteSurroundingTextSignalInfo,
#endif
    afterInputContextDeleteSurroundingText  ,
    genClosure_InputContextDeleteSurroundingText,
    mk_InputContextDeleteSurroundingTextCallback,
    noInputContextDeleteSurroundingTextCallback,
    onInputContextDeleteSurroundingText     ,
    wrap_InputContextDeleteSurroundingTextCallback,


-- ** disabled #signal:disabled#

    C_InputContextDisabledCallback          ,
    InputContextDisabledCallback            ,
#if defined(ENABLE_OVERLOADING)
    InputContextDisabledSignalInfo          ,
#endif
    afterInputContextDisabled               ,
    genClosure_InputContextDisabled         ,
    mk_InputContextDisabledCallback         ,
    noInputContextDisabledCallback          ,
    onInputContextDisabled                  ,
    wrap_InputContextDisabledCallback       ,


-- ** enabled #signal:enabled#

    C_InputContextEnabledCallback           ,
    InputContextEnabledCallback             ,
#if defined(ENABLE_OVERLOADING)
    InputContextEnabledSignalInfo           ,
#endif
    afterInputContextEnabled                ,
    genClosure_InputContextEnabled          ,
    mk_InputContextEnabledCallback          ,
    noInputContextEnabledCallback           ,
    onInputContextEnabled                   ,
    wrap_InputContextEnabledCallback        ,


-- ** forwardKeyEvent #signal:forwardKeyEvent#

    C_InputContextForwardKeyEventCallback   ,
    InputContextForwardKeyEventCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextForwardKeyEventSignalInfo   ,
#endif
    afterInputContextForwardKeyEvent        ,
    genClosure_InputContextForwardKeyEvent  ,
    mk_InputContextForwardKeyEventCallback  ,
    noInputContextForwardKeyEventCallback   ,
    onInputContextForwardKeyEvent           ,
    wrap_InputContextForwardKeyEventCallback,


-- ** hideAuxiliaryText #signal:hideAuxiliaryText#

    C_InputContextHideAuxiliaryTextCallback ,
    InputContextHideAuxiliaryTextCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextHideAuxiliaryTextSignalInfo ,
#endif
    afterInputContextHideAuxiliaryText      ,
    genClosure_InputContextHideAuxiliaryText,
    mk_InputContextHideAuxiliaryTextCallback,
    noInputContextHideAuxiliaryTextCallback ,
    onInputContextHideAuxiliaryText         ,
    wrap_InputContextHideAuxiliaryTextCallback,


-- ** hideLookupTable #signal:hideLookupTable#

    C_InputContextHideLookupTableCallback   ,
    InputContextHideLookupTableCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextHideLookupTableSignalInfo   ,
#endif
    afterInputContextHideLookupTable        ,
    genClosure_InputContextHideLookupTable  ,
    mk_InputContextHideLookupTableCallback  ,
    noInputContextHideLookupTableCallback   ,
    onInputContextHideLookupTable           ,
    wrap_InputContextHideLookupTableCallback,


-- ** hidePreeditText #signal:hidePreeditText#

    C_InputContextHidePreeditTextCallback   ,
    InputContextHidePreeditTextCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextHidePreeditTextSignalInfo   ,
#endif
    afterInputContextHidePreeditText        ,
    genClosure_InputContextHidePreeditText  ,
    mk_InputContextHidePreeditTextCallback  ,
    noInputContextHidePreeditTextCallback   ,
    onInputContextHidePreeditText           ,
    wrap_InputContextHidePreeditTextCallback,


-- ** pageDownLookupTable #signal:pageDownLookupTable#

    C_InputContextPageDownLookupTableCallback,
    InputContextPageDownLookupTableCallback ,
#if defined(ENABLE_OVERLOADING)
    InputContextPageDownLookupTableSignalInfo,
#endif
    afterInputContextPageDownLookupTable    ,
    genClosure_InputContextPageDownLookupTable,
    mk_InputContextPageDownLookupTableCallback,
    noInputContextPageDownLookupTableCallback,
    onInputContextPageDownLookupTable       ,
    wrap_InputContextPageDownLookupTableCallback,


-- ** pageUpLookupTable #signal:pageUpLookupTable#

    C_InputContextPageUpLookupTableCallback ,
    InputContextPageUpLookupTableCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextPageUpLookupTableSignalInfo ,
#endif
    afterInputContextPageUpLookupTable      ,
    genClosure_InputContextPageUpLookupTable,
    mk_InputContextPageUpLookupTableCallback,
    noInputContextPageUpLookupTableCallback ,
    onInputContextPageUpLookupTable         ,
    wrap_InputContextPageUpLookupTableCallback,


-- ** registerProperties #signal:registerProperties#

    C_InputContextRegisterPropertiesCallback,
    InputContextRegisterPropertiesCallback  ,
#if defined(ENABLE_OVERLOADING)
    InputContextRegisterPropertiesSignalInfo,
#endif
    afterInputContextRegisterProperties     ,
    genClosure_InputContextRegisterProperties,
    mk_InputContextRegisterPropertiesCallback,
    noInputContextRegisterPropertiesCallback,
    onInputContextRegisterProperties        ,
    wrap_InputContextRegisterPropertiesCallback,


-- ** showAuxiliaryText #signal:showAuxiliaryText#

    C_InputContextShowAuxiliaryTextCallback ,
    InputContextShowAuxiliaryTextCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextShowAuxiliaryTextSignalInfo ,
#endif
    afterInputContextShowAuxiliaryText      ,
    genClosure_InputContextShowAuxiliaryText,
    mk_InputContextShowAuxiliaryTextCallback,
    noInputContextShowAuxiliaryTextCallback ,
    onInputContextShowAuxiliaryText         ,
    wrap_InputContextShowAuxiliaryTextCallback,


-- ** showLookupTable #signal:showLookupTable#

    C_InputContextShowLookupTableCallback   ,
    InputContextShowLookupTableCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextShowLookupTableSignalInfo   ,
#endif
    afterInputContextShowLookupTable        ,
    genClosure_InputContextShowLookupTable  ,
    mk_InputContextShowLookupTableCallback  ,
    noInputContextShowLookupTableCallback   ,
    onInputContextShowLookupTable           ,
    wrap_InputContextShowLookupTableCallback,


-- ** showPreeditText #signal:showPreeditText#

    C_InputContextShowPreeditTextCallback   ,
    InputContextShowPreeditTextCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextShowPreeditTextSignalInfo   ,
#endif
    afterInputContextShowPreeditText        ,
    genClosure_InputContextShowPreeditText  ,
    mk_InputContextShowPreeditTextCallback  ,
    noInputContextShowPreeditTextCallback   ,
    onInputContextShowPreeditText           ,
    wrap_InputContextShowPreeditTextCallback,


-- ** updateAuxiliaryText #signal:updateAuxiliaryText#

    C_InputContextUpdateAuxiliaryTextCallback,
    InputContextUpdateAuxiliaryTextCallback ,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdateAuxiliaryTextSignalInfo,
#endif
    afterInputContextUpdateAuxiliaryText    ,
    genClosure_InputContextUpdateAuxiliaryText,
    mk_InputContextUpdateAuxiliaryTextCallback,
    noInputContextUpdateAuxiliaryTextCallback,
    onInputContextUpdateAuxiliaryText       ,
    wrap_InputContextUpdateAuxiliaryTextCallback,


-- ** updateLookupTable #signal:updateLookupTable#

    C_InputContextUpdateLookupTableCallback ,
    InputContextUpdateLookupTableCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdateLookupTableSignalInfo ,
#endif
    afterInputContextUpdateLookupTable      ,
    genClosure_InputContextUpdateLookupTable,
    mk_InputContextUpdateLookupTableCallback,
    noInputContextUpdateLookupTableCallback ,
    onInputContextUpdateLookupTable         ,
    wrap_InputContextUpdateLookupTableCallback,


-- ** updatePreeditText #signal:updatePreeditText#

    C_InputContextUpdatePreeditTextCallback ,
    InputContextUpdatePreeditTextCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdatePreeditTextSignalInfo ,
#endif
    afterInputContextUpdatePreeditText      ,
    genClosure_InputContextUpdatePreeditText,
    mk_InputContextUpdatePreeditTextCallback,
    noInputContextUpdatePreeditTextCallback ,
    onInputContextUpdatePreeditText         ,
    wrap_InputContextUpdatePreeditTextCallback,


-- ** updatePreeditTextWithMode #signal:updatePreeditTextWithMode#

    C_InputContextUpdatePreeditTextWithModeCallback,
    InputContextUpdatePreeditTextWithModeCallback,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdatePreeditTextWithModeSignalInfo,
#endif
    afterInputContextUpdatePreeditTextWithMode,
    genClosure_InputContextUpdatePreeditTextWithMode,
    mk_InputContextUpdatePreeditTextWithModeCallback,
    noInputContextUpdatePreeditTextWithModeCallback,
    onInputContextUpdatePreeditTextWithMode ,
    wrap_InputContextUpdatePreeditTextWithModeCallback,


-- ** updateProperty #signal:updateProperty#

    C_InputContextUpdatePropertyCallback    ,
    InputContextUpdatePropertyCallback      ,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdatePropertySignalInfo    ,
#endif
    afterInputContextUpdateProperty         ,
    genClosure_InputContextUpdateProperty   ,
    mk_InputContextUpdatePropertyCallback   ,
    noInputContextUpdatePropertyCallback    ,
    onInputContextUpdateProperty            ,
    wrap_InputContextUpdatePropertyCallback ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncInitable as Gio.AsyncInitable
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.DBusInterface as Gio.DBusInterface
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import qualified GI.Gio.Objects.DBusProxy as Gio.DBusProxy
import {-# SOURCE #-} qualified GI.IBus.Objects.EngineDesc as IBus.EngineDesc
import {-# SOURCE #-} qualified GI.IBus.Objects.LookupTable as IBus.LookupTable
import {-# SOURCE #-} qualified GI.IBus.Objects.PropList as IBus.PropList
import {-# SOURCE #-} qualified GI.IBus.Objects.Property as IBus.Property
import {-# SOURCE #-} qualified GI.IBus.Objects.Proxy as IBus.Proxy
import {-# SOURCE #-} qualified GI.IBus.Objects.Text as IBus.Text

-- | Memory-managed wrapper type.
newtype InputContext = InputContext (SP.ManagedPtr InputContext)
    deriving (InputContext -> InputContext -> Bool
(InputContext -> InputContext -> Bool)
-> (InputContext -> InputContext -> Bool) -> Eq InputContext
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputContext -> InputContext -> Bool
$c/= :: InputContext -> InputContext -> Bool
== :: InputContext -> InputContext -> Bool
$c== :: InputContext -> InputContext -> Bool
Eq)

instance SP.ManagedPtrNewtype InputContext where
    toManagedPtr :: InputContext -> ManagedPtr InputContext
toManagedPtr (InputContext ManagedPtr InputContext
p) = ManagedPtr InputContext
p

foreign import ccall "ibus_input_context_get_type"
    c_ibus_input_context_get_type :: IO B.Types.GType

instance B.Types.TypedObject InputContext where
    glibType :: IO GType
glibType = IO GType
c_ibus_input_context_get_type

instance B.Types.GObject InputContext

-- | Type class for types which can be safely cast to `InputContext`, for instance with `toInputContext`.
class (SP.GObject o, O.IsDescendantOf InputContext o) => IsInputContext o
instance (SP.GObject o, O.IsDescendantOf InputContext o) => IsInputContext o

instance O.HasParentTypes InputContext
type instance O.ParentTypes InputContext = '[IBus.Proxy.Proxy, Gio.DBusProxy.DBusProxy, GObject.Object.Object, Gio.AsyncInitable.AsyncInitable, Gio.DBusInterface.DBusInterface, Gio.Initable.Initable]

-- | Cast to `InputContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toInputContext :: (MIO.MonadIO m, IsInputContext o) => o -> m InputContext
toInputContext :: forall (m :: * -> *) o.
(MonadIO m, IsInputContext o) =>
o -> m InputContext
toInputContext = IO InputContext -> m InputContext
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO InputContext -> m InputContext)
-> (o -> IO InputContext) -> o -> m InputContext
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr InputContext -> InputContext) -> o -> IO InputContext
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr InputContext -> InputContext
InputContext

-- | Convert 'InputContext' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe InputContext) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ibus_input_context_get_type
    gvalueSet_ :: Ptr GValue -> Maybe InputContext -> IO ()
gvalueSet_ Ptr GValue
gv Maybe InputContext
P.Nothing = Ptr GValue -> Ptr InputContext -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr InputContext
forall a. Ptr a
FP.nullPtr :: FP.Ptr InputContext)
    gvalueSet_ Ptr GValue
gv (P.Just InputContext
obj) = InputContext -> (Ptr InputContext -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr InputContext
obj (Ptr GValue -> Ptr InputContext -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe InputContext)
gvalueGet_ Ptr GValue
gv = do
        Ptr InputContext
ptr <- Ptr GValue -> IO (Ptr InputContext)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr InputContext)
        if Ptr InputContext
ptr Ptr InputContext -> Ptr InputContext -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr InputContext
forall a. Ptr a
FP.nullPtr
        then InputContext -> Maybe InputContext
forall a. a -> Maybe a
P.Just (InputContext -> Maybe InputContext)
-> IO InputContext -> IO (Maybe InputContext)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr InputContext -> InputContext)
-> Ptr InputContext -> IO InputContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr InputContext -> InputContext
InputContext Ptr InputContext
ptr
        else Maybe InputContext -> IO (Maybe InputContext)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputContext
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveInputContextMethod (t :: Symbol) (o :: *) :: * where
    ResolveInputContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveInputContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveInputContextMethod "call" o = Gio.DBusProxy.DBusProxyCallMethodInfo
    ResolveInputContextMethod "callFinish" o = Gio.DBusProxy.DBusProxyCallFinishMethodInfo
    ResolveInputContextMethod "callSync" o = Gio.DBusProxy.DBusProxyCallSyncMethodInfo
    ResolveInputContextMethod "callWithUnixFdList" o = Gio.DBusProxy.DBusProxyCallWithUnixFdListMethodInfo
    ResolveInputContextMethod "callWithUnixFdListFinish" o = Gio.DBusProxy.DBusProxyCallWithUnixFdListFinishMethodInfo
    ResolveInputContextMethod "callWithUnixFdListSync" o = Gio.DBusProxy.DBusProxyCallWithUnixFdListSyncMethodInfo
    ResolveInputContextMethod "cancelHandWriting" o = InputContextCancelHandWritingMethodInfo
    ResolveInputContextMethod "destroy" o = IBus.Proxy.ProxyDestroyMethodInfo
    ResolveInputContextMethod "focusIn" o = InputContextFocusInMethodInfo
    ResolveInputContextMethod "focusOut" o = InputContextFocusOutMethodInfo
    ResolveInputContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveInputContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveInputContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveInputContextMethod "init" o = Gio.Initable.InitableInitMethodInfo
    ResolveInputContextMethod "initAsync" o = Gio.AsyncInitable.AsyncInitableInitAsyncMethodInfo
    ResolveInputContextMethod "initFinish" o = Gio.AsyncInitable.AsyncInitableInitFinishMethodInfo
    ResolveInputContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveInputContextMethod "needsSurroundingText" o = InputContextNeedsSurroundingTextMethodInfo
    ResolveInputContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveInputContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveInputContextMethod "processHandWritingEvent" o = InputContextProcessHandWritingEventMethodInfo
    ResolveInputContextMethod "processKeyEvent" o = InputContextProcessKeyEventMethodInfo
    ResolveInputContextMethod "processKeyEventAsync" o = InputContextProcessKeyEventAsyncMethodInfo
    ResolveInputContextMethod "processKeyEventAsyncFinish" o = InputContextProcessKeyEventAsyncFinishMethodInfo
    ResolveInputContextMethod "propertyActivate" o = InputContextPropertyActivateMethodInfo
    ResolveInputContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveInputContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveInputContextMethod "reset" o = InputContextResetMethodInfo
    ResolveInputContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveInputContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveInputContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveInputContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveInputContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveInputContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveInputContextMethod "getCachedProperty" o = Gio.DBusProxy.DBusProxyGetCachedPropertyMethodInfo
    ResolveInputContextMethod "getCachedPropertyNames" o = Gio.DBusProxy.DBusProxyGetCachedPropertyNamesMethodInfo
    ResolveInputContextMethod "getConnection" o = Gio.DBusProxy.DBusProxyGetConnectionMethodInfo
    ResolveInputContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveInputContextMethod "getDefaultTimeout" o = Gio.DBusProxy.DBusProxyGetDefaultTimeoutMethodInfo
    ResolveInputContextMethod "getEngine" o = InputContextGetEngineMethodInfo
    ResolveInputContextMethod "getEngineAsync" o = InputContextGetEngineAsyncMethodInfo
    ResolveInputContextMethod "getEngineAsyncFinish" o = InputContextGetEngineAsyncFinishMethodInfo
    ResolveInputContextMethod "getFlags" o = Gio.DBusProxy.DBusProxyGetFlagsMethodInfo
    ResolveInputContextMethod "getInfo" o = Gio.DBusInterface.DBusInterfaceGetInfoMethodInfo
    ResolveInputContextMethod "getInterfaceInfo" o = Gio.DBusProxy.DBusProxyGetInterfaceInfoMethodInfo
    ResolveInputContextMethod "getInterfaceName" o = Gio.DBusProxy.DBusProxyGetInterfaceNameMethodInfo
    ResolveInputContextMethod "getName" o = Gio.DBusProxy.DBusProxyGetNameMethodInfo
    ResolveInputContextMethod "getNameOwner" o = Gio.DBusProxy.DBusProxyGetNameOwnerMethodInfo
    ResolveInputContextMethod "getObject" o = Gio.DBusInterface.DBusInterfaceGetObjectMethodInfo
    ResolveInputContextMethod "getObjectPath" o = Gio.DBusProxy.DBusProxyGetObjectPathMethodInfo
    ResolveInputContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveInputContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveInputContextMethod "setCachedProperty" o = Gio.DBusProxy.DBusProxySetCachedPropertyMethodInfo
    ResolveInputContextMethod "setCapabilities" o = InputContextSetCapabilitiesMethodInfo
    ResolveInputContextMethod "setClientCommitPreedit" o = InputContextSetClientCommitPreeditMethodInfo
    ResolveInputContextMethod "setContentType" o = InputContextSetContentTypeMethodInfo
    ResolveInputContextMethod "setCursorLocation" o = InputContextSetCursorLocationMethodInfo
    ResolveInputContextMethod "setCursorLocationRelative" o = InputContextSetCursorLocationRelativeMethodInfo
    ResolveInputContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveInputContextMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveInputContextMethod "setDefaultTimeout" o = Gio.DBusProxy.DBusProxySetDefaultTimeoutMethodInfo
    ResolveInputContextMethod "setEngine" o = InputContextSetEngineMethodInfo
    ResolveInputContextMethod "setInterfaceInfo" o = Gio.DBusProxy.DBusProxySetInterfaceInfoMethodInfo
    ResolveInputContextMethod "setObject" o = Gio.DBusInterface.DBusInterfaceSetObjectMethodInfo
    ResolveInputContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveInputContextMethod "setSurroundingText" o = InputContextSetSurroundingTextMethodInfo
    ResolveInputContextMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveInputContextMethod t InputContext, O.OverloadedMethod info InputContext p) => OL.IsLabel t (InputContext -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveInputContextMethod t InputContext, O.OverloadedMethod info InputContext p, R.HasField t InputContext p) => R.HasField t InputContext p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveInputContextMethod t InputContext, O.OverloadedMethodInfo info InputContext) => OL.IsLabel t (O.MethodProxy info InputContext) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal InputContext::commit-text
-- | Emitted when the text is going to be committed.
-- 
-- (Note: The text object is floating, and it will be released after the
--  signal. If signal handler wants to keep the object, the handler should
--  use 'GI.GObject.Objects.Object.objectRefSink' to get the ownership of the object.)
type InputContextCommitTextCallback =
    IBus.Text.Text
    -- ^ /@text@/: Text to be committed.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextCommitTextCallback`@.
noInputContextCommitTextCallback :: Maybe InputContextCommitTextCallback
noInputContextCommitTextCallback :: Maybe InputContextCommitTextCallback
noInputContextCommitTextCallback = Maybe InputContextCommitTextCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextCommitTextCallback =
    Ptr () ->                               -- object
    Ptr IBus.Text.Text ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextCommitTextCallback`.
foreign import ccall "wrapper"
    mk_InputContextCommitTextCallback :: C_InputContextCommitTextCallback -> IO (FunPtr C_InputContextCommitTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextCommitText :: MonadIO m => InputContextCommitTextCallback -> m (GClosure C_InputContextCommitTextCallback)
genClosure_InputContextCommitText :: forall (m :: * -> *).
MonadIO m =>
InputContextCommitTextCallback
-> m (GClosure C_InputContextCommitTextCallback)
genClosure_InputContextCommitText InputContextCommitTextCallback
cb = IO (GClosure C_InputContextCommitTextCallback)
-> m (GClosure C_InputContextCommitTextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCommitTextCallback)
 -> m (GClosure C_InputContextCommitTextCallback))
-> IO (GClosure C_InputContextCommitTextCallback)
-> m (GClosure C_InputContextCommitTextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCommitTextCallback
cb' = InputContextCommitTextCallback -> C_InputContextCommitTextCallback
wrap_InputContextCommitTextCallback InputContextCommitTextCallback
cb
    C_InputContextCommitTextCallback
-> IO (FunPtr C_InputContextCommitTextCallback)
mk_InputContextCommitTextCallback C_InputContextCommitTextCallback
cb' IO (FunPtr C_InputContextCommitTextCallback)
-> (FunPtr C_InputContextCommitTextCallback
    -> IO (GClosure C_InputContextCommitTextCallback))
-> IO (GClosure C_InputContextCommitTextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCommitTextCallback
-> IO (GClosure C_InputContextCommitTextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextCommitTextCallback` into a `C_InputContextCommitTextCallback`.
wrap_InputContextCommitTextCallback ::
    InputContextCommitTextCallback ->
    C_InputContextCommitTextCallback
wrap_InputContextCommitTextCallback :: InputContextCommitTextCallback -> C_InputContextCommitTextCallback
wrap_InputContextCommitTextCallback InputContextCommitTextCallback
_cb Ptr ()
_ Ptr Text
text Ptr ()
_ = do
    Text
text' <- ((ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Text -> Text
IBus.Text.Text) Ptr Text
text
    InputContextCommitTextCallback
_cb  Text
text'


-- | Connect a signal handler for the [commitText](#signal:commitText) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #commitText callback
-- @
-- 
-- 
onInputContextCommitText :: (IsInputContext a, MonadIO m) => a -> InputContextCommitTextCallback -> m SignalHandlerId
onInputContextCommitText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextCommitTextCallback -> m SignalHandlerId
onInputContextCommitText a
obj InputContextCommitTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCommitTextCallback
cb' = InputContextCommitTextCallback -> C_InputContextCommitTextCallback
wrap_InputContextCommitTextCallback InputContextCommitTextCallback
cb
    FunPtr C_InputContextCommitTextCallback
cb'' <- C_InputContextCommitTextCallback
-> IO (FunPtr C_InputContextCommitTextCallback)
mk_InputContextCommitTextCallback C_InputContextCommitTextCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCommitTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"commit-text" FunPtr C_InputContextCommitTextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [commitText](#signal:commitText) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #commitText callback
-- @
-- 
-- 
afterInputContextCommitText :: (IsInputContext a, MonadIO m) => a -> InputContextCommitTextCallback -> m SignalHandlerId
afterInputContextCommitText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextCommitTextCallback -> m SignalHandlerId
afterInputContextCommitText a
obj InputContextCommitTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCommitTextCallback
cb' = InputContextCommitTextCallback -> C_InputContextCommitTextCallback
wrap_InputContextCommitTextCallback InputContextCommitTextCallback
cb
    FunPtr C_InputContextCommitTextCallback
cb'' <- C_InputContextCommitTextCallback
-> IO (FunPtr C_InputContextCommitTextCallback)
mk_InputContextCommitTextCallback C_InputContextCommitTextCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCommitTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"commit-text" FunPtr C_InputContextCommitTextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextCommitTextSignalInfo
instance SignalInfo InputContextCommitTextSignalInfo where
    type HaskellCallbackType InputContextCommitTextSignalInfo = InputContextCommitTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextCommitTextCallback cb
        cb'' <- mk_InputContextCommitTextCallback cb'
        connectSignalFunPtr obj "commit-text" cb'' connectMode detail

#endif

-- signal InputContext::cursor-down-lookup-table
-- | Emitted to select next candidate of lookup table.
type InputContextCursorDownLookupTableCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextCursorDownLookupTableCallback`@.
noInputContextCursorDownLookupTableCallback :: Maybe InputContextCursorDownLookupTableCallback
noInputContextCursorDownLookupTableCallback :: Maybe (IO ())
noInputContextCursorDownLookupTableCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextCursorDownLookupTableCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextCursorDownLookupTableCallback`.
foreign import ccall "wrapper"
    mk_InputContextCursorDownLookupTableCallback :: C_InputContextCursorDownLookupTableCallback -> IO (FunPtr C_InputContextCursorDownLookupTableCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextCursorDownLookupTable :: MonadIO m => InputContextCursorDownLookupTableCallback -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextCursorDownLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextCursorDownLookupTable IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorDownLookupTableCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextCursorDownLookupTableCallback` into a `C_InputContextCursorDownLookupTableCallback`.
wrap_InputContextCursorDownLookupTableCallback ::
    InputContextCursorDownLookupTableCallback ->
    C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorDownLookupTableCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorDownLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [cursorDownLookupTable](#signal:cursorDownLookupTable) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #cursorDownLookupTable callback
-- @
-- 
-- 
onInputContextCursorDownLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextCursorDownLookupTableCallback -> m SignalHandlerId
onInputContextCursorDownLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextCursorDownLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorDownLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-down-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cursorDownLookupTable](#signal:cursorDownLookupTable) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #cursorDownLookupTable callback
-- @
-- 
-- 
afterInputContextCursorDownLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextCursorDownLookupTableCallback -> m SignalHandlerId
afterInputContextCursorDownLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextCursorDownLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorDownLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-down-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextCursorDownLookupTableSignalInfo
instance SignalInfo InputContextCursorDownLookupTableSignalInfo where
    type HaskellCallbackType InputContextCursorDownLookupTableSignalInfo = InputContextCursorDownLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextCursorDownLookupTableCallback cb
        cb'' <- mk_InputContextCursorDownLookupTableCallback cb'
        connectSignalFunPtr obj "cursor-down-lookup-table" cb'' connectMode detail

#endif

-- signal InputContext::cursor-up-lookup-table
-- | Emitted to select previous candidate of lookup table.
type InputContextCursorUpLookupTableCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextCursorUpLookupTableCallback`@.
noInputContextCursorUpLookupTableCallback :: Maybe InputContextCursorUpLookupTableCallback
noInputContextCursorUpLookupTableCallback :: Maybe (IO ())
noInputContextCursorUpLookupTableCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextCursorUpLookupTableCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextCursorUpLookupTableCallback`.
foreign import ccall "wrapper"
    mk_InputContextCursorUpLookupTableCallback :: C_InputContextCursorUpLookupTableCallback -> IO (FunPtr C_InputContextCursorUpLookupTableCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextCursorUpLookupTable :: MonadIO m => InputContextCursorUpLookupTableCallback -> m (GClosure C_InputContextCursorUpLookupTableCallback)
genClosure_InputContextCursorUpLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextCursorUpLookupTable IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorUpLookupTableCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextCursorUpLookupTableCallback` into a `C_InputContextCursorUpLookupTableCallback`.
wrap_InputContextCursorUpLookupTableCallback ::
    InputContextCursorUpLookupTableCallback ->
    C_InputContextCursorUpLookupTableCallback
wrap_InputContextCursorUpLookupTableCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorUpLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [cursorUpLookupTable](#signal:cursorUpLookupTable) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #cursorUpLookupTable callback
-- @
-- 
-- 
onInputContextCursorUpLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextCursorUpLookupTableCallback -> m SignalHandlerId
onInputContextCursorUpLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextCursorUpLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorUpLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-up-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cursorUpLookupTable](#signal:cursorUpLookupTable) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #cursorUpLookupTable callback
-- @
-- 
-- 
afterInputContextCursorUpLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextCursorUpLookupTableCallback -> m SignalHandlerId
afterInputContextCursorUpLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextCursorUpLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorUpLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cursor-up-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextCursorUpLookupTableSignalInfo
instance SignalInfo InputContextCursorUpLookupTableSignalInfo where
    type HaskellCallbackType InputContextCursorUpLookupTableSignalInfo = InputContextCursorUpLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextCursorUpLookupTableCallback cb
        cb'' <- mk_InputContextCursorUpLookupTableCallback cb'
        connectSignalFunPtr obj "cursor-up-lookup-table" cb'' connectMode detail

#endif

-- signal InputContext::delete-surrounding-text
-- | Emitted to delete surrounding text event from IME to client of IME.
type InputContextDeleteSurroundingTextCallback =
    Int32
    -- ^ /@offset@/: the character offset from the cursor position of the text to be deleted.
    --   A negative value indicates a position before the cursor.
    -> Word32
    -- ^ /@nChars@/: the number of characters to be deleted.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextDeleteSurroundingTextCallback`@.
noInputContextDeleteSurroundingTextCallback :: Maybe InputContextDeleteSurroundingTextCallback
noInputContextDeleteSurroundingTextCallback :: Maybe InputContextDeleteSurroundingTextCallback
noInputContextDeleteSurroundingTextCallback = Maybe InputContextDeleteSurroundingTextCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextDeleteSurroundingTextCallback =
    Ptr () ->                               -- object
    Int32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextDeleteSurroundingTextCallback`.
foreign import ccall "wrapper"
    mk_InputContextDeleteSurroundingTextCallback :: C_InputContextDeleteSurroundingTextCallback -> IO (FunPtr C_InputContextDeleteSurroundingTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextDeleteSurroundingText :: MonadIO m => InputContextDeleteSurroundingTextCallback -> m (GClosure C_InputContextDeleteSurroundingTextCallback)
genClosure_InputContextDeleteSurroundingText :: forall (m :: * -> *).
MonadIO m =>
InputContextDeleteSurroundingTextCallback
-> m (GClosure C_InputContextDeleteSurroundingTextCallback)
genClosure_InputContextDeleteSurroundingText InputContextDeleteSurroundingTextCallback
cb = IO (GClosure C_InputContextDeleteSurroundingTextCallback)
-> m (GClosure C_InputContextDeleteSurroundingTextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextDeleteSurroundingTextCallback)
 -> m (GClosure C_InputContextDeleteSurroundingTextCallback))
-> IO (GClosure C_InputContextDeleteSurroundingTextCallback)
-> m (GClosure C_InputContextDeleteSurroundingTextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextDeleteSurroundingTextCallback
cb' = InputContextDeleteSurroundingTextCallback
-> C_InputContextDeleteSurroundingTextCallback
wrap_InputContextDeleteSurroundingTextCallback InputContextDeleteSurroundingTextCallback
cb
    C_InputContextDeleteSurroundingTextCallback
-> IO (FunPtr C_InputContextDeleteSurroundingTextCallback)
mk_InputContextDeleteSurroundingTextCallback C_InputContextDeleteSurroundingTextCallback
cb' IO (FunPtr C_InputContextDeleteSurroundingTextCallback)
-> (FunPtr C_InputContextDeleteSurroundingTextCallback
    -> IO (GClosure C_InputContextDeleteSurroundingTextCallback))
-> IO (GClosure C_InputContextDeleteSurroundingTextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextDeleteSurroundingTextCallback
-> IO (GClosure C_InputContextDeleteSurroundingTextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextDeleteSurroundingTextCallback` into a `C_InputContextDeleteSurroundingTextCallback`.
wrap_InputContextDeleteSurroundingTextCallback ::
    InputContextDeleteSurroundingTextCallback ->
    C_InputContextDeleteSurroundingTextCallback
wrap_InputContextDeleteSurroundingTextCallback :: InputContextDeleteSurroundingTextCallback
-> C_InputContextDeleteSurroundingTextCallback
wrap_InputContextDeleteSurroundingTextCallback InputContextDeleteSurroundingTextCallback
_cb Ptr ()
_ Int32
offset Word32
nChars Ptr ()
_ = do
    InputContextDeleteSurroundingTextCallback
_cb  Int32
offset Word32
nChars


-- | Connect a signal handler for the [deleteSurroundingText](#signal:deleteSurroundingText) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #deleteSurroundingText callback
-- @
-- 
-- 
onInputContextDeleteSurroundingText :: (IsInputContext a, MonadIO m) => a -> InputContextDeleteSurroundingTextCallback -> m SignalHandlerId
onInputContextDeleteSurroundingText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextDeleteSurroundingTextCallback -> m SignalHandlerId
onInputContextDeleteSurroundingText a
obj InputContextDeleteSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextDeleteSurroundingTextCallback
cb' = InputContextDeleteSurroundingTextCallback
-> C_InputContextDeleteSurroundingTextCallback
wrap_InputContextDeleteSurroundingTextCallback InputContextDeleteSurroundingTextCallback
cb
    FunPtr C_InputContextDeleteSurroundingTextCallback
cb'' <- C_InputContextDeleteSurroundingTextCallback
-> IO (FunPtr C_InputContextDeleteSurroundingTextCallback)
mk_InputContextDeleteSurroundingTextCallback C_InputContextDeleteSurroundingTextCallback
cb'
    a
-> Text
-> FunPtr C_InputContextDeleteSurroundingTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"delete-surrounding-text" FunPtr C_InputContextDeleteSurroundingTextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [deleteSurroundingText](#signal:deleteSurroundingText) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #deleteSurroundingText callback
-- @
-- 
-- 
afterInputContextDeleteSurroundingText :: (IsInputContext a, MonadIO m) => a -> InputContextDeleteSurroundingTextCallback -> m SignalHandlerId
afterInputContextDeleteSurroundingText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextDeleteSurroundingTextCallback -> m SignalHandlerId
afterInputContextDeleteSurroundingText a
obj InputContextDeleteSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextDeleteSurroundingTextCallback
cb' = InputContextDeleteSurroundingTextCallback
-> C_InputContextDeleteSurroundingTextCallback
wrap_InputContextDeleteSurroundingTextCallback InputContextDeleteSurroundingTextCallback
cb
    FunPtr C_InputContextDeleteSurroundingTextCallback
cb'' <- C_InputContextDeleteSurroundingTextCallback
-> IO (FunPtr C_InputContextDeleteSurroundingTextCallback)
mk_InputContextDeleteSurroundingTextCallback C_InputContextDeleteSurroundingTextCallback
cb'
    a
-> Text
-> FunPtr C_InputContextDeleteSurroundingTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"delete-surrounding-text" FunPtr C_InputContextDeleteSurroundingTextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextDeleteSurroundingTextSignalInfo
instance SignalInfo InputContextDeleteSurroundingTextSignalInfo where
    type HaskellCallbackType InputContextDeleteSurroundingTextSignalInfo = InputContextDeleteSurroundingTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextDeleteSurroundingTextCallback cb
        cb'' <- mk_InputContextDeleteSurroundingTextCallback cb'
        connectSignalFunPtr obj "delete-surrounding-text" cb'' connectMode detail

#endif

-- signal InputContext::disabled
-- | Emitted when an IME is disabled.
type InputContextDisabledCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextDisabledCallback`@.
noInputContextDisabledCallback :: Maybe InputContextDisabledCallback
noInputContextDisabledCallback :: Maybe (IO ())
noInputContextDisabledCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextDisabledCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextDisabledCallback`.
foreign import ccall "wrapper"
    mk_InputContextDisabledCallback :: C_InputContextDisabledCallback -> IO (FunPtr C_InputContextDisabledCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextDisabled :: MonadIO m => InputContextDisabledCallback -> m (GClosure C_InputContextDisabledCallback)
genClosure_InputContextDisabled :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextDisabled IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextDisabledCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextDisabledCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextDisabledCallback` into a `C_InputContextDisabledCallback`.
wrap_InputContextDisabledCallback ::
    InputContextDisabledCallback ->
    C_InputContextDisabledCallback
wrap_InputContextDisabledCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextDisabledCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [disabled](#signal:disabled) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #disabled callback
-- @
-- 
-- 
onInputContextDisabled :: (IsInputContext a, MonadIO m) => a -> InputContextDisabledCallback -> m SignalHandlerId
onInputContextDisabled :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextDisabled a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextDisabledCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextDisabledCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"disabled" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [disabled](#signal:disabled) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #disabled callback
-- @
-- 
-- 
afterInputContextDisabled :: (IsInputContext a, MonadIO m) => a -> InputContextDisabledCallback -> m SignalHandlerId
afterInputContextDisabled :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextDisabled a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextDisabledCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextDisabledCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"disabled" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextDisabledSignalInfo
instance SignalInfo InputContextDisabledSignalInfo where
    type HaskellCallbackType InputContextDisabledSignalInfo = InputContextDisabledCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextDisabledCallback cb
        cb'' <- mk_InputContextDisabledCallback cb'
        connectSignalFunPtr obj "disabled" cb'' connectMode detail

#endif

-- signal InputContext::enabled
-- | Emitted when an IME is enabled.
type InputContextEnabledCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextEnabledCallback`@.
noInputContextEnabledCallback :: Maybe InputContextEnabledCallback
noInputContextEnabledCallback :: Maybe (IO ())
noInputContextEnabledCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextEnabledCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextEnabledCallback`.
foreign import ccall "wrapper"
    mk_InputContextEnabledCallback :: C_InputContextEnabledCallback -> IO (FunPtr C_InputContextEnabledCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextEnabled :: MonadIO m => InputContextEnabledCallback -> m (GClosure C_InputContextEnabledCallback)
genClosure_InputContextEnabled :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextEnabled IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextEnabledCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextEnabledCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextEnabledCallback` into a `C_InputContextEnabledCallback`.
wrap_InputContextEnabledCallback ::
    InputContextEnabledCallback ->
    C_InputContextEnabledCallback
wrap_InputContextEnabledCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextEnabledCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [enabled](#signal:enabled) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #enabled callback
-- @
-- 
-- 
onInputContextEnabled :: (IsInputContext a, MonadIO m) => a -> InputContextEnabledCallback -> m SignalHandlerId
onInputContextEnabled :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextEnabled a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextEnabledCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextEnabledCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enabled" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [enabled](#signal:enabled) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #enabled callback
-- @
-- 
-- 
afterInputContextEnabled :: (IsInputContext a, MonadIO m) => a -> InputContextEnabledCallback -> m SignalHandlerId
afterInputContextEnabled :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextEnabled a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextEnabledCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextEnabledCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enabled" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextEnabledSignalInfo
instance SignalInfo InputContextEnabledSignalInfo where
    type HaskellCallbackType InputContextEnabledSignalInfo = InputContextEnabledCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextEnabledCallback cb
        cb'' <- mk_InputContextEnabledCallback cb'
        connectSignalFunPtr obj "enabled" cb'' connectMode detail

#endif

-- signal InputContext::forward-key-event
-- | Emitted to forward key event from IME to client of IME.
type InputContextForwardKeyEventCallback =
    Word32
    -- ^ /@keyval@/: Key symbol of the keyboard event.
    -> Word32
    -- ^ /@keycode@/: Key symbol of the keyboard event.
    -> Word32
    -- ^ /@modifiers@/: Key modifier flags.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextForwardKeyEventCallback`@.
noInputContextForwardKeyEventCallback :: Maybe InputContextForwardKeyEventCallback
noInputContextForwardKeyEventCallback :: Maybe InputContextForwardKeyEventCallback
noInputContextForwardKeyEventCallback = Maybe InputContextForwardKeyEventCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextForwardKeyEventCallback =
    Ptr () ->                               -- object
    Word32 ->
    Word32 ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextForwardKeyEventCallback`.
foreign import ccall "wrapper"
    mk_InputContextForwardKeyEventCallback :: C_InputContextForwardKeyEventCallback -> IO (FunPtr C_InputContextForwardKeyEventCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextForwardKeyEvent :: MonadIO m => InputContextForwardKeyEventCallback -> m (GClosure C_InputContextForwardKeyEventCallback)
genClosure_InputContextForwardKeyEvent :: forall (m :: * -> *).
MonadIO m =>
InputContextForwardKeyEventCallback
-> m (GClosure C_InputContextForwardKeyEventCallback)
genClosure_InputContextForwardKeyEvent InputContextForwardKeyEventCallback
cb = IO (GClosure C_InputContextForwardKeyEventCallback)
-> m (GClosure C_InputContextForwardKeyEventCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextForwardKeyEventCallback)
 -> m (GClosure C_InputContextForwardKeyEventCallback))
-> IO (GClosure C_InputContextForwardKeyEventCallback)
-> m (GClosure C_InputContextForwardKeyEventCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextForwardKeyEventCallback
cb' = InputContextForwardKeyEventCallback
-> C_InputContextForwardKeyEventCallback
wrap_InputContextForwardKeyEventCallback InputContextForwardKeyEventCallback
cb
    C_InputContextForwardKeyEventCallback
-> IO (FunPtr C_InputContextForwardKeyEventCallback)
mk_InputContextForwardKeyEventCallback C_InputContextForwardKeyEventCallback
cb' IO (FunPtr C_InputContextForwardKeyEventCallback)
-> (FunPtr C_InputContextForwardKeyEventCallback
    -> IO (GClosure C_InputContextForwardKeyEventCallback))
-> IO (GClosure C_InputContextForwardKeyEventCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextForwardKeyEventCallback
-> IO (GClosure C_InputContextForwardKeyEventCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextForwardKeyEventCallback` into a `C_InputContextForwardKeyEventCallback`.
wrap_InputContextForwardKeyEventCallback ::
    InputContextForwardKeyEventCallback ->
    C_InputContextForwardKeyEventCallback
wrap_InputContextForwardKeyEventCallback :: InputContextForwardKeyEventCallback
-> C_InputContextForwardKeyEventCallback
wrap_InputContextForwardKeyEventCallback InputContextForwardKeyEventCallback
_cb Ptr ()
_ Word32
keyval Word32
keycode Word32
modifiers Ptr ()
_ = do
    InputContextForwardKeyEventCallback
_cb  Word32
keyval Word32
keycode Word32
modifiers


-- | Connect a signal handler for the [forwardKeyEvent](#signal:forwardKeyEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #forwardKeyEvent callback
-- @
-- 
-- 
onInputContextForwardKeyEvent :: (IsInputContext a, MonadIO m) => a -> InputContextForwardKeyEventCallback -> m SignalHandlerId
onInputContextForwardKeyEvent :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextForwardKeyEventCallback -> m SignalHandlerId
onInputContextForwardKeyEvent a
obj InputContextForwardKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextForwardKeyEventCallback
cb' = InputContextForwardKeyEventCallback
-> C_InputContextForwardKeyEventCallback
wrap_InputContextForwardKeyEventCallback InputContextForwardKeyEventCallback
cb
    FunPtr C_InputContextForwardKeyEventCallback
cb'' <- C_InputContextForwardKeyEventCallback
-> IO (FunPtr C_InputContextForwardKeyEventCallback)
mk_InputContextForwardKeyEventCallback C_InputContextForwardKeyEventCallback
cb'
    a
-> Text
-> FunPtr C_InputContextForwardKeyEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"forward-key-event" FunPtr C_InputContextForwardKeyEventCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [forwardKeyEvent](#signal:forwardKeyEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #forwardKeyEvent callback
-- @
-- 
-- 
afterInputContextForwardKeyEvent :: (IsInputContext a, MonadIO m) => a -> InputContextForwardKeyEventCallback -> m SignalHandlerId
afterInputContextForwardKeyEvent :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextForwardKeyEventCallback -> m SignalHandlerId
afterInputContextForwardKeyEvent a
obj InputContextForwardKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextForwardKeyEventCallback
cb' = InputContextForwardKeyEventCallback
-> C_InputContextForwardKeyEventCallback
wrap_InputContextForwardKeyEventCallback InputContextForwardKeyEventCallback
cb
    FunPtr C_InputContextForwardKeyEventCallback
cb'' <- C_InputContextForwardKeyEventCallback
-> IO (FunPtr C_InputContextForwardKeyEventCallback)
mk_InputContextForwardKeyEventCallback C_InputContextForwardKeyEventCallback
cb'
    a
-> Text
-> FunPtr C_InputContextForwardKeyEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"forward-key-event" FunPtr C_InputContextForwardKeyEventCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextForwardKeyEventSignalInfo
instance SignalInfo InputContextForwardKeyEventSignalInfo where
    type HaskellCallbackType InputContextForwardKeyEventSignalInfo = InputContextForwardKeyEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextForwardKeyEventCallback cb
        cb'' <- mk_InputContextForwardKeyEventCallback cb'
        connectSignalFunPtr obj "forward-key-event" cb'' connectMode detail

#endif

-- signal InputContext::hide-auxiliary-text
-- | Emitted to hide auxiliary text.
type InputContextHideAuxiliaryTextCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextHideAuxiliaryTextCallback`@.
noInputContextHideAuxiliaryTextCallback :: Maybe InputContextHideAuxiliaryTextCallback
noInputContextHideAuxiliaryTextCallback :: Maybe (IO ())
noInputContextHideAuxiliaryTextCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextHideAuxiliaryTextCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextHideAuxiliaryTextCallback`.
foreign import ccall "wrapper"
    mk_InputContextHideAuxiliaryTextCallback :: C_InputContextHideAuxiliaryTextCallback -> IO (FunPtr C_InputContextHideAuxiliaryTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextHideAuxiliaryText :: MonadIO m => InputContextHideAuxiliaryTextCallback -> m (GClosure C_InputContextHideAuxiliaryTextCallback)
genClosure_InputContextHideAuxiliaryText :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextHideAuxiliaryText IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideAuxiliaryTextCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextHideAuxiliaryTextCallback` into a `C_InputContextHideAuxiliaryTextCallback`.
wrap_InputContextHideAuxiliaryTextCallback ::
    InputContextHideAuxiliaryTextCallback ->
    C_InputContextHideAuxiliaryTextCallback
wrap_InputContextHideAuxiliaryTextCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideAuxiliaryTextCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [hideAuxiliaryText](#signal:hideAuxiliaryText) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #hideAuxiliaryText callback
-- @
-- 
-- 
onInputContextHideAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextHideAuxiliaryTextCallback -> m SignalHandlerId
onInputContextHideAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextHideAuxiliaryText a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideAuxiliaryTextCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide-auxiliary-text" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [hideAuxiliaryText](#signal:hideAuxiliaryText) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #hideAuxiliaryText callback
-- @
-- 
-- 
afterInputContextHideAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextHideAuxiliaryTextCallback -> m SignalHandlerId
afterInputContextHideAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextHideAuxiliaryText a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideAuxiliaryTextCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide-auxiliary-text" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextHideAuxiliaryTextSignalInfo
instance SignalInfo InputContextHideAuxiliaryTextSignalInfo where
    type HaskellCallbackType InputContextHideAuxiliaryTextSignalInfo = InputContextHideAuxiliaryTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextHideAuxiliaryTextCallback cb
        cb'' <- mk_InputContextHideAuxiliaryTextCallback cb'
        connectSignalFunPtr obj "hide-auxiliary-text" cb'' connectMode detail

#endif

-- signal InputContext::hide-lookup-table
-- | Emitted to hide lookup table.
type InputContextHideLookupTableCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextHideLookupTableCallback`@.
noInputContextHideLookupTableCallback :: Maybe InputContextHideLookupTableCallback
noInputContextHideLookupTableCallback :: Maybe (IO ())
noInputContextHideLookupTableCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextHideLookupTableCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextHideLookupTableCallback`.
foreign import ccall "wrapper"
    mk_InputContextHideLookupTableCallback :: C_InputContextHideLookupTableCallback -> IO (FunPtr C_InputContextHideLookupTableCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextHideLookupTable :: MonadIO m => InputContextHideLookupTableCallback -> m (GClosure C_InputContextHideLookupTableCallback)
genClosure_InputContextHideLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextHideLookupTable IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideLookupTableCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextHideLookupTableCallback` into a `C_InputContextHideLookupTableCallback`.
wrap_InputContextHideLookupTableCallback ::
    InputContextHideLookupTableCallback ->
    C_InputContextHideLookupTableCallback
wrap_InputContextHideLookupTableCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [hideLookupTable](#signal:hideLookupTable) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #hideLookupTable callback
-- @
-- 
-- 
onInputContextHideLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextHideLookupTableCallback -> m SignalHandlerId
onInputContextHideLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextHideLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [hideLookupTable](#signal:hideLookupTable) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #hideLookupTable callback
-- @
-- 
-- 
afterInputContextHideLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextHideLookupTableCallback -> m SignalHandlerId
afterInputContextHideLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextHideLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextHideLookupTableSignalInfo
instance SignalInfo InputContextHideLookupTableSignalInfo where
    type HaskellCallbackType InputContextHideLookupTableSignalInfo = InputContextHideLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextHideLookupTableCallback cb
        cb'' <- mk_InputContextHideLookupTableCallback cb'
        connectSignalFunPtr obj "hide-lookup-table" cb'' connectMode detail

#endif

-- signal InputContext::hide-preedit-text
-- | Emitted to hide preedit text.
type InputContextHidePreeditTextCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextHidePreeditTextCallback`@.
noInputContextHidePreeditTextCallback :: Maybe InputContextHidePreeditTextCallback
noInputContextHidePreeditTextCallback :: Maybe (IO ())
noInputContextHidePreeditTextCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextHidePreeditTextCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextHidePreeditTextCallback`.
foreign import ccall "wrapper"
    mk_InputContextHidePreeditTextCallback :: C_InputContextHidePreeditTextCallback -> IO (FunPtr C_InputContextHidePreeditTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextHidePreeditText :: MonadIO m => InputContextHidePreeditTextCallback -> m (GClosure C_InputContextHidePreeditTextCallback)
genClosure_InputContextHidePreeditText :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextHidePreeditText IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHidePreeditTextCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHidePreeditTextCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextHidePreeditTextCallback` into a `C_InputContextHidePreeditTextCallback`.
wrap_InputContextHidePreeditTextCallback ::
    InputContextHidePreeditTextCallback ->
    C_InputContextHidePreeditTextCallback
wrap_InputContextHidePreeditTextCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHidePreeditTextCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [hidePreeditText](#signal:hidePreeditText) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #hidePreeditText callback
-- @
-- 
-- 
onInputContextHidePreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextHidePreeditTextCallback -> m SignalHandlerId
onInputContextHidePreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextHidePreeditText a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHidePreeditTextCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHidePreeditTextCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide-preedit-text" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [hidePreeditText](#signal:hidePreeditText) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #hidePreeditText callback
-- @
-- 
-- 
afterInputContextHidePreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextHidePreeditTextCallback -> m SignalHandlerId
afterInputContextHidePreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextHidePreeditText a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHidePreeditTextCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHidePreeditTextCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide-preedit-text" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextHidePreeditTextSignalInfo
instance SignalInfo InputContextHidePreeditTextSignalInfo where
    type HaskellCallbackType InputContextHidePreeditTextSignalInfo = InputContextHidePreeditTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextHidePreeditTextCallback cb
        cb'' <- mk_InputContextHidePreeditTextCallback cb'
        connectSignalFunPtr obj "hide-preedit-text" cb'' connectMode detail

#endif

-- signal InputContext::page-down-lookup-table
-- | Emitted to view the next page of lookup table.
type InputContextPageDownLookupTableCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextPageDownLookupTableCallback`@.
noInputContextPageDownLookupTableCallback :: Maybe InputContextPageDownLookupTableCallback
noInputContextPageDownLookupTableCallback :: Maybe (IO ())
noInputContextPageDownLookupTableCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextPageDownLookupTableCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextPageDownLookupTableCallback`.
foreign import ccall "wrapper"
    mk_InputContextPageDownLookupTableCallback :: C_InputContextPageDownLookupTableCallback -> IO (FunPtr C_InputContextPageDownLookupTableCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextPageDownLookupTable :: MonadIO m => InputContextPageDownLookupTableCallback -> m (GClosure C_InputContextPageDownLookupTableCallback)
genClosure_InputContextPageDownLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextPageDownLookupTable IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageDownLookupTableCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextPageDownLookupTableCallback` into a `C_InputContextPageDownLookupTableCallback`.
wrap_InputContextPageDownLookupTableCallback ::
    InputContextPageDownLookupTableCallback ->
    C_InputContextPageDownLookupTableCallback
wrap_InputContextPageDownLookupTableCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageDownLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [pageDownLookupTable](#signal:pageDownLookupTable) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #pageDownLookupTable callback
-- @
-- 
-- 
onInputContextPageDownLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextPageDownLookupTableCallback -> m SignalHandlerId
onInputContextPageDownLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextPageDownLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageDownLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-down-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pageDownLookupTable](#signal:pageDownLookupTable) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #pageDownLookupTable callback
-- @
-- 
-- 
afterInputContextPageDownLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextPageDownLookupTableCallback -> m SignalHandlerId
afterInputContextPageDownLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextPageDownLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageDownLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-down-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextPageDownLookupTableSignalInfo
instance SignalInfo InputContextPageDownLookupTableSignalInfo where
    type HaskellCallbackType InputContextPageDownLookupTableSignalInfo = InputContextPageDownLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextPageDownLookupTableCallback cb
        cb'' <- mk_InputContextPageDownLookupTableCallback cb'
        connectSignalFunPtr obj "page-down-lookup-table" cb'' connectMode detail

#endif

-- signal InputContext::page-up-lookup-table
-- | Emitted to view the previous page of lookup table.
type InputContextPageUpLookupTableCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextPageUpLookupTableCallback`@.
noInputContextPageUpLookupTableCallback :: Maybe InputContextPageUpLookupTableCallback
noInputContextPageUpLookupTableCallback :: Maybe (IO ())
noInputContextPageUpLookupTableCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextPageUpLookupTableCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextPageUpLookupTableCallback`.
foreign import ccall "wrapper"
    mk_InputContextPageUpLookupTableCallback :: C_InputContextPageUpLookupTableCallback -> IO (FunPtr C_InputContextPageUpLookupTableCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextPageUpLookupTable :: MonadIO m => InputContextPageUpLookupTableCallback -> m (GClosure C_InputContextPageUpLookupTableCallback)
genClosure_InputContextPageUpLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextPageUpLookupTable IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageUpLookupTableCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextPageUpLookupTableCallback` into a `C_InputContextPageUpLookupTableCallback`.
wrap_InputContextPageUpLookupTableCallback ::
    InputContextPageUpLookupTableCallback ->
    C_InputContextPageUpLookupTableCallback
wrap_InputContextPageUpLookupTableCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageUpLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [pageUpLookupTable](#signal:pageUpLookupTable) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #pageUpLookupTable callback
-- @
-- 
-- 
onInputContextPageUpLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextPageUpLookupTableCallback -> m SignalHandlerId
onInputContextPageUpLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextPageUpLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageUpLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-up-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pageUpLookupTable](#signal:pageUpLookupTable) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #pageUpLookupTable callback
-- @
-- 
-- 
afterInputContextPageUpLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextPageUpLookupTableCallback -> m SignalHandlerId
afterInputContextPageUpLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextPageUpLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageUpLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"page-up-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextPageUpLookupTableSignalInfo
instance SignalInfo InputContextPageUpLookupTableSignalInfo where
    type HaskellCallbackType InputContextPageUpLookupTableSignalInfo = InputContextPageUpLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextPageUpLookupTableCallback cb
        cb'' <- mk_InputContextPageUpLookupTableCallback cb'
        connectSignalFunPtr obj "page-up-lookup-table" cb'' connectMode detail

#endif

-- signal InputContext::register-properties
-- | Emitted to register the properties in /@props@/.
-- 
-- (Note: The props object is floating, and it will be released after the
--  signal. If signal handler wants to keep the object, the handler should
--  use 'GI.GObject.Objects.Object.objectRefSink' to get the ownership of the object.)
type InputContextRegisterPropertiesCallback =
    IBus.PropList.PropList
    -- ^ /@props@/: An IBusPropList that contains properties.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextRegisterPropertiesCallback`@.
noInputContextRegisterPropertiesCallback :: Maybe InputContextRegisterPropertiesCallback
noInputContextRegisterPropertiesCallback :: Maybe InputContextRegisterPropertiesCallback
noInputContextRegisterPropertiesCallback = Maybe InputContextRegisterPropertiesCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextRegisterPropertiesCallback =
    Ptr () ->                               -- object
    Ptr IBus.PropList.PropList ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextRegisterPropertiesCallback`.
foreign import ccall "wrapper"
    mk_InputContextRegisterPropertiesCallback :: C_InputContextRegisterPropertiesCallback -> IO (FunPtr C_InputContextRegisterPropertiesCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextRegisterProperties :: MonadIO m => InputContextRegisterPropertiesCallback -> m (GClosure C_InputContextRegisterPropertiesCallback)
genClosure_InputContextRegisterProperties :: forall (m :: * -> *).
MonadIO m =>
InputContextRegisterPropertiesCallback
-> m (GClosure C_InputContextRegisterPropertiesCallback)
genClosure_InputContextRegisterProperties InputContextRegisterPropertiesCallback
cb = IO (GClosure C_InputContextRegisterPropertiesCallback)
-> m (GClosure C_InputContextRegisterPropertiesCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextRegisterPropertiesCallback)
 -> m (GClosure C_InputContextRegisterPropertiesCallback))
-> IO (GClosure C_InputContextRegisterPropertiesCallback)
-> m (GClosure C_InputContextRegisterPropertiesCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextRegisterPropertiesCallback
cb' = InputContextRegisterPropertiesCallback
-> C_InputContextRegisterPropertiesCallback
wrap_InputContextRegisterPropertiesCallback InputContextRegisterPropertiesCallback
cb
    C_InputContextRegisterPropertiesCallback
-> IO (FunPtr C_InputContextRegisterPropertiesCallback)
mk_InputContextRegisterPropertiesCallback C_InputContextRegisterPropertiesCallback
cb' IO (FunPtr C_InputContextRegisterPropertiesCallback)
-> (FunPtr C_InputContextRegisterPropertiesCallback
    -> IO (GClosure C_InputContextRegisterPropertiesCallback))
-> IO (GClosure C_InputContextRegisterPropertiesCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextRegisterPropertiesCallback
-> IO (GClosure C_InputContextRegisterPropertiesCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextRegisterPropertiesCallback` into a `C_InputContextRegisterPropertiesCallback`.
wrap_InputContextRegisterPropertiesCallback ::
    InputContextRegisterPropertiesCallback ->
    C_InputContextRegisterPropertiesCallback
wrap_InputContextRegisterPropertiesCallback :: InputContextRegisterPropertiesCallback
-> C_InputContextRegisterPropertiesCallback
wrap_InputContextRegisterPropertiesCallback InputContextRegisterPropertiesCallback
_cb Ptr ()
_ Ptr PropList
props Ptr ()
_ = do
    PropList
props' <- ((ManagedPtr PropList -> PropList) -> Ptr PropList -> IO PropList
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PropList -> PropList
IBus.PropList.PropList) Ptr PropList
props
    InputContextRegisterPropertiesCallback
_cb  PropList
props'


-- | Connect a signal handler for the [registerProperties](#signal:registerProperties) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #registerProperties callback
-- @
-- 
-- 
onInputContextRegisterProperties :: (IsInputContext a, MonadIO m) => a -> InputContextRegisterPropertiesCallback -> m SignalHandlerId
onInputContextRegisterProperties :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextRegisterPropertiesCallback -> m SignalHandlerId
onInputContextRegisterProperties a
obj InputContextRegisterPropertiesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextRegisterPropertiesCallback
cb' = InputContextRegisterPropertiesCallback
-> C_InputContextRegisterPropertiesCallback
wrap_InputContextRegisterPropertiesCallback InputContextRegisterPropertiesCallback
cb
    FunPtr C_InputContextRegisterPropertiesCallback
cb'' <- C_InputContextRegisterPropertiesCallback
-> IO (FunPtr C_InputContextRegisterPropertiesCallback)
mk_InputContextRegisterPropertiesCallback C_InputContextRegisterPropertiesCallback
cb'
    a
-> Text
-> FunPtr C_InputContextRegisterPropertiesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"register-properties" FunPtr C_InputContextRegisterPropertiesCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [registerProperties](#signal:registerProperties) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #registerProperties callback
-- @
-- 
-- 
afterInputContextRegisterProperties :: (IsInputContext a, MonadIO m) => a -> InputContextRegisterPropertiesCallback -> m SignalHandlerId
afterInputContextRegisterProperties :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextRegisterPropertiesCallback -> m SignalHandlerId
afterInputContextRegisterProperties a
obj InputContextRegisterPropertiesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextRegisterPropertiesCallback
cb' = InputContextRegisterPropertiesCallback
-> C_InputContextRegisterPropertiesCallback
wrap_InputContextRegisterPropertiesCallback InputContextRegisterPropertiesCallback
cb
    FunPtr C_InputContextRegisterPropertiesCallback
cb'' <- C_InputContextRegisterPropertiesCallback
-> IO (FunPtr C_InputContextRegisterPropertiesCallback)
mk_InputContextRegisterPropertiesCallback C_InputContextRegisterPropertiesCallback
cb'
    a
-> Text
-> FunPtr C_InputContextRegisterPropertiesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"register-properties" FunPtr C_InputContextRegisterPropertiesCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextRegisterPropertiesSignalInfo
instance SignalInfo InputContextRegisterPropertiesSignalInfo where
    type HaskellCallbackType InputContextRegisterPropertiesSignalInfo = InputContextRegisterPropertiesCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextRegisterPropertiesCallback cb
        cb'' <- mk_InputContextRegisterPropertiesCallback cb'
        connectSignalFunPtr obj "register-properties" cb'' connectMode detail

#endif

-- signal InputContext::show-auxiliary-text
-- | Emitted to show auxiliary text.
type InputContextShowAuxiliaryTextCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextShowAuxiliaryTextCallback`@.
noInputContextShowAuxiliaryTextCallback :: Maybe InputContextShowAuxiliaryTextCallback
noInputContextShowAuxiliaryTextCallback :: Maybe (IO ())
noInputContextShowAuxiliaryTextCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextShowAuxiliaryTextCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextShowAuxiliaryTextCallback`.
foreign import ccall "wrapper"
    mk_InputContextShowAuxiliaryTextCallback :: C_InputContextShowAuxiliaryTextCallback -> IO (FunPtr C_InputContextShowAuxiliaryTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextShowAuxiliaryText :: MonadIO m => InputContextShowAuxiliaryTextCallback -> m (GClosure C_InputContextShowAuxiliaryTextCallback)
genClosure_InputContextShowAuxiliaryText :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextShowAuxiliaryText IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowAuxiliaryTextCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextShowAuxiliaryTextCallback` into a `C_InputContextShowAuxiliaryTextCallback`.
wrap_InputContextShowAuxiliaryTextCallback ::
    InputContextShowAuxiliaryTextCallback ->
    C_InputContextShowAuxiliaryTextCallback
wrap_InputContextShowAuxiliaryTextCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowAuxiliaryTextCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [showAuxiliaryText](#signal:showAuxiliaryText) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #showAuxiliaryText callback
-- @
-- 
-- 
onInputContextShowAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextShowAuxiliaryTextCallback -> m SignalHandlerId
onInputContextShowAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextShowAuxiliaryText a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowAuxiliaryTextCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-auxiliary-text" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [showAuxiliaryText](#signal:showAuxiliaryText) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #showAuxiliaryText callback
-- @
-- 
-- 
afterInputContextShowAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextShowAuxiliaryTextCallback -> m SignalHandlerId
afterInputContextShowAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextShowAuxiliaryText a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowAuxiliaryTextCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-auxiliary-text" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextShowAuxiliaryTextSignalInfo
instance SignalInfo InputContextShowAuxiliaryTextSignalInfo where
    type HaskellCallbackType InputContextShowAuxiliaryTextSignalInfo = InputContextShowAuxiliaryTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextShowAuxiliaryTextCallback cb
        cb'' <- mk_InputContextShowAuxiliaryTextCallback cb'
        connectSignalFunPtr obj "show-auxiliary-text" cb'' connectMode detail

#endif

-- signal InputContext::show-lookup-table
-- | Emitted to show lookup table.
type InputContextShowLookupTableCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextShowLookupTableCallback`@.
noInputContextShowLookupTableCallback :: Maybe InputContextShowLookupTableCallback
noInputContextShowLookupTableCallback :: Maybe (IO ())
noInputContextShowLookupTableCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextShowLookupTableCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextShowLookupTableCallback`.
foreign import ccall "wrapper"
    mk_InputContextShowLookupTableCallback :: C_InputContextShowLookupTableCallback -> IO (FunPtr C_InputContextShowLookupTableCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextShowLookupTable :: MonadIO m => InputContextShowLookupTableCallback -> m (GClosure C_InputContextShowLookupTableCallback)
genClosure_InputContextShowLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextShowLookupTable IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowLookupTableCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextShowLookupTableCallback` into a `C_InputContextShowLookupTableCallback`.
wrap_InputContextShowLookupTableCallback ::
    InputContextShowLookupTableCallback ->
    C_InputContextShowLookupTableCallback
wrap_InputContextShowLookupTableCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [showLookupTable](#signal:showLookupTable) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #showLookupTable callback
-- @
-- 
-- 
onInputContextShowLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextShowLookupTableCallback -> m SignalHandlerId
onInputContextShowLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextShowLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [showLookupTable](#signal:showLookupTable) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #showLookupTable callback
-- @
-- 
-- 
afterInputContextShowLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextShowLookupTableCallback -> m SignalHandlerId
afterInputContextShowLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextShowLookupTable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowLookupTableCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowLookupTableCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-lookup-table" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextShowLookupTableSignalInfo
instance SignalInfo InputContextShowLookupTableSignalInfo where
    type HaskellCallbackType InputContextShowLookupTableSignalInfo = InputContextShowLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextShowLookupTableCallback cb
        cb'' <- mk_InputContextShowLookupTableCallback cb'
        connectSignalFunPtr obj "show-lookup-table" cb'' connectMode detail

#endif

-- signal InputContext::show-preedit-text
-- | Emitted to show preedit text.
type InputContextShowPreeditTextCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextShowPreeditTextCallback`@.
noInputContextShowPreeditTextCallback :: Maybe InputContextShowPreeditTextCallback
noInputContextShowPreeditTextCallback :: Maybe (IO ())
noInputContextShowPreeditTextCallback = Maybe (IO ())
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextShowPreeditTextCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextShowPreeditTextCallback`.
foreign import ccall "wrapper"
    mk_InputContextShowPreeditTextCallback :: C_InputContextShowPreeditTextCallback -> IO (FunPtr C_InputContextShowPreeditTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextShowPreeditText :: MonadIO m => InputContextShowPreeditTextCallback -> m (GClosure C_InputContextShowPreeditTextCallback)
genClosure_InputContextShowPreeditText :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_InputContextCursorDownLookupTableCallback)
genClosure_InputContextShowPreeditText IO ()
cb = IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextCursorDownLookupTableCallback)
 -> m (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
-> m (GClosure C_InputContextCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowPreeditTextCallback IO ()
cb
    C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowPreeditTextCallback C_InputContextCursorDownLookupTableCallback
cb' IO (FunPtr C_InputContextCursorDownLookupTableCallback)
-> (FunPtr C_InputContextCursorDownLookupTableCallback
    -> IO (GClosure C_InputContextCursorDownLookupTableCallback))
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextCursorDownLookupTableCallback
-> IO (GClosure C_InputContextCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextShowPreeditTextCallback` into a `C_InputContextShowPreeditTextCallback`.
wrap_InputContextShowPreeditTextCallback ::
    InputContextShowPreeditTextCallback ->
    C_InputContextShowPreeditTextCallback
wrap_InputContextShowPreeditTextCallback :: IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowPreeditTextCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [showPreeditText](#signal:showPreeditText) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #showPreeditText callback
-- @
-- 
-- 
onInputContextShowPreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextShowPreeditTextCallback -> m SignalHandlerId
onInputContextShowPreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onInputContextShowPreeditText a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowPreeditTextCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowPreeditTextCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-preedit-text" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [showPreeditText](#signal:showPreeditText) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #showPreeditText callback
-- @
-- 
-- 
afterInputContextShowPreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextShowPreeditTextCallback -> m SignalHandlerId
afterInputContextShowPreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterInputContextShowPreeditText a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextCursorDownLookupTableCallback
cb' = IO () -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowPreeditTextCallback IO ()
cb
    FunPtr C_InputContextCursorDownLookupTableCallback
cb'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowPreeditTextCallback C_InputContextCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-preedit-text" FunPtr C_InputContextCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextShowPreeditTextSignalInfo
instance SignalInfo InputContextShowPreeditTextSignalInfo where
    type HaskellCallbackType InputContextShowPreeditTextSignalInfo = InputContextShowPreeditTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextShowPreeditTextCallback cb
        cb'' <- mk_InputContextShowPreeditTextCallback cb'
        connectSignalFunPtr obj "show-preedit-text" cb'' connectMode detail

#endif

-- signal InputContext::update-auxiliary-text
-- | Emitted to hide auxilary text.
-- 
-- (Note: The text object is floating, and it will be released after the
--  signal. If signal handler wants to keep the object, the handler should
--  use 'GI.GObject.Objects.Object.objectRefSink' to get the ownership of the object.)
type InputContextUpdateAuxiliaryTextCallback =
    IBus.Text.Text
    -- ^ /@text@/: An auxiliary text
    -> Bool
    -- ^ /@visible@/: The visibility of /@text@/
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextUpdateAuxiliaryTextCallback`@.
noInputContextUpdateAuxiliaryTextCallback :: Maybe InputContextUpdateAuxiliaryTextCallback
noInputContextUpdateAuxiliaryTextCallback :: Maybe InputContextUpdateAuxiliaryTextCallback
noInputContextUpdateAuxiliaryTextCallback = Maybe InputContextUpdateAuxiliaryTextCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextUpdateAuxiliaryTextCallback =
    Ptr () ->                               -- object
    Ptr IBus.Text.Text ->
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextUpdateAuxiliaryTextCallback`.
foreign import ccall "wrapper"
    mk_InputContextUpdateAuxiliaryTextCallback :: C_InputContextUpdateAuxiliaryTextCallback -> IO (FunPtr C_InputContextUpdateAuxiliaryTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextUpdateAuxiliaryText :: MonadIO m => InputContextUpdateAuxiliaryTextCallback -> m (GClosure C_InputContextUpdateAuxiliaryTextCallback)
genClosure_InputContextUpdateAuxiliaryText :: forall (m :: * -> *).
MonadIO m =>
InputContextUpdateAuxiliaryTextCallback
-> m (GClosure C_InputContextUpdateAuxiliaryTextCallback)
genClosure_InputContextUpdateAuxiliaryText InputContextUpdateAuxiliaryTextCallback
cb = IO (GClosure C_InputContextUpdateAuxiliaryTextCallback)
-> m (GClosure C_InputContextUpdateAuxiliaryTextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextUpdateAuxiliaryTextCallback)
 -> m (GClosure C_InputContextUpdateAuxiliaryTextCallback))
-> IO (GClosure C_InputContextUpdateAuxiliaryTextCallback)
-> m (GClosure C_InputContextUpdateAuxiliaryTextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdateAuxiliaryTextCallback
cb' = InputContextUpdateAuxiliaryTextCallback
-> C_InputContextUpdateAuxiliaryTextCallback
wrap_InputContextUpdateAuxiliaryTextCallback InputContextUpdateAuxiliaryTextCallback
cb
    C_InputContextUpdateAuxiliaryTextCallback
-> IO (FunPtr C_InputContextUpdateAuxiliaryTextCallback)
mk_InputContextUpdateAuxiliaryTextCallback C_InputContextUpdateAuxiliaryTextCallback
cb' IO (FunPtr C_InputContextUpdateAuxiliaryTextCallback)
-> (FunPtr C_InputContextUpdateAuxiliaryTextCallback
    -> IO (GClosure C_InputContextUpdateAuxiliaryTextCallback))
-> IO (GClosure C_InputContextUpdateAuxiliaryTextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextUpdateAuxiliaryTextCallback
-> IO (GClosure C_InputContextUpdateAuxiliaryTextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextUpdateAuxiliaryTextCallback` into a `C_InputContextUpdateAuxiliaryTextCallback`.
wrap_InputContextUpdateAuxiliaryTextCallback ::
    InputContextUpdateAuxiliaryTextCallback ->
    C_InputContextUpdateAuxiliaryTextCallback
wrap_InputContextUpdateAuxiliaryTextCallback :: InputContextUpdateAuxiliaryTextCallback
-> C_InputContextUpdateAuxiliaryTextCallback
wrap_InputContextUpdateAuxiliaryTextCallback InputContextUpdateAuxiliaryTextCallback
_cb Ptr ()
_ Ptr Text
text CInt
visible Ptr ()
_ = do
    Text
text' <- ((ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Text -> Text
IBus.Text.Text) Ptr Text
text
    let visible' :: Bool
visible' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
visible
    InputContextUpdateAuxiliaryTextCallback
_cb  Text
text' Bool
visible'


-- | Connect a signal handler for the [updateAuxiliaryText](#signal:updateAuxiliaryText) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #updateAuxiliaryText callback
-- @
-- 
-- 
onInputContextUpdateAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextUpdateAuxiliaryTextCallback -> m SignalHandlerId
onInputContextUpdateAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextUpdateAuxiliaryTextCallback -> m SignalHandlerId
onInputContextUpdateAuxiliaryText a
obj InputContextUpdateAuxiliaryTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdateAuxiliaryTextCallback
cb' = InputContextUpdateAuxiliaryTextCallback
-> C_InputContextUpdateAuxiliaryTextCallback
wrap_InputContextUpdateAuxiliaryTextCallback InputContextUpdateAuxiliaryTextCallback
cb
    FunPtr C_InputContextUpdateAuxiliaryTextCallback
cb'' <- C_InputContextUpdateAuxiliaryTextCallback
-> IO (FunPtr C_InputContextUpdateAuxiliaryTextCallback)
mk_InputContextUpdateAuxiliaryTextCallback C_InputContextUpdateAuxiliaryTextCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdateAuxiliaryTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-auxiliary-text" FunPtr C_InputContextUpdateAuxiliaryTextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [updateAuxiliaryText](#signal:updateAuxiliaryText) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #updateAuxiliaryText callback
-- @
-- 
-- 
afterInputContextUpdateAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> InputContextUpdateAuxiliaryTextCallback -> m SignalHandlerId
afterInputContextUpdateAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextUpdateAuxiliaryTextCallback -> m SignalHandlerId
afterInputContextUpdateAuxiliaryText a
obj InputContextUpdateAuxiliaryTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdateAuxiliaryTextCallback
cb' = InputContextUpdateAuxiliaryTextCallback
-> C_InputContextUpdateAuxiliaryTextCallback
wrap_InputContextUpdateAuxiliaryTextCallback InputContextUpdateAuxiliaryTextCallback
cb
    FunPtr C_InputContextUpdateAuxiliaryTextCallback
cb'' <- C_InputContextUpdateAuxiliaryTextCallback
-> IO (FunPtr C_InputContextUpdateAuxiliaryTextCallback)
mk_InputContextUpdateAuxiliaryTextCallback C_InputContextUpdateAuxiliaryTextCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdateAuxiliaryTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-auxiliary-text" FunPtr C_InputContextUpdateAuxiliaryTextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextUpdateAuxiliaryTextSignalInfo
instance SignalInfo InputContextUpdateAuxiliaryTextSignalInfo where
    type HaskellCallbackType InputContextUpdateAuxiliaryTextSignalInfo = InputContextUpdateAuxiliaryTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextUpdateAuxiliaryTextCallback cb
        cb'' <- mk_InputContextUpdateAuxiliaryTextCallback cb'
        connectSignalFunPtr obj "update-auxiliary-text" cb'' connectMode detail

#endif

-- signal InputContext::update-lookup-table
-- | Emitted to update lookup table.
-- 
-- (Note: The table object is floating, and it will be released after the
--  signal. If signal handler wants to keep the object, the handler should
--  use 'GI.GObject.Objects.Object.objectRefSink' to get the ownership of the object.)
type InputContextUpdateLookupTableCallback =
    IBus.LookupTable.LookupTable
    -- ^ /@table@/: An IBusLookupTable to be updated.
    -> Bool
    -- ^ /@visible@/: Whether the table should be visible.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextUpdateLookupTableCallback`@.
noInputContextUpdateLookupTableCallback :: Maybe InputContextUpdateLookupTableCallback
noInputContextUpdateLookupTableCallback :: Maybe InputContextUpdateLookupTableCallback
noInputContextUpdateLookupTableCallback = Maybe InputContextUpdateLookupTableCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextUpdateLookupTableCallback =
    Ptr () ->                               -- object
    Ptr IBus.LookupTable.LookupTable ->
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextUpdateLookupTableCallback`.
foreign import ccall "wrapper"
    mk_InputContextUpdateLookupTableCallback :: C_InputContextUpdateLookupTableCallback -> IO (FunPtr C_InputContextUpdateLookupTableCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextUpdateLookupTable :: MonadIO m => InputContextUpdateLookupTableCallback -> m (GClosure C_InputContextUpdateLookupTableCallback)
genClosure_InputContextUpdateLookupTable :: forall (m :: * -> *).
MonadIO m =>
InputContextUpdateLookupTableCallback
-> m (GClosure C_InputContextUpdateLookupTableCallback)
genClosure_InputContextUpdateLookupTable InputContextUpdateLookupTableCallback
cb = IO (GClosure C_InputContextUpdateLookupTableCallback)
-> m (GClosure C_InputContextUpdateLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextUpdateLookupTableCallback)
 -> m (GClosure C_InputContextUpdateLookupTableCallback))
-> IO (GClosure C_InputContextUpdateLookupTableCallback)
-> m (GClosure C_InputContextUpdateLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdateLookupTableCallback
cb' = InputContextUpdateLookupTableCallback
-> C_InputContextUpdateLookupTableCallback
wrap_InputContextUpdateLookupTableCallback InputContextUpdateLookupTableCallback
cb
    C_InputContextUpdateLookupTableCallback
-> IO (FunPtr C_InputContextUpdateLookupTableCallback)
mk_InputContextUpdateLookupTableCallback C_InputContextUpdateLookupTableCallback
cb' IO (FunPtr C_InputContextUpdateLookupTableCallback)
-> (FunPtr C_InputContextUpdateLookupTableCallback
    -> IO (GClosure C_InputContextUpdateLookupTableCallback))
-> IO (GClosure C_InputContextUpdateLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextUpdateLookupTableCallback
-> IO (GClosure C_InputContextUpdateLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextUpdateLookupTableCallback` into a `C_InputContextUpdateLookupTableCallback`.
wrap_InputContextUpdateLookupTableCallback ::
    InputContextUpdateLookupTableCallback ->
    C_InputContextUpdateLookupTableCallback
wrap_InputContextUpdateLookupTableCallback :: InputContextUpdateLookupTableCallback
-> C_InputContextUpdateLookupTableCallback
wrap_InputContextUpdateLookupTableCallback InputContextUpdateLookupTableCallback
_cb Ptr ()
_ Ptr LookupTable
table CInt
visible Ptr ()
_ = do
    LookupTable
table' <- ((ManagedPtr LookupTable -> LookupTable)
-> Ptr LookupTable -> IO LookupTable
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr LookupTable -> LookupTable
IBus.LookupTable.LookupTable) Ptr LookupTable
table
    let visible' :: Bool
visible' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
visible
    InputContextUpdateLookupTableCallback
_cb  LookupTable
table' Bool
visible'


-- | Connect a signal handler for the [updateLookupTable](#signal:updateLookupTable) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #updateLookupTable callback
-- @
-- 
-- 
onInputContextUpdateLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextUpdateLookupTableCallback -> m SignalHandlerId
onInputContextUpdateLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextUpdateLookupTableCallback -> m SignalHandlerId
onInputContextUpdateLookupTable a
obj InputContextUpdateLookupTableCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdateLookupTableCallback
cb' = InputContextUpdateLookupTableCallback
-> C_InputContextUpdateLookupTableCallback
wrap_InputContextUpdateLookupTableCallback InputContextUpdateLookupTableCallback
cb
    FunPtr C_InputContextUpdateLookupTableCallback
cb'' <- C_InputContextUpdateLookupTableCallback
-> IO (FunPtr C_InputContextUpdateLookupTableCallback)
mk_InputContextUpdateLookupTableCallback C_InputContextUpdateLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdateLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-lookup-table" FunPtr C_InputContextUpdateLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [updateLookupTable](#signal:updateLookupTable) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #updateLookupTable callback
-- @
-- 
-- 
afterInputContextUpdateLookupTable :: (IsInputContext a, MonadIO m) => a -> InputContextUpdateLookupTableCallback -> m SignalHandlerId
afterInputContextUpdateLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextUpdateLookupTableCallback -> m SignalHandlerId
afterInputContextUpdateLookupTable a
obj InputContextUpdateLookupTableCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdateLookupTableCallback
cb' = InputContextUpdateLookupTableCallback
-> C_InputContextUpdateLookupTableCallback
wrap_InputContextUpdateLookupTableCallback InputContextUpdateLookupTableCallback
cb
    FunPtr C_InputContextUpdateLookupTableCallback
cb'' <- C_InputContextUpdateLookupTableCallback
-> IO (FunPtr C_InputContextUpdateLookupTableCallback)
mk_InputContextUpdateLookupTableCallback C_InputContextUpdateLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdateLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-lookup-table" FunPtr C_InputContextUpdateLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextUpdateLookupTableSignalInfo
instance SignalInfo InputContextUpdateLookupTableSignalInfo where
    type HaskellCallbackType InputContextUpdateLookupTableSignalInfo = InputContextUpdateLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextUpdateLookupTableCallback cb
        cb'' <- mk_InputContextUpdateLookupTableCallback cb'
        connectSignalFunPtr obj "update-lookup-table" cb'' connectMode detail

#endif

-- signal InputContext::update-preedit-text
-- | Emitted to update preedit text.
-- 
-- (Note: The text object is floating, and it will be released after the
--  signal. If signal handler wants to keep the object, the handler should
--  use 'GI.GObject.Objects.Object.objectRefSink' to get the ownership of the object.)
type InputContextUpdatePreeditTextCallback =
    IBus.Text.Text
    -- ^ /@text@/: Text to be updated.
    -> Word32
    -- ^ /@cursorPos@/: Cursor position.
    -> Bool
    -- ^ /@visible@/: Whether the update is visible.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextUpdatePreeditTextCallback`@.
noInputContextUpdatePreeditTextCallback :: Maybe InputContextUpdatePreeditTextCallback
noInputContextUpdatePreeditTextCallback :: Maybe InputContextUpdatePreeditTextCallback
noInputContextUpdatePreeditTextCallback = Maybe InputContextUpdatePreeditTextCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextUpdatePreeditTextCallback =
    Ptr () ->                               -- object
    Ptr IBus.Text.Text ->
    Word32 ->
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextUpdatePreeditTextCallback`.
foreign import ccall "wrapper"
    mk_InputContextUpdatePreeditTextCallback :: C_InputContextUpdatePreeditTextCallback -> IO (FunPtr C_InputContextUpdatePreeditTextCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextUpdatePreeditText :: MonadIO m => InputContextUpdatePreeditTextCallback -> m (GClosure C_InputContextUpdatePreeditTextCallback)
genClosure_InputContextUpdatePreeditText :: forall (m :: * -> *).
MonadIO m =>
InputContextUpdatePreeditTextCallback
-> m (GClosure C_InputContextUpdatePreeditTextCallback)
genClosure_InputContextUpdatePreeditText InputContextUpdatePreeditTextCallback
cb = IO (GClosure C_InputContextUpdatePreeditTextCallback)
-> m (GClosure C_InputContextUpdatePreeditTextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextUpdatePreeditTextCallback)
 -> m (GClosure C_InputContextUpdatePreeditTextCallback))
-> IO (GClosure C_InputContextUpdatePreeditTextCallback)
-> m (GClosure C_InputContextUpdatePreeditTextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdatePreeditTextCallback
cb' = InputContextUpdatePreeditTextCallback
-> C_InputContextUpdatePreeditTextCallback
wrap_InputContextUpdatePreeditTextCallback InputContextUpdatePreeditTextCallback
cb
    C_InputContextUpdatePreeditTextCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextCallback)
mk_InputContextUpdatePreeditTextCallback C_InputContextUpdatePreeditTextCallback
cb' IO (FunPtr C_InputContextUpdatePreeditTextCallback)
-> (FunPtr C_InputContextUpdatePreeditTextCallback
    -> IO (GClosure C_InputContextUpdatePreeditTextCallback))
-> IO (GClosure C_InputContextUpdatePreeditTextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextUpdatePreeditTextCallback
-> IO (GClosure C_InputContextUpdatePreeditTextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextUpdatePreeditTextCallback` into a `C_InputContextUpdatePreeditTextCallback`.
wrap_InputContextUpdatePreeditTextCallback ::
    InputContextUpdatePreeditTextCallback ->
    C_InputContextUpdatePreeditTextCallback
wrap_InputContextUpdatePreeditTextCallback :: InputContextUpdatePreeditTextCallback
-> C_InputContextUpdatePreeditTextCallback
wrap_InputContextUpdatePreeditTextCallback InputContextUpdatePreeditTextCallback
_cb Ptr ()
_ Ptr Text
text Word32
cursorPos CInt
visible Ptr ()
_ = do
    Text
text' <- ((ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Text -> Text
IBus.Text.Text) Ptr Text
text
    let visible' :: Bool
visible' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
visible
    InputContextUpdatePreeditTextCallback
_cb  Text
text' Word32
cursorPos Bool
visible'


-- | Connect a signal handler for the [updatePreeditText](#signal:updatePreeditText) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #updatePreeditText callback
-- @
-- 
-- 
onInputContextUpdatePreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePreeditTextCallback -> m SignalHandlerId
onInputContextUpdatePreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextUpdatePreeditTextCallback -> m SignalHandlerId
onInputContextUpdatePreeditText a
obj InputContextUpdatePreeditTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdatePreeditTextCallback
cb' = InputContextUpdatePreeditTextCallback
-> C_InputContextUpdatePreeditTextCallback
wrap_InputContextUpdatePreeditTextCallback InputContextUpdatePreeditTextCallback
cb
    FunPtr C_InputContextUpdatePreeditTextCallback
cb'' <- C_InputContextUpdatePreeditTextCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextCallback)
mk_InputContextUpdatePreeditTextCallback C_InputContextUpdatePreeditTextCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdatePreeditTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-preedit-text" FunPtr C_InputContextUpdatePreeditTextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [updatePreeditText](#signal:updatePreeditText) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #updatePreeditText callback
-- @
-- 
-- 
afterInputContextUpdatePreeditText :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePreeditTextCallback -> m SignalHandlerId
afterInputContextUpdatePreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextUpdatePreeditTextCallback -> m SignalHandlerId
afterInputContextUpdatePreeditText a
obj InputContextUpdatePreeditTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdatePreeditTextCallback
cb' = InputContextUpdatePreeditTextCallback
-> C_InputContextUpdatePreeditTextCallback
wrap_InputContextUpdatePreeditTextCallback InputContextUpdatePreeditTextCallback
cb
    FunPtr C_InputContextUpdatePreeditTextCallback
cb'' <- C_InputContextUpdatePreeditTextCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextCallback)
mk_InputContextUpdatePreeditTextCallback C_InputContextUpdatePreeditTextCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdatePreeditTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-preedit-text" FunPtr C_InputContextUpdatePreeditTextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextUpdatePreeditTextSignalInfo
instance SignalInfo InputContextUpdatePreeditTextSignalInfo where
    type HaskellCallbackType InputContextUpdatePreeditTextSignalInfo = InputContextUpdatePreeditTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextUpdatePreeditTextCallback cb
        cb'' <- mk_InputContextUpdatePreeditTextCallback cb'
        connectSignalFunPtr obj "update-preedit-text" cb'' connectMode detail

#endif

-- signal InputContext::update-preedit-text-with-mode
-- | Emitted to update preedit text with the mode.
-- 
-- (Note: The text object is floating, and it will be released after the
--  signal. If signal handler wants to keep the object, the handler should
--  use 'GI.GObject.Objects.Object.objectRefSink' to get the ownership of the object.)
type InputContextUpdatePreeditTextWithModeCallback =
    IBus.Text.Text
    -- ^ /@text@/: Text to be updated.
    -> Word32
    -- ^ /@cursorPos@/: Cursor position.
    -> Bool
    -- ^ /@visible@/: Whether the update is visible.
    -> Word32
    -- ^ /@mode@/: Preedit mode.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextUpdatePreeditTextWithModeCallback`@.
noInputContextUpdatePreeditTextWithModeCallback :: Maybe InputContextUpdatePreeditTextWithModeCallback
noInputContextUpdatePreeditTextWithModeCallback :: Maybe InputContextUpdatePreeditTextWithModeCallback
noInputContextUpdatePreeditTextWithModeCallback = Maybe InputContextUpdatePreeditTextWithModeCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextUpdatePreeditTextWithModeCallback =
    Ptr () ->                               -- object
    Ptr IBus.Text.Text ->
    Word32 ->
    CInt ->
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextUpdatePreeditTextWithModeCallback`.
foreign import ccall "wrapper"
    mk_InputContextUpdatePreeditTextWithModeCallback :: C_InputContextUpdatePreeditTextWithModeCallback -> IO (FunPtr C_InputContextUpdatePreeditTextWithModeCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextUpdatePreeditTextWithMode :: MonadIO m => InputContextUpdatePreeditTextWithModeCallback -> m (GClosure C_InputContextUpdatePreeditTextWithModeCallback)
genClosure_InputContextUpdatePreeditTextWithMode :: forall (m :: * -> *).
MonadIO m =>
InputContextUpdatePreeditTextWithModeCallback
-> m (GClosure C_InputContextUpdatePreeditTextWithModeCallback)
genClosure_InputContextUpdatePreeditTextWithMode InputContextUpdatePreeditTextWithModeCallback
cb = IO (GClosure C_InputContextUpdatePreeditTextWithModeCallback)
-> m (GClosure C_InputContextUpdatePreeditTextWithModeCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextUpdatePreeditTextWithModeCallback)
 -> m (GClosure C_InputContextUpdatePreeditTextWithModeCallback))
-> IO (GClosure C_InputContextUpdatePreeditTextWithModeCallback)
-> m (GClosure C_InputContextUpdatePreeditTextWithModeCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdatePreeditTextWithModeCallback
cb' = InputContextUpdatePreeditTextWithModeCallback
-> C_InputContextUpdatePreeditTextWithModeCallback
wrap_InputContextUpdatePreeditTextWithModeCallback InputContextUpdatePreeditTextWithModeCallback
cb
    C_InputContextUpdatePreeditTextWithModeCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextWithModeCallback)
mk_InputContextUpdatePreeditTextWithModeCallback C_InputContextUpdatePreeditTextWithModeCallback
cb' IO (FunPtr C_InputContextUpdatePreeditTextWithModeCallback)
-> (FunPtr C_InputContextUpdatePreeditTextWithModeCallback
    -> IO (GClosure C_InputContextUpdatePreeditTextWithModeCallback))
-> IO (GClosure C_InputContextUpdatePreeditTextWithModeCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextUpdatePreeditTextWithModeCallback
-> IO (GClosure C_InputContextUpdatePreeditTextWithModeCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextUpdatePreeditTextWithModeCallback` into a `C_InputContextUpdatePreeditTextWithModeCallback`.
wrap_InputContextUpdatePreeditTextWithModeCallback ::
    InputContextUpdatePreeditTextWithModeCallback ->
    C_InputContextUpdatePreeditTextWithModeCallback
wrap_InputContextUpdatePreeditTextWithModeCallback :: InputContextUpdatePreeditTextWithModeCallback
-> C_InputContextUpdatePreeditTextWithModeCallback
wrap_InputContextUpdatePreeditTextWithModeCallback InputContextUpdatePreeditTextWithModeCallback
_cb Ptr ()
_ Ptr Text
text Word32
cursorPos CInt
visible Word32
mode Ptr ()
_ = do
    Text
text' <- ((ManagedPtr Text -> Text) -> Ptr Text -> IO Text
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Text -> Text
IBus.Text.Text) Ptr Text
text
    let visible' :: Bool
visible' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
visible
    InputContextUpdatePreeditTextWithModeCallback
_cb  Text
text' Word32
cursorPos Bool
visible' Word32
mode


-- | Connect a signal handler for the [updatePreeditTextWithMode](#signal:updatePreeditTextWithMode) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #updatePreeditTextWithMode callback
-- @
-- 
-- 
onInputContextUpdatePreeditTextWithMode :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePreeditTextWithModeCallback -> m SignalHandlerId
onInputContextUpdatePreeditTextWithMode :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> InputContextUpdatePreeditTextWithModeCallback
-> m SignalHandlerId
onInputContextUpdatePreeditTextWithMode a
obj InputContextUpdatePreeditTextWithModeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdatePreeditTextWithModeCallback
cb' = InputContextUpdatePreeditTextWithModeCallback
-> C_InputContextUpdatePreeditTextWithModeCallback
wrap_InputContextUpdatePreeditTextWithModeCallback InputContextUpdatePreeditTextWithModeCallback
cb
    FunPtr C_InputContextUpdatePreeditTextWithModeCallback
cb'' <- C_InputContextUpdatePreeditTextWithModeCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextWithModeCallback)
mk_InputContextUpdatePreeditTextWithModeCallback C_InputContextUpdatePreeditTextWithModeCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdatePreeditTextWithModeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-preedit-text-with-mode" FunPtr C_InputContextUpdatePreeditTextWithModeCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [updatePreeditTextWithMode](#signal:updatePreeditTextWithMode) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #updatePreeditTextWithMode callback
-- @
-- 
-- 
afterInputContextUpdatePreeditTextWithMode :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePreeditTextWithModeCallback -> m SignalHandlerId
afterInputContextUpdatePreeditTextWithMode :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> InputContextUpdatePreeditTextWithModeCallback
-> m SignalHandlerId
afterInputContextUpdatePreeditTextWithMode a
obj InputContextUpdatePreeditTextWithModeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdatePreeditTextWithModeCallback
cb' = InputContextUpdatePreeditTextWithModeCallback
-> C_InputContextUpdatePreeditTextWithModeCallback
wrap_InputContextUpdatePreeditTextWithModeCallback InputContextUpdatePreeditTextWithModeCallback
cb
    FunPtr C_InputContextUpdatePreeditTextWithModeCallback
cb'' <- C_InputContextUpdatePreeditTextWithModeCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextWithModeCallback)
mk_InputContextUpdatePreeditTextWithModeCallback C_InputContextUpdatePreeditTextWithModeCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdatePreeditTextWithModeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-preedit-text-with-mode" FunPtr C_InputContextUpdatePreeditTextWithModeCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextUpdatePreeditTextWithModeSignalInfo
instance SignalInfo InputContextUpdatePreeditTextWithModeSignalInfo where
    type HaskellCallbackType InputContextUpdatePreeditTextWithModeSignalInfo = InputContextUpdatePreeditTextWithModeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextUpdatePreeditTextWithModeCallback cb
        cb'' <- mk_InputContextUpdatePreeditTextWithModeCallback cb'
        connectSignalFunPtr obj "update-preedit-text-with-mode" cb'' connectMode detail

#endif

-- signal InputContext::update-property
-- | Emitted to update the property /@prop@/.
-- 
-- (Note: The prop object is floating, and it will be released after the
--  signal. If signal handler wants to keep the object, the handler should
--  use 'GI.GObject.Objects.Object.objectRefSink' to get the ownership of the object.)
type InputContextUpdatePropertyCallback =
    IBus.Property.Property
    -- ^ /@prop@/: The IBusProperty to be updated.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `InputContextUpdatePropertyCallback`@.
noInputContextUpdatePropertyCallback :: Maybe InputContextUpdatePropertyCallback
noInputContextUpdatePropertyCallback :: Maybe InputContextUpdatePropertyCallback
noInputContextUpdatePropertyCallback = Maybe InputContextUpdatePropertyCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_InputContextUpdatePropertyCallback =
    Ptr () ->                               -- object
    Ptr IBus.Property.Property ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_InputContextUpdatePropertyCallback`.
foreign import ccall "wrapper"
    mk_InputContextUpdatePropertyCallback :: C_InputContextUpdatePropertyCallback -> IO (FunPtr C_InputContextUpdatePropertyCallback)

-- | Wrap the callback into a `GClosure`.
genClosure_InputContextUpdateProperty :: MonadIO m => InputContextUpdatePropertyCallback -> m (GClosure C_InputContextUpdatePropertyCallback)
genClosure_InputContextUpdateProperty :: forall (m :: * -> *).
MonadIO m =>
InputContextUpdatePropertyCallback
-> m (GClosure C_InputContextUpdatePropertyCallback)
genClosure_InputContextUpdateProperty InputContextUpdatePropertyCallback
cb = IO (GClosure C_InputContextUpdatePropertyCallback)
-> m (GClosure C_InputContextUpdatePropertyCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_InputContextUpdatePropertyCallback)
 -> m (GClosure C_InputContextUpdatePropertyCallback))
-> IO (GClosure C_InputContextUpdatePropertyCallback)
-> m (GClosure C_InputContextUpdatePropertyCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdatePropertyCallback
cb' = InputContextUpdatePropertyCallback
-> C_InputContextUpdatePropertyCallback
wrap_InputContextUpdatePropertyCallback InputContextUpdatePropertyCallback
cb
    C_InputContextUpdatePropertyCallback
-> IO (FunPtr C_InputContextUpdatePropertyCallback)
mk_InputContextUpdatePropertyCallback C_InputContextUpdatePropertyCallback
cb' IO (FunPtr C_InputContextUpdatePropertyCallback)
-> (FunPtr C_InputContextUpdatePropertyCallback
    -> IO (GClosure C_InputContextUpdatePropertyCallback))
-> IO (GClosure C_InputContextUpdatePropertyCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_InputContextUpdatePropertyCallback
-> IO (GClosure C_InputContextUpdatePropertyCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `InputContextUpdatePropertyCallback` into a `C_InputContextUpdatePropertyCallback`.
wrap_InputContextUpdatePropertyCallback ::
    InputContextUpdatePropertyCallback ->
    C_InputContextUpdatePropertyCallback
wrap_InputContextUpdatePropertyCallback :: InputContextUpdatePropertyCallback
-> C_InputContextUpdatePropertyCallback
wrap_InputContextUpdatePropertyCallback InputContextUpdatePropertyCallback
_cb Ptr ()
_ Ptr Property
prop Ptr ()
_ = do
    Property
prop' <- ((ManagedPtr Property -> Property) -> Ptr Property -> IO Property
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Property -> Property
IBus.Property.Property) Ptr Property
prop
    InputContextUpdatePropertyCallback
_cb  Property
prop'


-- | Connect a signal handler for the [updateProperty](#signal:updateProperty) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' inputContext #updateProperty callback
-- @
-- 
-- 
onInputContextUpdateProperty :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePropertyCallback -> m SignalHandlerId
onInputContextUpdateProperty :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextUpdatePropertyCallback -> m SignalHandlerId
onInputContextUpdateProperty a
obj InputContextUpdatePropertyCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdatePropertyCallback
cb' = InputContextUpdatePropertyCallback
-> C_InputContextUpdatePropertyCallback
wrap_InputContextUpdatePropertyCallback InputContextUpdatePropertyCallback
cb
    FunPtr C_InputContextUpdatePropertyCallback
cb'' <- C_InputContextUpdatePropertyCallback
-> IO (FunPtr C_InputContextUpdatePropertyCallback)
mk_InputContextUpdatePropertyCallback C_InputContextUpdatePropertyCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdatePropertyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-property" FunPtr C_InputContextUpdatePropertyCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [updateProperty](#signal:updateProperty) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' inputContext #updateProperty callback
-- @
-- 
-- 
afterInputContextUpdateProperty :: (IsInputContext a, MonadIO m) => a -> InputContextUpdatePropertyCallback -> m SignalHandlerId
afterInputContextUpdateProperty :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> InputContextUpdatePropertyCallback -> m SignalHandlerId
afterInputContextUpdateProperty a
obj InputContextUpdatePropertyCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_InputContextUpdatePropertyCallback
cb' = InputContextUpdatePropertyCallback
-> C_InputContextUpdatePropertyCallback
wrap_InputContextUpdatePropertyCallback InputContextUpdatePropertyCallback
cb
    FunPtr C_InputContextUpdatePropertyCallback
cb'' <- C_InputContextUpdatePropertyCallback
-> IO (FunPtr C_InputContextUpdatePropertyCallback)
mk_InputContextUpdatePropertyCallback C_InputContextUpdatePropertyCallback
cb'
    a
-> Text
-> FunPtr C_InputContextUpdatePropertyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"update-property" FunPtr C_InputContextUpdatePropertyCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextUpdatePropertySignalInfo
instance SignalInfo InputContextUpdatePropertySignalInfo where
    type HaskellCallbackType InputContextUpdatePropertySignalInfo = InputContextUpdatePropertyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextUpdatePropertyCallback cb
        cb'' <- mk_InputContextUpdatePropertyCallback cb'
        connectSignalFunPtr obj "update-property" cb'' connectMode detail

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList InputContext
type instance O.AttributeList InputContext = InputContextAttributeList
type InputContextAttributeList = ('[ '("gBusType", Gio.DBusProxy.DBusProxyGBusTypePropertyInfo), '("gConnection", Gio.DBusProxy.DBusProxyGConnectionPropertyInfo), '("gDefaultTimeout", Gio.DBusProxy.DBusProxyGDefaultTimeoutPropertyInfo), '("gFlags", Gio.DBusProxy.DBusProxyGFlagsPropertyInfo), '("gInterfaceInfo", Gio.DBusProxy.DBusProxyGInterfaceInfoPropertyInfo), '("gInterfaceName", Gio.DBusProxy.DBusProxyGInterfaceNamePropertyInfo), '("gName", Gio.DBusProxy.DBusProxyGNamePropertyInfo), '("gNameOwner", Gio.DBusProxy.DBusProxyGNameOwnerPropertyInfo), '("gObjectPath", Gio.DBusProxy.DBusProxyGObjectPathPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList InputContext = InputContextSignalList
type InputContextSignalList = ('[ '("commitText", InputContextCommitTextSignalInfo), '("cursorDownLookupTable", InputContextCursorDownLookupTableSignalInfo), '("cursorUpLookupTable", InputContextCursorUpLookupTableSignalInfo), '("deleteSurroundingText", InputContextDeleteSurroundingTextSignalInfo), '("destroy", IBus.Proxy.ProxyDestroySignalInfo), '("disabled", InputContextDisabledSignalInfo), '("enabled", InputContextEnabledSignalInfo), '("forwardKeyEvent", InputContextForwardKeyEventSignalInfo), '("gPropertiesChanged", Gio.DBusProxy.DBusProxyGPropertiesChangedSignalInfo), '("gSignal", Gio.DBusProxy.DBusProxyGSignalSignalInfo), '("hideAuxiliaryText", InputContextHideAuxiliaryTextSignalInfo), '("hideLookupTable", InputContextHideLookupTableSignalInfo), '("hidePreeditText", InputContextHidePreeditTextSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pageDownLookupTable", InputContextPageDownLookupTableSignalInfo), '("pageUpLookupTable", InputContextPageUpLookupTableSignalInfo), '("registerProperties", InputContextRegisterPropertiesSignalInfo), '("showAuxiliaryText", InputContextShowAuxiliaryTextSignalInfo), '("showLookupTable", InputContextShowLookupTableSignalInfo), '("showPreeditText", InputContextShowPreeditTextSignalInfo), '("updateAuxiliaryText", InputContextUpdateAuxiliaryTextSignalInfo), '("updateLookupTable", InputContextUpdateLookupTableSignalInfo), '("updatePreeditText", InputContextUpdatePreeditTextSignalInfo), '("updatePreeditTextWithMode", InputContextUpdatePreeditTextWithModeSignalInfo), '("updateProperty", InputContextUpdatePropertySignalInfo)] :: [(Symbol, *)])

#endif

-- method InputContext::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The path to the object that emitting the signal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GCancellable or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "IBus" , name = "InputContext" })
-- throws : True
-- Skip return : False

foreign import ccall "ibus_input_context_new" ibus_input_context_new :: 
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr InputContext)

-- | Creates a new t'GI.IBus.Objects.InputContext.InputContext'.
inputContextNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
    T.Text
    -- ^ /@path@/: The path to the object that emitting the signal.
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> Maybe (b)
    -- ^ /@cancellable@/: A t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing'.
    -> m InputContext
    -- ^ __Returns:__ A newly allocated t'GI.IBus.Objects.InputContext.InputContext'. /(Can throw 'Data.GI.Base.GError.GError')/
inputContextNew :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusConnection a, IsCancellable b) =>
Text -> a -> Maybe b -> m InputContext
inputContextNew Text
path a
connection Maybe b
cancellable = IO InputContext -> m InputContext
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InputContext -> m InputContext)
-> IO InputContext -> m InputContext
forall a b. (a -> b) -> a -> b
$ do
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr DBusConnection
connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO InputContext -> IO () -> IO InputContext
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr InputContext
result <- (Ptr (Ptr GError) -> IO (Ptr InputContext))
-> IO (Ptr InputContext)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr InputContext))
 -> IO (Ptr InputContext))
-> (Ptr (Ptr GError) -> IO (Ptr InputContext))
-> IO (Ptr InputContext)
forall a b. (a -> b) -> a -> b
$ CString
-> Ptr DBusConnection
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr InputContext)
ibus_input_context_new CString
path' Ptr DBusConnection
connection' Ptr Cancellable
maybeCancellable
        Text -> Ptr InputContext -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"inputContextNew" Ptr InputContext
result
        InputContext
result' <- ((ManagedPtr InputContext -> InputContext)
-> Ptr InputContext -> IO InputContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputContext -> InputContext
InputContext) Ptr InputContext
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
        Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
        InputContext -> IO InputContext
forall (m :: * -> *) a. Monad m => a -> m a
return InputContext
result'
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
     )

#if defined(ENABLE_OVERLOADING)
#endif

-- method InputContext::new_async_finish
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GAsyncResult obtained from the #GAsyncReadyCallback pass to\n     ibus_input_context_new_async()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "IBus" , name = "InputContext" })
-- throws : True
-- Skip return : False

foreign import ccall "ibus_input_context_new_async_finish" ibus_input_context_new_async_finish :: 
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr InputContext)

-- | Finishes an operation started with 'GI.IBus.Objects.InputContext.inputContextNewAsync'.
inputContextNewAsyncFinish ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>
    a
    -- ^ /@res@/: A t'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the t'GI.Gio.Callbacks.AsyncReadyCallback' pass to
    --      'GI.IBus.Objects.InputContext.inputContextNewAsync'.
    -> m InputContext
    -- ^ __Returns:__ A newly allocated t'GI.IBus.Objects.InputContext.InputContext'. /(Can throw 'Data.GI.Base.GError.GError')/
inputContextNewAsyncFinish :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncResult a) =>
a -> m InputContext
inputContextNewAsyncFinish a
res = IO InputContext -> m InputContext
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InputContext -> m InputContext)
-> IO InputContext -> m InputContext
forall a b. (a -> b) -> a -> b
$ do
    Ptr AsyncResult
res' <- a -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
res
    IO InputContext -> IO () -> IO InputContext
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr InputContext
result <- (Ptr (Ptr GError) -> IO (Ptr InputContext))
-> IO (Ptr InputContext)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr InputContext))
 -> IO (Ptr InputContext))
-> (Ptr (Ptr GError) -> IO (Ptr InputContext))
-> IO (Ptr InputContext)
forall a b. (a -> b) -> a -> b
$ Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr InputContext)
ibus_input_context_new_async_finish Ptr AsyncResult
res'
        Text -> Ptr InputContext -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"inputContextNewAsyncFinish" Ptr InputContext
result
        InputContext
result' <- ((ManagedPtr InputContext -> InputContext)
-> Ptr InputContext -> IO InputContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputContext -> InputContext
InputContext) Ptr InputContext
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
res
        InputContext -> IO InputContext
forall (m :: * -> *) a. Monad m => a -> m a
return InputContext
result'
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
#endif

-- method InputContext::cancel_hand_writing
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "n_strokes"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The number of strokes to be removed. Pass 0 to remove all."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_cancel_hand_writing" ibus_input_context_cancel_hand_writing :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Word32 ->                               -- n_strokes : TBasicType TUInt
    IO ()

-- | Clear handwriting stroke(s) in the current input method engine.
-- 
-- see_also: [cancelHandWriting]("GI.IBus.Objects.Engine#g:signal:cancelHandWriting")
inputContextCancelHandWriting ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An IBusInputContext.
    -> Word32
    -- ^ /@nStrokes@/: The number of strokes to be removed. Pass 0 to remove all.
    -> m ()
inputContextCancelHandWriting :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Word32 -> m ()
inputContextCancelHandWriting a
context Word32
nStrokes = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr InputContext -> Word32 -> IO ()
ibus_input_context_cancel_hand_writing Ptr InputContext
context' Word32
nStrokes
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextCancelHandWritingMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextCancelHandWritingMethodInfo a signature where
    overloadedMethod = inputContextCancelHandWriting

instance O.OverloadedMethodInfo InputContextCancelHandWritingMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextCancelHandWriting",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextCancelHandWriting"
        }


#endif

-- method InputContext::focus_in
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_focus_in" ibus_input_context_focus_in :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    IO ()

-- | Invoked when the client application get focus. An asynchronous IPC will
-- be performed.
-- 
-- see_also: t'GI.IBus.Objects.Engine.Engine'::@/focus_in/@.
inputContextFocusIn ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> m ()
inputContextFocusIn :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> m ()
inputContextFocusIn a
context = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr InputContext -> IO ()
ibus_input_context_focus_in Ptr InputContext
context'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextFocusInMethodInfo
instance (signature ~ (m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextFocusInMethodInfo a signature where
    overloadedMethod = inputContextFocusIn

instance O.OverloadedMethodInfo InputContextFocusInMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextFocusIn",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextFocusIn"
        }


#endif

-- method InputContext::focus_out
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_focus_out" ibus_input_context_focus_out :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    IO ()

-- | Invoked when the client application get focus. An asynchronous IPC will be performed.
-- 
-- see_also: t'GI.IBus.Objects.Engine.Engine'::@/focus_out/@.
inputContextFocusOut ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> m ()
inputContextFocusOut :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> m ()
inputContextFocusOut a
context = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr InputContext -> IO ()
ibus_input_context_focus_out Ptr InputContext
context'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextFocusOutMethodInfo
instance (signature ~ (m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextFocusOutMethodInfo a signature where
    overloadedMethod = inputContextFocusOut

instance O.OverloadedMethodInfo InputContextFocusOutMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextFocusOut",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextFocusOut"
        }


#endif

-- method InputContext::get_engine
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "IBus" , name = "EngineDesc" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_get_engine" ibus_input_context_get_engine :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    IO (Ptr IBus.EngineDesc.EngineDesc)

-- | Gets an IME engine description for the context.
-- A synchronous IPC will be performed.
inputContextGetEngine ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> m IBus.EngineDesc.EngineDesc
    -- ^ __Returns:__ An IME engine description for the context, or NULL.
inputContextGetEngine :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> m EngineDesc
inputContextGetEngine a
context = IO EngineDesc -> m EngineDesc
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EngineDesc -> m EngineDesc) -> IO EngineDesc -> m EngineDesc
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr EngineDesc
result <- Ptr InputContext -> IO (Ptr EngineDesc)
ibus_input_context_get_engine Ptr InputContext
context'
    Text -> Ptr EngineDesc -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"inputContextGetEngine" Ptr EngineDesc
result
    EngineDesc
result' <- ((ManagedPtr EngineDesc -> EngineDesc)
-> Ptr EngineDesc -> IO EngineDesc
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr EngineDesc -> EngineDesc
IBus.EngineDesc.EngineDesc) Ptr EngineDesc
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    EngineDesc -> IO EngineDesc
forall (m :: * -> *) a. Monad m => a -> m a
return EngineDesc
result'

#if defined(ENABLE_OVERLOADING)
data InputContextGetEngineMethodInfo
instance (signature ~ (m IBus.EngineDesc.EngineDesc), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextGetEngineMethodInfo a signature where
    overloadedMethod = inputContextGetEngine

instance O.OverloadedMethodInfo InputContextGetEngineMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextGetEngine",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextGetEngine"
        }


#endif

-- method InputContext::get_engine_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeout_msec"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The timeout in milliseconds or -1 to use the default timeout."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GCancellable or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GAsyncReadyCallback to call when the request is satisfied or\n    %NULL if you don't care about the result of the method invocation."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The data to pass to callback."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_get_engine_async" ibus_input_context_get_engine_async :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Int32 ->                                -- timeout_msec : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | An asynchronous IPC will be performed.
inputContextGetEngineAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> Int32
    -- ^ /@timeoutMsec@/: The timeout in milliseconds or -1 to use the default timeout.
    -> Maybe (b)
    -- ^ /@cancellable@/: A t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing'.
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: A t'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied or
    --     'P.Nothing' if you don\'t care about the result of the method invocation.
    -> m ()
inputContextGetEngineAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputContext a, IsCancellable b) =>
a -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
inputContextGetEngineAsync a
context Int32
timeoutMsec Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr InputContext
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ibus_input_context_get_engine_async Ptr InputContext
context' Int32
timeoutMsec Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextGetEngineAsyncMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsInputContext a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputContextGetEngineAsyncMethodInfo a signature where
    overloadedMethod = inputContextGetEngineAsync

instance O.OverloadedMethodInfo InputContextGetEngineAsyncMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextGetEngineAsync",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextGetEngineAsync"
        }


#endif

-- method InputContext::get_engine_async_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GAsyncResult obtained from the #GAsyncReadyCallback passed to\n  ibus_input_context_get_engine_async()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "IBus" , name = "EngineDesc" })
-- throws : True
-- Skip return : False

foreign import ccall "ibus_input_context_get_engine_async_finish" ibus_input_context_get_engine_async_finish :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr IBus.EngineDesc.EngineDesc)

-- | Finishes an operation started with 'GI.IBus.Objects.InputContext.inputContextGetEngineAsync'.
inputContextGetEngineAsyncFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> b
    -- ^ /@res@/: A t'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the t'GI.Gio.Callbacks.AsyncReadyCallback' passed to
    --   'GI.IBus.Objects.InputContext.inputContextGetEngineAsync'.
    -> m IBus.EngineDesc.EngineDesc
    -- ^ __Returns:__ An IME engine description for the context, or
    --     'P.Nothing'. /(Can throw 'Data.GI.Base.GError.GError')/
inputContextGetEngineAsyncFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputContext a, IsAsyncResult b) =>
a -> b -> m EngineDesc
inputContextGetEngineAsyncFinish a
context b
res = IO EngineDesc -> m EngineDesc
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO EngineDesc -> m EngineDesc) -> IO EngineDesc -> m EngineDesc
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr AsyncResult
res' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
res
    IO EngineDesc -> IO () -> IO EngineDesc
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr EngineDesc
result <- (Ptr (Ptr GError) -> IO (Ptr EngineDesc)) -> IO (Ptr EngineDesc)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr EngineDesc)) -> IO (Ptr EngineDesc))
-> (Ptr (Ptr GError) -> IO (Ptr EngineDesc)) -> IO (Ptr EngineDesc)
forall a b. (a -> b) -> a -> b
$ Ptr InputContext
-> Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr EngineDesc)
ibus_input_context_get_engine_async_finish Ptr InputContext
context' Ptr AsyncResult
res'
        Text -> Ptr EngineDesc -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"inputContextGetEngineAsyncFinish" Ptr EngineDesc
result
        EngineDesc
result' <- ((ManagedPtr EngineDesc -> EngineDesc)
-> Ptr EngineDesc -> IO EngineDesc
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr EngineDesc -> EngineDesc
IBus.EngineDesc.EngineDesc) Ptr EngineDesc
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
res
        EngineDesc -> IO EngineDesc
forall (m :: * -> *) a. Monad m => a -> m a
return EngineDesc
result'
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data InputContextGetEngineAsyncFinishMethodInfo
instance (signature ~ (b -> m IBus.EngineDesc.EngineDesc), MonadIO m, IsInputContext a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod InputContextGetEngineAsyncFinishMethodInfo a signature where
    overloadedMethod = inputContextGetEngineAsyncFinish

instance O.OverloadedMethodInfo InputContextGetEngineAsyncFinishMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextGetEngineAsyncFinish",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextGetEngineAsyncFinish"
        }


#endif

-- method InputContext::needs_surrounding_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_needs_surrounding_text" ibus_input_context_needs_surrounding_text :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    IO CInt

-- | Check whether the current engine requires surrounding-text.
inputContextNeedsSurroundingText ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if surrounding-text is needed by the current engine;
    -- 'P.False' otherwise.
inputContextNeedsSurroundingText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> m Bool
inputContextNeedsSurroundingText a
context = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    CInt
result <- Ptr InputContext -> IO CInt
ibus_input_context_needs_surrounding_text Ptr InputContext
context'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data InputContextNeedsSurroundingTextMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextNeedsSurroundingTextMethodInfo a signature where
    overloadedMethod = inputContextNeedsSurroundingText

instance O.OverloadedMethodInfo InputContextNeedsSurroundingTextMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextNeedsSurroundingText",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextNeedsSurroundingText"
        }


#endif

-- method InputContext::process_hand_writing_event
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "coordinates"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "An array of gdouble (0.0 to 1.0) which represents a stroke (i.e. [x1, y1, x2, y2, x3, y3, ...])."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "coordinates_len"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The number of elements in the array. The number should be even and >= 4."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_process_hand_writing_event" ibus_input_context_process_hand_writing_event :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    CDouble ->                              -- coordinates : TBasicType TDouble
    Word32 ->                               -- coordinates_len : TBasicType TUInt
    IO ()

-- | Pass a handwriting stroke to an input method engine.
-- 
-- In this API, a coordinate (0.0, 0.0) represents the top-left corner of an area for
-- handwriting, and (1.0, 1.0) does the bottom-right. Therefore, for example, if
-- a user writes a character \'L\', the array would be something like [0.0, 0.0, 0.0, 1.0, 1.0, 1.0]
-- and coordinates_len would be 6.
-- 
-- The function is usually called when a user releases the mouse button in a hand
-- writing area.
-- 
-- see_also: [processHandWritingEvent]("GI.IBus.Objects.Engine#g:signal:processHandWritingEvent")
inputContextProcessHandWritingEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An IBusInputContext.
    -> Double
    -- ^ /@coordinates@/: An array of gdouble (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. The number should be even and >= 4.
    -> m ()
inputContextProcessHandWritingEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Double -> Word32 -> m ()
inputContextProcessHandWritingEvent a
context Double
coordinates Word32
coordinatesLen = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    let coordinates' :: CDouble
coordinates' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
coordinates
    Ptr InputContext -> CDouble -> Word32 -> IO ()
ibus_input_context_process_hand_writing_event Ptr InputContext
context' CDouble
coordinates' Word32
coordinatesLen
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextProcessHandWritingEventMethodInfo
instance (signature ~ (Double -> Word32 -> m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextProcessHandWritingEventMethodInfo a signature where
    overloadedMethod = inputContextProcessHandWritingEvent

instance O.OverloadedMethodInfo InputContextProcessHandWritingEventMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextProcessHandWritingEvent",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextProcessHandWritingEvent"
        }


#endif

-- method InputContext::process_key_event
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyval"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Key symbol of a key event."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keycode"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Keycode of a key event."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "state"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Key modifier flags."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_process_key_event" ibus_input_context_process_key_event :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Word32 ->                               -- keyval : TBasicType TUInt32
    Word32 ->                               -- keycode : TBasicType TUInt32
    Word32 ->                               -- state : TBasicType TUInt32
    IO CInt

-- | Pass the key event to input method engine and wait for the reply from
-- ibus (i.e. synchronous IPC).
inputContextProcessKeyEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> Word32
    -- ^ /@keyval@/: Key symbol of a key event.
    -> Word32
    -- ^ /@keycode@/: Keycode of a key event.
    -> Word32
    -- ^ /@state@/: Key modifier flags.
    -> m Bool
    -- ^ __Returns:__ 'P.True' for successfully process the key; 'P.False' otherwise.
    -- 
    -- See also: 'GI.IBus.Objects.InputContext.inputContextProcessKeyEventAsync'
inputContextProcessKeyEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Word32 -> Word32 -> Word32 -> m Bool
inputContextProcessKeyEvent a
context Word32
keyval Word32
keycode Word32
state = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    CInt
result <- Ptr InputContext -> Word32 -> Word32 -> Word32 -> IO CInt
ibus_input_context_process_key_event Ptr InputContext
context' Word32
keyval Word32
keycode Word32
state
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data InputContextProcessKeyEventMethodInfo
instance (signature ~ (Word32 -> Word32 -> Word32 -> m Bool), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextProcessKeyEventMethodInfo a signature where
    overloadedMethod = inputContextProcessKeyEvent

instance O.OverloadedMethodInfo InputContextProcessKeyEventMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextProcessKeyEvent",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextProcessKeyEvent"
        }


#endif

-- method InputContext::process_key_event_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyval"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Key symbol of a key event."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keycode"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Keycode of a key event."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "state"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Key modifier flags."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeout_msec"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The timeout in milliseconds or -1 to use the default timeout."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A GCancellable or NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A GAsyncReadyCallback to call when the request is satisfied or NULL\n     if you don't care about the result of the method invocation."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 7
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The data to pass to callback."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_process_key_event_async" ibus_input_context_process_key_event_async :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Word32 ->                               -- keyval : TBasicType TUInt32
    Word32 ->                               -- keycode : TBasicType TUInt32
    Word32 ->                               -- state : TBasicType TUInt32
    Int32 ->                                -- timeout_msec : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Pass the key event to input method engine.
-- 
-- Key symbols are characters\/symbols produced by key press, for example,
-- pressing \"s\" generates key symbol \"s\"; pressing shift-\"s\" generates key symbol \"S\".
-- Same key on keyboard may produce different key symbols on different keyboard layout.
-- e.g., \"s\" key on QWERTY keyboard produces \"o\" in DVORAK layout.
-- 
-- Unlike key symbol, keycode is only determined by the location of the key, and
-- irrelevant of the keyboard layout.
-- 
-- Briefly speaking, input methods that expect certain keyboard layout should use
-- keycode; otherwise keyval is sufficient.
-- For example, Chewing, Cangjie, Wubi expect an en-US QWERTY keyboard, these should
-- use keycode; while pinyin can rely on keyval only, as it is less sensitive to
-- the keyboard layout change, DVORAK users can still use DVORAK layout to input pinyin.
-- 
-- Use 'GI.IBus.Objects.Keymap.keymapLookupKeysym' to convert keycode to keysym in given keyboard layout.
-- 
-- see_also: [processKeyEvent]("GI.IBus.Objects.Engine#g:signal:processKeyEvent")
inputContextProcessKeyEventAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@context@/: An IBusInputContext.
    -> Word32
    -- ^ /@keyval@/: Key symbol of a key event.
    -> Word32
    -- ^ /@keycode@/: Keycode of a key event.
    -> Word32
    -- ^ /@state@/: Key modifier flags.
    -> Int32
    -- ^ /@timeoutMsec@/: The timeout in milliseconds or -1 to use the default timeout.
    -> Maybe (b)
    -- ^ /@cancellable@/: A GCancellable or NULL.
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: A GAsyncReadyCallback to call when the request is satisfied or NULL
    --      if you don\'t care about the result of the method invocation.
    -> m ()
inputContextProcessKeyEventAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputContext a, IsCancellable b) =>
a
-> Word32
-> Word32
-> Word32
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
inputContextProcessKeyEventAsync a
context Word32
keyval Word32
keycode Word32
state Int32
timeoutMsec Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr InputContext
-> Word32
-> Word32
-> Word32
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ibus_input_context_process_key_event_async Ptr InputContext
context' Word32
keyval Word32
keycode Word32
state Int32
timeoutMsec Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextProcessKeyEventAsyncMethodInfo
instance (signature ~ (Word32 -> Word32 -> Word32 -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsInputContext a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputContextProcessKeyEventAsyncMethodInfo a signature where
    overloadedMethod = inputContextProcessKeyEventAsync

instance O.OverloadedMethodInfo InputContextProcessKeyEventAsyncMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextProcessKeyEventAsync",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextProcessKeyEventAsync"
        }


#endif

-- method InputContext::process_key_event_async_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GAsyncResult obtained from the #GAsyncReadyCallback passed to\n     ibus_input_context_process_key_event_async()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ibus_input_context_process_key_event_async_finish" ibus_input_context_process_key_event_async_finish :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Finishes an operation started with
--      'GI.IBus.Objects.InputContext.inputContextProcessKeyEventAsync'.
inputContextProcessKeyEventAsyncFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> b
    -- ^ /@res@/: A t'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the t'GI.Gio.Callbacks.AsyncReadyCallback' passed to
    --      'GI.IBus.Objects.InputContext.inputContextProcessKeyEventAsync'.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
inputContextProcessKeyEventAsyncFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputContext a, IsAsyncResult b) =>
a -> b -> m ()
inputContextProcessKeyEventAsyncFinish a
context b
res = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr AsyncResult
res' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
res
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr InputContext -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
ibus_input_context_process_key_event_async_finish Ptr InputContext
context' Ptr AsyncResult
res'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
res
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data InputContextProcessKeyEventAsyncFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsInputContext a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod InputContextProcessKeyEventAsyncFinishMethodInfo a signature where
    overloadedMethod = inputContextProcessKeyEventAsyncFinish

instance O.OverloadedMethodInfo InputContextProcessKeyEventAsyncFinishMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextProcessKeyEventAsyncFinish",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextProcessKeyEventAsyncFinish"
        }


#endif

-- method InputContext::property_activate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A property name (e.g. \"InputMode.WideLatin\")"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "state"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A status of the property (e.g. PROP_STATE_CHECKED)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_property_activate" ibus_input_context_property_activate :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    CString ->                              -- prop_name : TBasicType TUTF8
    Word32 ->                               -- state : TBasicType TUInt32
    IO ()

-- | Activate the property asynchronously.
-- 
-- See also: t'GI.IBus.Objects.Engine.Engine'::@/property_activate/@
inputContextPropertyActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> T.Text
    -- ^ /@propName@/: A property name (e.g. \"InputMode.WideLatin\")
    -> Word32
    -- ^ /@state@/: A status of the property (e.g. PROP_STATE_CHECKED)
    -> m ()
inputContextPropertyActivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Text -> Word32 -> m ()
inputContextPropertyActivate a
context Text
propName Word32
state = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    CString
propName' <- Text -> IO CString
textToCString Text
propName
    Ptr InputContext -> CString -> Word32 -> IO ()
ibus_input_context_property_activate Ptr InputContext
context' CString
propName' Word32
state
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextPropertyActivateMethodInfo
instance (signature ~ (T.Text -> Word32 -> m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextPropertyActivateMethodInfo a signature where
    overloadedMethod = inputContextPropertyActivate

instance O.OverloadedMethodInfo InputContextPropertyActivateMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextPropertyActivate",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextPropertyActivate"
        }


#endif

-- method InputContext::reset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_reset" ibus_input_context_reset :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    IO ()

-- | Invoked when the IME is reset. An asynchronous IPC will be performed.
-- 
-- see_also: [reset]("GI.IBus.Objects.Engine#g:signal:reset")
inputContextReset ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> m ()
inputContextReset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> m ()
inputContextReset a
context = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr InputContext -> IO ()
ibus_input_context_reset Ptr InputContext
context'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextResetMethodInfo
instance (signature ~ (m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextResetMethodInfo a signature where
    overloadedMethod = inputContextReset

instance O.OverloadedMethodInfo InputContextResetMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextReset",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextReset"
        }


#endif

-- method InputContext::set_capabilities
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "capabilities"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Capabilities flags of IBusEngine, see #IBusCapabilite"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_set_capabilities" ibus_input_context_set_capabilities :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Word32 ->                               -- capabilities : TBasicType TUInt32
    IO ()

-- | Set the capabilities flags of client application asynchronously.
-- When IBUS_CAP_FOCUS is not set, IBUS_CAP_PREEDIT_TEXT, IBUS_CAP_AUXILIARY_TEXT, IBUS_CAP_LOOKUP_TABLE, and IBUS_CAP_PROPERTY have to be all set.
-- The panel component does nothing for an application that doesn\'t support focus.
-- 
-- see_also: [setCapabilities]("GI.IBus.Objects.Engine#g:signal:setCapabilities")
inputContextSetCapabilities ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An IBusInputContext.
    -> Word32
    -- ^ /@capabilities@/: Capabilities flags of IBusEngine, see t'GI.IBus.Flags.Capabilite'
    -> m ()
inputContextSetCapabilities :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Word32 -> m ()
inputContextSetCapabilities a
context Word32
capabilities = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr InputContext -> Word32 -> IO ()
ibus_input_context_set_capabilities Ptr InputContext
context' Word32
capabilities
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextSetCapabilitiesMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextSetCapabilitiesMethodInfo a signature where
    overloadedMethod = inputContextSetCapabilities

instance O.OverloadedMethodInfo InputContextSetCapabilitiesMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextSetCapabilities",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextSetCapabilities"
        }


#endif

-- method InputContext::set_client_commit_preedit
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "client_commit"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "%TRUE if your input context commits pre-edit texts\n    with Space or Enter key events or mouse click events. %FALSE if\n    ibus-daemon commits pre-edit texts with those events.\n    The default is %FALSE. The behavior is decided with\n    ibus_engine_update_preedit_text_with_mode() to commit, clear or\n    keep the pre-edit text and this API is important in ibus-hangul."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_set_client_commit_preedit" ibus_input_context_set_client_commit_preedit :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    CInt ->                                 -- client_commit : TBasicType TBoolean
    IO ()

-- | Set whether t'GI.IBus.Objects.InputContext.InputContext' commits pre-edit texts or not.
-- If 'P.True', \'update-preedit-text-with-mode\' signal is emitted
-- instead of \'update-preedit-text\' signal.
-- If your client receives the \'update-preedit-text-with-mode\' signal,
-- the client needs to implement @/commit_text()/@ of pre-edit text when
-- GtkIMContextClass.@/focus_out()/@ is called in case an IME desires that
-- behavior but it depends on each IME.
-- 
-- See also 'GI.IBus.Objects.Engine.engineUpdatePreeditTextWithMode'.
inputContextSetClientCommitPreedit ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> Bool
    -- ^ /@clientCommit@/: 'P.True' if your input context commits pre-edit texts
    --     with Space or Enter key events or mouse click events. 'P.False' if
    --     ibus-daemon commits pre-edit texts with those events.
    --     The default is 'P.False'. The behavior is decided with
    --     'GI.IBus.Objects.Engine.engineUpdatePreeditTextWithMode' to commit, clear or
    --     keep the pre-edit text and this API is important in ibus-hangul.
    -> m ()
inputContextSetClientCommitPreedit :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Bool -> m ()
inputContextSetClientCommitPreedit a
context Bool
clientCommit = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    let clientCommit' :: CInt
clientCommit' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
clientCommit
    Ptr InputContext -> CInt -> IO ()
ibus_input_context_set_client_commit_preedit Ptr InputContext
context' CInt
clientCommit'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextSetClientCommitPreeditMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextSetClientCommitPreeditMethodInfo a signature where
    overloadedMethod = inputContextSetClientCommitPreedit

instance O.OverloadedMethodInfo InputContextSetClientCommitPreeditMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextSetClientCommitPreedit",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextSetClientCommitPreedit"
        }


#endif

-- method InputContext::set_content_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "purpose"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Primary purpose of the input context, as an #IBusInputPurpose."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "hints"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Hints that augment @purpose, as an #IBusInputHints."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_set_content_type" ibus_input_context_set_content_type :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Word32 ->                               -- purpose : TBasicType TUInt
    Word32 ->                               -- hints : TBasicType TUInt
    IO ()

-- | Set content-type (primary purpose and hints) of the context.  This
-- information is particularly useful to implement intelligent
-- behavior in engines, such as automatic input-mode switch and text
-- prediction.  For example, to restrict input to numbers, the client
-- can call this function with /@purpose@/ set to
-- @/IBUS_INPUT_PURPOSE_NUMBER/@.
-- 
-- See also: [setContentType]("GI.IBus.Objects.Engine#g:signal:setContentType")
inputContextSetContentType ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> Word32
    -- ^ /@purpose@/: Primary purpose of the input context, as an t'GI.IBus.Enums.InputPurpose'.
    -> Word32
    -- ^ /@hints@/: Hints that augment /@purpose@/, as an t'GI.IBus.Flags.InputHints'.
    -> m ()
inputContextSetContentType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Word32 -> Word32 -> m ()
inputContextSetContentType a
context Word32
purpose Word32
hints = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr InputContext -> Word32 -> Word32 -> IO ()
ibus_input_context_set_content_type Ptr InputContext
context' Word32
purpose Word32
hints
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextSetContentTypeMethodInfo
instance (signature ~ (Word32 -> Word32 -> m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextSetContentTypeMethodInfo a signature where
    overloadedMethod = inputContextSetContentType

instance O.OverloadedMethodInfo InputContextSetContentTypeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextSetContentType",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextSetContentType"
        }


#endif

-- method InputContext::set_cursor_location
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "X coordinate of the cursor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Y coordinate of the cursor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "w"
--           , argType = TBasicType TInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Width of the cursor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "h"
--           , argType = TBasicType TInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Height of the cursor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_set_cursor_location" ibus_input_context_set_cursor_location :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Int32 ->                                -- x : TBasicType TInt32
    Int32 ->                                -- y : TBasicType TInt32
    Int32 ->                                -- w : TBasicType TInt32
    Int32 ->                                -- h : TBasicType TInt32
    IO ()

-- | Set the cursor location of IBus input context asynchronously.
-- 
-- see_also: [setCursorLocation]("GI.IBus.Objects.Engine#g:signal:setCursorLocation")
inputContextSetCursorLocation ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An IBusInputContext.
    -> 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.
    -> m ()
inputContextSetCursorLocation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Int32 -> Int32 -> Int32 -> Int32 -> m ()
inputContextSetCursorLocation a
context Int32
x Int32
y Int32
w Int32
h = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr InputContext -> Int32 -> Int32 -> Int32 -> Int32 -> IO ()
ibus_input_context_set_cursor_location Ptr InputContext
context' Int32
x Int32
y Int32
w Int32
h
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextSetCursorLocationMethodInfo
instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextSetCursorLocationMethodInfo a signature where
    overloadedMethod = inputContextSetCursorLocation

instance O.OverloadedMethodInfo InputContextSetCursorLocationMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextSetCursorLocation",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextSetCursorLocation"
        }


#endif

-- method InputContext::set_cursor_location_relative
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "x"
--           , argType = TBasicType TInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "X coordinate of the cursor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "y"
--           , argType = TBasicType TInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Y coordinate of the cursor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "w"
--           , argType = TBasicType TInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Width of the cursor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "h"
--           , argType = TBasicType TInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Height of the cursor."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_set_cursor_location_relative" ibus_input_context_set_cursor_location_relative :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Int32 ->                                -- x : TBasicType TInt32
    Int32 ->                                -- y : TBasicType TInt32
    Int32 ->                                -- w : TBasicType TInt32
    Int32 ->                                -- h : TBasicType TInt32
    IO ()

-- | Set the relative cursor location of IBus input context asynchronously.
inputContextSetCursorLocationRelative ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An IBusInputContext.
    -> 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.
    -> m ()
inputContextSetCursorLocationRelative :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Int32 -> Int32 -> Int32 -> Int32 -> m ()
inputContextSetCursorLocationRelative a
context Int32
x Int32
y Int32
w Int32
h = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr InputContext -> Int32 -> Int32 -> Int32 -> Int32 -> IO ()
ibus_input_context_set_cursor_location_relative Ptr InputContext
context' Int32
x Int32
y Int32
w Int32
h
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextSetCursorLocationRelativeMethodInfo
instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextSetCursorLocationRelativeMethodInfo a signature where
    overloadedMethod = inputContextSetCursorLocationRelative

instance O.OverloadedMethodInfo InputContextSetCursorLocationRelativeMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextSetCursorLocationRelative",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextSetCursorLocationRelative"
        }


#endif

-- method InputContext::set_engine
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A name of the engine."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_set_engine" ibus_input_context_set_engine :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Invoked when the IME engine is changed.
-- An asynchronous IPC will be performed.
inputContextSetEngine ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> T.Text
    -- ^ /@name@/: A name of the engine.
    -> m ()
inputContextSetEngine :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Text -> m ()
inputContextSetEngine a
context Text
name = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr InputContext -> CString -> IO ()
ibus_input_context_set_engine Ptr InputContext
context' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextSetEngineMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsInputContext a) => O.OverloadedMethod InputContextSetEngineMethodInfo a signature where
    overloadedMethod = inputContextSetEngine

instance O.OverloadedMethodInfo InputContextSetEngineMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextSetEngine",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextSetEngine"
        }


#endif

-- method InputContext::set_surrounding_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "context"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "InputContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusInputContext."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TInterface Name { namespace = "IBus" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "An #IBusText surrounding the current cursor on the application."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_pos"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "Current cursor position in characters in @text."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "anchor_pos"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Anchor position of selection in @text."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_set_surrounding_text" ibus_input_context_set_surrounding_text :: 
    Ptr InputContext ->                     -- context : TInterface (Name {namespace = "IBus", name = "InputContext"})
    Ptr IBus.Text.Text ->                   -- text : TInterface (Name {namespace = "IBus", name = "Text"})
    Word32 ->                               -- cursor_pos : TBasicType TUInt32
    Word32 ->                               -- anchor_pos : TBasicType TUInt32
    IO ()

-- | /No description available in the introspection data./
inputContextSetSurroundingText ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a, IBus.Text.IsText b) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> b
    -- ^ /@text@/: An t'GI.IBus.Objects.Text.Text' surrounding the current cursor on the application.
    -> Word32
    -- ^ /@cursorPos@/: Current cursor position in characters in /@text@/.
    -> Word32
    -- ^ /@anchorPos@/: Anchor position of selection in /@text@/.
    -> m ()
inputContextSetSurroundingText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputContext a, IsText b) =>
a -> b -> Word32 -> Word32 -> m ()
inputContextSetSurroundingText a
context b
text Word32
cursorPos Word32
anchorPos = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr InputContext
context' <- a -> IO (Ptr InputContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
    Ptr InputContext -> Ptr Text -> Word32 -> Word32 -> IO ()
ibus_input_context_set_surrounding_text Ptr InputContext
context' Ptr Text
text' Word32
cursorPos Word32
anchorPos
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data InputContextSetSurroundingTextMethodInfo
instance (signature ~ (b -> Word32 -> Word32 -> m ()), MonadIO m, IsInputContext a, IBus.Text.IsText b) => O.OverloadedMethod InputContextSetSurroundingTextMethodInfo a signature where
    overloadedMethod = inputContextSetSurroundingText

instance O.OverloadedMethodInfo InputContextSetSurroundingTextMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.IBus.Objects.InputContext.inputContextSetSurroundingText",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-ibus-1.5.3/docs/GI-IBus-Objects-InputContext.html#v:inputContextSetSurroundingText"
        }


#endif

-- method InputContext::get_input_context
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The path to the object that emitting the signal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A GDBusConnection." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "IBus" , name = "InputContext" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_get_input_context" ibus_input_context_get_input_context :: 
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO (Ptr InputContext)

-- | Gets an existing IBusInputContext.
inputContextGetInputContext ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    T.Text
    -- ^ /@path@/: The path to the object that emitting the signal.
    -> a
    -- ^ /@connection@/: A GDBusConnection.
    -> m InputContext
    -- ^ __Returns:__ An existing t'GI.IBus.Objects.InputContext.InputContext'.
inputContextGetInputContext :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
Text -> a -> m InputContext
inputContextGetInputContext Text
path a
connection = IO InputContext -> m InputContext
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InputContext -> m InputContext)
-> IO InputContext -> m InputContext
forall a b. (a -> b) -> a -> b
$ do
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr DBusConnection
connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    Ptr InputContext
result <- CString -> Ptr DBusConnection -> IO (Ptr InputContext)
ibus_input_context_get_input_context CString
path' Ptr DBusConnection
connection'
    Text -> Ptr InputContext -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"inputContextGetInputContext" Ptr InputContext
result
    InputContext
result' <- ((ManagedPtr InputContext -> InputContext)
-> Ptr InputContext -> IO InputContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr InputContext -> InputContext
InputContext) Ptr InputContext
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
    InputContext -> IO InputContext
forall (m :: * -> *) a. Monad m => a -> m a
return InputContext
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method InputContext::get_input_context_async
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The path to the object that emitting the signal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GCancellable or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GAsyncReadyCallback to call when the request is satisfied.\n     The callback should not be %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The data to pass to callback."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_get_input_context_async" ibus_input_context_get_input_context_async :: 
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Gets an existing t'GI.IBus.Objects.InputContext.InputContext' asynchronously.
inputContextGetInputContextAsync ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
    T.Text
    -- ^ /@path@/: The path to the object that emitting the signal.
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> Maybe (b)
    -- ^ /@cancellable@/: A t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing'.
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: A t'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied.
    --      The callback should not be 'P.Nothing'.
    -> m ()
inputContextGetInputContextAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusConnection a, IsCancellable b) =>
Text -> a -> Maybe b -> Maybe AsyncReadyCallback -> m ()
inputContextGetInputContextAsync Text
path a
connection Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr DBusConnection
connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    CString
-> Ptr DBusConnection
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ibus_input_context_get_input_context_async CString
path' Ptr DBusConnection
connection' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif

-- method InputContext::get_input_context_async_finish
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GAsyncResult obtained from the #GAsyncReadyCallback pass to\n     ibus_input_context_get_input_context_async()."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "IBus" , name = "InputContext" })
-- throws : True
-- Skip return : False

foreign import ccall "ibus_input_context_get_input_context_async_finish" ibus_input_context_get_input_context_async_finish :: 
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr InputContext)

-- | Finishes an operation started with
-- 'GI.IBus.Objects.InputContext.inputContextGetInputContextAsync'.
inputContextGetInputContextAsyncFinish ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>
    a
    -- ^ /@res@/: A t'GI.Gio.Interfaces.AsyncResult.AsyncResult' obtained from the t'GI.Gio.Callbacks.AsyncReadyCallback' pass to
    --      'GI.IBus.Objects.InputContext.inputContextGetInputContextAsync'.
    -> m InputContext
    -- ^ __Returns:__ An existing t'GI.IBus.Objects.InputContext.InputContext'. /(Can throw 'Data.GI.Base.GError.GError')/
inputContextGetInputContextAsyncFinish :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncResult a) =>
a -> m InputContext
inputContextGetInputContextAsyncFinish a
res = IO InputContext -> m InputContext
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InputContext -> m InputContext)
-> IO InputContext -> m InputContext
forall a b. (a -> b) -> a -> b
$ do
    Ptr AsyncResult
res' <- a -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
res
    IO InputContext -> IO () -> IO InputContext
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr InputContext
result <- (Ptr (Ptr GError) -> IO (Ptr InputContext))
-> IO (Ptr InputContext)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr InputContext))
 -> IO (Ptr InputContext))
-> (Ptr (Ptr GError) -> IO (Ptr InputContext))
-> IO (Ptr InputContext)
forall a b. (a -> b) -> a -> b
$ Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr InputContext)
ibus_input_context_get_input_context_async_finish Ptr AsyncResult
res'
        Text -> Ptr InputContext -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"inputContextGetInputContextAsyncFinish" Ptr InputContext
result
        InputContext
result' <- ((ManagedPtr InputContext -> InputContext)
-> Ptr InputContext -> IO InputContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr InputContext -> InputContext
InputContext) Ptr InputContext
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
res
        InputContext -> IO InputContext
forall (m :: * -> *) a. Monad m => a -> m a
return InputContext
result'
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
#endif

-- method InputContext::new_async
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The path to the object that emitting the signal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GCancellable or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #GAsyncReadyCallback to call when the request is satisfied.\n     The callback should not be %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The data to pass to callback."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_input_context_new_async" ibus_input_context_new_async :: 
    CString ->                              -- path : TBasicType TUTF8
    Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Creates a new t'GI.IBus.Objects.InputContext.InputContext' asynchronously.
inputContextNewAsync ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a, Gio.Cancellable.IsCancellable b) =>
    T.Text
    -- ^ /@path@/: The path to the object that emitting the signal.
    -> a
    -- ^ /@connection@/: A t'GI.Gio.Objects.DBusConnection.DBusConnection'.
    -> Maybe (b)
    -- ^ /@cancellable@/: A t'GI.Gio.Objects.Cancellable.Cancellable' or 'P.Nothing'.
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: A t'GI.Gio.Callbacks.AsyncReadyCallback' to call when the request is satisfied.
    --      The callback should not be 'P.Nothing'.
    -> m ()
inputContextNewAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDBusConnection a, IsCancellable b) =>
Text -> a -> Maybe b -> Maybe AsyncReadyCallback -> m ()
inputContextNewAsync Text
path a
connection Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    CString
path' <- Text -> IO CString
textToCString Text
path
    Ptr DBusConnection
connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    CString
-> Ptr DBusConnection
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ibus_input_context_new_async CString
path' Ptr DBusConnection
connection' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif