{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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"), [postProcessKeyEvent]("GI.IBus.Objects.InputContext#g:method:postProcessKeyEvent"), [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"), [setPostProcessKeyEvent]("GI.IBus.Objects.InputContext#g:method:setPostProcessKeyEvent"), [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              ,


-- ** postProcessKeyEvent #method:postProcessKeyEvent#

#if defined(ENABLE_OVERLOADING)
    InputContextPostProcessKeyEventMethodInfo,
#endif
    inputContextPostProcessKeyEvent         ,


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


-- ** setPostProcessKeyEvent #method:setPostProcessKeyEvent#

#if defined(ENABLE_OVERLOADING)
    InputContextSetPostProcessKeyEventMethodInfo,
#endif
    inputContextSetPostProcessKeyEvent      ,


-- ** setSurroundingText #method:setSurroundingText#

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




 -- * Signals


-- ** commitText #signal:commitText#

    InputContextCommitTextCallback          ,
#if defined(ENABLE_OVERLOADING)
    InputContextCommitTextSignalInfo        ,
#endif
    afterInputContextCommitText             ,
    onInputContextCommitText                ,


-- ** cursorDownLookupTable #signal:cursorDownLookupTable#

    InputContextCursorDownLookupTableCallback,
#if defined(ENABLE_OVERLOADING)
    InputContextCursorDownLookupTableSignalInfo,
#endif
    afterInputContextCursorDownLookupTable  ,
    onInputContextCursorDownLookupTable     ,


-- ** cursorUpLookupTable #signal:cursorUpLookupTable#

    InputContextCursorUpLookupTableCallback ,
#if defined(ENABLE_OVERLOADING)
    InputContextCursorUpLookupTableSignalInfo,
#endif
    afterInputContextCursorUpLookupTable    ,
    onInputContextCursorUpLookupTable       ,


-- ** deleteSurroundingText #signal:deleteSurroundingText#

    InputContextDeleteSurroundingTextCallback,
#if defined(ENABLE_OVERLOADING)
    InputContextDeleteSurroundingTextSignalInfo,
#endif
    afterInputContextDeleteSurroundingText  ,
    onInputContextDeleteSurroundingText     ,


-- ** disabled #signal:disabled#

    InputContextDisabledCallback            ,
#if defined(ENABLE_OVERLOADING)
    InputContextDisabledSignalInfo          ,
#endif
    afterInputContextDisabled               ,
    onInputContextDisabled                  ,


-- ** enabled #signal:enabled#

    InputContextEnabledCallback             ,
#if defined(ENABLE_OVERLOADING)
    InputContextEnabledSignalInfo           ,
#endif
    afterInputContextEnabled                ,
    onInputContextEnabled                   ,


-- ** forwardKeyEvent #signal:forwardKeyEvent#

    InputContextForwardKeyEventCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextForwardKeyEventSignalInfo   ,
#endif
    afterInputContextForwardKeyEvent        ,
    onInputContextForwardKeyEvent           ,


-- ** hideAuxiliaryText #signal:hideAuxiliaryText#

    InputContextHideAuxiliaryTextCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextHideAuxiliaryTextSignalInfo ,
#endif
    afterInputContextHideAuxiliaryText      ,
    onInputContextHideAuxiliaryText         ,


-- ** hideLookupTable #signal:hideLookupTable#

    InputContextHideLookupTableCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextHideLookupTableSignalInfo   ,
#endif
    afterInputContextHideLookupTable        ,
    onInputContextHideLookupTable           ,


-- ** hidePreeditText #signal:hidePreeditText#

    InputContextHidePreeditTextCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextHidePreeditTextSignalInfo   ,
#endif
    afterInputContextHidePreeditText        ,
    onInputContextHidePreeditText           ,


-- ** pageDownLookupTable #signal:pageDownLookupTable#

    InputContextPageDownLookupTableCallback ,
#if defined(ENABLE_OVERLOADING)
    InputContextPageDownLookupTableSignalInfo,
#endif
    afterInputContextPageDownLookupTable    ,
    onInputContextPageDownLookupTable       ,


-- ** pageUpLookupTable #signal:pageUpLookupTable#

    InputContextPageUpLookupTableCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextPageUpLookupTableSignalInfo ,
#endif
    afterInputContextPageUpLookupTable      ,
    onInputContextPageUpLookupTable         ,


-- ** registerProperties #signal:registerProperties#

    InputContextRegisterPropertiesCallback  ,
#if defined(ENABLE_OVERLOADING)
    InputContextRegisterPropertiesSignalInfo,
#endif
    afterInputContextRegisterProperties     ,
    onInputContextRegisterProperties        ,


-- ** requireSurroundingText #signal:requireSurroundingText#

    InputContextRequireSurroundingTextCallback,
#if defined(ENABLE_OVERLOADING)
    InputContextRequireSurroundingTextSignalInfo,
#endif
    afterInputContextRequireSurroundingText ,
    onInputContextRequireSurroundingText    ,


-- ** showAuxiliaryText #signal:showAuxiliaryText#

    InputContextShowAuxiliaryTextCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextShowAuxiliaryTextSignalInfo ,
#endif
    afterInputContextShowAuxiliaryText      ,
    onInputContextShowAuxiliaryText         ,


-- ** showLookupTable #signal:showLookupTable#

    InputContextShowLookupTableCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextShowLookupTableSignalInfo   ,
#endif
    afterInputContextShowLookupTable        ,
    onInputContextShowLookupTable           ,


-- ** showPreeditText #signal:showPreeditText#

    InputContextShowPreeditTextCallback     ,
#if defined(ENABLE_OVERLOADING)
    InputContextShowPreeditTextSignalInfo   ,
#endif
    afterInputContextShowPreeditText        ,
    onInputContextShowPreeditText           ,


-- ** updateAuxiliaryText #signal:updateAuxiliaryText#

    InputContextUpdateAuxiliaryTextCallback ,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdateAuxiliaryTextSignalInfo,
#endif
    afterInputContextUpdateAuxiliaryText    ,
    onInputContextUpdateAuxiliaryText       ,


-- ** updateLookupTable #signal:updateLookupTable#

    InputContextUpdateLookupTableCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdateLookupTableSignalInfo ,
#endif
    afterInputContextUpdateLookupTable      ,
    onInputContextUpdateLookupTable         ,


-- ** updatePreeditText #signal:updatePreeditText#

    InputContextUpdatePreeditTextCallback   ,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdatePreeditTextSignalInfo ,
#endif
    afterInputContextUpdatePreeditText      ,
    onInputContextUpdatePreeditText         ,


-- ** updatePreeditTextWithMode #signal:updatePreeditTextWithMode#

    InputContextUpdatePreeditTextWithModeCallback,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdatePreeditTextWithModeSignalInfo,
#endif
    afterInputContextUpdatePreeditTextWithMode,
    onInputContextUpdatePreeditTextWithMode ,


-- ** updateProperty #signal:updateProperty#

    InputContextUpdatePropertyCallback      ,
#if defined(ENABLE_OVERLOADING)
    InputContextUpdatePropertySignalInfo    ,
#endif
    afterInputContextUpdateProperty         ,
    onInputContextUpdateProperty            ,




    ) 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.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Structs.String as GLib.String
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.Enums as IBus.Enums
import {-# SOURCE #-} qualified GI.IBus.Objects.AttrList as IBus.AttrList
import {-# SOURCE #-} qualified GI.IBus.Objects.Attribute as IBus.Attribute
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.Object as IBus.Object
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.Serializable as IBus.Serializable
import {-# SOURCE #-} qualified GI.IBus.Objects.Text as IBus.Text
import {-# SOURCE #-} qualified GI.IBus.Structs.XML as IBus.XML

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

#endif

-- | 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
$c== :: InputContext -> InputContext -> Bool
== :: InputContext -> InputContext -> Bool
$c/= :: InputContext -> InputContext -> Bool
/= :: 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 a. IO a -> m a
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 a. a -> IO a
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 :: DK.Type) :: DK.Type 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 "postProcessKeyEvent" o = InputContextPostProcessKeyEventMethodInfo
    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 "setPostProcessKeyEvent" o = InputContextSetPostProcessKeyEventMethodInfo
    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 ()

type C_InputContextCommitTextCallback =
    Ptr InputContext ->                     -- 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_InputContextCommitTextCallback :: 
    GObject a => (a -> InputContextCommitTextCallback) ->
    C_InputContextCommitTextCallback
wrap_InputContextCommitTextCallback :: forall a.
GObject a =>
(a -> InputContextCommitTextCallback)
-> C_InputContextCommitTextCallback
wrap_InputContextCommitTextCallback a -> InputContextCommitTextCallback
gi'cb Ptr InputContext
gi'selfPtr 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
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> InputContextCommitTextCallback
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self)  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 -> ((?self :: a) => InputContextCommitTextCallback) -> m SignalHandlerId
onInputContextCommitText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextCommitTextCallback)
-> m SignalHandlerId
onInputContextCommitText a
obj (?self::a) => InputContextCommitTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextCommitTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextCommitTextCallback
InputContextCommitTextCallback
cb
    let wrapped' :: C_InputContextCommitTextCallback
wrapped' = (a -> InputContextCommitTextCallback)
-> C_InputContextCommitTextCallback
forall a.
GObject a =>
(a -> InputContextCommitTextCallback)
-> C_InputContextCommitTextCallback
wrap_InputContextCommitTextCallback a -> InputContextCommitTextCallback
wrapped
    FunPtr C_InputContextCommitTextCallback
wrapped'' <- C_InputContextCommitTextCallback
-> IO (FunPtr C_InputContextCommitTextCallback)
mk_InputContextCommitTextCallback C_InputContextCommitTextCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextCommitText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextCommitTextCallback) -> m SignalHandlerId
afterInputContextCommitText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextCommitTextCallback)
-> m SignalHandlerId
afterInputContextCommitText a
obj (?self::a) => InputContextCommitTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextCommitTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextCommitTextCallback
InputContextCommitTextCallback
cb
    let wrapped' :: C_InputContextCommitTextCallback
