{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An IBusEngine provides infrastructure for input method engine.
-- Developers can \"extend\" this class for input method engine development.
-- 
-- see_also: t'GI.IBus.Objects.Component.Component', t'GI.IBus.Objects.EngineDesc.EngineDesc'

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

module GI.IBus.Objects.Engine
    ( 

-- * Exported types
    Engine(..)                              ,
    IsEngine                                ,
    toEngine                                ,


 -- * 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"), [commitText]("GI.IBus.Objects.Engine#g:method:commitText"), [deleteSurroundingText]("GI.IBus.Objects.Engine#g:method:deleteSurroundingText"), [destroy]("GI.IBus.Objects.Object#g:method:destroy"), [emitSignal]("GI.IBus.Objects.Service#g:method:emitSignal"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [forwardKeyEvent]("GI.IBus.Objects.Engine#g:method:forwardKeyEvent"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hideAuxiliaryText]("GI.IBus.Objects.Engine#g:method:hideAuxiliaryText"), [hideLookupTable]("GI.IBus.Objects.Engine#g:method:hideLookupTable"), [hidePreeditText]("GI.IBus.Objects.Engine#g:method:hidePreeditText"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [register]("GI.IBus.Objects.Service#g:method:register"), [registerProperties]("GI.IBus.Objects.Engine#g:method:registerProperties"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [showAuxiliaryText]("GI.IBus.Objects.Engine#g:method:showAuxiliaryText"), [showLookupTable]("GI.IBus.Objects.Engine#g:method:showLookupTable"), [showPreeditText]("GI.IBus.Objects.Engine#g:method:showPreeditText"), [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"), [unregister]("GI.IBus.Objects.Service#g:method:unregister"), [updateAuxiliaryText]("GI.IBus.Objects.Engine#g:method:updateAuxiliaryText"), [updateLookupTable]("GI.IBus.Objects.Engine#g:method:updateLookupTable"), [updateLookupTableFast]("GI.IBus.Objects.Engine#g:method:updateLookupTableFast"), [updatePreeditText]("GI.IBus.Objects.Engine#g:method:updatePreeditText"), [updatePreeditTextWithMode]("GI.IBus.Objects.Engine#g:method:updatePreeditTextWithMode"), [updateProperty]("GI.IBus.Objects.Engine#g:method:updateProperty"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getConnection]("GI.IBus.Objects.Service#g:method:getConnection"), [getContentType]("GI.IBus.Objects.Engine#g:method:getContentType"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getName]("GI.IBus.Objects.Engine#g:method:getName"), [getObjectPath]("GI.IBus.Objects.Service#g:method:getObjectPath"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSurroundingText]("GI.IBus.Objects.Engine#g:method:getSurroundingText").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveEngineMethod                     ,
#endif

-- ** commitText #method:commitText#

#if defined(ENABLE_OVERLOADING)
    EngineCommitTextMethodInfo              ,
#endif
    engineCommitText                        ,


-- ** deleteSurroundingText #method:deleteSurroundingText#

#if defined(ENABLE_OVERLOADING)
    EngineDeleteSurroundingTextMethodInfo   ,
#endif
    engineDeleteSurroundingText             ,


-- ** forwardKeyEvent #method:forwardKeyEvent#

#if defined(ENABLE_OVERLOADING)
    EngineForwardKeyEventMethodInfo         ,
#endif
    engineForwardKeyEvent                   ,


-- ** getContentType #method:getContentType#

#if defined(ENABLE_OVERLOADING)
    EngineGetContentTypeMethodInfo          ,
#endif
    engineGetContentType                    ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    EngineGetNameMethodInfo                 ,
#endif
    engineGetName                           ,


-- ** getSurroundingText #method:getSurroundingText#

#if defined(ENABLE_OVERLOADING)
    EngineGetSurroundingTextMethodInfo      ,
#endif
    engineGetSurroundingText                ,


-- ** hideAuxiliaryText #method:hideAuxiliaryText#

#if defined(ENABLE_OVERLOADING)
    EngineHideAuxiliaryTextMethodInfo       ,
#endif
    engineHideAuxiliaryText                 ,


-- ** hideLookupTable #method:hideLookupTable#

#if defined(ENABLE_OVERLOADING)
    EngineHideLookupTableMethodInfo         ,
#endif
    engineHideLookupTable                   ,


-- ** hidePreeditText #method:hidePreeditText#

#if defined(ENABLE_OVERLOADING)
    EngineHidePreeditTextMethodInfo         ,
#endif
    engineHidePreeditText                   ,


-- ** new #method:new#

    engineNew                               ,


-- ** newWithType #method:newWithType#

    engineNewWithType                       ,


-- ** registerProperties #method:registerProperties#

#if defined(ENABLE_OVERLOADING)
    EngineRegisterPropertiesMethodInfo      ,
#endif
    engineRegisterProperties                ,


-- ** showAuxiliaryText #method:showAuxiliaryText#

#if defined(ENABLE_OVERLOADING)
    EngineShowAuxiliaryTextMethodInfo       ,
#endif
    engineShowAuxiliaryText                 ,


-- ** showLookupTable #method:showLookupTable#

#if defined(ENABLE_OVERLOADING)
    EngineShowLookupTableMethodInfo         ,
#endif
    engineShowLookupTable                   ,


-- ** showPreeditText #method:showPreeditText#

#if defined(ENABLE_OVERLOADING)
    EngineShowPreeditTextMethodInfo         ,
#endif
    engineShowPreeditText                   ,


-- ** updateAuxiliaryText #method:updateAuxiliaryText#

#if defined(ENABLE_OVERLOADING)
    EngineUpdateAuxiliaryTextMethodInfo     ,
#endif
    engineUpdateAuxiliaryText               ,


-- ** updateLookupTable #method:updateLookupTable#

#if defined(ENABLE_OVERLOADING)
    EngineUpdateLookupTableMethodInfo       ,
#endif
    engineUpdateLookupTable                 ,


-- ** updateLookupTableFast #method:updateLookupTableFast#

#if defined(ENABLE_OVERLOADING)
    EngineUpdateLookupTableFastMethodInfo   ,
#endif
    engineUpdateLookupTableFast             ,


-- ** updatePreeditText #method:updatePreeditText#

#if defined(ENABLE_OVERLOADING)
    EngineUpdatePreeditTextMethodInfo       ,
#endif
    engineUpdatePreeditText                 ,


-- ** updatePreeditTextWithMode #method:updatePreeditTextWithMode#

#if defined(ENABLE_OVERLOADING)
    EngineUpdatePreeditTextWithModeMethodInfo,
#endif
    engineUpdatePreeditTextWithMode         ,


-- ** updateProperty #method:updateProperty#

#if defined(ENABLE_OVERLOADING)
    EngineUpdatePropertyMethodInfo          ,
#endif
    engineUpdateProperty                    ,




 -- * Properties


-- ** engineName #attr:engineName#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    EngineEngineNamePropertyInfo            ,
#endif
    constructEngineEngineName               ,
#if defined(ENABLE_OVERLOADING)
    engineEngineName                        ,
#endif
    getEngineEngineName                     ,




 -- * Signals


-- ** cancelHandWriting #signal:cancelHandWriting#

    C_EngineCancelHandWritingCallback       ,
    EngineCancelHandWritingCallback         ,
#if defined(ENABLE_OVERLOADING)
    EngineCancelHandWritingSignalInfo       ,
#endif
    afterEngineCancelHandWriting            ,
    genClosure_EngineCancelHandWriting      ,
    mk_EngineCancelHandWritingCallback      ,
    noEngineCancelHandWritingCallback       ,
    onEngineCancelHandWriting               ,
    wrap_EngineCancelHandWritingCallback    ,


-- ** candidateClicked #signal:candidateClicked#

    C_EngineCandidateClickedCallback        ,
    EngineCandidateClickedCallback          ,
#if defined(ENABLE_OVERLOADING)
    EngineCandidateClickedSignalInfo        ,
#endif
    afterEngineCandidateClicked             ,
    genClosure_EngineCandidateClicked       ,
    mk_EngineCandidateClickedCallback       ,
    noEngineCandidateClickedCallback        ,
    onEngineCandidateClicked                ,
    wrap_EngineCandidateClickedCallback     ,


-- ** cursorDown #signal:cursorDown#

    C_EngineCursorDownCallback              ,
    EngineCursorDownCallback                ,
#if defined(ENABLE_OVERLOADING)
    EngineCursorDownSignalInfo              ,
#endif
    afterEngineCursorDown                   ,
    genClosure_EngineCursorDown             ,
    mk_EngineCursorDownCallback             ,
    noEngineCursorDownCallback              ,
    onEngineCursorDown                      ,
    wrap_EngineCursorDownCallback           ,


-- ** cursorUp #signal:cursorUp#

    C_EngineCursorUpCallback                ,
    EngineCursorUpCallback                  ,
#if defined(ENABLE_OVERLOADING)
    EngineCursorUpSignalInfo                ,
#endif
    afterEngineCursorUp                     ,
    genClosure_EngineCursorUp               ,
    mk_EngineCursorUpCallback               ,
    noEngineCursorUpCallback                ,
    onEngineCursorUp                        ,
    wrap_EngineCursorUpCallback             ,


-- ** disable #signal:disable#

    C_EngineDisableCallback                 ,
    EngineDisableCallback                   ,
#if defined(ENABLE_OVERLOADING)
    EngineDisableSignalInfo                 ,
#endif
    afterEngineDisable                      ,
    genClosure_EngineDisable                ,
    mk_EngineDisableCallback                ,
    noEngineDisableCallback                 ,
    onEngineDisable                         ,
    wrap_EngineDisableCallback              ,


-- ** enable #signal:enable#

    C_EngineEnableCallback                  ,
    EngineEnableCallback                    ,
#if defined(ENABLE_OVERLOADING)
    EngineEnableSignalInfo                  ,
#endif
    afterEngineEnable                       ,
    genClosure_EngineEnable                 ,
    mk_EngineEnableCallback                 ,
    noEngineEnableCallback                  ,
    onEngineEnable                          ,
    wrap_EngineEnableCallback               ,


-- ** focusIn #signal:focusIn#

    C_EngineFocusInCallback                 ,
    EngineFocusInCallback                   ,
#if defined(ENABLE_OVERLOADING)
    EngineFocusInSignalInfo                 ,
#endif
    afterEngineFocusIn                      ,
    genClosure_EngineFocusIn                ,
    mk_EngineFocusInCallback                ,
    noEngineFocusInCallback                 ,
    onEngineFocusIn                         ,
    wrap_EngineFocusInCallback              ,


-- ** focusOut #signal:focusOut#

    C_EngineFocusOutCallback                ,
    EngineFocusOutCallback                  ,
#if defined(ENABLE_OVERLOADING)
    EngineFocusOutSignalInfo                ,
#endif
    afterEngineFocusOut                     ,
    genClosure_EngineFocusOut               ,
    mk_EngineFocusOutCallback               ,
    noEngineFocusOutCallback                ,
    onEngineFocusOut                        ,
    wrap_EngineFocusOutCallback             ,


-- ** pageDown #signal:pageDown#

    C_EnginePageDownCallback                ,
    EnginePageDownCallback                  ,
#if defined(ENABLE_OVERLOADING)
    EnginePageDownSignalInfo                ,
#endif
    afterEnginePageDown                     ,
    genClosure_EnginePageDown               ,
    mk_EnginePageDownCallback               ,
    noEnginePageDownCallback                ,
    onEnginePageDown                        ,
    wrap_EnginePageDownCallback             ,


-- ** pageUp #signal:pageUp#

    C_EnginePageUpCallback                  ,
    EnginePageUpCallback                    ,
#if defined(ENABLE_OVERLOADING)
    EnginePageUpSignalInfo                  ,
#endif
    afterEnginePageUp                       ,
    genClosure_EnginePageUp                 ,
    mk_EnginePageUpCallback                 ,
    noEnginePageUpCallback                  ,
    onEnginePageUp                          ,
    wrap_EnginePageUpCallback               ,


-- ** processHandWritingEvent #signal:processHandWritingEvent#

    C_EngineProcessHandWritingEventCallback ,
    EngineProcessHandWritingEventCallback   ,
#if defined(ENABLE_OVERLOADING)
    EngineProcessHandWritingEventSignalInfo ,
#endif
    afterEngineProcessHandWritingEvent      ,
    genClosure_EngineProcessHandWritingEvent,
    mk_EngineProcessHandWritingEventCallback,
    noEngineProcessHandWritingEventCallback ,
    onEngineProcessHandWritingEvent         ,
    wrap_EngineProcessHandWritingEventCallback,


-- ** processKeyEvent #signal:processKeyEvent#

    C_EngineProcessKeyEventCallback         ,
    EngineProcessKeyEventCallback           ,
#if defined(ENABLE_OVERLOADING)
    EngineProcessKeyEventSignalInfo         ,
#endif
    afterEngineProcessKeyEvent              ,
    genClosure_EngineProcessKeyEvent        ,
    mk_EngineProcessKeyEventCallback        ,
    noEngineProcessKeyEventCallback         ,
    onEngineProcessKeyEvent                 ,
    wrap_EngineProcessKeyEventCallback      ,


-- ** propertyActivate #signal:propertyActivate#

    C_EnginePropertyActivateCallback        ,
    EnginePropertyActivateCallback          ,
#if defined(ENABLE_OVERLOADING)
    EnginePropertyActivateSignalInfo        ,
#endif
    afterEnginePropertyActivate             ,
    genClosure_EnginePropertyActivate       ,
    mk_EnginePropertyActivateCallback       ,
    noEnginePropertyActivateCallback        ,
    onEnginePropertyActivate                ,
    wrap_EnginePropertyActivateCallback     ,


-- ** propertyHide #signal:propertyHide#

    C_EnginePropertyHideCallback            ,
    EnginePropertyHideCallback              ,
#if defined(ENABLE_OVERLOADING)
    EnginePropertyHideSignalInfo            ,
#endif
    afterEnginePropertyHide                 ,
    genClosure_EnginePropertyHide           ,
    mk_EnginePropertyHideCallback           ,
    noEnginePropertyHideCallback            ,
    onEnginePropertyHide                    ,
    wrap_EnginePropertyHideCallback         ,


-- ** propertyShow #signal:propertyShow#

    C_EnginePropertyShowCallback            ,
    EnginePropertyShowCallback              ,
#if defined(ENABLE_OVERLOADING)
    EnginePropertyShowSignalInfo            ,
#endif
    afterEnginePropertyShow                 ,
    genClosure_EnginePropertyShow           ,
    mk_EnginePropertyShowCallback           ,
    noEnginePropertyShowCallback            ,
    onEnginePropertyShow                    ,
    wrap_EnginePropertyShowCallback         ,


-- ** reset #signal:reset#

    C_EngineResetCallback                   ,
    EngineResetCallback                     ,
#if defined(ENABLE_OVERLOADING)
    EngineResetSignalInfo                   ,
#endif
    afterEngineReset                        ,
    genClosure_EngineReset                  ,
    mk_EngineResetCallback                  ,
    noEngineResetCallback                   ,
    onEngineReset                           ,
    wrap_EngineResetCallback                ,


-- ** setCapabilities #signal:setCapabilities#

    C_EngineSetCapabilitiesCallback         ,
    EngineSetCapabilitiesCallback           ,
#if defined(ENABLE_OVERLOADING)
    EngineSetCapabilitiesSignalInfo         ,
#endif
    afterEngineSetCapabilities              ,
    genClosure_EngineSetCapabilities        ,
    mk_EngineSetCapabilitiesCallback        ,
    noEngineSetCapabilitiesCallback         ,
    onEngineSetCapabilities                 ,
    wrap_EngineSetCapabilitiesCallback      ,


-- ** setContentType #signal:setContentType#

    C_EngineSetContentTypeCallback          ,
    EngineSetContentTypeCallback            ,
#if defined(ENABLE_OVERLOADING)
    EngineSetContentTypeSignalInfo          ,
#endif
    afterEngineSetContentType               ,
    genClosure_EngineSetContentType         ,
    mk_EngineSetContentTypeCallback         ,
    noEngineSetContentTypeCallback          ,
    onEngineSetContentType                  ,
    wrap_EngineSetContentTypeCallback       ,


-- ** setCursorLocation #signal:setCursorLocation#

    C_EngineSetCursorLocationCallback       ,
    EngineSetCursorLocationCallback         ,
#if defined(ENABLE_OVERLOADING)
    EngineSetCursorLocationSignalInfo       ,
#endif
    afterEngineSetCursorLocation            ,
    genClosure_EngineSetCursorLocation      ,
    mk_EngineSetCursorLocationCallback      ,
    noEngineSetCursorLocationCallback       ,
    onEngineSetCursorLocation               ,
    wrap_EngineSetCursorLocationCallback    ,


-- ** setSurroundingText #signal:setSurroundingText#

    C_EngineSetSurroundingTextCallback      ,
    EngineSetSurroundingTextCallback        ,
#if defined(ENABLE_OVERLOADING)
    EngineSetSurroundingTextSignalInfo      ,
#endif
    afterEngineSetSurroundingText           ,
    genClosure_EngineSetSurroundingText     ,
    mk_EngineSetSurroundingTextCallback     ,
    noEngineSetSurroundingTextCallback      ,
    onEngineSetSurroundingText              ,
    wrap_EngineSetSurroundingTextCallback   ,




    ) where

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

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

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.IBus.Enums as IBus.Enums
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.Service as IBus.Service
import {-# SOURCE #-} qualified GI.IBus.Objects.Text as IBus.Text

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

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

foreign import ccall "ibus_engine_get_type"
    c_ibus_engine_get_type :: IO B.Types.GType

instance B.Types.TypedObject Engine where
    glibType :: IO GType
glibType = IO GType
c_ibus_engine_get_type

instance B.Types.GObject Engine

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

instance O.HasParentTypes Engine
type instance O.ParentTypes Engine = '[IBus.Service.Service, IBus.Object.Object, GObject.Object.Object]

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

-- | Convert 'Engine' 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 Engine) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ibus_engine_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Engine -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Engine
P.Nothing = Ptr GValue -> Ptr Engine -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Engine
forall a. Ptr a
FP.nullPtr :: FP.Ptr Engine)
    gvalueSet_ Ptr GValue