wrapped' = (a -> InputContextCommitTextCallback)
-> C_InputContextCommitTextCallback
forall a.
GObject a =>
(a -> InputContextCommitTextCallback)
-> C_InputContextCommitTextCallback
wrap_InputContextCommitTextCallback a -> InputContextCommitTextCallback
wrapped
    FunPtr C_InputContextCommitTextCallback
wrapped'' <- C_InputContextCommitTextCallback
-> IO (FunPtr C_InputContextCommitTextCallback)
mk_InputContextCommitTextCallback C_InputContextCommitTextCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::commit-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:commitText"})

#endif

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

type C_InputContextCursorDownLookupTableCallback =
    Ptr InputContext ->                     -- 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_InputContextCursorDownLookupTableCallback :: 
    GObject a => (a -> InputContextCursorDownLookupTableCallback) ->
    C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorDownLookupTableCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorDownLookupTableCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextCursorDownLookupTableCallback) -> m SignalHandlerId
onInputContextCursorDownLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextCursorDownLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorDownLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextCursorDownLookupTable :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextCursorDownLookupTableCallback) -> m SignalHandlerId
afterInputContextCursorDownLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextCursorDownLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorDownLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::cursor-down-lookup-table"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:cursorDownLookupTable"})

#endif

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

type C_InputContextCursorUpLookupTableCallback =
    Ptr InputContext ->                     -- 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_InputContextCursorUpLookupTableCallback :: 
    GObject a => (a -> InputContextCursorUpLookupTableCallback) ->
    C_InputContextCursorUpLookupTableCallback
wrap_InputContextCursorUpLookupTableCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorUpLookupTableCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextCursorUpLookupTableCallback) -> m SignalHandlerId
onInputContextCursorUpLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextCursorUpLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorUpLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextCursorUpLookupTable :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextCursorUpLookupTableCallback) -> m SignalHandlerId
afterInputContextCursorUpLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextCursorUpLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextCursorUpLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextCursorUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::cursor-up-lookup-table"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:cursorUpLookupTable"})

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

type C_InputContextDeleteSurroundingTextCallback =
    Ptr InputContext ->                     -- 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_InputContextDeleteSurroundingTextCallback :: 
    GObject a => (a -> InputContextDeleteSurroundingTextCallback) ->
    C_InputContextDeleteSurroundingTextCallback
wrap_InputContextDeleteSurroundingTextCallback :: forall a.
GObject a =>
(a -> InputContextDeleteSurroundingTextCallback)
-> C_InputContextDeleteSurroundingTextCallback
wrap_InputContextDeleteSurroundingTextCallback a -> InputContextDeleteSurroundingTextCallback
gi'cb Ptr InputContext
gi'selfPtr Int32
offset Word32
nChars Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> InputContextDeleteSurroundingTextCallback
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self)  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 -> ((?self :: a) => InputContextDeleteSurroundingTextCallback) -> m SignalHandlerId
onInputContextDeleteSurroundingText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextDeleteSurroundingTextCallback)
-> m SignalHandlerId
onInputContextDeleteSurroundingText a
obj (?self::a) => InputContextDeleteSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextDeleteSurroundingTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextDeleteSurroundingTextCallback
InputContextDeleteSurroundingTextCallback
cb
    let wrapped' :: C_InputContextDeleteSurroundingTextCallback
wrapped' = (a -> InputContextDeleteSurroundingTextCallback)
-> C_InputContextDeleteSurroundingTextCallback
forall a.
GObject a =>
(a -> InputContextDeleteSurroundingTextCallback)
-> C_InputContextDeleteSurroundingTextCallback
wrap_InputContextDeleteSurroundingTextCallback a -> InputContextDeleteSurroundingTextCallback
wrapped
    FunPtr C_InputContextDeleteSurroundingTextCallback
wrapped'' <- C_InputContextDeleteSurroundingTextCallback
-> IO (FunPtr C_InputContextDeleteSurroundingTextCallback)
mk_InputContextDeleteSurroundingTextCallback C_InputContextDeleteSurroundingTextCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextDeleteSurroundingText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextDeleteSurroundingTextCallback) -> m SignalHandlerId
afterInputContextDeleteSurroundingText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextDeleteSurroundingTextCallback)
-> m SignalHandlerId
afterInputContextDeleteSurroundingText a
obj (?self::a) => InputContextDeleteSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextDeleteSurroundingTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextDeleteSurroundingTextCallback
InputContextDeleteSurroundingTextCallback
cb
    let wrapped' :: C_InputContextDeleteSurroundingTextCallback
wrapped' = (a -> InputContextDeleteSurroundingTextCallback)
-> C_InputContextDeleteSurroundingTextCallback
forall a.
GObject a =>
(a -> InputContextDeleteSurroundingTextCallback)
-> C_InputContextDeleteSurroundingTextCallback
wrap_InputContextDeleteSurroundingTextCallback a -> InputContextDeleteSurroundingTextCallback
wrapped
    FunPtr C_InputContextDeleteSurroundingTextCallback
wrapped'' <- C_InputContextDeleteSurroundingTextCallback
-> IO (FunPtr C_InputContextDeleteSurroundingTextCallback)
mk_InputContextDeleteSurroundingTextCallback C_InputContextDeleteSurroundingTextCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::delete-surrounding-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:deleteSurroundingText"})

#endif

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

type C_InputContextDisabledCallback =
    Ptr InputContext ->                     -- 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_InputContextDisabledCallback :: 
    GObject a => (a -> InputContextDisabledCallback) ->
    C_InputContextDisabledCallback
wrap_InputContextDisabledCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextDisabledCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextDisabledCallback) -> m SignalHandlerId
onInputContextDisabled :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextDisabled a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextDisabledCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextDisabledCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextDisabled :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextDisabledCallback) -> m SignalHandlerId
afterInputContextDisabled :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextDisabled a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextDisabledCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextDisabledCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::disabled"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:disabled"})

#endif

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

type C_InputContextEnabledCallback =
    Ptr InputContext ->                     -- 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_InputContextEnabledCallback :: 
    GObject a => (a -> InputContextEnabledCallback) ->
    C_InputContextEnabledCallback
wrap_InputContextEnabledCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextEnabledCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextEnabledCallback) -> m SignalHandlerId
onInputContextEnabled :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextEnabled a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextEnabledCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextEnabledCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextEnabled :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextEnabledCallback) -> m SignalHandlerId
afterInputContextEnabled :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextEnabled a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextEnabledCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextEnabledCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::enabled"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:enabled"})

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

type C_InputContextForwardKeyEventCallback =
    Ptr InputContext ->                     -- 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_InputContextForwardKeyEventCallback :: 
    GObject a => (a -> InputContextForwardKeyEventCallback) ->
    C_InputContextForwardKeyEventCallback
wrap_InputContextForwardKeyEventCallback :: forall a.
GObject a =>
(a -> InputContextForwardKeyEventCallback)
-> C_InputContextForwardKeyEventCallback
wrap_InputContextForwardKeyEventCallback a -> InputContextForwardKeyEventCallback
gi'cb Ptr InputContext
gi'selfPtr Word32
keyval Word32
keycode Word32
modifiers Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> InputContextForwardKeyEventCallback
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self)  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 -> ((?self :: a) => InputContextForwardKeyEventCallback) -> m SignalHandlerId
onInputContextForwardKeyEvent :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextForwardKeyEventCallback)
-> m SignalHandlerId
onInputContextForwardKeyEvent a
obj (?self::a) => InputContextForwardKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextForwardKeyEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextForwardKeyEventCallback
InputContextForwardKeyEventCallback
cb
    let wrapped' :: C_InputContextForwardKeyEventCallback
wrapped' = (a -> InputContextForwardKeyEventCallback)
-> C_InputContextForwardKeyEventCallback
forall a.
GObject a =>
(a -> InputContextForwardKeyEventCallback)
-> C_InputContextForwardKeyEventCallback
wrap_InputContextForwardKeyEventCallback a -> InputContextForwardKeyEventCallback
wrapped
    FunPtr C_InputContextForwardKeyEventCallback
wrapped'' <- C_InputContextForwardKeyEventCallback
-> IO (FunPtr C_InputContextForwardKeyEventCallback)
mk_InputContextForwardKeyEventCallback C_InputContextForwardKeyEventCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextForwardKeyEvent :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextForwardKeyEventCallback) -> m SignalHandlerId
afterInputContextForwardKeyEvent :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextForwardKeyEventCallback)
-> m SignalHandlerId
afterInputContextForwardKeyEvent a
obj (?self::a) => InputContextForwardKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextForwardKeyEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextForwardKeyEventCallback
InputContextForwardKeyEventCallback
cb
    let wrapped' :: C_InputContextForwardKeyEventCallback
wrapped' = (a -> InputContextForwardKeyEventCallback)
-> C_InputContextForwardKeyEventCallback
forall a.
GObject a =>
(a -> InputContextForwardKeyEventCallback)
-> C_InputContextForwardKeyEventCallback
wrap_InputContextForwardKeyEventCallback a -> InputContextForwardKeyEventCallback
wrapped
    FunPtr C_InputContextForwardKeyEventCallback