gv (P.Just Engine
obj) = Engine -> (Ptr Engine -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Engine
obj (Ptr GValue -> Ptr Engine -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Engine)
gvalueGet_ Ptr GValue
gv = do
        Ptr Engine
ptr <- Ptr GValue -> IO (Ptr Engine)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Engine)
        if Ptr Engine
ptr Ptr Engine -> Ptr Engine -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Engine
forall a. Ptr a
FP.nullPtr
        then Engine -> Maybe Engine
forall a. a -> Maybe a
P.Just (Engine -> Maybe Engine) -> IO Engine -> IO (Maybe Engine)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Engine -> Engine) -> Ptr Engine -> IO Engine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Engine -> Engine
Engine Ptr Engine
ptr
        else Maybe Engine -> IO (Maybe Engine)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Engine
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveEngineMethod (t :: Symbol) (o :: *) :: * where
    ResolveEngineMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveEngineMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveEngineMethod "commitText" o = EngineCommitTextMethodInfo
    ResolveEngineMethod "deleteSurroundingText" o = EngineDeleteSurroundingTextMethodInfo
    ResolveEngineMethod "destroy" o = IBus.Object.ObjectDestroyMethodInfo
    ResolveEngineMethod "emitSignal" o = IBus.Service.ServiceEmitSignalMethodInfo
    ResolveEngineMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveEngineMethod "forwardKeyEvent" o = EngineForwardKeyEventMethodInfo
    ResolveEngineMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveEngineMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveEngineMethod "hideAuxiliaryText" o = EngineHideAuxiliaryTextMethodInfo
    ResolveEngineMethod "hideLookupTable" o = EngineHideLookupTableMethodInfo
    ResolveEngineMethod "hidePreeditText" o = EngineHidePreeditTextMethodInfo
    ResolveEngineMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveEngineMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveEngineMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveEngineMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveEngineMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveEngineMethod "register" o = IBus.Service.ServiceRegisterMethodInfo
    ResolveEngineMethod "registerProperties" o = EngineRegisterPropertiesMethodInfo
    ResolveEngineMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveEngineMethod "showAuxiliaryText" o = EngineShowAuxiliaryTextMethodInfo
    ResolveEngineMethod "showLookupTable" o = EngineShowLookupTableMethodInfo
    ResolveEngineMethod "showPreeditText" o = EngineShowPreeditTextMethodInfo
    ResolveEngineMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveEngineMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveEngineMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveEngineMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveEngineMethod "unregister" o = IBus.Service.ServiceUnregisterMethodInfo
    ResolveEngineMethod "updateAuxiliaryText" o = EngineUpdateAuxiliaryTextMethodInfo
    ResolveEngineMethod "updateLookupTable" o = EngineUpdateLookupTableMethodInfo
    ResolveEngineMethod "updateLookupTableFast" o = EngineUpdateLookupTableFastMethodInfo
    ResolveEngineMethod "updatePreeditText" o = EngineUpdatePreeditTextMethodInfo
    ResolveEngineMethod "updatePreeditTextWithMode" o = EngineUpdatePreeditTextWithModeMethodInfo
    ResolveEngineMethod "updateProperty" o = EngineUpdatePropertyMethodInfo
    ResolveEngineMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveEngineMethod "getConnection" o = IBus.Service.ServiceGetConnectionMethodInfo
    ResolveEngineMethod "getContentType" o = EngineGetContentTypeMethodInfo
    ResolveEngineMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveEngineMethod "getName" o = EngineGetNameMethodInfo
    ResolveEngineMethod "getObjectPath" o = IBus.Service.ServiceGetObjectPathMethodInfo
    ResolveEngineMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveEngineMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveEngineMethod "getSurroundingText" o = EngineGetSurroundingTextMethodInfo
    ResolveEngineMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveEngineMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveEngineMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveEngineMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveEngineMethod t Engine, O.OverloadedMethod info Engine p) => OL.IsLabel t (Engine -> 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 ~ ResolveEngineMethod t Engine, O.OverloadedMethod info Engine p, R.HasField t Engine p) => R.HasField t Engine p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- signal Engine::cancel-hand-writing