wrapped'' <- C_InputContextForwardKeyEventCallback
-> IO (FunPtr C_InputContextForwardKeyEventCallback)
mk_InputContextForwardKeyEventCallback C_InputContextForwardKeyEventCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::forward-key-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:forwardKeyEvent"})

#endif

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

type C_InputContextHideAuxiliaryTextCallback =
    Ptr InputContext ->                     -- 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_InputContextHideAuxiliaryTextCallback :: 
    GObject a => (a -> InputContextHideAuxiliaryTextCallback) ->
    C_InputContextHideAuxiliaryTextCallback
wrap_InputContextHideAuxiliaryTextCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideAuxiliaryTextCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextHideAuxiliaryTextCallback) -> m SignalHandlerId
onInputContextHideAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextHideAuxiliaryText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideAuxiliaryTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextHideAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextHideAuxiliaryTextCallback) -> m SignalHandlerId
afterInputContextHideAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextHideAuxiliaryText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideAuxiliaryTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::hide-auxiliary-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:hideAuxiliaryText"})

#endif

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

type C_InputContextHideLookupTableCallback =
    Ptr InputContext ->                     -- 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_InputContextHideLookupTableCallback :: 
    GObject a => (a -> InputContextHideLookupTableCallback) ->
    C_InputContextHideLookupTableCallback
wrap_InputContextHideLookupTableCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideLookupTableCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextHideLookupTableCallback) -> m SignalHandlerId
onInputContextHideLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextHideLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextHideLookupTable :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextHideLookupTableCallback) -> m SignalHandlerId
afterInputContextHideLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextHideLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHideLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHideLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::hide-lookup-table"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:hideLookupTable"})

#endif

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

type C_InputContextHidePreeditTextCallback =
    Ptr InputContext ->                     -- 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_InputContextHidePreeditTextCallback :: 
    GObject a => (a -> InputContextHidePreeditTextCallback) ->
    C_InputContextHidePreeditTextCallback
wrap_InputContextHidePreeditTextCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHidePreeditTextCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextHidePreeditTextCallback) -> m SignalHandlerId
onInputContextHidePreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextHidePreeditText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHidePreeditTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHidePreeditTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextHidePreeditText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextHidePreeditTextCallback) -> m SignalHandlerId
afterInputContextHidePreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextHidePreeditText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextHidePreeditTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextHidePreeditTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::hide-preedit-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:hidePreeditText"})

#endif

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

type C_InputContextPageDownLookupTableCallback =
    Ptr InputContext ->                     -- 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_InputContextPageDownLookupTableCallback :: 
    GObject a => (a -> InputContextPageDownLookupTableCallback) ->
    C_InputContextPageDownLookupTableCallback
wrap_InputContextPageDownLookupTableCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageDownLookupTableCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextPageDownLookupTableCallback) -> m SignalHandlerId
onInputContextPageDownLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextPageDownLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageDownLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextPageDownLookupTable :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextPageDownLookupTableCallback) -> m SignalHandlerId
afterInputContextPageDownLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextPageDownLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageDownLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageDownLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::page-down-lookup-table"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:pageDownLookupTable"})

#endif

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

type C_InputContextPageUpLookupTableCallback =
    Ptr InputContext ->                     -- 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_InputContextPageUpLookupTableCallback :: 
    GObject a => (a -> InputContextPageUpLookupTableCallback) ->
    C_InputContextPageUpLookupTableCallback
wrap_InputContextPageUpLookupTableCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageUpLookupTableCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextPageUpLookupTableCallback) -> m SignalHandlerId
onInputContextPageUpLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextPageUpLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageUpLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextPageUpLookupTable :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextPageUpLookupTableCallback) -> m SignalHandlerId
afterInputContextPageUpLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextPageUpLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextPageUpLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextPageUpLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::page-up-lookup-table"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:pageUpLookupTable"})

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

type C_InputContextRegisterPropertiesCallback =
    Ptr InputContext ->                     -- 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_InputContextRegisterPropertiesCallback :: 
    GObject a => (a -> InputContextRegisterPropertiesCallback) ->
    C_InputContextRegisterPropertiesCallback
wrap_InputContextRegisterPropertiesCallback :: forall a.
GObject a =>
(a -> InputContextRegisterPropertiesCallback)
-> C_InputContextRegisterPropertiesCallback
wrap_InputContextRegisterPropertiesCallback a -> InputContextRegisterPropertiesCallback
gi'cb Ptr InputContext
gi'selfPtr 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
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> InputContextRegisterPropertiesCallback
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self)  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 -> ((?self :: a) => InputContextRegisterPropertiesCallback) -> m SignalHandlerId
onInputContextRegisterProperties :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextRegisterPropertiesCallback)
-> m SignalHandlerId
onInputContextRegisterProperties a
obj (?self::a) => InputContextRegisterPropertiesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextRegisterPropertiesCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextRegisterPropertiesCallback
InputContextRegisterPropertiesCallback
cb
    let wrapped' :: C_InputContextRegisterPropertiesCallback
wrapped' = (a -> InputContextRegisterPropertiesCallback)
-> C_InputContextRegisterPropertiesCallback
forall a.
GObject a =>
(a -> InputContextRegisterPropertiesCallback)
-> C_InputContextRegisterPropertiesCallback
wrap_InputContextRegisterPropertiesCallback a -> InputContextRegisterPropertiesCallback
wrapped
    FunPtr C_InputContextRegisterPropertiesCallback
wrapped'' <- C_InputContextRegisterPropertiesCallback
-> IO (FunPtr C_InputContextRegisterPropertiesCallback)
mk_InputContextRegisterPropertiesCallback C_InputContextRegisterPropertiesCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextRegisterProperties :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextRegisterPropertiesCallback) -> m SignalHandlerId
afterInputContextRegisterProperties :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextRegisterPropertiesCallback)
-> m SignalHandlerId
afterInputContextRegisterProperties a
obj (?self::a) => InputContextRegisterPropertiesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextRegisterPropertiesCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextRegisterPropertiesCallback
InputContextRegisterPropertiesCallback
cb
    let wrapped' :: C_InputContextRegisterPropertiesCallback
wrapped' = (a -> InputContextRegisterPropertiesCallback)
-> C_InputContextRegisterPropertiesCallback
forall a.
GObject a =>
(a -> InputContextRegisterPropertiesCallback)
-> C_InputContextRegisterPropertiesCallback
wrap_InputContextRegisterPropertiesCallback a -> InputContextRegisterPropertiesCallback
wrapped
    FunPtr C_InputContextRegisterPropertiesCallback
wrapped'' <- C_InputContextRegisterPropertiesCallback
-> IO (FunPtr C_InputContextRegisterPropertiesCallback)
mk_InputContextRegisterPropertiesCallback C_InputContextRegisterPropertiesCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::register-properties"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:registerProperties"})

#endif

-- signal InputContext::require-surrounding-text
-- | Emitted to receive the RequireSurroundingText signal from the daemon.
type InputContextRequireSurroundingTextCallback =
    IO ()

type C_InputContextRequireSurroundingTextCallback =
    Ptr InputContext ->                     -- object
    Ptr () ->                               -- user_data
    IO ()

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

wrap_InputContextRequireSurroundingTextCallback :: 
    GObject a => (a -> InputContextRequireSurroundingTextCallback) ->
    C_InputContextRequireSurroundingTextCallback
wrap_InputContextRequireSurroundingTextCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextRequireSurroundingTextCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | Connect a signal handler for the [requireSurroundingText](#signal:requireSurroundingText) 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 #requireSurroundingText callback
-- @
-- 
-- 
onInputContextRequireSurroundingText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextRequireSurroundingTextCallback) -> m SignalHandlerId
onInputContextRequireSurroundingText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextRequireSurroundingText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextRequireSurroundingTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextRequireSurroundingTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
"require-surrounding-text" FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [requireSurroundingText](#signal:requireSurroundingText) 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 #requireSurroundingText callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextRequireSurroundingText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextRequireSurroundingTextCallback) -> m SignalHandlerId
afterInputContextRequireSurroundingText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextRequireSurroundingText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextRequireSurroundingTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextRequireSurroundingTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
"require-surrounding-text" FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data InputContextRequireSurroundingTextSignalInfo
instance SignalInfo InputContextRequireSurroundingTextSignalInfo where
    type HaskellCallbackType InputContextRequireSurroundingTextSignalInfo = InputContextRequireSurroundingTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_InputContextRequireSurroundingTextCallback cb
        cb'' <- mk_InputContextRequireSurroundingTextCallback cb'
        connectSignalFunPtr obj "require-surrounding-text" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::require-surrounding-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:requireSurroundingText"})

#endif

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

type C_InputContextShowAuxiliaryTextCallback =
    Ptr InputContext ->                     -- 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_InputContextShowAuxiliaryTextCallback :: 
    GObject a => (a -> InputContextShowAuxiliaryTextCallback) ->
    C_InputContextShowAuxiliaryTextCallback
wrap_InputContextShowAuxiliaryTextCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowAuxiliaryTextCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextShowAuxiliaryTextCallback) -> m SignalHandlerId
onInputContextShowAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextShowAuxiliaryText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowAuxiliaryTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextShowAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextShowAuxiliaryTextCallback) -> m SignalHandlerId
afterInputContextShowAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextShowAuxiliaryText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowAuxiliaryTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowAuxiliaryTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::show-auxiliary-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:showAuxiliaryText"})

#endif

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

type C_InputContextShowLookupTableCallback =
    Ptr InputContext ->                     -- 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_InputContextShowLookupTableCallback :: 
    GObject a => (a -> InputContextShowLookupTableCallback) ->
    C_InputContextShowLookupTableCallback
wrap_InputContextShowLookupTableCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowLookupTableCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextShowLookupTableCallback) -> m SignalHandlerId
onInputContextShowLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextShowLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextShowLookupTable :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextShowLookupTableCallback) -> m SignalHandlerId
afterInputContextShowLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextShowLookupTable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowLookupTableCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowLookupTableCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::show-lookup-table"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:showLookupTable"})

#endif

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

type C_InputContextShowPreeditTextCallback =
    Ptr InputContext ->                     -- 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_InputContextShowPreeditTextCallback :: 
    GObject a => (a -> InputContextShowPreeditTextCallback) ->
    C_InputContextShowPreeditTextCallback
wrap_InputContextShowPreeditTextCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowPreeditTextCallback a -> IO ()
gi'cb Ptr InputContext
gi'selfPtr Ptr ()
_ = do
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> IO ()
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self) 


-- | 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 -> ((?self :: a) => InputContextShowPreeditTextCallback) -> m SignalHandlerId
onInputContextShowPreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onInputContextShowPreeditText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowPreeditTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowPreeditTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextShowPreeditText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextShowPreeditTextCallback) -> m SignalHandlerId
afterInputContextShowPreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterInputContextShowPreeditText a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_InputContextCursorDownLookupTableCallback
wrapped' = (a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
forall a.
GObject a =>
(a -> IO ()) -> C_InputContextCursorDownLookupTableCallback
wrap_InputContextShowPreeditTextCallback a -> IO ()
wrapped
    FunPtr C_InputContextCursorDownLookupTableCallback
wrapped'' <- C_InputContextCursorDownLookupTableCallback
-> IO (FunPtr C_InputContextCursorDownLookupTableCallback)
mk_InputContextShowPreeditTextCallback C_InputContextCursorDownLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::show-preedit-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:showPreeditText"})

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

type C_InputContextUpdateAuxiliaryTextCallback =
    Ptr InputContext ->                     -- 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_InputContextUpdateAuxiliaryTextCallback :: 
    GObject a => (a -> InputContextUpdateAuxiliaryTextCallback) ->
    C_InputContextUpdateAuxiliaryTextCallback
wrap_InputContextUpdateAuxiliaryTextCallback :: forall a.
GObject a =>
(a -> InputContextUpdateAuxiliaryTextCallback)
-> C_InputContextUpdateAuxiliaryTextCallback
wrap_InputContextUpdateAuxiliaryTextCallback a -> InputContextUpdateAuxiliaryTextCallback
gi'cb Ptr InputContext
gi'selfPtr 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
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> InputContextUpdateAuxiliaryTextCallback
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self)  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 -> ((?self :: a) => InputContextUpdateAuxiliaryTextCallback) -> m SignalHandlerId
onInputContextUpdateAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdateAuxiliaryTextCallback)
-> m SignalHandlerId
onInputContextUpdateAuxiliaryText a
obj (?self::a) => InputContextUpdateAuxiliaryTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdateAuxiliaryTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdateAuxiliaryTextCallback
InputContextUpdateAuxiliaryTextCallback
cb
    let wrapped' :: C_InputContextUpdateAuxiliaryTextCallback