-- | Emitted when a hand writing operation is cancelled.
-- Implement the member function IBusEngineClass[cancel_hand_writing](#g:signal:cancel_hand_writing)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineCancelHandWritingCallback =
    Word32
    -- ^ /@nStrokes@/: The number of strokes to be removed. 0 means \"remove all\".
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EngineCancelHandWritingCallback`@.
noEngineCancelHandWritingCallback :: Maybe EngineCancelHandWritingCallback
noEngineCancelHandWritingCallback :: Maybe EngineCancelHandWritingCallback
noEngineCancelHandWritingCallback = Maybe EngineCancelHandWritingCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineCancelHandWriting :: MonadIO m => EngineCancelHandWritingCallback -> m (GClosure C_EngineCancelHandWritingCallback)
genClosure_EngineCancelHandWriting :: forall (m :: * -> *).
MonadIO m =>
EngineCancelHandWritingCallback
-> m (GClosure C_EngineCancelHandWritingCallback)
genClosure_EngineCancelHandWriting EngineCancelHandWritingCallback
cb = IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCancelHandWritingCallback)
 -> m (GClosure C_EngineCancelHandWritingCallback))
-> IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback EngineCancelHandWritingCallback
cb
    C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineCancelHandWritingCallback C_EngineCancelHandWritingCallback
cb' IO (FunPtr C_EngineCancelHandWritingCallback)
-> (FunPtr C_EngineCancelHandWritingCallback
    -> IO (GClosure C_EngineCancelHandWritingCallback))
-> IO (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCancelHandWritingCallback
-> IO (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineCancelHandWritingCallback` into a `C_EngineCancelHandWritingCallback`.
wrap_EngineCancelHandWritingCallback ::
    EngineCancelHandWritingCallback ->
    C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback :: EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback EngineCancelHandWritingCallback
_cb Ptr ()
_ Word32
nStrokes Ptr ()
_ = do
    EngineCancelHandWritingCallback
_cb  Word32
nStrokes


-- | Connect a signal handler for the [cancelHandWriting](#signal:cancelHandWriting) 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' engine #cancelHandWriting callback
-- @
-- 
-- 
onEngineCancelHandWriting :: (IsEngine a, MonadIO m) => a -> EngineCancelHandWritingCallback -> m SignalHandlerId
onEngineCancelHandWriting :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCancelHandWritingCallback -> m SignalHandlerId
onEngineCancelHandWriting a
obj EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback EngineCancelHandWritingCallback
cb
    FunPtr C_EngineCancelHandWritingCallback
cb'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineCancelHandWritingCallback C_EngineCancelHandWritingCallback
cb'
    a
-> Text
-> FunPtr C_EngineCancelHandWritingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancel-hand-writing" FunPtr C_EngineCancelHandWritingCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cancelHandWriting](#signal:cancelHandWriting) 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' engine #cancelHandWriting callback
-- @
-- 
-- 
afterEngineCancelHandWriting :: (IsEngine a, MonadIO m) => a -> EngineCancelHandWritingCallback -> m SignalHandlerId
afterEngineCancelHandWriting :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCancelHandWritingCallback -> m SignalHandlerId
afterEngineCancelHandWriting a
obj EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback EngineCancelHandWritingCallback
cb
    FunPtr C_EngineCancelHandWritingCallback
cb'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineCancelHandWritingCallback C_EngineCancelHandWritingCallback
cb'
    a
-> Text
-> FunPtr C_EngineCancelHandWritingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancel-hand-writing" FunPtr C_EngineCancelHandWritingCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineCancelHandWritingSignalInfo
instance SignalInfo EngineCancelHandWritingSignalInfo where
    type HaskellCallbackType EngineCancelHandWritingSignalInfo = EngineCancelHandWritingCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineCancelHandWritingCallback cb
        cb'' <- mk_EngineCancelHandWritingCallback cb'
        connectSignalFunPtr obj "cancel-hand-writing" cb'' connectMode detail

#endif

-- signal Engine::candidate-clicked
-- | Emitted when candidate on lookup table is clicked.
-- Implement the member function IBusEngineClass[candidate_clicked](#g:signal:candidate_clicked)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineCandidateClickedCallback =
    Word32
    -- ^ /@index@/: Index of candidate be clicked.
    -> Word32
    -- ^ /@button@/: Mouse button.
    -> Word32
    -- ^ /@state@/: Keyboard state.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EngineCandidateClickedCallback`@.
noEngineCandidateClickedCallback :: Maybe EngineCandidateClickedCallback
noEngineCandidateClickedCallback :: Maybe EngineCandidateClickedCallback
noEngineCandidateClickedCallback = Maybe EngineCandidateClickedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineCandidateClicked :: MonadIO m => EngineCandidateClickedCallback -> m (GClosure C_EngineCandidateClickedCallback)
genClosure_EngineCandidateClicked :: forall (m :: * -> *).
MonadIO m =>
EngineCandidateClickedCallback
-> m (GClosure C_EngineCandidateClickedCallback)
genClosure_EngineCandidateClicked EngineCandidateClickedCallback
cb = IO (GClosure C_EngineCandidateClickedCallback)
-> m (GClosure C_EngineCandidateClickedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCandidateClickedCallback)
 -> m (GClosure C_EngineCandidateClickedCallback))
-> IO (GClosure C_EngineCandidateClickedCallback)
-> m (GClosure C_EngineCandidateClickedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCandidateClickedCallback
cb' = EngineCandidateClickedCallback -> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback EngineCandidateClickedCallback
cb
    C_EngineCandidateClickedCallback
-> IO (FunPtr C_EngineCandidateClickedCallback)
mk_EngineCandidateClickedCallback C_EngineCandidateClickedCallback
cb' IO (FunPtr C_EngineCandidateClickedCallback)
-> (FunPtr C_EngineCandidateClickedCallback
    -> IO (GClosure C_EngineCandidateClickedCallback))
-> IO (GClosure C_EngineCandidateClickedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCandidateClickedCallback
-> IO (GClosure C_EngineCandidateClickedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineCandidateClickedCallback` into a `C_EngineCandidateClickedCallback`.
wrap_EngineCandidateClickedCallback ::
    EngineCandidateClickedCallback ->
    C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback :: EngineCandidateClickedCallback -> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback EngineCandidateClickedCallback
_cb Ptr ()
_ Word32
index Word32
button Word32
state Ptr ()
_ = do
    EngineCandidateClickedCallback
_cb  Word32
index Word32
button Word32
state


-- | Connect a signal handler for the [candidateClicked](#signal:candidateClicked) 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' engine #candidateClicked callback
-- @
-- 
-- 
onEngineCandidateClicked :: (IsEngine a, MonadIO m) => a -> EngineCandidateClickedCallback -> m SignalHandlerId
onEngineCandidateClicked :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCandidateClickedCallback -> m SignalHandlerId
onEngineCandidateClicked a
obj EngineCandidateClickedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCandidateClickedCallback
cb' = EngineCandidateClickedCallback -> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback EngineCandidateClickedCallback
cb
    FunPtr C_EngineCandidateClickedCallback
cb'' <- C_EngineCandidateClickedCallback
-> IO (FunPtr C_EngineCandidateClickedCallback)
mk_EngineCandidateClickedCallback C_EngineCandidateClickedCallback
cb'
    a
-> Text
-> FunPtr C_EngineCandidateClickedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"candidate-clicked" FunPtr C_EngineCandidateClickedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [candidateClicked](#signal:candidateClicked) 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' engine #candidateClicked callback
-- @
-- 
-- 
afterEngineCandidateClicked :: (IsEngine a, MonadIO m) => a -> EngineCandidateClickedCallback -> m SignalHandlerId
afterEngineCandidateClicked :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCandidateClickedCallback -> m SignalHandlerId
afterEngineCandidateClicked a
obj EngineCandidateClickedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCandidateClickedCallback
cb' = EngineCandidateClickedCallback -> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback EngineCandidateClickedCallback
cb
    FunPtr C_EngineCandidateClickedCallback
cb'' <- C_EngineCandidateClickedCallback
-> IO (FunPtr C_EngineCandidateClickedCallback)
mk_EngineCandidateClickedCallback C_EngineCandidateClickedCallback
cb'
    a
-> Text
-> FunPtr C_EngineCandidateClickedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"candidate-clicked" FunPtr C_EngineCandidateClickedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineCandidateClickedSignalInfo
instance SignalInfo EngineCandidateClickedSignalInfo where
    type HaskellCallbackType EngineCandidateClickedSignalInfo = EngineCandidateClickedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineCandidateClickedCallback cb
        cb'' <- mk_EngineCandidateClickedCallback cb'
        connectSignalFunPtr obj "candidate-clicked" cb'' connectMode detail

#endif

-- signal Engine::cursor-down
-- | Emitted when the down cursor button is pressed.
-- Implement the member function IBusEngineClass[cursor_down](#g:signal:cursor_down)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineCursorDownCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineCursorDown :: MonadIO m => EngineCursorDownCallback -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineCursorDown :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineCursorDown IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
 -> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback IO ()
cb
    C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorDownCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
    -> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineCursorDownCallback` into a `C_EngineCursorDownCallback`.
wrap_EngineCursorDownCallback ::
    EngineCursorDownCallback ->
    C_EngineCursorDownCallback
wrap_EngineCursorDownCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [cursorDown](#signal:cursorDown) 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' engine #cursorDown callback
-- @
-- 
-- 
onEngineCursorDown :: (IsEngine a, MonadIO m) => a -> EngineCursorDownCallback -> m SignalHandlerId
onEngineCursorDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineCursorDown a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorDownCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> 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" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cursorDown](#signal:cursorDown) 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' engine #cursorDown callback
-- @
-- 
-- 
afterEngineCursorDown :: (IsEngine a, MonadIO m) => a -> EngineCursorDownCallback -> m SignalHandlerId
afterEngineCursorDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineCursorDown a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorDownCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> 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" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineCursorDownSignalInfo
instance SignalInfo EngineCursorDownSignalInfo where
    type HaskellCallbackType EngineCursorDownSignalInfo = EngineCursorDownCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineCursorDownCallback cb
        cb'' <- mk_EngineCursorDownCallback cb'
        connectSignalFunPtr obj "cursor-down" cb'' connectMode detail

#endif

-- signal Engine::cursor-up
-- | Emitted when the up cursor button is pressed.
-- Implement the member function IBusEngineClass[cursor_up](#g:signal:cursor_up)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineCursorUpCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineCursorUp :: MonadIO m => EngineCursorUpCallback -> m (GClosure C_EngineCursorUpCallback)
genClosure_EngineCursorUp :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineCursorUp IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
 -> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback IO ()
cb
    C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorUpCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
    -> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineCursorUpCallback` into a `C_EngineCursorUpCallback`.
wrap_EngineCursorUpCallback ::
    EngineCursorUpCallback ->
    C_EngineCursorUpCallback
wrap_EngineCursorUpCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [cursorUp](#signal:cursorUp) 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' engine #cursorUp callback
-- @
-- 
-- 
onEngineCursorUp :: (IsEngine a, MonadIO m) => a -> EngineCursorUpCallback -> m SignalHandlerId
onEngineCursorUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineCursorUp a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorUpCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> 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" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cursorUp](#signal:cursorUp) 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' engine #cursorUp callback
-- @
-- 
-- 
afterEngineCursorUp :: (IsEngine a, MonadIO m) => a -> EngineCursorUpCallback -> m SignalHandlerId
afterEngineCursorUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineCursorUp a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorUpCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> 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" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineCursorUpSignalInfo
instance SignalInfo EngineCursorUpSignalInfo where
    type HaskellCallbackType EngineCursorUpSignalInfo = EngineCursorUpCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineCursorUpCallback cb
        cb'' <- mk_EngineCursorUpCallback cb'
        connectSignalFunPtr obj "cursor-up" cb'' connectMode detail

#endif

-- signal Engine::disable
-- | Emitted when the IME is disabled.
-- Implement the member function IBusEngineClass[disable](#g:signal:disable)
-- in extended class to receive this signal.
-- 
-- See also:  'GI.IBus.Objects.Bus.busSetGlobalEngine'.
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineDisableCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineDisable :: MonadIO m => EngineDisableCallback -> m (GClosure C_EngineDisableCallback)
genClosure_EngineDisable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineDisable IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
 -> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineDisableCallback IO ()
cb
    C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineDisableCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
    -> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineDisableCallback` into a `C_EngineDisableCallback`.
wrap_EngineDisableCallback ::
    EngineDisableCallback ->
    C_EngineDisableCallback
wrap_EngineDisableCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineDisableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [disable](#signal:disable) 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' engine #disable callback
-- @
-- 
-- 
onEngineDisable :: (IsEngine a, MonadIO m) => a -> EngineDisableCallback -> m SignalHandlerId
onEngineDisable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineDisable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineDisableCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineDisableCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"disable" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [disable](#signal:disable) 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' engine #disable callback
-- @
-- 
-- 
afterEngineDisable :: (IsEngine a, MonadIO m) => a -> EngineDisableCallback -> m SignalHandlerId
afterEngineDisable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineDisable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineDisableCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineDisableCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"disable" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineDisableSignalInfo
instance SignalInfo EngineDisableSignalInfo where
    type HaskellCallbackType EngineDisableSignalInfo = EngineDisableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineDisableCallback cb
        cb'' <- mk_EngineDisableCallback cb'
        connectSignalFunPtr obj "disable" cb'' connectMode detail

#endif

-- signal Engine::enable
-- | Emitted when the IME is enabled.
-- Implement the member function IBusEngineClass[enable](#g:signal:enable)
-- in extended class to receive this signal.
-- 
-- See also:  'GI.IBus.Objects.Bus.busSetGlobalEngine'.
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineEnableCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineEnable :: MonadIO m => EngineEnableCallback -> m (GClosure C_EngineEnableCallback)
genClosure_EngineEnable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineEnable IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
 -> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineEnableCallback IO ()
cb
    C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineEnableCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
    -> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineEnableCallback` into a `C_EngineEnableCallback`.
wrap_EngineEnableCallback ::
    EngineEnableCallback ->
    C_EngineEnableCallback
wrap_EngineEnableCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineEnableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [enable](#signal:enable) 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' engine #enable callback
-- @
-- 
-- 
onEngineEnable :: (IsEngine a, MonadIO m) => a -> EngineEnableCallback -> m SignalHandlerId
onEngineEnable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineEnable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineEnableCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineEnableCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enable" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [enable](#signal:enable) 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' engine #enable callback
-- @
-- 
-- 
afterEngineEnable :: (IsEngine a, MonadIO m) => a -> EngineEnableCallback -> m SignalHandlerId
afterEngineEnable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineEnable a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineEnableCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineEnableCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"enable" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineEnableSignalInfo
instance SignalInfo EngineEnableSignalInfo where
    type HaskellCallbackType EngineEnableSignalInfo = EngineEnableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineEnableCallback cb
        cb'' <- mk_EngineEnableCallback cb'
        connectSignalFunPtr obj "enable" cb'' connectMode detail

#endif

-- signal Engine::focus-in
-- | Emitted when the client application get the focus.
-- Implement the member function IBusEngineClass[focus_in](#g:signal:focus_in)
-- in extended class to receive this signal.
-- 
-- See also: 'GI.IBus.Objects.InputContext.inputContextFocusIn'
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineFocusInCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineFocusIn :: MonadIO m => EngineFocusInCallback -> m (GClosure C_EngineFocusInCallback)
genClosure_EngineFocusIn :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineFocusIn IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
 -> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback IO ()
cb
    C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusInCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
    -> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineFocusInCallback` into a `C_EngineFocusInCallback`.
wrap_EngineFocusInCallback ::
    EngineFocusInCallback ->
    C_EngineFocusInCallback
wrap_EngineFocusInCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [focusIn](#signal:focusIn) 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' engine #focusIn callback
-- @
-- 
-- 
onEngineFocusIn :: (IsEngine a, MonadIO m) => a -> EngineFocusInCallback -> m SignalHandlerId
onEngineFocusIn :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineFocusIn a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusInCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-in" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [focusIn](#signal:focusIn) 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' engine #focusIn callback
-- @
-- 
-- 
afterEngineFocusIn :: (IsEngine a, MonadIO m) => a -> EngineFocusInCallback -> m SignalHandlerId
afterEngineFocusIn :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineFocusIn a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusInCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-in" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineFocusInSignalInfo
instance SignalInfo EngineFocusInSignalInfo where
    type HaskellCallbackType EngineFocusInSignalInfo = EngineFocusInCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineFocusInCallback cb
        cb'' <- mk_EngineFocusInCallback cb'
        connectSignalFunPtr obj "focus-in" cb'' connectMode detail

#endif

-- signal Engine::focus-out
-- | Emitted when the client application  lost the focus.
-- Implement the member function IBusEngineClass[focus_out](#g:signal:focus_out)
-- in extended class to receive this signal.
-- 
-- See also: 'GI.IBus.Objects.InputContext.inputContextFocusOut'
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineFocusOutCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineFocusOut :: MonadIO m => EngineFocusOutCallback -> m (GClosure C_EngineFocusOutCallback)
genClosure_EngineFocusOut :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineFocusOut IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
 -> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback IO ()
cb
    C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusOutCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
    -> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineFocusOutCallback` into a `C_EngineFocusOutCallback`.
wrap_EngineFocusOutCallback ::
    EngineFocusOutCallback ->
    C_EngineFocusOutCallback
wrap_EngineFocusOutCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [focusOut](#signal:focusOut) 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' engine #focusOut callback
-- @
-- 
-- 
onEngineFocusOut :: (IsEngine a, MonadIO m) => a -> EngineFocusOutCallback -> m SignalHandlerId
onEngineFocusOut :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineFocusOut a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusOutCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-out" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [focusOut](#signal:focusOut) 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' engine #focusOut callback
-- @
-- 
-- 
afterEngineFocusOut :: (IsEngine a, MonadIO m) => a -> EngineFocusOutCallback -> m SignalHandlerId
afterEngineFocusOut :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineFocusOut a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusOutCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"focus-out" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineFocusOutSignalInfo
instance SignalInfo EngineFocusOutSignalInfo where
    type HaskellCallbackType EngineFocusOutSignalInfo = EngineFocusOutCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineFocusOutCallback cb
        cb'' <- mk_EngineFocusOutCallback cb'
        connectSignalFunPtr obj "focus-out" cb'' connectMode detail

#endif

-- signal Engine::page-down
-- | Emitted when the page-down button is pressed.
-- Implement the member function IBusEngineClass[page_down](#g:signal:page_down)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EnginePageDownCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EnginePageDown :: MonadIO m => EnginePageDownCallback -> m (GClosure C_EnginePageDownCallback)
genClosure_EnginePageDown :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EnginePageDown IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
 -> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback IO ()
cb
    C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageDownCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
    -> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EnginePageDownCallback` into a `C_EnginePageDownCallback`.
wrap_EnginePageDownCallback ::
    EnginePageDownCallback ->
    C_EnginePageDownCallback
wrap_EnginePageDownCallback :: IO () -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [pageDown](#signal:pageDown) 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' engine #pageDown callback
-- @
-- 
-- 
onEnginePageDown :: (IsEngine a, MonadIO m) => a -> EnginePageDownCallback -> m SignalHandlerId
onEnginePageDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEnginePageDown a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageDownCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> 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" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pageDown](#signal:pageDown) 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' engine #pageDown callback
-- @
-- 
-- 
afterEnginePageDown :: (IsEngine a, MonadIO m) => a -> EnginePageDownCallback -> m SignalHandlerId
afterEnginePageDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEnginePageDown a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageDownCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> 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" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EnginePageDownSignalInfo
instance SignalInfo EnginePageDownSignalInfo where
    type HaskellCallbackType EnginePageDownSignalInfo = EnginePageDownCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EnginePageDownCallback cb
        cb'' <- mk_EnginePageDownCallback cb'
        connectSignalFunPtr obj "page-down" cb'' connectMode detail

#endif

-- signal Engine::page-up
-- | Emitted when the page-up button is pressed.
-- Implement the member function IBusEngineClass[page_up](#g:signal:page_up)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EnginePageUpCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EnginePageUp :: MonadIO m => EnginePageUpCallback -> m (GClosure C_EnginePageUpCallback)
genClosure_EnginePageUp :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EnginePageUp IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
 -> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback IO ()
cb
    C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageUpCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
    -> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EnginePageUpCallback` into a `C_EnginePageUpCallback`.
wrap_EnginePageUpCallback ::
    EnginePageUpCallback ->
    C_EnginePageUpCallback
wrap_EnginePageUpCallback :: IO () -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [pageUp](#signal:pageUp) 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' engine #pageUp callback
-- @
-- 
-- 
onEnginePageUp :: (IsEngine a, MonadIO m) => a -> EnginePageUpCallback -> m SignalHandlerId
onEnginePageUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEnginePageUp a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageUpCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> 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" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pageUp](#signal:pageUp) 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' engine #pageUp callback
-- @
-- 
-- 
afterEnginePageUp :: (IsEngine a, MonadIO m) => a -> EnginePageUpCallback -> m SignalHandlerId
afterEnginePageUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEnginePageUp a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageUpCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> 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" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EnginePageUpSignalInfo
instance SignalInfo EnginePageUpSignalInfo where
    type HaskellCallbackType EnginePageUpSignalInfo = EnginePageUpCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EnginePageUpCallback cb
        cb'' <- mk_EnginePageUpCallback cb'
        connectSignalFunPtr obj "page-up" cb'' connectMode detail

#endif

-- signal Engine::process-hand-writing-event
-- | Emitted when a hand writing operation is cancelled.
-- Implement the member function IBusEngineClass[cancel_hand_writing](#g:signal:cancel_hand_writing)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineProcessHandWritingEventCallback =
    Ptr ()
    -- ^ /@coordinates@/: An array of double (0.0 to 1.0) which represents a stroke (i.e. [x1, y1, x2, y2, x3, y3, ...]).
    -> Word32
    -- ^ /@coordinatesLen@/: The number of elements in the array.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EngineProcessHandWritingEventCallback`@.
noEngineProcessHandWritingEventCallback :: Maybe EngineProcessHandWritingEventCallback
noEngineProcessHandWritingEventCallback :: Maybe EngineProcessHandWritingEventCallback
noEngineProcessHandWritingEventCallback = Maybe EngineProcessHandWritingEventCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineProcessHandWritingEvent :: MonadIO m => EngineProcessHandWritingEventCallback -> m (GClosure C_EngineProcessHandWritingEventCallback)
genClosure_EngineProcessHandWritingEvent :: forall (m :: * -> *).
MonadIO m =>
EngineProcessHandWritingEventCallback
-> m (GClosure C_EngineProcessHandWritingEventCallback)
genClosure_EngineProcessHandWritingEvent EngineProcessHandWritingEventCallback
cb = IO (GClosure C_EngineProcessHandWritingEventCallback)
-> m (GClosure C_EngineProcessHandWritingEventCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineProcessHandWritingEventCallback)
 -> m (GClosure C_EngineProcessHandWritingEventCallback))
-> IO (GClosure C_EngineProcessHandWritingEventCallback)
-> m (GClosure C_EngineProcessHandWritingEventCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineProcessHandWritingEventCallback
cb' = EngineProcessHandWritingEventCallback
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback EngineProcessHandWritingEventCallback
cb
    C_EngineProcessHandWritingEventCallback
-> IO (FunPtr C_EngineProcessHandWritingEventCallback)
mk_EngineProcessHandWritingEventCallback C_EngineProcessHandWritingEventCallback
cb' IO (FunPtr C_EngineProcessHandWritingEventCallback)
-> (FunPtr C_EngineProcessHandWritingEventCallback
    -> IO (GClosure C_EngineProcessHandWritingEventCallback))
-> IO (GClosure C_EngineProcessHandWritingEventCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineProcessHandWritingEventCallback
-> IO (GClosure C_EngineProcessHandWritingEventCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineProcessHandWritingEventCallback` into a `C_EngineProcessHandWritingEventCallback`.
wrap_EngineProcessHandWritingEventCallback ::
    EngineProcessHandWritingEventCallback ->
    C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback :: EngineProcessHandWritingEventCallback
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback EngineProcessHandWritingEventCallback
_cb Ptr ()
_ Ptr ()
coordinates Word32
coordinatesLen Ptr ()
_ = do
    EngineProcessHandWritingEventCallback
_cb  Ptr ()
coordinates Word32
coordinatesLen


-- | Connect a signal handler for the [processHandWritingEvent](#signal:processHandWritingEvent) 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' engine #processHandWritingEvent callback
-- @
-- 
-- 
onEngineProcessHandWritingEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId
onEngineProcessHandWritingEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId
onEngineProcessHandWritingEvent a
obj EngineProcessHandWritingEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineProcessHandWritingEventCallback
cb' = EngineProcessHandWritingEventCallback
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback EngineProcessHandWritingEventCallback
cb
    FunPtr C_EngineProcessHandWritingEventCallback
cb'' <- C_EngineProcessHandWritingEventCallback
-> IO (FunPtr C_EngineProcessHandWritingEventCallback)
mk_EngineProcessHandWritingEventCallback C_EngineProcessHandWritingEventCallback
cb'
    a
-> Text
-> FunPtr C_EngineProcessHandWritingEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"process-hand-writing-event" FunPtr C_EngineProcessHandWritingEventCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [processHandWritingEvent](#signal:processHandWritingEvent) 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' engine #processHandWritingEvent callback
-- @
-- 
-- 
afterEngineProcessHandWritingEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId
afterEngineProcessHandWritingEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineProcessHandWritingEventCallback -> m SignalHandlerId
afterEngineProcessHandWritingEvent a
obj EngineProcessHandWritingEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineProcessHandWritingEventCallback
cb' = EngineProcessHandWritingEventCallback
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback EngineProcessHandWritingEventCallback
cb
    FunPtr C_EngineProcessHandWritingEventCallback
cb'' <- C_EngineProcessHandWritingEventCallback
-> IO (FunPtr C_EngineProcessHandWritingEventCallback)
mk_EngineProcessHandWritingEventCallback C_EngineProcessHandWritingEventCallback
cb'
    a
-> Text
-> FunPtr C_EngineProcessHandWritingEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"process-hand-writing-event" FunPtr C_EngineProcessHandWritingEventCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineProcessHandWritingEventSignalInfo
instance SignalInfo EngineProcessHandWritingEventSignalInfo where
    type HaskellCallbackType EngineProcessHandWritingEventSignalInfo = EngineProcessHandWritingEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineProcessHandWritingEventCallback cb
        cb'' <- mk_EngineProcessHandWritingEventCallback cb'
        connectSignalFunPtr obj "process-hand-writing-event" cb'' connectMode detail

#endif

-- signal Engine::process-key-event
-- | Emitted when a key event is received.
-- Implement the member function IBusEngineClass[process_key_event](#g:signal:process_key_event)
-- in extended class to receive this signal.
-- Both the key symbol and keycode are passed to the member function.
-- See 'GI.IBus.Objects.InputContext.inputContextProcessKeyEvent' for further explanation of
-- key symbol, keycode and which to use.
type EngineProcessKeyEventCallback =
    Word32
    -- ^ /@keyval@/: Key symbol of the key press.
    -> Word32
    -- ^ /@keycode@/: KeyCode of the key press.
    -> Word32
    -- ^ /@state@/: Key modifier flags.
    -> IO Bool
    -- ^ __Returns:__ 'P.True' for successfully process the key; 'P.False' otherwise.
    -- See also:  'GI.IBus.Objects.InputContext.inputContextProcessKeyEvent'.
    -- 
    -- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>

-- | A convenience synonym for @`Nothing` :: `Maybe` `EngineProcessKeyEventCallback`@.
noEngineProcessKeyEventCallback :: Maybe EngineProcessKeyEventCallback
noEngineProcessKeyEventCallback :: Maybe EngineProcessKeyEventCallback
noEngineProcessKeyEventCallback = Maybe EngineProcessKeyEventCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineProcessKeyEvent :: MonadIO m => EngineProcessKeyEventCallback -> m (GClosure C_EngineProcessKeyEventCallback)
genClosure_EngineProcessKeyEvent :: forall (m :: * -> *).
MonadIO m =>
EngineProcessKeyEventCallback
-> m (GClosure C_EngineProcessKeyEventCallback)
genClosure_EngineProcessKeyEvent EngineProcessKeyEventCallback
cb = IO (GClosure C_EngineProcessKeyEventCallback)
-> m (GClosure C_EngineProcessKeyEventCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineProcessKeyEventCallback)
 -> m (GClosure C_EngineProcessKeyEventCallback))
-> IO (GClosure C_EngineProcessKeyEventCallback)
-> m (GClosure C_EngineProcessKeyEventCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineProcessKeyEventCallback
cb' = EngineProcessKeyEventCallback -> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback EngineProcessKeyEventCallback
cb
    C_EngineProcessKeyEventCallback
-> IO (FunPtr C_EngineProcessKeyEventCallback)
mk_EngineProcessKeyEventCallback C_EngineProcessKeyEventCallback
cb' IO (FunPtr C_EngineProcessKeyEventCallback)
-> (FunPtr C_EngineProcessKeyEventCallback
    -> IO (GClosure C_EngineProcessKeyEventCallback))
-> IO (GClosure C_EngineProcessKeyEventCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineProcessKeyEventCallback
-> IO (GClosure C_EngineProcessKeyEventCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineProcessKeyEventCallback` into a `C_EngineProcessKeyEventCallback`.
wrap_EngineProcessKeyEventCallback ::
    EngineProcessKeyEventCallback ->
    C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback :: EngineProcessKeyEventCallback -> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback EngineProcessKeyEventCallback
_cb Ptr ()
_ Word32
keyval Word32
keycode Word32
state Ptr ()
_ = do
    Bool
result <- EngineProcessKeyEventCallback
_cb  Word32
keyval Word32
keycode Word32
state
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
result
    CInt -> IO CInt
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [processKeyEvent](#signal:processKeyEvent) 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' engine #processKeyEvent callback
-- @
-- 
-- 
onEngineProcessKeyEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessKeyEventCallback -> m SignalHandlerId
onEngineProcessKeyEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineProcessKeyEventCallback -> m SignalHandlerId
onEngineProcessKeyEvent a
obj EngineProcessKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineProcessKeyEventCallback
cb' = EngineProcessKeyEventCallback -> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback EngineProcessKeyEventCallback
cb
    FunPtr C_EngineProcessKeyEventCallback
cb'' <- C_EngineProcessKeyEventCallback
-> IO (FunPtr C_EngineProcessKeyEventCallback)
mk_EngineProcessKeyEventCallback C_EngineProcessKeyEventCallback
cb'
    a
-> Text
-> FunPtr C_EngineProcessKeyEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"process-key-event" FunPtr C_EngineProcessKeyEventCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [processKeyEvent](#signal:processKeyEvent) 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' engine #processKeyEvent callback
-- @
-- 
-- 
afterEngineProcessKeyEvent :: (IsEngine a, MonadIO m) => a -> EngineProcessKeyEventCallback -> m SignalHandlerId
afterEngineProcessKeyEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineProcessKeyEventCallback -> m SignalHandlerId
afterEngineProcessKeyEvent a
obj EngineProcessKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineProcessKeyEventCallback
cb' = EngineProcessKeyEventCallback -> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback EngineProcessKeyEventCallback
cb
    FunPtr C_EngineProcessKeyEventCallback
cb'' <- C_EngineProcessKeyEventCallback
-> IO (FunPtr C_EngineProcessKeyEventCallback)
mk_EngineProcessKeyEventCallback C_EngineProcessKeyEventCallback
cb'
    a
-> Text
-> FunPtr C_EngineProcessKeyEventCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"process-key-event" FunPtr C_EngineProcessKeyEventCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineProcessKeyEventSignalInfo
instance SignalInfo EngineProcessKeyEventSignalInfo where
    type HaskellCallbackType EngineProcessKeyEventSignalInfo = EngineProcessKeyEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineProcessKeyEventCallback cb
        cb'' <- mk_EngineProcessKeyEventCallback cb'
        connectSignalFunPtr obj "process-key-event" cb'' connectMode detail

#endif

-- signal Engine::property-activate
-- | Emitted when a property is activated or change changed.
-- Implement the member function IBusEngineClass[property_activate](#g:signal:property_activate)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EnginePropertyActivateCallback =
    T.Text
    -- ^ /@name@/: Property name.
    -> Word32
    -- ^ /@state@/: Property state.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EnginePropertyActivateCallback`@.
noEnginePropertyActivateCallback :: Maybe EnginePropertyActivateCallback
noEnginePropertyActivateCallback :: Maybe EnginePropertyActivateCallback
noEnginePropertyActivateCallback = Maybe EnginePropertyActivateCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EnginePropertyActivate :: MonadIO m => EnginePropertyActivateCallback -> m (GClosure C_EnginePropertyActivateCallback)
genClosure_EnginePropertyActivate :: forall (m :: * -> *).
MonadIO m =>
EnginePropertyActivateCallback
-> m (GClosure C_EnginePropertyActivateCallback)
genClosure_EnginePropertyActivate EnginePropertyActivateCallback
cb = IO (GClosure C_EnginePropertyActivateCallback)
-> m (GClosure C_EnginePropertyActivateCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EnginePropertyActivateCallback)
 -> m (GClosure C_EnginePropertyActivateCallback))
-> IO (GClosure C_EnginePropertyActivateCallback)
-> m (GClosure C_EnginePropertyActivateCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EnginePropertyActivateCallback
cb' = EnginePropertyActivateCallback -> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback EnginePropertyActivateCallback
cb
    C_EnginePropertyActivateCallback
-> IO (FunPtr C_EnginePropertyActivateCallback)
mk_EnginePropertyActivateCallback C_EnginePropertyActivateCallback
cb' IO (FunPtr C_EnginePropertyActivateCallback)
-> (FunPtr C_EnginePropertyActivateCallback
    -> IO (GClosure C_EnginePropertyActivateCallback))
-> IO (GClosure C_EnginePropertyActivateCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EnginePropertyActivateCallback
-> IO (GClosure C_EnginePropertyActivateCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EnginePropertyActivateCallback` into a `C_EnginePropertyActivateCallback`.
wrap_EnginePropertyActivateCallback ::
    EnginePropertyActivateCallback ->
    C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback :: EnginePropertyActivateCallback -> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback EnginePropertyActivateCallback
_cb Ptr ()
_ CString
name Word32
state Ptr ()
_ = do
    Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
    EnginePropertyActivateCallback
_cb  Text
name' Word32
state


-- | Connect a signal handler for the [propertyActivate](#signal:propertyActivate) 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' engine #propertyActivate callback
-- @
-- 
-- 
onEnginePropertyActivate :: (IsEngine a, MonadIO m) => a -> EnginePropertyActivateCallback -> m SignalHandlerId
onEnginePropertyActivate :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyActivateCallback -> m SignalHandlerId
onEnginePropertyActivate a
obj EnginePropertyActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EnginePropertyActivateCallback
cb' = EnginePropertyActivateCallback -> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback EnginePropertyActivateCallback
cb
    FunPtr C_EnginePropertyActivateCallback
cb'' <- C_EnginePropertyActivateCallback
-> IO (FunPtr C_EnginePropertyActivateCallback)
mk_EnginePropertyActivateCallback C_EnginePropertyActivateCallback
cb'
    a
-> Text
-> FunPtr C_EnginePropertyActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-activate" FunPtr C_EnginePropertyActivateCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [propertyActivate](#signal:propertyActivate) 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' engine #propertyActivate callback
-- @
-- 
-- 
afterEnginePropertyActivate :: (IsEngine a, MonadIO m) => a -> EnginePropertyActivateCallback -> m SignalHandlerId
afterEnginePropertyActivate :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyActivateCallback -> m SignalHandlerId
afterEnginePropertyActivate a
obj EnginePropertyActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EnginePropertyActivateCallback
cb' = EnginePropertyActivateCallback -> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback EnginePropertyActivateCallback
cb
    FunPtr C_EnginePropertyActivateCallback
cb'' <- C_EnginePropertyActivateCallback
-> IO (FunPtr C_EnginePropertyActivateCallback)
mk_EnginePropertyActivateCallback C_EnginePropertyActivateCallback
cb'
    a
-> Text
-> FunPtr C_EnginePropertyActivateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-activate" FunPtr C_EnginePropertyActivateCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EnginePropertyActivateSignalInfo
instance SignalInfo EnginePropertyActivateSignalInfo where
    type HaskellCallbackType EnginePropertyActivateSignalInfo = EnginePropertyActivateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EnginePropertyActivateCallback cb
        cb'' <- mk_EnginePropertyActivateCallback cb'
        connectSignalFunPtr obj "property-activate" cb'' connectMode detail

#endif

-- signal Engine::property-hide
-- | Emitted when a property is hidden.
-- Implement the member function IBusEngineClass[property_hide](#g:signal:property_hide)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EnginePropertyHideCallback =
    T.Text
    -- ^ /@name@/: Property name.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EnginePropertyHideCallback`@.
noEnginePropertyHideCallback :: Maybe EnginePropertyHideCallback
noEnginePropertyHideCallback :: Maybe EnginePropertyHideCallback
noEnginePropertyHideCallback = Maybe EnginePropertyHideCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EnginePropertyHide :: MonadIO m => EnginePropertyHideCallback -> m (GClosure C_EnginePropertyHideCallback)
genClosure_EnginePropertyHide :: forall (m :: * -> *).
MonadIO m =>
EnginePropertyHideCallback
-> m (GClosure C_EnginePropertyHideCallback)
genClosure_EnginePropertyHide EnginePropertyHideCallback
cb = IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EnginePropertyHideCallback)
 -> m (GClosure C_EnginePropertyHideCallback))
-> IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback EnginePropertyHideCallback
cb
    C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyHideCallback C_EnginePropertyHideCallback
cb' IO (FunPtr C_EnginePropertyHideCallback)
-> (FunPtr C_EnginePropertyHideCallback
    -> IO (GClosure C_EnginePropertyHideCallback))
-> IO (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EnginePropertyHideCallback
-> IO (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EnginePropertyHideCallback` into a `C_EnginePropertyHideCallback`.
wrap_EnginePropertyHideCallback ::
    EnginePropertyHideCallback ->
    C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback :: EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback EnginePropertyHideCallback
_cb Ptr ()
_ CString
name Ptr ()
_ = do
    Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
    EnginePropertyHideCallback
_cb  Text
name'


-- | Connect a signal handler for the [propertyHide](#signal:propertyHide) 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' engine #propertyHide callback
-- @
-- 
-- 
onEnginePropertyHide :: (IsEngine a, MonadIO m) => a -> EnginePropertyHideCallback -> m SignalHandlerId
onEnginePropertyHide :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyHideCallback -> m SignalHandlerId
onEnginePropertyHide a
obj EnginePropertyHideCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback EnginePropertyHideCallback
cb
    FunPtr C_EnginePropertyHideCallback
cb'' <- C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyHideCallback C_EnginePropertyHideCallback
cb'
    a
-> Text
-> FunPtr C_EnginePropertyHideCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-hide" FunPtr C_EnginePropertyHideCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [propertyHide](#signal:propertyHide) 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' engine #propertyHide callback
-- @
-- 
-- 
afterEnginePropertyHide :: (IsEngine a, MonadIO m) => a -> EnginePropertyHideCallback -> m SignalHandlerId
afterEnginePropertyHide :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyHideCallback -> m SignalHandlerId
afterEnginePropertyHide a
obj EnginePropertyHideCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback EnginePropertyHideCallback
cb
    FunPtr C_EnginePropertyHideCallback
cb'' <- C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyHideCallback C_EnginePropertyHideCallback
cb'
    a
-> Text
-> FunPtr C_EnginePropertyHideCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-hide" FunPtr C_EnginePropertyHideCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EnginePropertyHideSignalInfo
instance SignalInfo EnginePropertyHideSignalInfo where
    type HaskellCallbackType EnginePropertyHideSignalInfo = EnginePropertyHideCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EnginePropertyHideCallback cb
        cb'' <- mk_EnginePropertyHideCallback cb'
        connectSignalFunPtr obj "property-hide" cb'' connectMode detail

#endif

-- signal Engine::property-show
-- | Emitted when a property is shown.
-- Implement the member function IBusEngineClass[property_side](#g:signal:property_side)
-- in extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EnginePropertyShowCallback =
    T.Text
    -- ^ /@name@/: Property name.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EnginePropertyShowCallback`@.
noEnginePropertyShowCallback :: Maybe EnginePropertyShowCallback
noEnginePropertyShowCallback :: Maybe EnginePropertyHideCallback
noEnginePropertyShowCallback = Maybe EnginePropertyHideCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EnginePropertyShow :: MonadIO m => EnginePropertyShowCallback -> m (GClosure C_EnginePropertyShowCallback)
genClosure_EnginePropertyShow :: forall (m :: * -> *).
MonadIO m =>
EnginePropertyHideCallback
-> m (GClosure C_EnginePropertyHideCallback)
genClosure_EnginePropertyShow EnginePropertyHideCallback
cb = IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EnginePropertyHideCallback)
 -> m (GClosure C_EnginePropertyHideCallback))
-> IO (GClosure C_EnginePropertyHideCallback)
-> m (GClosure C_EnginePropertyHideCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyShowCallback EnginePropertyHideCallback
cb
    C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyShowCallback C_EnginePropertyHideCallback
cb' IO (FunPtr C_EnginePropertyHideCallback)
-> (FunPtr C_EnginePropertyHideCallback
    -> IO (GClosure C_EnginePropertyHideCallback))
-> IO (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EnginePropertyHideCallback
-> IO (GClosure C_EnginePropertyHideCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EnginePropertyShowCallback` into a `C_EnginePropertyShowCallback`.
wrap_EnginePropertyShowCallback ::
    EnginePropertyShowCallback ->
    C_EnginePropertyShowCallback
wrap_EnginePropertyShowCallback :: EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyShowCallback EnginePropertyHideCallback
_cb Ptr ()
_ CString
name Ptr ()
_ = do
    Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
    EnginePropertyHideCallback
_cb  Text
name'


-- | Connect a signal handler for the [propertyShow](#signal:propertyShow) 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' engine #propertyShow callback
-- @
-- 
-- 
onEnginePropertyShow :: (IsEngine a, MonadIO m) => a -> EnginePropertyShowCallback -> m SignalHandlerId
onEnginePropertyShow :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyHideCallback -> m SignalHandlerId
onEnginePropertyShow a
obj EnginePropertyHideCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyShowCallback EnginePropertyHideCallback
cb
    FunPtr C_EnginePropertyHideCallback
cb'' <- C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyShowCallback C_EnginePropertyHideCallback
cb'
    a
-> Text
-> FunPtr C_EnginePropertyHideCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-show" FunPtr C_EnginePropertyHideCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [propertyShow](#signal:propertyShow) 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' engine #propertyShow callback
-- @
-- 
-- 
afterEnginePropertyShow :: (IsEngine a, MonadIO m) => a -> EnginePropertyShowCallback -> m SignalHandlerId
afterEnginePropertyShow :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EnginePropertyHideCallback -> m SignalHandlerId
afterEnginePropertyShow a
obj EnginePropertyHideCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EnginePropertyHideCallback
cb' = EnginePropertyHideCallback -> C_EnginePropertyHideCallback
wrap_EnginePropertyShowCallback EnginePropertyHideCallback
cb
    FunPtr C_EnginePropertyHideCallback
cb'' <- C_EnginePropertyHideCallback
-> IO (FunPtr C_EnginePropertyHideCallback)
mk_EnginePropertyShowCallback C_EnginePropertyHideCallback
cb'
    a
-> Text
-> FunPtr C_EnginePropertyHideCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"property-show" FunPtr C_EnginePropertyHideCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EnginePropertyShowSignalInfo
instance SignalInfo EnginePropertyShowSignalInfo where
    type HaskellCallbackType EnginePropertyShowSignalInfo = EnginePropertyShowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EnginePropertyShowCallback cb
        cb'' <- mk_EnginePropertyShowCallback cb'
        connectSignalFunPtr obj "property-show" cb'' connectMode detail

#endif

-- signal Engine::reset
-- | Emitted when the IME is reset.
-- Implement the member function IBusEngineClass[reset](#g:signal:reset)
-- in extended class to receive this signal.
-- 
-- See also:  'GI.IBus.Objects.InputContext.inputContextReset'.
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineResetCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineReset :: MonadIO m => EngineResetCallback -> m (GClosure C_EngineResetCallback)
genClosure_EngineReset :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_EngineCursorDownCallback)
genClosure_EngineReset IO ()
cb = IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCursorDownCallback)
 -> m (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
-> m (GClosure C_EngineCursorDownCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineResetCallback IO ()
cb
    C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineResetCallback C_EngineCursorDownCallback
cb' IO (FunPtr C_EngineCursorDownCallback)
-> (FunPtr C_EngineCursorDownCallback
    -> IO (GClosure C_EngineCursorDownCallback))
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCursorDownCallback
-> IO (GClosure C_EngineCursorDownCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineResetCallback` into a `C_EngineResetCallback`.
wrap_EngineResetCallback ::
    EngineResetCallback ->
    C_EngineResetCallback
wrap_EngineResetCallback :: IO () -> C_EngineCursorDownCallback
wrap_EngineResetCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [reset](#signal:reset) 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' engine #reset callback
-- @
-- 
-- 
onEngineReset :: (IsEngine a, MonadIO m) => a -> EngineResetCallback -> m SignalHandlerId
onEngineReset :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onEngineReset a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineResetCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineResetCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"reset" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [reset](#signal:reset) 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' engine #reset callback
-- @
-- 
-- 
afterEngineReset :: (IsEngine a, MonadIO m) => a -> EngineResetCallback -> m SignalHandlerId
afterEngineReset :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterEngineReset a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCursorDownCallback
cb' = IO () -> C_EngineCursorDownCallback
wrap_EngineResetCallback IO ()
cb
    FunPtr C_EngineCursorDownCallback
cb'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineResetCallback C_EngineCursorDownCallback
cb'
    a
-> Text
-> FunPtr C_EngineCursorDownCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"reset" FunPtr C_EngineCursorDownCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineResetSignalInfo
instance SignalInfo EngineResetSignalInfo where
    type HaskellCallbackType EngineResetSignalInfo = EngineResetCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineResetCallback cb
        cb'' <- mk_EngineResetCallback cb'
        connectSignalFunPtr obj "reset" cb'' connectMode detail

#endif

-- signal Engine::set-capabilities
-- | Emitted when the client application capabilities is set.
-- Implement the member function IBusEngineClass[set_capabilities](#g:signal:set_capabilities)
-- in extended class to receive this signal.
-- 
-- See also:  'GI.IBus.Objects.InputContext.inputContextSetCapabilities'.
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineSetCapabilitiesCallback =
    Word32
    -- ^ /@caps@/: Capabilities flags of IBusEngine, see t'GI.IBus.Flags.Capabilite'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EngineSetCapabilitiesCallback`@.
noEngineSetCapabilitiesCallback :: Maybe EngineSetCapabilitiesCallback
noEngineSetCapabilitiesCallback :: Maybe EngineCancelHandWritingCallback
noEngineSetCapabilitiesCallback = Maybe EngineCancelHandWritingCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineSetCapabilities :: MonadIO m => EngineSetCapabilitiesCallback -> m (GClosure C_EngineSetCapabilitiesCallback)
genClosure_EngineSetCapabilities :: forall (m :: * -> *).
MonadIO m =>
EngineCancelHandWritingCallback
-> m (GClosure C_EngineCancelHandWritingCallback)
genClosure_EngineSetCapabilities EngineCancelHandWritingCallback
cb = IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineCancelHandWritingCallback)
 -> m (GClosure C_EngineCancelHandWritingCallback))
-> IO (GClosure C_EngineCancelHandWritingCallback)
-> m (GClosure C_EngineCancelHandWritingCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback EngineCancelHandWritingCallback
cb
    C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineSetCapabilitiesCallback C_EngineCancelHandWritingCallback
cb' IO (FunPtr C_EngineCancelHandWritingCallback)
-> (FunPtr C_EngineCancelHandWritingCallback
    -> IO (GClosure C_EngineCancelHandWritingCallback))
-> IO (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineCancelHandWritingCallback
-> IO (GClosure C_EngineCancelHandWritingCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineSetCapabilitiesCallback` into a `C_EngineSetCapabilitiesCallback`.
wrap_EngineSetCapabilitiesCallback ::
    EngineSetCapabilitiesCallback ->
    C_EngineSetCapabilitiesCallback
wrap_EngineSetCapabilitiesCallback :: EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback EngineCancelHandWritingCallback
_cb Ptr ()
_ Word32
caps Ptr ()
_ = do
    EngineCancelHandWritingCallback
_cb  Word32
caps


-- | Connect a signal handler for the [setCapabilities](#signal:setCapabilities) 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' engine #setCapabilities callback
-- @
-- 
-- 
onEngineSetCapabilities :: (IsEngine a, MonadIO m) => a -> EngineSetCapabilitiesCallback -> m SignalHandlerId
onEngineSetCapabilities :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCancelHandWritingCallback -> m SignalHandlerId
onEngineSetCapabilities a
obj EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback EngineCancelHandWritingCallback
cb
    FunPtr C_EngineCancelHandWritingCallback
cb'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineSetCapabilitiesCallback C_EngineCancelHandWritingCallback
cb'
    a
-> Text
-> FunPtr C_EngineCancelHandWritingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-capabilities" FunPtr C_EngineCancelHandWritingCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [setCapabilities](#signal:setCapabilities) 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' engine #setCapabilities callback
-- @
-- 
-- 
afterEngineSetCapabilities :: (IsEngine a, MonadIO m) => a -> EngineSetCapabilitiesCallback -> m SignalHandlerId
afterEngineSetCapabilities :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineCancelHandWritingCallback -> m SignalHandlerId
afterEngineSetCapabilities a
obj EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineCancelHandWritingCallback
cb' = EngineCancelHandWritingCallback
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback EngineCancelHandWritingCallback
cb
    FunPtr C_EngineCancelHandWritingCallback
cb'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineSetCapabilitiesCallback C_EngineCancelHandWritingCallback
cb'
    a
-> Text
-> FunPtr C_EngineCancelHandWritingCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-capabilities" FunPtr C_EngineCancelHandWritingCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineSetCapabilitiesSignalInfo
instance SignalInfo EngineSetCapabilitiesSignalInfo where
    type HaskellCallbackType EngineSetCapabilitiesSignalInfo = EngineSetCapabilitiesCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineSetCapabilitiesCallback cb
        cb'' <- mk_EngineSetCapabilitiesCallback cb'
        connectSignalFunPtr obj "set-capabilities" cb'' connectMode detail

#endif

-- signal Engine::set-content-type
-- | Emitted when the client application content-type (primary
-- purpose and hints) is set.  The engine could change the
-- behavior according to the content-type.  Implement the member
-- function IBusEngineClass[set_content_type](#g:signal:set_content_type)
-- in extended class to receive this signal.
-- 
-- For example, if the client application wants to restrict input
-- to numbers, this signal will be emitted with /@purpose@/ set to
-- @/IBUS_INPUT_PURPOSE_NUMBER/@, so the engine can switch the input
-- mode to latin.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this
-- function.\<\/para>\<\/note>
type EngineSetContentTypeCallback =
    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'.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EngineSetContentTypeCallback`@.
noEngineSetContentTypeCallback :: Maybe EngineSetContentTypeCallback
noEngineSetContentTypeCallback :: Maybe EngineSetContentTypeCallback
noEngineSetContentTypeCallback = Maybe EngineSetContentTypeCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineSetContentType :: MonadIO m => EngineSetContentTypeCallback -> m (GClosure C_EngineSetContentTypeCallback)
genClosure_EngineSetContentType :: forall (m :: * -> *).
MonadIO m =>
EngineSetContentTypeCallback
-> m (GClosure C_EngineSetContentTypeCallback)
genClosure_EngineSetContentType EngineSetContentTypeCallback
cb = IO (GClosure C_EngineSetContentTypeCallback)
-> m (GClosure C_EngineSetContentTypeCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineSetContentTypeCallback)
 -> m (GClosure C_EngineSetContentTypeCallback))
-> IO (GClosure C_EngineSetContentTypeCallback)
-> m (GClosure C_EngineSetContentTypeCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineSetContentTypeCallback
cb' = EngineSetContentTypeCallback -> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback EngineSetContentTypeCallback
cb
    C_EngineSetContentTypeCallback
-> IO (FunPtr C_EngineSetContentTypeCallback)
mk_EngineSetContentTypeCallback C_EngineSetContentTypeCallback
cb' IO (FunPtr C_EngineSetContentTypeCallback)
-> (FunPtr C_EngineSetContentTypeCallback
    -> IO (GClosure C_EngineSetContentTypeCallback))
-> IO (GClosure C_EngineSetContentTypeCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineSetContentTypeCallback
-> IO (GClosure C_EngineSetContentTypeCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineSetContentTypeCallback` into a `C_EngineSetContentTypeCallback`.
wrap_EngineSetContentTypeCallback ::
    EngineSetContentTypeCallback ->
    C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback :: EngineSetContentTypeCallback -> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback EngineSetContentTypeCallback
_cb Ptr ()
_ Word32
purpose Word32
hints Ptr ()
_ = do
    EngineSetContentTypeCallback
_cb  Word32
purpose Word32
hints


-- | Connect a signal handler for the [setContentType](#signal:setContentType) 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' engine #setContentType callback
-- @
-- 
-- 
onEngineSetContentType :: (IsEngine a, MonadIO m) => a -> EngineSetContentTypeCallback -> m SignalHandlerId
onEngineSetContentType :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetContentTypeCallback -> m SignalHandlerId
onEngineSetContentType a
obj EngineSetContentTypeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineSetContentTypeCallback
cb' = EngineSetContentTypeCallback -> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback EngineSetContentTypeCallback
cb
    FunPtr C_EngineSetContentTypeCallback
cb'' <- C_EngineSetContentTypeCallback
-> IO (FunPtr C_EngineSetContentTypeCallback)
mk_EngineSetContentTypeCallback C_EngineSetContentTypeCallback
cb'
    a
-> Text
-> FunPtr C_EngineSetContentTypeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-content-type" FunPtr C_EngineSetContentTypeCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [setContentType](#signal:setContentType) 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' engine #setContentType callback
-- @
-- 
-- 
afterEngineSetContentType :: (IsEngine a, MonadIO m) => a -> EngineSetContentTypeCallback -> m SignalHandlerId
afterEngineSetContentType :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetContentTypeCallback -> m SignalHandlerId
afterEngineSetContentType a
obj EngineSetContentTypeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineSetContentTypeCallback
cb' = EngineSetContentTypeCallback -> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback EngineSetContentTypeCallback
cb
    FunPtr C_EngineSetContentTypeCallback
cb'' <- C_EngineSetContentTypeCallback
-> IO (FunPtr C_EngineSetContentTypeCallback)
mk_EngineSetContentTypeCallback C_EngineSetContentTypeCallback
cb'
    a
-> Text
-> FunPtr C_EngineSetContentTypeCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-content-type" FunPtr C_EngineSetContentTypeCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineSetContentTypeSignalInfo
instance SignalInfo EngineSetContentTypeSignalInfo where
    type HaskellCallbackType EngineSetContentTypeSignalInfo = EngineSetContentTypeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineSetContentTypeCallback cb
        cb'' <- mk_EngineSetContentTypeCallback cb'
        connectSignalFunPtr obj "set-content-type" cb'' connectMode detail

#endif

-- signal Engine::set-cursor-location
-- | Emitted when the location of IME is set.
-- Implement the member function IBusEngineClass[set_cursor_location](#g:signal:set_cursor_location)
-- in extended class to receive this signal.
-- 
-- See also:  'GI.IBus.Objects.InputContext.inputContextSetCursorLocation'.
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineSetCursorLocationCallback =
    Int32
    -- ^ /@x@/: X coordinate of the cursor.
    -> Int32
    -- ^ /@y@/: Y coordinate of the cursor.
    -> Int32
    -- ^ /@w@/: Width of the cursor.
    -> Int32
    -- ^ /@h@/: Height of the cursor.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EngineSetCursorLocationCallback`@.
noEngineSetCursorLocationCallback :: Maybe EngineSetCursorLocationCallback
noEngineSetCursorLocationCallback :: Maybe EngineSetCursorLocationCallback
noEngineSetCursorLocationCallback = Maybe EngineSetCursorLocationCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineSetCursorLocation :: MonadIO m => EngineSetCursorLocationCallback -> m (GClosure C_EngineSetCursorLocationCallback)
genClosure_EngineSetCursorLocation :: forall (m :: * -> *).
MonadIO m =>
EngineSetCursorLocationCallback
-> m (GClosure C_EngineSetCursorLocationCallback)
genClosure_EngineSetCursorLocation EngineSetCursorLocationCallback
cb = IO (GClosure C_EngineSetCursorLocationCallback)
-> m (GClosure C_EngineSetCursorLocationCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineSetCursorLocationCallback)
 -> m (GClosure C_EngineSetCursorLocationCallback))
-> IO (GClosure C_EngineSetCursorLocationCallback)
-> m (GClosure C_EngineSetCursorLocationCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineSetCursorLocationCallback
cb' = EngineSetCursorLocationCallback
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback EngineSetCursorLocationCallback
cb
    C_EngineSetCursorLocationCallback
-> IO (FunPtr C_EngineSetCursorLocationCallback)
mk_EngineSetCursorLocationCallback C_EngineSetCursorLocationCallback
cb' IO (FunPtr C_EngineSetCursorLocationCallback)
-> (FunPtr C_EngineSetCursorLocationCallback
    -> IO (GClosure C_EngineSetCursorLocationCallback))
-> IO (GClosure C_EngineSetCursorLocationCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineSetCursorLocationCallback
-> IO (GClosure C_EngineSetCursorLocationCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineSetCursorLocationCallback` into a `C_EngineSetCursorLocationCallback`.
wrap_EngineSetCursorLocationCallback ::
    EngineSetCursorLocationCallback ->
    C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback :: EngineSetCursorLocationCallback
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback EngineSetCursorLocationCallback
_cb Ptr ()
_ Int32
x Int32
y Int32
w Int32
h Ptr ()
_ = do
    EngineSetCursorLocationCallback
_cb  Int32
x Int32
y Int32
w Int32
h


-- | Connect a signal handler for the [setCursorLocation](#signal:setCursorLocation) 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' engine #setCursorLocation callback
-- @
-- 
-- 
onEngineSetCursorLocation :: (IsEngine a, MonadIO m) => a -> EngineSetCursorLocationCallback -> m SignalHandlerId
onEngineSetCursorLocation :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetCursorLocationCallback -> m SignalHandlerId
onEngineSetCursorLocation a
obj EngineSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineSetCursorLocationCallback
cb' = EngineSetCursorLocationCallback
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback EngineSetCursorLocationCallback
cb
    FunPtr C_EngineSetCursorLocationCallback
cb'' <- C_EngineSetCursorLocationCallback
-> IO (FunPtr C_EngineSetCursorLocationCallback)
mk_EngineSetCursorLocationCallback C_EngineSetCursorLocationCallback
cb'
    a
-> Text
-> FunPtr C_EngineSetCursorLocationCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-cursor-location" FunPtr C_EngineSetCursorLocationCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [setCursorLocation](#signal:setCursorLocation) 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' engine #setCursorLocation callback
-- @
-- 
-- 
afterEngineSetCursorLocation :: (IsEngine a, MonadIO m) => a -> EngineSetCursorLocationCallback -> m SignalHandlerId
afterEngineSetCursorLocation :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetCursorLocationCallback -> m SignalHandlerId
afterEngineSetCursorLocation a
obj EngineSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineSetCursorLocationCallback
cb' = EngineSetCursorLocationCallback
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback EngineSetCursorLocationCallback
cb
    FunPtr C_EngineSetCursorLocationCallback
cb'' <- C_EngineSetCursorLocationCallback
-> IO (FunPtr C_EngineSetCursorLocationCallback)
mk_EngineSetCursorLocationCallback C_EngineSetCursorLocationCallback
cb'
    a
-> Text
-> FunPtr C_EngineSetCursorLocationCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-cursor-location" FunPtr C_EngineSetCursorLocationCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineSetCursorLocationSignalInfo
instance SignalInfo EngineSetCursorLocationSignalInfo where
    type HaskellCallbackType EngineSetCursorLocationSignalInfo = EngineSetCursorLocationCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineSetCursorLocationCallback cb
        cb'' <- mk_EngineSetCursorLocationCallback cb'
        connectSignalFunPtr obj "set-cursor-location" cb'' connectMode detail

#endif

-- signal Engine::set-surrounding-text
-- | Emitted when a surrounding text is set.
-- Implement the member function IBusEngineClass[set_surrounding_text](#g:signal:set_surrounding_text)
-- in extended class to receive this signal.
-- If anchor_pos equals to cursor_pos, it means \"there are no selection\"
-- or \"does not support selection retrival\".
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>\<\/note>
type EngineSetSurroundingTextCallback =
    GObject.Object.Object
    -- ^ /@text@/: The surrounding text.
    -> Word32
    -- ^ /@cursorPos@/: The cursor position on surrounding text.
    -> Word32
    -- ^ /@anchorPos@/: The anchor position on selection area.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `EngineSetSurroundingTextCallback`@.
noEngineSetSurroundingTextCallback :: Maybe EngineSetSurroundingTextCallback
noEngineSetSurroundingTextCallback :: Maybe EngineSetSurroundingTextCallback
noEngineSetSurroundingTextCallback = Maybe EngineSetSurroundingTextCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_EngineSetSurroundingText :: MonadIO m => EngineSetSurroundingTextCallback -> m (GClosure C_EngineSetSurroundingTextCallback)
genClosure_EngineSetSurroundingText :: forall (m :: * -> *).
MonadIO m =>
EngineSetSurroundingTextCallback
-> m (GClosure C_EngineSetSurroundingTextCallback)
genClosure_EngineSetSurroundingText EngineSetSurroundingTextCallback
cb = IO (GClosure C_EngineSetSurroundingTextCallback)
-> m (GClosure C_EngineSetSurroundingTextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_EngineSetSurroundingTextCallback)
 -> m (GClosure C_EngineSetSurroundingTextCallback))
-> IO (GClosure C_EngineSetSurroundingTextCallback)
-> m (GClosure C_EngineSetSurroundingTextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineSetSurroundingTextCallback
cb' = EngineSetSurroundingTextCallback
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback EngineSetSurroundingTextCallback
cb
    C_EngineSetSurroundingTextCallback
-> IO (FunPtr C_EngineSetSurroundingTextCallback)
mk_EngineSetSurroundingTextCallback C_EngineSetSurroundingTextCallback
cb' IO (FunPtr C_EngineSetSurroundingTextCallback)
-> (FunPtr C_EngineSetSurroundingTextCallback
    -> IO (GClosure C_EngineSetSurroundingTextCallback))
-> IO (GClosure C_EngineSetSurroundingTextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_EngineSetSurroundingTextCallback
-> IO (GClosure C_EngineSetSurroundingTextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `EngineSetSurroundingTextCallback` into a `C_EngineSetSurroundingTextCallback`.
wrap_EngineSetSurroundingTextCallback ::
    EngineSetSurroundingTextCallback ->
    C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback :: EngineSetSurroundingTextCallback
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback EngineSetSurroundingTextCallback
_cb Ptr ()
_ Ptr Object
text Word32
cursorPos Word32
anchorPos Ptr ()
_ = do
    Object
text' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
text
    EngineSetSurroundingTextCallback
_cb  Object
text' Word32
cursorPos Word32
anchorPos


-- | Connect a signal handler for the [setSurroundingText](#signal:setSurroundingText) 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' engine #setSurroundingText callback
-- @
-- 
-- 
onEngineSetSurroundingText :: (IsEngine a, MonadIO m) => a -> EngineSetSurroundingTextCallback -> m SignalHandlerId
onEngineSetSurroundingText :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetSurroundingTextCallback -> m SignalHandlerId
onEngineSetSurroundingText a
obj EngineSetSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineSetSurroundingTextCallback
cb' = EngineSetSurroundingTextCallback
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback EngineSetSurroundingTextCallback
cb
    FunPtr C_EngineSetSurroundingTextCallback
cb'' <- C_EngineSetSurroundingTextCallback
-> IO (FunPtr C_EngineSetSurroundingTextCallback)
mk_EngineSetSurroundingTextCallback C_EngineSetSurroundingTextCallback
cb'
    a
-> Text
-> FunPtr C_EngineSetSurroundingTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-surrounding-text" FunPtr C_EngineSetSurroundingTextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [setSurroundingText](#signal:setSurroundingText) 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' engine #setSurroundingText callback
-- @
-- 
-- 
afterEngineSetSurroundingText :: (IsEngine a, MonadIO m) => a -> EngineSetSurroundingTextCallback -> m SignalHandlerId
afterEngineSetSurroundingText :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> EngineSetSurroundingTextCallback -> m SignalHandlerId
afterEngineSetSurroundingText a
obj EngineSetSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_EngineSetSurroundingTextCallback
cb' = EngineSetSurroundingTextCallback
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback EngineSetSurroundingTextCallback
cb
    FunPtr C_EngineSetSurroundingTextCallback
cb'' <- C_EngineSetSurroundingTextCallback
-> IO (FunPtr C_EngineSetSurroundingTextCallback)
mk_EngineSetSurroundingTextCallback C_EngineSetSurroundingTextCallback
cb'
    a
-> Text
-> FunPtr C_EngineSetSurroundingTextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"set-surrounding-text" FunPtr C_EngineSetSurroundingTextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineSetSurroundingTextSignalInfo
instance SignalInfo EngineSetSurroundingTextSignalInfo where
    type HaskellCallbackType EngineSetSurroundingTextSignalInfo = EngineSetSurroundingTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineSetSurroundingTextCallback cb
        cb'' <- mk_EngineSetSurroundingTextCallback cb'
        connectSignalFunPtr obj "set-surrounding-text" cb'' connectMode detail

#endif

-- VVV Prop "engine-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@engine-name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' engine #engineName
-- @
getEngineEngineName :: (MonadIO m, IsEngine o) => o -> m (Maybe T.Text)
getEngineEngineName :: forall (m :: * -> *) o.
(MonadIO m, IsEngine o) =>
o -> m (Maybe Text)
getEngineEngineName o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"engine-name"

-- | Construct a `GValueConstruct` with valid value for the “@engine-name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructEngineEngineName :: (IsEngine o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructEngineEngineName :: forall o (m :: * -> *).
(IsEngine o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructEngineEngineName Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"engine-name" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data EngineEngineNamePropertyInfo
instance AttrInfo EngineEngineNamePropertyInfo where
    type AttrAllowedOps EngineEngineNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint EngineEngineNamePropertyInfo = IsEngine
    type AttrSetTypeConstraint EngineEngineNamePropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint EngineEngineNamePropertyInfo = (~) T.Text
    type AttrTransferType EngineEngineNamePropertyInfo = T.Text
    type AttrGetType EngineEngineNamePropertyInfo = (Maybe T.Text)
    type AttrLabel EngineEngineNamePropertyInfo = "engine-name"
    type AttrOrigin EngineEngineNamePropertyInfo = Engine
    attrGet = getEngineEngineName
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructEngineEngineName
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Engine
type instance O.AttributeList Engine = EngineAttributeList
type EngineAttributeList = ('[ '("connection", IBus.Service.ServiceConnectionPropertyInfo), '("engineName", EngineEngineNamePropertyInfo), '("objectPath", IBus.Service.ServiceObjectPathPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
engineEngineName :: AttrLabelProxy "engineName"
engineEngineName = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Engine = EngineSignalList
type EngineSignalList = ('[ '("cancelHandWriting", EngineCancelHandWritingSignalInfo), '("candidateClicked", EngineCandidateClickedSignalInfo), '("cursorDown", EngineCursorDownSignalInfo), '("cursorUp", EngineCursorUpSignalInfo), '("destroy", IBus.Object.ObjectDestroySignalInfo), '("disable", EngineDisableSignalInfo), '("enable", EngineEnableSignalInfo), '("focusIn", EngineFocusInSignalInfo), '("focusOut", EngineFocusOutSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pageDown", EnginePageDownSignalInfo), '("pageUp", EnginePageUpSignalInfo), '("processHandWritingEvent", EngineProcessHandWritingEventSignalInfo), '("processKeyEvent", EngineProcessKeyEventSignalInfo), '("propertyActivate", EnginePropertyActivateSignalInfo), '("propertyHide", EnginePropertyHideSignalInfo), '("propertyShow", EnginePropertyShowSignalInfo), '("reset", EngineResetSignalInfo), '("setCapabilities", EngineSetCapabilitiesSignalInfo), '("setContentType", EngineSetContentTypeSignalInfo), '("setCursorLocation", EngineSetCursorLocationSignalInfo), '("setSurroundingText", EngineSetSurroundingTextSignalInfo)] :: [(Symbol, *)])

#endif

-- method Engine::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "engine_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of the IBusObject."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Path for IBusService."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An opened GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "IBus" , name = "Engine" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_new" ibus_engine_new :: 
    CString ->                              -- engine_name : TBasicType TUTF8
    CString ->                              -- object_path : TBasicType TUTF8
    Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO (Ptr Engine)

-- | Create a new t'GI.IBus.Objects.Engine.Engine'.
engineNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    T.Text
    -- ^ /@engineName@/: Name of the IBusObject.
    -> T.Text
    -- ^ /@objectPath@/: Path for IBusService.
    -> a
    -- ^ /@connection@/: An opened GDBusConnection.
    -> m Engine
    -- ^ __Returns:__ A newly allocated IBusEngine.
engineNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
Text -> Text -> a -> m Engine
engineNew Text
engineName Text
objectPath a
connection = IO Engine -> m Engine
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Engine -> m Engine) -> IO Engine -> m Engine
forall a b. (a -> b) -> a -> b
$ do
    CString
engineName' <- Text -> IO CString
textToCString Text
engineName
    CString
objectPath' <- Text -> IO CString
textToCString Text
objectPath
    Ptr DBusConnection
connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    Ptr Engine
result <- CString -> CString -> Ptr DBusConnection -> IO (Ptr Engine)
ibus_engine_new CString
engineName' CString
objectPath' Ptr DBusConnection
connection'
    Text -> Ptr Engine -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"engineNew" Ptr Engine
result
    Engine
result' <- ((ManagedPtr Engine -> Engine) -> Ptr Engine -> IO Engine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Engine -> Engine
Engine) Ptr Engine
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
engineName'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
objectPath'
    Engine -> IO Engine
forall (m :: * -> *) a. Monad m => a -> m a
return Engine
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Engine::new_with_type
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "engine_type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GType of #IBusEngine."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "engine_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Name of the IBusObject."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "object_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Path for IBusService."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "connection"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "DBusConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An opened GDBusConnection."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "IBus" , name = "Engine" })
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_new_with_type" ibus_engine_new_with_type :: 
    CGType ->                               -- engine_type : TBasicType TGType
    CString ->                              -- engine_name : TBasicType TUTF8
    CString ->                              -- object_path : TBasicType TUTF8
    Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO (Ptr Engine)

-- | Create a new t'GI.IBus.Objects.Engine.Engine'.
engineNewWithType ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    GType
    -- ^ /@engineType@/: GType of t'GI.IBus.Objects.Engine.Engine'.
    -> T.Text
    -- ^ /@engineName@/: Name of the IBusObject.
    -> T.Text
    -- ^ /@objectPath@/: Path for IBusService.
    -> a
    -- ^ /@connection@/: An opened GDBusConnection.
    -> m Engine
    -- ^ __Returns:__ A newly allocated IBusEngine.
engineNewWithType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
GType -> Text -> Text -> a -> m Engine
engineNewWithType GType
engineType Text
engineName Text
objectPath a
connection = IO Engine -> m Engine
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Engine -> m Engine) -> IO Engine -> m Engine
forall a b. (a -> b) -> a -> b
$ do
    let engineType' :: CGType
engineType' = GType -> CGType
gtypeToCGType GType
engineType
    CString
engineName' <- Text -> IO CString
textToCString Text
engineName
    CString
objectPath' <- Text -> IO CString
textToCString Text
objectPath
    Ptr DBusConnection
connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    Ptr Engine
result <- CGType
-> CString -> CString -> Ptr DBusConnection -> IO (Ptr Engine)
ibus_engine_new_with_type CGType
engineType' CString
engineName' CString
objectPath' Ptr DBusConnection
connection'
    Text -> Ptr Engine -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"engineNewWithType" Ptr Engine
result
    Engine
result' <- ((ManagedPtr Engine -> Engine) -> Ptr Engine -> IO Engine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Engine -> Engine
Engine) Ptr Engine
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
engineName'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
objectPath'
    Engine -> IO Engine
forall (m :: * -> *) a. Monad m => a -> m a
return Engine
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Engine::commit_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TInterface Name { namespace = "IBus" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "String commit to IBusEngine."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_commit_text" ibus_engine_commit_text :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Ptr IBus.Text.Text ->                   -- text : TInterface (Name {namespace = "IBus", name = "Text"})
    IO ()

-- | Commit output of input method to IBus client.
-- 
-- (Note: The text object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
engineCommitText ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Text.IsText b) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> b
    -- ^ /@text@/: String commit to IBusEngine.
    -> m ()
engineCommitText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsText b) =>
a -> b -> m ()
engineCommitText a
engine b
text = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
    Ptr Engine -> Ptr Text -> IO ()
ibus_engine_commit_text Ptr Engine
engine' Ptr Text
text'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineCommitTextMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEngine a, IBus.Text.IsText b) => O.OverloadedMethod EngineCommitTextMethodInfo a signature where
    overloadedMethod = engineCommitText

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


#endif

-- method Engine::delete_surrounding_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "offset"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The offset of the first char."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "nchars"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Number of chars to be deleted."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_delete_surrounding_text" ibus_engine_delete_surrounding_text :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Int32 ->                                -- offset : TBasicType TInt
    Word32 ->                               -- nchars : TBasicType TUInt
    IO ()

-- | Delete surrounding text.
engineDeleteSurroundingText ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> Int32
    -- ^ /@offset@/: The offset of the first char.
    -> Word32
    -- ^ /@nchars@/: Number of chars to be deleted.
    -> m ()
engineDeleteSurroundingText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> Int32 -> Word32 -> m ()
engineDeleteSurroundingText a
engine Int32
offset Word32
nchars = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Engine -> Int32 -> EngineCancelHandWritingCallback
ibus_engine_delete_surrounding_text Ptr Engine
engine' Int32
offset Word32
nchars
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineDeleteSurroundingTextMethodInfo
instance (signature ~ (Int32 -> Word32 -> m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineDeleteSurroundingTextMethodInfo a signature where
    overloadedMethod = engineDeleteSurroundingText

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


#endif

-- method Engine::forward_key_event
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keyval"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "KeySym." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "keycode"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "keyboard scancode." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "state"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Key modifier flags."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_forward_key_event" ibus_engine_forward_key_event :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Word32 ->                               -- keyval : TBasicType TUInt
    Word32 ->                               -- keycode : TBasicType TUInt
    Word32 ->                               -- state : TBasicType TUInt
    IO ()

-- | Forward the key event.
engineForwardKeyEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> Word32
    -- ^ /@keyval@/: KeySym.
    -> Word32
    -- ^ /@keycode@/: keyboard scancode.
    -> Word32
    -- ^ /@state@/: Key modifier flags.
    -> m ()
engineForwardKeyEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> Word32 -> Word32 -> Word32 -> m ()
engineForwardKeyEvent a
engine Word32
keyval Word32
keycode Word32
state = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Engine -> EngineCandidateClickedCallback
ibus_engine_forward_key_event Ptr Engine
engine' Word32
keyval Word32
keycode Word32
state
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineForwardKeyEventMethodInfo
instance (signature ~ (Word32 -> Word32 -> Word32 -> m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineForwardKeyEventMethodInfo a signature where
    overloadedMethod = engineForwardKeyEvent

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


#endif

-- method Engine::get_content_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "purpose"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Primary purpose of the input context."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "hints"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Hints that augument @purpose."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

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

-- | Get content-type (primary purpose and hints) of the current input
-- context.
-- 
-- See also: [setContentType]("GI.IBus.Objects.Engine#g:signal:setContentType")
engineGetContentType ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An t'GI.IBus.Objects.Engine.Engine'.
    -> m ((Word32, Word32))
engineGetContentType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m (Word32, Word32)
engineGetContentType a
engine = IO (Word32, Word32) -> m (Word32, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word32, Word32) -> m (Word32, Word32))
-> IO (Word32, Word32) -> m (Word32, Word32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Word32
purpose <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr Word32
hints <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr Engine -> Ptr Word32 -> Ptr Word32 -> IO ()
ibus_engine_get_content_type Ptr Engine
engine' Ptr Word32
purpose Ptr Word32
hints
    Word32
purpose' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
purpose
    Word32
hints' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
hints
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
purpose
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
hints
    (Word32, Word32) -> IO (Word32, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32
purpose', Word32
hints')

#if defined(ENABLE_OVERLOADING)
data EngineGetContentTypeMethodInfo
instance (signature ~ (m ((Word32, Word32))), MonadIO m, IsEngine a) => O.OverloadedMethod EngineGetContentTypeMethodInfo a signature where
    overloadedMethod = engineGetContentType

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


#endif

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

foreign import ccall "ibus_engine_get_name" ibus_engine_get_name :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    IO CString

-- | Return the name of t'GI.IBus.Objects.Engine.Engine'.
engineGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> m T.Text
    -- ^ __Returns:__ Name of t'GI.IBus.Objects.Engine.Engine'.
engineGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m Text
engineGetName a
engine = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    CString
result <- Ptr Engine -> IO CString
ibus_engine_get_name Ptr Engine
engine'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"engineGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data EngineGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsEngine a) => O.OverloadedMethod EngineGetNameMethodInfo a signature where
    overloadedMethod = engineGetName

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


#endif

-- method Engine::get_surrounding_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TInterface Name { namespace = "IBus" , name = "Text" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Location to store surrounding text."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_pos"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Cursor position in characters in @text."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "anchor_pos"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Anchor position of selection in @text."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_get_surrounding_text" ibus_engine_get_surrounding_text :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Ptr (Ptr IBus.Text.Text) ->             -- text : TInterface (Name {namespace = "IBus", name = "Text"})
    Ptr Word32 ->                           -- cursor_pos : TBasicType TUInt
    Ptr Word32 ->                           -- anchor_pos : TBasicType TUInt
    IO ()

-- | Get surrounding text.
-- 
-- It is also used to tell the input-context that the engine will
-- utilize surrounding-text.  In that case, it must be called in
-- [enable]("GI.IBus.Objects.Engine#g:signal:enable") handler, with both /@text@/ and /@cursor@/ set to
-- 'P.Nothing'.
-- 
-- See also: [setSurroundingText]("GI.IBus.Objects.Engine#g:signal:setSurroundingText")
engineGetSurroundingText ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> m ((IBus.Text.Text, Word32, Word32))
engineGetSurroundingText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m (Text, Word32, Word32)
engineGetSurroundingText a
engine = IO (Text, Word32, Word32) -> m (Text, Word32, Word32)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Word32, Word32) -> m (Text, Word32, Word32))
-> IO (Text, Word32, Word32) -> m (Text, Word32, Word32)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr (Ptr Text)
text <- IO (Ptr (Ptr Text))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr IBus.Text.Text))
    Ptr Word32
cursorPos <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr Word32
anchorPos <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr Engine -> Ptr (Ptr Text) -> Ptr Word32 -> Ptr Word32 -> IO ()
ibus_engine_get_surrounding_text Ptr Engine
engine' Ptr (Ptr Text)
text Ptr Word32
cursorPos Ptr Word32
anchorPos
    Ptr Text
text' <- Ptr (Ptr Text) -> IO (Ptr Text)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Text)
text
    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'
    Word32
cursorPos' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
cursorPos
    Word32
anchorPos' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
anchorPos
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    Ptr (Ptr Text) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Text)
text
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
cursorPos
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
anchorPos
    (Text, Word32, Word32) -> IO (Text, Word32, Word32)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
text'', Word32
cursorPos', Word32
anchorPos')

#if defined(ENABLE_OVERLOADING)
data EngineGetSurroundingTextMethodInfo
instance (signature ~ (m ((IBus.Text.Text, Word32, Word32))), MonadIO m, IsEngine a) => O.OverloadedMethod EngineGetSurroundingTextMethodInfo a signature where
    overloadedMethod = engineGetSurroundingText

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


#endif

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

foreign import ccall "ibus_engine_hide_auxiliary_text" ibus_engine_hide_auxiliary_text :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    IO ()

-- | Hide the auxiliary bar.
engineHideAuxiliaryText ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> m ()
engineHideAuxiliaryText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineHideAuxiliaryText a
engine = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Engine -> IO ()
ibus_engine_hide_auxiliary_text Ptr Engine
engine'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineHideAuxiliaryTextMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineHideAuxiliaryTextMethodInfo a signature where
    overloadedMethod = engineHideAuxiliaryText

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


#endif

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

foreign import ccall "ibus_engine_hide_lookup_table" ibus_engine_hide_lookup_table :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    IO ()

-- | Hide the lookup table.
engineHideLookupTable ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> m ()
engineHideLookupTable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineHideLookupTable a
engine = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Engine -> IO ()
ibus_engine_hide_lookup_table Ptr Engine
engine'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineHideLookupTableMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineHideLookupTableMethodInfo a signature where
    overloadedMethod = engineHideLookupTable

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


#endif

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

foreign import ccall "ibus_engine_hide_preedit_text" ibus_engine_hide_preedit_text :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    IO ()

-- | Hide the pre-edit buffer.
engineHidePreeditText ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> m ()
engineHidePreeditText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineHidePreeditText a
engine = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Engine -> IO ()
ibus_engine_hide_preedit_text Ptr Engine
engine'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineHidePreeditTextMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineHidePreeditTextMethodInfo a signature where
    overloadedMethod = engineHidePreeditText

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


#endif

-- method Engine::register_properties
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop_list"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PropList" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Property List." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_register_properties" ibus_engine_register_properties :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Ptr IBus.PropList.PropList ->           -- prop_list : TInterface (Name {namespace = "IBus", name = "PropList"})
    IO ()

-- | Register and show properties in language bar.
-- 
-- (Note: The prop_list object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
engineRegisterProperties ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.PropList.IsPropList b) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> b
    -- ^ /@propList@/: Property List.
    -> m ()
engineRegisterProperties :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsPropList b) =>
a -> b -> m ()
engineRegisterProperties a
engine b
propList = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr PropList
propList' <- b -> IO (Ptr PropList)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
propList
    Ptr Engine -> Ptr PropList -> IO ()
ibus_engine_register_properties Ptr Engine
engine' Ptr PropList
propList'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
propList
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineRegisterPropertiesMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEngine a, IBus.PropList.IsPropList b) => O.OverloadedMethod EngineRegisterPropertiesMethodInfo a signature where
    overloadedMethod = engineRegisterProperties

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


#endif

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

foreign import ccall "ibus_engine_show_auxiliary_text" ibus_engine_show_auxiliary_text :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    IO ()

-- | Show the auxiliary bar.
engineShowAuxiliaryText ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> m ()
engineShowAuxiliaryText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineShowAuxiliaryText a
engine = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Engine -> IO ()
ibus_engine_show_auxiliary_text Ptr Engine
engine'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineShowAuxiliaryTextMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineShowAuxiliaryTextMethodInfo a signature where
    overloadedMethod = engineShowAuxiliaryText

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


#endif

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

foreign import ccall "ibus_engine_show_lookup_table" ibus_engine_show_lookup_table :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    IO ()

-- | Show the lookup table.
engineShowLookupTable ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> m ()
engineShowLookupTable :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineShowLookupTable a
engine = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Engine -> IO ()
ibus_engine_show_lookup_table Ptr Engine
engine'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineShowLookupTableMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineShowLookupTableMethodInfo a signature where
    overloadedMethod = engineShowLookupTable

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


#endif

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

foreign import ccall "ibus_engine_show_preedit_text" ibus_engine_show_preedit_text :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    IO ()

-- | Show the pre-edit buffer.
engineShowPreeditText ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> m ()
engineShowPreeditText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsEngine a) =>
a -> m ()
engineShowPreeditText a
engine = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Engine -> IO ()
ibus_engine_show_preedit_text Ptr Engine
engine'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineShowPreeditTextMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEngine a) => O.OverloadedMethod EngineShowPreeditTextMethodInfo a signature where
    overloadedMethod = engineShowPreeditText

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


#endif

-- method Engine::update_auxiliary_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TInterface Name { namespace = "IBus" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Update content." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether the auxiliary text bar is visible."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_update_auxiliary_text" ibus_engine_update_auxiliary_text :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Ptr IBus.Text.Text ->                   -- text : TInterface (Name {namespace = "IBus", name = "Text"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

-- | Update the auxiliary bar.
-- 
-- (Note: The text object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
engineUpdateAuxiliaryText ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Text.IsText b) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> b
    -- ^ /@text@/: Update content.
    -> Bool
    -- ^ /@visible@/: Whether the auxiliary text bar is visible.
    -> m ()
engineUpdateAuxiliaryText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsText b) =>
a -> b -> Bool -> m ()
engineUpdateAuxiliaryText a
engine b
text Bool
visible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    Ptr Engine -> Ptr Text -> CInt -> IO ()
ibus_engine_update_auxiliary_text Ptr Engine
engine' Ptr Text
text' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineUpdateAuxiliaryTextMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsEngine a, IBus.Text.IsText b) => O.OverloadedMethod EngineUpdateAuxiliaryTextMethodInfo a signature where
    overloadedMethod = engineUpdateAuxiliaryText

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


#endif

-- method Engine::update_lookup_table
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "lookup_table"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "LookupTable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An lookup_table." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether the lookup_table is visible."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_update_lookup_table" ibus_engine_update_lookup_table :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Ptr IBus.LookupTable.LookupTable ->     -- lookup_table : TInterface (Name {namespace = "IBus", name = "LookupTable"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

-- | Update the lookup table.
-- 
-- (Note: The table object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
engineUpdateLookupTable ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.LookupTable.IsLookupTable b) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> b
    -- ^ /@lookupTable@/: An lookup_table.
    -> Bool
    -- ^ /@visible@/: Whether the lookup_table is visible.
    -> m ()
engineUpdateLookupTable :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsLookupTable b) =>
a -> b -> Bool -> m ()
engineUpdateLookupTable a
engine b
lookupTable Bool
visible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr LookupTable
lookupTable' <- b -> IO (Ptr LookupTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
lookupTable
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    Ptr Engine -> Ptr LookupTable -> CInt -> IO ()
ibus_engine_update_lookup_table Ptr Engine
engine' Ptr LookupTable
lookupTable' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
lookupTable
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineUpdateLookupTableMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsEngine a, IBus.LookupTable.IsLookupTable b) => O.OverloadedMethod EngineUpdateLookupTableMethodInfo a signature where
    overloadedMethod = engineUpdateLookupTable

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


#endif

-- method Engine::update_lookup_table_fast
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "lookup_table"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "LookupTable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An lookup_table." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether the lookup_table is visible."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_update_lookup_table_fast" ibus_engine_update_lookup_table_fast :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Ptr IBus.LookupTable.LookupTable ->     -- lookup_table : TInterface (Name {namespace = "IBus", name = "LookupTable"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

-- | Fast update for big lookup table.
-- 
-- If size of lookup table is not over table page size *4,
-- then it calls 'GI.IBus.Objects.Engine.engineUpdateLookupTable'.
-- 
-- (Note: The table object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
engineUpdateLookupTableFast ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.LookupTable.IsLookupTable b) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> b
    -- ^ /@lookupTable@/: An lookup_table.
    -> Bool
    -- ^ /@visible@/: Whether the lookup_table is visible.
    -> m ()
engineUpdateLookupTableFast :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsLookupTable b) =>
a -> b -> Bool -> m ()
engineUpdateLookupTableFast a
engine b
lookupTable Bool
visible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr LookupTable
lookupTable' <- b -> IO (Ptr LookupTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
lookupTable
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    Ptr Engine -> Ptr LookupTable -> CInt -> IO ()
ibus_engine_update_lookup_table_fast Ptr Engine
engine' Ptr LookupTable
lookupTable' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
lookupTable
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineUpdateLookupTableFastMethodInfo
instance (signature ~ (b -> Bool -> m ()), MonadIO m, IsEngine a, IBus.LookupTable.IsLookupTable b) => O.OverloadedMethod EngineUpdateLookupTableFastMethodInfo a signature where
    overloadedMethod = engineUpdateLookupTableFast

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


#endif

-- method Engine::update_preedit_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TInterface Name { namespace = "IBus" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Update content." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_pos"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Current position of cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether the pre-edit buffer is visible."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_update_preedit_text" ibus_engine_update_preedit_text :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Ptr IBus.Text.Text ->                   -- text : TInterface (Name {namespace = "IBus", name = "Text"})
    Word32 ->                               -- cursor_pos : TBasicType TUInt
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

-- | Update the pre-edit buffer.
-- 
-- (Note: The text object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
engineUpdatePreeditText ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Text.IsText b) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> b
    -- ^ /@text@/: Update content.
    -> Word32
    -- ^ /@cursorPos@/: Current position of cursor
    -> Bool
    -- ^ /@visible@/: Whether the pre-edit buffer is visible.
    -> m ()
engineUpdatePreeditText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsText b) =>
a -> b -> Word32 -> Bool -> m ()
engineUpdatePreeditText a
engine b
text Word32
cursorPos Bool
visible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    Ptr Engine -> Ptr Text -> Word32 -> CInt -> IO ()
ibus_engine_update_preedit_text Ptr Engine
engine' Ptr Text
text' Word32
cursorPos CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineUpdatePreeditTextMethodInfo
instance (signature ~ (b -> Word32 -> Bool -> m ()), MonadIO m, IsEngine a, IBus.Text.IsText b) => O.OverloadedMethod EngineUpdatePreeditTextMethodInfo a signature where
    overloadedMethod = engineUpdatePreeditText

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


#endif

-- method Engine::update_preedit_text_with_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TInterface Name { namespace = "IBus" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Update content." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cursor_pos"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Current position of cursor"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "visible"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether the pre-edit buffer is visible."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PreeditFocusMode" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Pre-edit commit mode when the focus is lost."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_update_preedit_text_with_mode" ibus_engine_update_preedit_text_with_mode :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Ptr IBus.Text.Text ->                   -- text : TInterface (Name {namespace = "IBus", name = "Text"})
    Word32 ->                               -- cursor_pos : TBasicType TUInt
    CInt ->                                 -- visible : TBasicType TBoolean
    CUInt ->                                -- mode : TInterface (Name {namespace = "IBus", name = "PreeditFocusMode"})
    IO ()

-- | Update the pre-edit buffer with commit mode. Similar to
-- 'GI.IBus.Objects.Engine.engineUpdatePreeditText', this function allows users to specify
-- the behavior on focus out when the pre-edit buffer is visible.
-- 
-- If /@mode@/ is IBUS_ENGINE_PREEDIT_COMMIT, contents of the pre-edit buffer
-- will be committed and cleared.
-- If /@mode@/ is IBUS_ENGINE_PREEDIT_CLEAR, contents of the pre-edit buffer
-- will be cleared only.
-- 
-- (Note: The text object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
engineUpdatePreeditTextWithMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Text.IsText b) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> b
    -- ^ /@text@/: Update content.
    -> Word32
    -- ^ /@cursorPos@/: Current position of cursor
    -> Bool
    -- ^ /@visible@/: Whether the pre-edit buffer is visible.
    -> IBus.Enums.PreeditFocusMode
    -- ^ /@mode@/: Pre-edit commit mode when the focus is lost.
    -> m ()
engineUpdatePreeditTextWithMode :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsText b) =>
a -> b -> Word32 -> Bool -> PreeditFocusMode -> m ()
engineUpdatePreeditTextWithMode a
engine b
text Word32
cursorPos Bool
visible PreeditFocusMode
mode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (PreeditFocusMode -> Int) -> PreeditFocusMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PreeditFocusMode -> Int
forall a. Enum a => a -> Int
fromEnum) PreeditFocusMode
mode
    Ptr Engine -> Ptr Text -> Word32 -> CInt -> CUInt -> IO ()
ibus_engine_update_preedit_text_with_mode Ptr Engine
engine' Ptr Text
text' Word32
cursorPos CInt
visible' CUInt
mode'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineUpdatePreeditTextWithModeMethodInfo
instance (signature ~ (b -> Word32 -> Bool -> IBus.Enums.PreeditFocusMode -> m ()), MonadIO m, IsEngine a, IBus.Text.IsText b) => O.OverloadedMethod EngineUpdatePreeditTextWithModeMethodInfo a signature where
    overloadedMethod = engineUpdatePreeditTextWithMode

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


#endif

-- method Engine::update_property
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "engine"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Engine" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusEngine." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "Property" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "IBusProperty to be updated."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_engine_update_property" ibus_engine_update_property :: 
    Ptr Engine ->                           -- engine : TInterface (Name {namespace = "IBus", name = "Engine"})
    Ptr IBus.Property.Property ->           -- prop : TInterface (Name {namespace = "IBus", name = "Property"})
    IO ()

-- | Update the state displayed in language bar.
-- 
-- (Note: The prop object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
engineUpdateProperty ::
    (B.CallStack.HasCallStack, MonadIO m, IsEngine a, IBus.Property.IsProperty b) =>
    a
    -- ^ /@engine@/: An IBusEngine.
    -> b
    -- ^ /@prop@/: IBusProperty to be updated.
    -> m ()
engineUpdateProperty :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsEngine a, IsProperty b) =>
a -> b -> m ()
engineUpdateProperty a
engine b
prop = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Engine
engine' <- a -> IO (Ptr Engine)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
engine
    Ptr Property
prop' <- b -> IO (Ptr Property)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
prop
    Ptr Engine -> Ptr Property -> IO ()
ibus_engine_update_property Ptr Engine
engine' Ptr Property
prop'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
engine
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
prop
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data EngineUpdatePropertyMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsEngine a, IBus.Property.IsProperty b) => O.OverloadedMethod EngineUpdatePropertyMethodInfo a signature where
    overloadedMethod = engineUpdateProperty

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


#endif