wrapped' = (a -> InputContextUpdateAuxiliaryTextCallback)
-> C_InputContextUpdateAuxiliaryTextCallback
forall a.
GObject a =>
(a -> InputContextUpdateAuxiliaryTextCallback)
-> C_InputContextUpdateAuxiliaryTextCallback
wrap_InputContextUpdateAuxiliaryTextCallback a -> InputContextUpdateAuxiliaryTextCallback
wrapped
    FunPtr C_InputContextUpdateAuxiliaryTextCallback
wrapped'' <- C_InputContextUpdateAuxiliaryTextCallback
-> IO (FunPtr C_InputContextUpdateAuxiliaryTextCallback)
mk_InputContextUpdateAuxiliaryTextCallback C_InputContextUpdateAuxiliaryTextCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextUpdateAuxiliaryText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextUpdateAuxiliaryTextCallback) -> m SignalHandlerId
afterInputContextUpdateAuxiliaryText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdateAuxiliaryTextCallback)
-> m SignalHandlerId
afterInputContextUpdateAuxiliaryText a
obj (?self::a) => InputContextUpdateAuxiliaryTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdateAuxiliaryTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdateAuxiliaryTextCallback
InputContextUpdateAuxiliaryTextCallback
cb
    let wrapped' :: C_InputContextUpdateAuxiliaryTextCallback
wrapped' = (a -> InputContextUpdateAuxiliaryTextCallback)
-> C_InputContextUpdateAuxiliaryTextCallback
forall a.
GObject a =>
(a -> InputContextUpdateAuxiliaryTextCallback)
-> C_InputContextUpdateAuxiliaryTextCallback
wrap_InputContextUpdateAuxiliaryTextCallback a -> InputContextUpdateAuxiliaryTextCallback
wrapped
    FunPtr C_InputContextUpdateAuxiliaryTextCallback
wrapped'' <- C_InputContextUpdateAuxiliaryTextCallback
-> IO (FunPtr C_InputContextUpdateAuxiliaryTextCallback)
mk_InputContextUpdateAuxiliaryTextCallback C_InputContextUpdateAuxiliaryTextCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::update-auxiliary-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:updateAuxiliaryText"})

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

type C_InputContextUpdateLookupTableCallback =
    Ptr InputContext ->                     -- 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_InputContextUpdateLookupTableCallback :: 
    GObject a => (a -> InputContextUpdateLookupTableCallback) ->
    C_InputContextUpdateLookupTableCallback
wrap_InputContextUpdateLookupTableCallback :: forall a.
GObject a =>
(a -> InputContextUpdateLookupTableCallback)
-> C_InputContextUpdateLookupTableCallback
wrap_InputContextUpdateLookupTableCallback a -> InputContextUpdateLookupTableCallback
gi'cb Ptr InputContext
gi'selfPtr 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
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> InputContextUpdateLookupTableCallback
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self)  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 -> ((?self :: a) => InputContextUpdateLookupTableCallback) -> m SignalHandlerId
onInputContextUpdateLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdateLookupTableCallback)
-> m SignalHandlerId
onInputContextUpdateLookupTable a
obj (?self::a) => InputContextUpdateLookupTableCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdateLookupTableCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdateLookupTableCallback
InputContextUpdateLookupTableCallback
cb
    let wrapped' :: C_InputContextUpdateLookupTableCallback
wrapped' = (a -> InputContextUpdateLookupTableCallback)
-> C_InputContextUpdateLookupTableCallback
forall a.
GObject a =>
(a -> InputContextUpdateLookupTableCallback)
-> C_InputContextUpdateLookupTableCallback
wrap_InputContextUpdateLookupTableCallback a -> InputContextUpdateLookupTableCallback
wrapped
    FunPtr C_InputContextUpdateLookupTableCallback
wrapped'' <- C_InputContextUpdateLookupTableCallback
-> IO (FunPtr C_InputContextUpdateLookupTableCallback)
mk_InputContextUpdateLookupTableCallback C_InputContextUpdateLookupTableCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextUpdateLookupTable :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextUpdateLookupTableCallback) -> m SignalHandlerId
afterInputContextUpdateLookupTable :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdateLookupTableCallback)
-> m SignalHandlerId
afterInputContextUpdateLookupTable a
obj (?self::a) => InputContextUpdateLookupTableCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdateLookupTableCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdateLookupTableCallback
InputContextUpdateLookupTableCallback
cb
    let wrapped' :: C_InputContextUpdateLookupTableCallback
wrapped' = (a -> InputContextUpdateLookupTableCallback)
-> C_InputContextUpdateLookupTableCallback
forall a.
GObject a =>
(a -> InputContextUpdateLookupTableCallback)
-> C_InputContextUpdateLookupTableCallback
wrap_InputContextUpdateLookupTableCallback a -> InputContextUpdateLookupTableCallback
wrapped
    FunPtr C_InputContextUpdateLookupTableCallback
wrapped'' <- C_InputContextUpdateLookupTableCallback
-> IO (FunPtr C_InputContextUpdateLookupTableCallback)
mk_InputContextUpdateLookupTableCallback C_InputContextUpdateLookupTableCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::update-lookup-table"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:updateLookupTable"})

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

type C_InputContextUpdatePreeditTextCallback =
    Ptr InputContext ->                     -- 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_InputContextUpdatePreeditTextCallback :: 
    GObject a => (a -> InputContextUpdatePreeditTextCallback) ->
    C_InputContextUpdatePreeditTextCallback
wrap_InputContextUpdatePreeditTextCallback :: forall a.
GObject a =>
(a -> InputContextUpdatePreeditTextCallback)
-> C_InputContextUpdatePreeditTextCallback
wrap_InputContextUpdatePreeditTextCallback a -> InputContextUpdatePreeditTextCallback
gi'cb Ptr InputContext
gi'selfPtr 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
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> InputContextUpdatePreeditTextCallback
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self)  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 -> ((?self :: a) => InputContextUpdatePreeditTextCallback) -> m SignalHandlerId
onInputContextUpdatePreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdatePreeditTextCallback)
-> m SignalHandlerId
onInputContextUpdatePreeditText a
obj (?self::a) => InputContextUpdatePreeditTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdatePreeditTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdatePreeditTextCallback
InputContextUpdatePreeditTextCallback
cb
    let wrapped' :: C_InputContextUpdatePreeditTextCallback
wrapped' = (a -> InputContextUpdatePreeditTextCallback)
-> C_InputContextUpdatePreeditTextCallback
forall a.
GObject a =>
(a -> InputContextUpdatePreeditTextCallback)
-> C_InputContextUpdatePreeditTextCallback
wrap_InputContextUpdatePreeditTextCallback a -> InputContextUpdatePreeditTextCallback
wrapped
    FunPtr C_InputContextUpdatePreeditTextCallback
wrapped'' <- C_InputContextUpdatePreeditTextCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextCallback)
mk_InputContextUpdatePreeditTextCallback C_InputContextUpdatePreeditTextCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextUpdatePreeditText :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextUpdatePreeditTextCallback) -> m SignalHandlerId
afterInputContextUpdatePreeditText :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdatePreeditTextCallback)
-> m SignalHandlerId
afterInputContextUpdatePreeditText a
obj (?self::a) => InputContextUpdatePreeditTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdatePreeditTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdatePreeditTextCallback
InputContextUpdatePreeditTextCallback
cb
    let wrapped' :: C_InputContextUpdatePreeditTextCallback
wrapped' = (a -> InputContextUpdatePreeditTextCallback)
-> C_InputContextUpdatePreeditTextCallback
forall a.
GObject a =>
(a -> InputContextUpdatePreeditTextCallback)
-> C_InputContextUpdatePreeditTextCallback
wrap_InputContextUpdatePreeditTextCallback a -> InputContextUpdatePreeditTextCallback
wrapped
    FunPtr C_InputContextUpdatePreeditTextCallback
wrapped'' <- C_InputContextUpdatePreeditTextCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextCallback)
mk_InputContextUpdatePreeditTextCallback C_InputContextUpdatePreeditTextCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::update-preedit-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:updatePreeditText"})

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

type C_InputContextUpdatePreeditTextWithModeCallback =
    Ptr InputContext ->                     -- 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_InputContextUpdatePreeditTextWithModeCallback :: 
    GObject a => (a -> InputContextUpdatePreeditTextWithModeCallback) ->
    C_InputContextUpdatePreeditTextWithModeCallback
wrap_InputContextUpdatePreeditTextWithModeCallback :: forall a.
GObject a =>
(a -> InputContextUpdatePreeditTextWithModeCallback)
-> C_InputContextUpdatePreeditTextWithModeCallback
wrap_InputContextUpdatePreeditTextWithModeCallback a -> InputContextUpdatePreeditTextWithModeCallback
gi'cb Ptr InputContext
gi'selfPtr 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
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> InputContextUpdatePreeditTextWithModeCallback
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self)  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 -> ((?self :: a) => InputContextUpdatePreeditTextWithModeCallback) -> m SignalHandlerId
onInputContextUpdatePreeditTextWithMode :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdatePreeditTextWithModeCallback)
-> m SignalHandlerId
onInputContextUpdatePreeditTextWithMode a
obj (?self::a) => InputContextUpdatePreeditTextWithModeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdatePreeditTextWithModeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdatePreeditTextWithModeCallback
InputContextUpdatePreeditTextWithModeCallback
cb
    let wrapped' :: C_InputContextUpdatePreeditTextWithModeCallback
wrapped' = (a -> InputContextUpdatePreeditTextWithModeCallback)
-> C_InputContextUpdatePreeditTextWithModeCallback
forall a.
GObject a =>
(a -> InputContextUpdatePreeditTextWithModeCallback)
-> C_InputContextUpdatePreeditTextWithModeCallback
wrap_InputContextUpdatePreeditTextWithModeCallback a -> InputContextUpdatePreeditTextWithModeCallback
wrapped
    FunPtr C_InputContextUpdatePreeditTextWithModeCallback
wrapped'' <- C_InputContextUpdatePreeditTextWithModeCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextWithModeCallback)
mk_InputContextUpdatePreeditTextWithModeCallback C_InputContextUpdatePreeditTextWithModeCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextUpdatePreeditTextWithMode :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextUpdatePreeditTextWithModeCallback) -> m SignalHandlerId
afterInputContextUpdatePreeditTextWithMode :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdatePreeditTextWithModeCallback)
-> m SignalHandlerId
afterInputContextUpdatePreeditTextWithMode a
obj (?self::a) => InputContextUpdatePreeditTextWithModeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdatePreeditTextWithModeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdatePreeditTextWithModeCallback
InputContextUpdatePreeditTextWithModeCallback
cb
    let wrapped' :: C_InputContextUpdatePreeditTextWithModeCallback
wrapped' = (a -> InputContextUpdatePreeditTextWithModeCallback)
-> C_InputContextUpdatePreeditTextWithModeCallback
forall a.
GObject a =>
(a -> InputContextUpdatePreeditTextWithModeCallback)
-> C_InputContextUpdatePreeditTextWithModeCallback
wrap_InputContextUpdatePreeditTextWithModeCallback a -> InputContextUpdatePreeditTextWithModeCallback
wrapped
    FunPtr C_InputContextUpdatePreeditTextWithModeCallback
wrapped'' <- C_InputContextUpdatePreeditTextWithModeCallback
-> IO (FunPtr C_InputContextUpdatePreeditTextWithModeCallback)
mk_InputContextUpdatePreeditTextWithModeCallback C_InputContextUpdatePreeditTextWithModeCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::update-preedit-text-with-mode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:updatePreeditTextWithMode"})

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

type C_InputContextUpdatePropertyCallback =
    Ptr InputContext ->                     -- 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_InputContextUpdatePropertyCallback :: 
    GObject a => (a -> InputContextUpdatePropertyCallback) ->
    C_InputContextUpdatePropertyCallback
wrap_InputContextUpdatePropertyCallback :: forall a.
GObject a =>
(a -> InputContextUpdatePropertyCallback)
-> C_InputContextUpdatePropertyCallback
wrap_InputContextUpdatePropertyCallback a -> InputContextUpdatePropertyCallback
gi'cb Ptr InputContext
gi'selfPtr 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
    Ptr InputContext -> (InputContext -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr InputContext
gi'selfPtr ((InputContext -> IO ()) -> IO ())
-> (InputContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \InputContext
gi'self -> a -> InputContextUpdatePropertyCallback
gi'cb (InputContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce InputContext
gi'self)  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 -> ((?self :: a) => InputContextUpdatePropertyCallback) -> m SignalHandlerId
onInputContextUpdateProperty :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdatePropertyCallback)
-> m SignalHandlerId
onInputContextUpdateProperty a
obj (?self::a) => InputContextUpdatePropertyCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdatePropertyCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdatePropertyCallback
InputContextUpdatePropertyCallback
cb
    let wrapped' :: C_InputContextUpdatePropertyCallback
wrapped' = (a -> InputContextUpdatePropertyCallback)
-> C_InputContextUpdatePropertyCallback
forall a.
GObject a =>
(a -> InputContextUpdatePropertyCallback)
-> C_InputContextUpdatePropertyCallback
wrap_InputContextUpdatePropertyCallback a -> InputContextUpdatePropertyCallback
wrapped
    FunPtr C_InputContextUpdatePropertyCallback
wrapped'' <- C_InputContextUpdatePropertyCallback
-> IO (FunPtr C_InputContextUpdatePropertyCallback)
mk_InputContextUpdatePropertyCallback C_InputContextUpdatePropertyCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterInputContextUpdateProperty :: (IsInputContext a, MonadIO m) => a -> ((?self :: a) => InputContextUpdatePropertyCallback) -> m SignalHandlerId
afterInputContextUpdateProperty :: forall a (m :: * -> *).
(IsInputContext a, MonadIO m) =>
a
-> ((?self::a) => InputContextUpdatePropertyCallback)
-> m SignalHandlerId
afterInputContextUpdateProperty a
obj (?self::a) => InputContextUpdatePropertyCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 wrapped :: a -> InputContextUpdatePropertyCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => InputContextUpdatePropertyCallback
InputContextUpdatePropertyCallback
cb
    let wrapped' :: C_InputContextUpdatePropertyCallback
wrapped' = (a -> InputContextUpdatePropertyCallback)
-> C_InputContextUpdatePropertyCallback
forall a.
GObject a =>
(a -> InputContextUpdatePropertyCallback)
-> C_InputContextUpdatePropertyCallback
wrap_InputContextUpdatePropertyCallback a -> InputContextUpdatePropertyCallback
wrapped
    FunPtr C_InputContextUpdatePropertyCallback
wrapped'' <- C_InputContextUpdatePropertyCallback
-> IO (FunPtr C_InputContextUpdatePropertyCallback)
mk_InputContextUpdatePropertyCallback C_InputContextUpdatePropertyCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext::update-property"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#g:signal:updateProperty"})

#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, DK.Type)])
#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), '("requireSurroundingText", InputContextRequireSurroundingTextSignalInfo), '("showAuxiliaryText", InputContextShowAuxiliaryTextSignalInfo), '("showLookupTable", InputContextShowLookupTableSignalInfo), '("showPreeditText", InputContextShowPreeditTextSignalInfo), '("updateAuxiliaryText", InputContextUpdateAuxiliaryTextSignalInfo), '("updateLookupTable", InputContextUpdateLookupTableSignalInfo), '("updatePreeditText", InputContextUpdatePreeditTextSignalInfo), '("updatePreeditTextWithMode", InputContextUpdatePreeditTextWithModeSignalInfo), '("updateProperty", InputContextUpdatePropertySignalInfo)] :: [(Symbol, DK.Type)])

#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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputContext
result'
     ) (do
        () -> IO ()
forall a. a -> IO a
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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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: [Engine::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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextCancelHandWriting",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextFocusIn",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextFocusOut",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextGetEngine",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextGetEngineAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return EngineDesc
result'
     ) (do
        () -> IO ()
forall a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextGetEngineAsyncFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextNeedsSurroundingText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#v:inputContextNeedsSurroundingText"
        })


#endif

-- method InputContext::post_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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Call this API after 'GI.IBus.Objects.InputContext.inputContextProcessKeyEvent' returns
-- to retrieve commit-text and forwar-key-event signals during
-- calling 'GI.IBus.Objects.InputContext.inputContextProcessKeyEvent'.
-- 
-- See also 'GI.IBus.Objects.InputContext.inputContextSetPostProcessKeyEvent'.
-- 
-- /Since: 1.5.29/
inputContextPostProcessKeyEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> m ()
inputContextPostProcessKeyEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> m ()
inputContextPostProcessKeyEvent a
context = IO () -> m ()
forall a. IO a -> m a
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_post_process_key_event Ptr InputContext
context'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo InputContextPostProcessKeyEventMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextPostProcessKeyEvent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#v:inputContextPostProcessKeyEvent"
        })


#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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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: [Engine::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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextProcessHandWritingEvent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextProcessKeyEvent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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: [Engine::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 a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextProcessKeyEventAsync",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextProcessKeyEventAsyncFinish",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextPropertyActivate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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: [Engine::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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextReset",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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: [Engine::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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextSetCapabilities",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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
P.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
P.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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextSetClientCommitPreedit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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: [Engine::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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextSetContentType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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: [Engine::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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextSetCursorLocation",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextSetCursorLocationRelative",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextSetEngine",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#v:inputContextSetEngine"
        })


#endif

-- method InputContext::set_post_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
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Can use ibus_input_context_post_process_key_event() to retrieve\ncommit-text and forwar-key-event signals during\ncalling ibus_input_context_process_key_event() if it's %TRUE."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | /No description available in the introspection data./
-- 
-- /Since: 1.5.29/
inputContextSetPostProcessKeyEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsInputContext a) =>
    a
    -- ^ /@context@/: An t'GI.IBus.Objects.InputContext.InputContext'.
    -> Bool
    -- ^ /@enable@/: Can use 'GI.IBus.Objects.InputContext.inputContextPostProcessKeyEvent' to retrieve
    -- commit-text and forwar-key-event signals during
    -- calling 'GI.IBus.Objects.InputContext.inputContextProcessKeyEvent' if it\'s 'P.True'.
    -> m ()
inputContextSetPostProcessKeyEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputContext a) =>
a -> Bool -> m ()
inputContextSetPostProcessKeyEvent a
context Bool
enable = IO () -> m ()
forall a. IO a -> m a
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 enable' :: CInt
enable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.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
P.fromEnum) Bool
enable
    Ptr InputContext -> CInt -> IO ()
ibus_input_context_set_post_process_key_event Ptr InputContext
context' CInt
enable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

instance O.OverloadedMethodInfo InputContextSetPostProcessKeyEventMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextSetPostProcessKeyEvent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/docs/GI-IBus-Objects-InputContext.html#v:inputContextSetPostProcessKeyEvent"
        })


#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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.InputContext.inputContextSetSurroundingText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.8/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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputContext
result'
     ) (do
        () -> IO ()
forall a. a -> IO a
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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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
--           , argCallbackUserData = 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 a. IO a -> m a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif