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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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


-- ** activeSurroundingText #attr:activeSurroundingText#
-- | When this property is set to 'P.True', \"RequireSurroundingText\" D-Bus
-- signal will be called by ibus-daemon on every focus-in\/out event, with
-- no need for the engine to call 'GI.IBus.Objects.Engine.engineGetSurroundingText'.
-- This property can only be set at construct time.

#if defined(ENABLE_OVERLOADING)
    EngineActiveSurroundingTextPropertyInfo ,
#endif
    constructEngineActiveSurroundingText    ,
#if defined(ENABLE_OVERLOADING)
    engineActiveSurroundingText             ,
#endif
    getEngineActiveSurroundingText          ,


-- ** engineName #attr:engineName#
-- | Name of this IBusEngine.

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


-- ** hasFocusId #attr:hasFocusId#
-- | Use t'GI.IBus.Objects.Engine.Engine'::@/focus_in_id/@()\/@/focus_out_id()/@ class method insteads of
-- @/focus_in()/@\/@/focus_out()/@ class methods when this property is set to 'P.True'.
-- Otherwise, use t'GI.IBus.Objects.Engine.Engine'::@/focus_in/@()\/focus_out class methods.
-- This property can only be set at construct time.
-- 
-- See also: IBusEngine[focusInId](#g:signal:focusInId)

#if defined(ENABLE_OVERLOADING)
    EngineHasFocusIdPropertyInfo            ,
#endif
    constructEngineHasFocusId               ,
#if defined(ENABLE_OVERLOADING)
    engineHasFocusId                        ,
#endif
    getEngineHasFocusId                     ,




 -- * Signals


-- ** cancelHandWriting #signal:cancelHandWriting#

    EngineCancelHandWritingCallback         ,
#if defined(ENABLE_OVERLOADING)
    EngineCancelHandWritingSignalInfo       ,
#endif
    afterEngineCancelHandWriting            ,
    onEngineCancelHandWriting               ,


-- ** candidateClicked #signal:candidateClicked#

    EngineCandidateClickedCallback          ,
#if defined(ENABLE_OVERLOADING)
    EngineCandidateClickedSignalInfo        ,
#endif
    afterEngineCandidateClicked             ,
    onEngineCandidateClicked                ,


-- ** cursorDown #signal:cursorDown#

    EngineCursorDownCallback                ,
#if defined(ENABLE_OVERLOADING)
    EngineCursorDownSignalInfo              ,
#endif
    afterEngineCursorDown                   ,
    onEngineCursorDown                      ,


-- ** cursorUp #signal:cursorUp#

    EngineCursorUpCallback                  ,
#if defined(ENABLE_OVERLOADING)
    EngineCursorUpSignalInfo                ,
#endif
    afterEngineCursorUp                     ,
    onEngineCursorUp                        ,


-- ** disable #signal:disable#

    EngineDisableCallback                   ,
#if defined(ENABLE_OVERLOADING)
    EngineDisableSignalInfo                 ,
#endif
    afterEngineDisable                      ,
    onEngineDisable                         ,


-- ** enable #signal:enable#

    EngineEnableCallback                    ,
#if defined(ENABLE_OVERLOADING)
    EngineEnableSignalInfo                  ,
#endif
    afterEngineEnable                       ,
    onEngineEnable                          ,


-- ** focusIn #signal:focusIn#

    EngineFocusInCallback                   ,
#if defined(ENABLE_OVERLOADING)
    EngineFocusInSignalInfo                 ,
#endif
    afterEngineFocusIn                      ,
    onEngineFocusIn                         ,


-- ** focusInId #signal:focusInId#

    EngineFocusInIdCallback                 ,
#if defined(ENABLE_OVERLOADING)
    EngineFocusInIdSignalInfo               ,
#endif
    afterEngineFocusInId                    ,
    onEngineFocusInId                       ,


-- ** focusOut #signal:focusOut#

    EngineFocusOutCallback                  ,
#if defined(ENABLE_OVERLOADING)
    EngineFocusOutSignalInfo                ,
#endif
    afterEngineFocusOut                     ,
    onEngineFocusOut                        ,


-- ** focusOutId #signal:focusOutId#

    EngineFocusOutIdCallback                ,
#if defined(ENABLE_OVERLOADING)
    EngineFocusOutIdSignalInfo              ,
#endif
    afterEngineFocusOutId                   ,
    onEngineFocusOutId                      ,


-- ** pageDown #signal:pageDown#

    EnginePageDownCallback                  ,
#if defined(ENABLE_OVERLOADING)
    EnginePageDownSignalInfo                ,
#endif
    afterEnginePageDown                     ,
    onEnginePageDown                        ,


-- ** pageUp #signal:pageUp#

    EnginePageUpCallback                    ,
#if defined(ENABLE_OVERLOADING)
    EnginePageUpSignalInfo                  ,
#endif
    afterEnginePageUp                       ,
    onEnginePageUp                          ,


-- ** processHandWritingEvent #signal:processHandWritingEvent#

    EngineProcessHandWritingEventCallback   ,
#if defined(ENABLE_OVERLOADING)
    EngineProcessHandWritingEventSignalInfo ,
#endif
    afterEngineProcessHandWritingEvent      ,
    onEngineProcessHandWritingEvent         ,


-- ** processKeyEvent #signal:processKeyEvent#

    EngineProcessKeyEventCallback           ,
#if defined(ENABLE_OVERLOADING)
    EngineProcessKeyEventSignalInfo         ,
#endif
    afterEngineProcessKeyEvent              ,
    onEngineProcessKeyEvent                 ,


-- ** propertyActivate #signal:propertyActivate#

    EnginePropertyActivateCallback          ,
#if defined(ENABLE_OVERLOADING)
    EnginePropertyActivateSignalInfo        ,
#endif
    afterEnginePropertyActivate             ,
    onEnginePropertyActivate                ,


-- ** propertyHide #signal:propertyHide#

    EnginePropertyHideCallback              ,
#if defined(ENABLE_OVERLOADING)
    EnginePropertyHideSignalInfo            ,
#endif
    afterEnginePropertyHide                 ,
    onEnginePropertyHide                    ,


-- ** propertyShow #signal:propertyShow#

    EnginePropertyShowCallback              ,
#if defined(ENABLE_OVERLOADING)
    EnginePropertyShowSignalInfo            ,
#endif
    afterEnginePropertyShow                 ,
    onEnginePropertyShow                    ,


-- ** reset #signal:reset#

    EngineResetCallback                     ,
#if defined(ENABLE_OVERLOADING)
    EngineResetSignalInfo                   ,
#endif
    afterEngineReset                        ,
    onEngineReset                           ,


-- ** setCapabilities #signal:setCapabilities#

    EngineSetCapabilitiesCallback           ,
#if defined(ENABLE_OVERLOADING)
    EngineSetCapabilitiesSignalInfo         ,
#endif
    afterEngineSetCapabilities              ,
    onEngineSetCapabilities                 ,


-- ** setContentType #signal:setContentType#

    EngineSetContentTypeCallback            ,
#if defined(ENABLE_OVERLOADING)
    EngineSetContentTypeSignalInfo          ,
#endif
    afterEngineSetContentType               ,
    onEngineSetContentType                  ,


-- ** setCursorLocation #signal:setCursorLocation#

    EngineSetCursorLocationCallback         ,
#if defined(ENABLE_OVERLOADING)
    EngineSetCursorLocationSignalInfo       ,
#endif
    afterEngineSetCursorLocation            ,
    onEngineSetCursorLocation               ,


-- ** setSurroundingText #signal:setSurroundingText#

    EngineSetSurroundingTextCallback        ,
#if defined(ENABLE_OVERLOADING)
    EngineSetSurroundingTextSignalInfo      ,
#endif
    afterEngineSetSurroundingText           ,
    onEngineSetSurroundingText              ,




    ) where

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

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

import qualified 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
$c== :: Engine -> Engine -> Bool
== :: Engine -> Engine -> Bool
$c/= :: Engine -> Engine -> Bool
/= :: 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 a. IO a -> m a
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 a. a -> IO a
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 :: DK.Type) :: DK.Type 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 ()

type C_EngineCancelHandWritingCallback =
    Ptr Engine ->                           -- 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_EngineCancelHandWritingCallback :: 
    GObject a => (a -> EngineCancelHandWritingCallback) ->
    C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback :: forall a.
GObject a =>
(a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback a -> EngineCancelHandWritingCallback
gi'cb Ptr Engine
gi'selfPtr Word32
nStrokes Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineCancelHandWritingCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EngineCancelHandWritingCallback) -> m SignalHandlerId
onEngineCancelHandWriting :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineCancelHandWritingCallback)
-> m SignalHandlerId
onEngineCancelHandWriting a
obj (?self::a) => EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineCancelHandWritingCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineCancelHandWritingCallback
EngineCancelHandWritingCallback
cb
    let wrapped' :: C_EngineCancelHandWritingCallback
wrapped' = (a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
forall a.
GObject a =>
(a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback a -> EngineCancelHandWritingCallback
wrapped
    FunPtr C_EngineCancelHandWritingCallback
wrapped'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineCancelHandWritingCallback C_EngineCancelHandWritingCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineCancelHandWriting :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineCancelHandWritingCallback) -> m SignalHandlerId
afterEngineCancelHandWriting :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineCancelHandWritingCallback)
-> m SignalHandlerId
afterEngineCancelHandWriting a
obj (?self::a) => EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineCancelHandWritingCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineCancelHandWritingCallback
EngineCancelHandWritingCallback
cb
    let wrapped' :: C_EngineCancelHandWritingCallback
wrapped' = (a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
forall a.
GObject a =>
(a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
wrap_EngineCancelHandWritingCallback a -> EngineCancelHandWritingCallback
wrapped
    FunPtr C_EngineCancelHandWritingCallback
wrapped'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineCancelHandWritingCallback C_EngineCancelHandWritingCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::cancel-hand-writing"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:cancelHandWriting"})

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

type C_EngineCandidateClickedCallback =
    Ptr Engine ->                           -- 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_EngineCandidateClickedCallback :: 
    GObject a => (a -> EngineCandidateClickedCallback) ->
    C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback :: forall a.
GObject a =>
(a -> EngineCandidateClickedCallback)
-> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback a -> EngineCandidateClickedCallback
gi'cb Ptr Engine
gi'selfPtr Word32
index Word32
button Word32
state Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineCandidateClickedCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EngineCandidateClickedCallback) -> m SignalHandlerId
onEngineCandidateClicked :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineCandidateClickedCallback)
-> m SignalHandlerId
onEngineCandidateClicked a
obj (?self::a) => EngineCandidateClickedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineCandidateClickedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineCandidateClickedCallback
EngineCandidateClickedCallback
cb
    let wrapped' :: C_EngineCandidateClickedCallback
wrapped' = (a -> EngineCandidateClickedCallback)
-> C_EngineCandidateClickedCallback
forall a.
GObject a =>
(a -> EngineCandidateClickedCallback)
-> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback a -> EngineCandidateClickedCallback
wrapped
    FunPtr C_EngineCandidateClickedCallback
wrapped'' <- C_EngineCandidateClickedCallback
-> IO (FunPtr C_EngineCandidateClickedCallback)
mk_EngineCandidateClickedCallback C_EngineCandidateClickedCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineCandidateClicked :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineCandidateClickedCallback) -> m SignalHandlerId
afterEngineCandidateClicked :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineCandidateClickedCallback)
-> m SignalHandlerId
afterEngineCandidateClicked a
obj (?self::a) => EngineCandidateClickedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineCandidateClickedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineCandidateClickedCallback
EngineCandidateClickedCallback
cb
    let wrapped' :: C_EngineCandidateClickedCallback
wrapped' = (a -> EngineCandidateClickedCallback)
-> C_EngineCandidateClickedCallback
forall a.
GObject a =>
(a -> EngineCandidateClickedCallback)
-> C_EngineCandidateClickedCallback
wrap_EngineCandidateClickedCallback a -> EngineCandidateClickedCallback
wrapped
    FunPtr C_EngineCandidateClickedCallback
wrapped'' <- C_EngineCandidateClickedCallback
-> IO (FunPtr C_EngineCandidateClickedCallback)
mk_EngineCandidateClickedCallback C_EngineCandidateClickedCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::candidate-clicked"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:candidateClicked"})

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

type C_EngineCursorDownCallback =
    Ptr Engine ->                           -- 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_EngineCursorDownCallback :: 
    GObject a => (a -> EngineCursorDownCallback) ->
    C_EngineCursorDownCallback
wrap_EngineCursorDownCallback :: forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback a -> IO ()
gi'cb Ptr Engine
gi'selfPtr Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> IO ()
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self) 


-- | 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 -> ((?self :: a) => EngineCursorDownCallback) -> m SignalHandlerId
onEngineCursorDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEngineCursorDown a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorDownCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineCursorDown :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineCursorDownCallback) -> m SignalHandlerId
afterEngineCursorDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEngineCursorDown a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineCursorDownCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorDownCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::cursor-down"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:cursorDown"})

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

type C_EngineCursorUpCallback =
    Ptr Engine ->                           -- 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_EngineCursorUpCallback :: 
    GObject a => (a -> EngineCursorUpCallback) ->
    C_EngineCursorUpCallback
wrap_EngineCursorUpCallback :: forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback a -> IO ()
gi'cb Ptr Engine
gi'selfPtr Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> IO ()
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self) 


-- | 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 -> ((?self :: a) => EngineCursorUpCallback) -> m SignalHandlerId
onEngineCursorUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEngineCursorUp a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorUpCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineCursorUp :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineCursorUpCallback) -> m SignalHandlerId
afterEngineCursorUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEngineCursorUp a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineCursorUpCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineCursorUpCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::cursor-up"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:cursorUp"})

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

type C_EngineDisableCallback =
    Ptr Engine ->                           -- 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_EngineDisableCallback :: 
    GObject a => (a -> EngineDisableCallback) ->
    C_EngineDisableCallback
wrap_EngineDisableCallback :: forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineDisableCallback a -> IO ()
gi'cb Ptr Engine
gi'selfPtr Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> IO ()
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self) 


-- | 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 -> ((?self :: a) => EngineDisableCallback) -> m SignalHandlerId
onEngineDisable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEngineDisable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineDisableCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineDisableCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineDisable :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineDisableCallback) -> m SignalHandlerId
afterEngineDisable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEngineDisable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineDisableCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineDisableCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::disable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:disable"})

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

type C_EngineEnableCallback =
    Ptr Engine ->                           -- 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_EngineEnableCallback :: 
    GObject a => (a -> EngineEnableCallback) ->
    C_EngineEnableCallback
wrap_EngineEnableCallback :: forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineEnableCallback a -> IO ()
gi'cb Ptr Engine
gi'selfPtr Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> IO ()
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self) 


-- | 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 -> ((?self :: a) => EngineEnableCallback) -> m SignalHandlerId
onEngineEnable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEngineEnable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineEnableCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineEnableCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineEnable :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineEnableCallback) -> m SignalHandlerId
afterEngineEnable :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEngineEnable a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineEnableCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineEnableCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::enable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:enable"})

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

type C_EngineFocusInCallback =
    Ptr Engine ->                           -- 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_EngineFocusInCallback :: 
    GObject a => (a -> EngineFocusInCallback) ->
    C_EngineFocusInCallback
wrap_EngineFocusInCallback :: forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback a -> IO ()
gi'cb Ptr Engine
gi'selfPtr Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> IO ()
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self) 


-- | 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 -> ((?self :: a) => EngineFocusInCallback) -> m SignalHandlerId
onEngineFocusIn :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEngineFocusIn a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusInCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineFocusIn :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineFocusInCallback) -> m SignalHandlerId
afterEngineFocusIn :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEngineFocusIn a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineFocusInCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusInCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::focus-in"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:focusIn"})

#endif

-- signal Engine::focus-in-id
-- | 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.
-- /@objectPath@/ is a unique id by input context.
-- /@client@/ indicates a client type:
-- \'fake\':    focus is on desktop background or other programs where no
--            input is possible
-- \'xim\':     old X11 programs like xterm, emacs, ...
--            GTK3 programs in a Gnome Xorg session when GTK_IM_MODULE
--            is unset also use xim
-- \'gtk-im:&lt;client-name&gt;\':  Gtk2 input module is used
-- \'gtk3-im:&lt;client-name&gt;\': Gtk3 input module is used
-- \'gtk4-im:&lt;client-name&gt;\': Gtk4 input module is used
--            In case of the Gtk input modules, the name of the
--            client is also shown after the “:”, for example
--            like \'gtk3-im:firefox\', \'gtk4-im:gnome-text-editor\', …
-- \'gnome-shell\': Entries handled by gnome-shell
--                (like the command line dialog opened with Alt+F2
--                or the search field when pressing the Super key.)
--                When GTK_IM_MODULE is unset in a Gnome Wayland session
--                all programs which would show \'gtk3-im\' or \'gtk4-im\'
--                with GTK_IM_MODULE=ibus then show \'gnome-shell\'
--                instead.
-- \'Qt\':      Qt4 programs like keepassx-2.0.3 …
-- \'QIBusInputContext\': Qt5 programs like keepassxc-2.7.1, anki-2.1.15
--                      telegram-desktop-3.7.3,
-- 
-- You need to set t'GI.IBus.Objects.Engine.Engine'::@/has-focus-id/@ property to 'P.True' when you
-- construct an t'GI.IBus.Objects.Engine.Engine' to use this class method.
-- 
-- See also: 'GI.IBus.Objects.InputContext.inputContextFocusIn'
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type EngineFocusInIdCallback =
    T.Text
    -- ^ /@objectPath@/: An object path.
    -> T.Text
    -- ^ /@client@/: An client name.
    -> IO ()

type C_EngineFocusInIdCallback =
    Ptr Engine ->                           -- object
    CString ->
    CString ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_EngineFocusInIdCallback :: 
    GObject a => (a -> EngineFocusInIdCallback) ->
    C_EngineFocusInIdCallback
wrap_EngineFocusInIdCallback :: forall a.
GObject a =>
(a -> EngineFocusInIdCallback) -> C_EngineFocusInIdCallback
wrap_EngineFocusInIdCallback a -> EngineFocusInIdCallback
gi'cb Ptr Engine
gi'selfPtr CString
objectPath CString
client Ptr ()
_ = do
    Text
objectPath' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
objectPath
    Text
client' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
client
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineFocusInIdCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  Text
objectPath' Text
client'


-- | Connect a signal handler for the [focusInId](#signal:focusInId) 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 #focusInId callback
-- @
-- 
-- 
onEngineFocusInId :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineFocusInIdCallback) -> m SignalHandlerId
onEngineFocusInId :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => EngineFocusInIdCallback) -> m SignalHandlerId
onEngineFocusInId a
obj (?self::a) => EngineFocusInIdCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineFocusInIdCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineFocusInIdCallback
EngineFocusInIdCallback
cb
    let wrapped' :: C_EngineFocusInIdCallback
wrapped' = (a -> EngineFocusInIdCallback) -> C_EngineFocusInIdCallback
forall a.
GObject a =>
(a -> EngineFocusInIdCallback) -> C_EngineFocusInIdCallback
wrap_EngineFocusInIdCallback a -> EngineFocusInIdCallback
wrapped
    FunPtr C_EngineFocusInIdCallback
wrapped'' <- C_EngineFocusInIdCallback -> IO (FunPtr C_EngineFocusInIdCallback)
mk_EngineFocusInIdCallback C_EngineFocusInIdCallback
wrapped'
    a
-> Text
-> FunPtr C_EngineFocusInIdCallback
-> 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-id" FunPtr C_EngineFocusInIdCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [focusInId](#signal:focusInId) 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 #focusInId callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineFocusInId :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineFocusInIdCallback) -> m SignalHandlerId
afterEngineFocusInId :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => EngineFocusInIdCallback) -> m SignalHandlerId
afterEngineFocusInId a
obj (?self::a) => EngineFocusInIdCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineFocusInIdCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineFocusInIdCallback
EngineFocusInIdCallback
cb
    let wrapped' :: C_EngineFocusInIdCallback
wrapped' = (a -> EngineFocusInIdCallback) -> C_EngineFocusInIdCallback
forall a.
GObject a =>
(a -> EngineFocusInIdCallback) -> C_EngineFocusInIdCallback
wrap_EngineFocusInIdCallback a -> EngineFocusInIdCallback
wrapped
    FunPtr C_EngineFocusInIdCallback
wrapped'' <- C_EngineFocusInIdCallback -> IO (FunPtr C_EngineFocusInIdCallback)
mk_EngineFocusInIdCallback C_EngineFocusInIdCallback
wrapped'
    a
-> Text
-> FunPtr C_EngineFocusInIdCallback
-> 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-id" FunPtr C_EngineFocusInIdCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineFocusInIdSignalInfo
instance SignalInfo EngineFocusInIdSignalInfo where
    type HaskellCallbackType EngineFocusInIdSignalInfo = EngineFocusInIdCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineFocusInIdCallback cb
        cb'' <- mk_EngineFocusInIdCallback cb'
        connectSignalFunPtr obj "focus-in-id" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::focus-in-id"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:focusInId"})

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

type C_EngineFocusOutCallback =
    Ptr Engine ->                           -- 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_EngineFocusOutCallback :: 
    GObject a => (a -> EngineFocusOutCallback) ->
    C_EngineFocusOutCallback
wrap_EngineFocusOutCallback :: forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback a -> IO ()
gi'cb Ptr Engine
gi'selfPtr Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> IO ()
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self) 


-- | 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 -> ((?self :: a) => EngineFocusOutCallback) -> m SignalHandlerId
onEngineFocusOut :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEngineFocusOut a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusOutCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineFocusOut :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineFocusOutCallback) -> m SignalHandlerId
afterEngineFocusOut :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEngineFocusOut a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineFocusOutCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineFocusOutCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::focus-out"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:focusOut"})

#endif

-- signal Engine::focus-out-id
-- | 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.
-- /@objectPath@/ is a unique id by input context.
-- You need to set t'GI.IBus.Objects.Engine.Engine'::@/has-focus-id/@ property to 'P.True' when you
-- construct an t'GI.IBus.Objects.Engine.Engine' to use this class method.
-- 
-- See also: 'GI.IBus.Objects.InputContext.inputContextFocusOut'
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type EngineFocusOutIdCallback =
    T.Text
    -- ^ /@objectPath@/: An object path.
    -> IO ()

type C_EngineFocusOutIdCallback =
    Ptr Engine ->                           -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_EngineFocusOutIdCallback :: 
    GObject a => (a -> EngineFocusOutIdCallback) ->
    C_EngineFocusOutIdCallback
wrap_EngineFocusOutIdCallback :: forall a.
GObject a =>
(a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
wrap_EngineFocusOutIdCallback a -> EngineFocusOutIdCallback
gi'cb Ptr Engine
gi'selfPtr CString
objectPath Ptr ()
_ = do
    Text
objectPath' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
objectPath
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineFocusOutIdCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  Text
objectPath'


-- | Connect a signal handler for the [focusOutId](#signal:focusOutId) 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 #focusOutId callback
-- @
-- 
-- 
onEngineFocusOutId :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineFocusOutIdCallback) -> m SignalHandlerId
onEngineFocusOutId :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => EngineFocusOutIdCallback) -> m SignalHandlerId
onEngineFocusOutId a
obj (?self::a) => EngineFocusOutIdCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineFocusOutIdCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineFocusOutIdCallback
EngineFocusOutIdCallback
cb
    let wrapped' :: C_EngineFocusOutIdCallback
wrapped' = (a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
forall a.
GObject a =>
(a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
wrap_EngineFocusOutIdCallback a -> EngineFocusOutIdCallback
wrapped
    FunPtr C_EngineFocusOutIdCallback
wrapped'' <- C_EngineFocusOutIdCallback
-> IO (FunPtr C_EngineFocusOutIdCallback)
mk_EngineFocusOutIdCallback C_EngineFocusOutIdCallback
wrapped'
    a
-> Text
-> FunPtr C_EngineFocusOutIdCallback
-> 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-id" FunPtr C_EngineFocusOutIdCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [focusOutId](#signal:focusOutId) 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 #focusOutId callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineFocusOutId :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineFocusOutIdCallback) -> m SignalHandlerId
afterEngineFocusOutId :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => EngineFocusOutIdCallback) -> m SignalHandlerId
afterEngineFocusOutId a
obj (?self::a) => EngineFocusOutIdCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineFocusOutIdCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineFocusOutIdCallback
EngineFocusOutIdCallback
cb
    let wrapped' :: C_EngineFocusOutIdCallback
wrapped' = (a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
forall a.
GObject a =>
(a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
wrap_EngineFocusOutIdCallback a -> EngineFocusOutIdCallback
wrapped
    FunPtr C_EngineFocusOutIdCallback
wrapped'' <- C_EngineFocusOutIdCallback
-> IO (FunPtr C_EngineFocusOutIdCallback)
mk_EngineFocusOutIdCallback C_EngineFocusOutIdCallback
wrapped'
    a
-> Text
-> FunPtr C_EngineFocusOutIdCallback
-> 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-id" FunPtr C_EngineFocusOutIdCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data EngineFocusOutIdSignalInfo
instance SignalInfo EngineFocusOutIdSignalInfo where
    type HaskellCallbackType EngineFocusOutIdSignalInfo = EngineFocusOutIdCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_EngineFocusOutIdCallback cb
        cb'' <- mk_EngineFocusOutIdCallback cb'
        connectSignalFunPtr obj "focus-out-id" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::focus-out-id"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:focusOutId"})

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

type C_EnginePageDownCallback =
    Ptr Engine ->                           -- 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_EnginePageDownCallback :: 
    GObject a => (a -> EnginePageDownCallback) ->
    C_EnginePageDownCallback
wrap_EnginePageDownCallback :: forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback a -> IO ()
gi'cb Ptr Engine
gi'selfPtr Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> IO ()
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self) 


-- | 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 -> ((?self :: a) => EnginePageDownCallback) -> m SignalHandlerId
onEnginePageDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEnginePageDown a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageDownCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEnginePageDown :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EnginePageDownCallback) -> m SignalHandlerId
afterEnginePageDown :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEnginePageDown a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EnginePageDownCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageDownCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::page-down"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:pageDown"})

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

type C_EnginePageUpCallback =
    Ptr Engine ->                           -- 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_EnginePageUpCallback :: 
    GObject a => (a -> EnginePageUpCallback) ->
    C_EnginePageUpCallback
wrap_EnginePageUpCallback :: forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback a -> IO ()
gi'cb Ptr Engine
gi'selfPtr Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> IO ()
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self) 


-- | 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 -> ((?self :: a) => EnginePageUpCallback) -> m SignalHandlerId
onEnginePageUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEnginePageUp a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageUpCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEnginePageUp :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EnginePageUpCallback) -> m SignalHandlerId
afterEnginePageUp :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEnginePageUp a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EnginePageUpCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EnginePageUpCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::page-up"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:pageUp"})

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

type C_EngineProcessHandWritingEventCallback =
    Ptr Engine ->                           -- 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_EngineProcessHandWritingEventCallback :: 
    GObject a => (a -> EngineProcessHandWritingEventCallback) ->
    C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback :: forall a.
GObject a =>
(a -> EngineProcessHandWritingEventCallback)
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback a -> EngineProcessHandWritingEventCallback
gi'cb Ptr Engine
gi'selfPtr Ptr ()
coordinates Word32
coordinatesLen Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineProcessHandWritingEventCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EngineProcessHandWritingEventCallback) -> m SignalHandlerId
onEngineProcessHandWritingEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineProcessHandWritingEventCallback)
-> m SignalHandlerId
onEngineProcessHandWritingEvent a
obj (?self::a) => EngineProcessHandWritingEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineProcessHandWritingEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineProcessHandWritingEventCallback
EngineProcessHandWritingEventCallback
cb
    let wrapped' :: C_EngineProcessHandWritingEventCallback
wrapped' = (a -> EngineProcessHandWritingEventCallback)
-> C_EngineProcessHandWritingEventCallback
forall a.
GObject a =>
(a -> EngineProcessHandWritingEventCallback)
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback a -> EngineProcessHandWritingEventCallback
wrapped
    FunPtr C_EngineProcessHandWritingEventCallback
wrapped'' <- C_EngineProcessHandWritingEventCallback
-> IO (FunPtr C_EngineProcessHandWritingEventCallback)
mk_EngineProcessHandWritingEventCallback C_EngineProcessHandWritingEventCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineProcessHandWritingEvent :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineProcessHandWritingEventCallback) -> m SignalHandlerId
afterEngineProcessHandWritingEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineProcessHandWritingEventCallback)
-> m SignalHandlerId
afterEngineProcessHandWritingEvent a
obj (?self::a) => EngineProcessHandWritingEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineProcessHandWritingEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineProcessHandWritingEventCallback
EngineProcessHandWritingEventCallback
cb
    let wrapped' :: C_EngineProcessHandWritingEventCallback
wrapped' = (a -> EngineProcessHandWritingEventCallback)
-> C_EngineProcessHandWritingEventCallback
forall a.
GObject a =>
(a -> EngineProcessHandWritingEventCallback)
-> C_EngineProcessHandWritingEventCallback
wrap_EngineProcessHandWritingEventCallback a -> EngineProcessHandWritingEventCallback
wrapped
    FunPtr C_EngineProcessHandWritingEventCallback
wrapped'' <- C_EngineProcessHandWritingEventCallback
-> IO (FunPtr C_EngineProcessHandWritingEventCallback)
mk_EngineProcessHandWritingEventCallback C_EngineProcessHandWritingEventCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::process-hand-writing-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:processHandWritingEvent"})

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

type C_EngineProcessKeyEventCallback =
    Ptr Engine ->                           -- 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_EngineProcessKeyEventCallback :: 
    GObject a => (a -> EngineProcessKeyEventCallback) ->
    C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback :: forall a.
GObject a =>
(a -> EngineProcessKeyEventCallback)
-> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback a -> EngineProcessKeyEventCallback
gi'cb Ptr Engine
gi'selfPtr Word32
keyval Word32
keycode Word32
state Ptr ()
_ = do
    Bool
result <- Ptr Engine -> (Engine -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO Bool) -> IO Bool) -> (Engine -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineProcessKeyEventCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  Word32
keyval Word32
keycode Word32
state
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
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 -> ((?self :: a) => EngineProcessKeyEventCallback) -> m SignalHandlerId
onEngineProcessKeyEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineProcessKeyEventCallback)
-> m SignalHandlerId
onEngineProcessKeyEvent a
obj (?self::a) => EngineProcessKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineProcessKeyEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineProcessKeyEventCallback
EngineProcessKeyEventCallback
cb
    let wrapped' :: C_EngineProcessKeyEventCallback
wrapped' = (a -> EngineProcessKeyEventCallback)
-> C_EngineProcessKeyEventCallback
forall a.
GObject a =>
(a -> EngineProcessKeyEventCallback)
-> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback a -> EngineProcessKeyEventCallback
wrapped
    FunPtr C_EngineProcessKeyEventCallback
wrapped'' <- C_EngineProcessKeyEventCallback
-> IO (FunPtr C_EngineProcessKeyEventCallback)
mk_EngineProcessKeyEventCallback C_EngineProcessKeyEventCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineProcessKeyEvent :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineProcessKeyEventCallback) -> m SignalHandlerId
afterEngineProcessKeyEvent :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineProcessKeyEventCallback)
-> m SignalHandlerId
afterEngineProcessKeyEvent a
obj (?self::a) => EngineProcessKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineProcessKeyEventCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineProcessKeyEventCallback
EngineProcessKeyEventCallback
cb
    let wrapped' :: C_EngineProcessKeyEventCallback
wrapped' = (a -> EngineProcessKeyEventCallback)
-> C_EngineProcessKeyEventCallback
forall a.
GObject a =>
(a -> EngineProcessKeyEventCallback)
-> C_EngineProcessKeyEventCallback
wrap_EngineProcessKeyEventCallback a -> EngineProcessKeyEventCallback
wrapped
    FunPtr C_EngineProcessKeyEventCallback
wrapped'' <- C_EngineProcessKeyEventCallback
-> IO (FunPtr C_EngineProcessKeyEventCallback)
mk_EngineProcessKeyEventCallback C_EngineProcessKeyEventCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::process-key-event"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:processKeyEvent"})

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

type C_EnginePropertyActivateCallback =
    Ptr Engine ->                           -- 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_EnginePropertyActivateCallback :: 
    GObject a => (a -> EnginePropertyActivateCallback) ->
    C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback :: forall a.
GObject a =>
(a -> EnginePropertyActivateCallback)
-> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback a -> EnginePropertyActivateCallback
gi'cb Ptr Engine
gi'selfPtr CString
name Word32
state Ptr ()
_ = do
    Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EnginePropertyActivateCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EnginePropertyActivateCallback) -> m SignalHandlerId
onEnginePropertyActivate :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EnginePropertyActivateCallback)
-> m SignalHandlerId
onEnginePropertyActivate a
obj (?self::a) => EnginePropertyActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EnginePropertyActivateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EnginePropertyActivateCallback
EnginePropertyActivateCallback
cb
    let wrapped' :: C_EnginePropertyActivateCallback
wrapped' = (a -> EnginePropertyActivateCallback)
-> C_EnginePropertyActivateCallback
forall a.
GObject a =>
(a -> EnginePropertyActivateCallback)
-> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback a -> EnginePropertyActivateCallback
wrapped
    FunPtr C_EnginePropertyActivateCallback
wrapped'' <- C_EnginePropertyActivateCallback
-> IO (FunPtr C_EnginePropertyActivateCallback)
mk_EnginePropertyActivateCallback C_EnginePropertyActivateCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEnginePropertyActivate :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EnginePropertyActivateCallback) -> m SignalHandlerId
afterEnginePropertyActivate :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EnginePropertyActivateCallback)
-> m SignalHandlerId
afterEnginePropertyActivate a
obj (?self::a) => EnginePropertyActivateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EnginePropertyActivateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EnginePropertyActivateCallback
EnginePropertyActivateCallback
cb
    let wrapped' :: C_EnginePropertyActivateCallback
wrapped' = (a -> EnginePropertyActivateCallback)
-> C_EnginePropertyActivateCallback
forall a.
GObject a =>
(a -> EnginePropertyActivateCallback)
-> C_EnginePropertyActivateCallback
wrap_EnginePropertyActivateCallback a -> EnginePropertyActivateCallback
wrapped
    FunPtr C_EnginePropertyActivateCallback
wrapped'' <- C_EnginePropertyActivateCallback
-> IO (FunPtr C_EnginePropertyActivateCallback)
mk_EnginePropertyActivateCallback C_EnginePropertyActivateCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::property-activate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:propertyActivate"})

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

type C_EnginePropertyHideCallback =
    Ptr Engine ->                           -- 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_EnginePropertyHideCallback :: 
    GObject a => (a -> EnginePropertyHideCallback) ->
    C_EnginePropertyHideCallback
wrap_EnginePropertyHideCallback :: forall a.
GObject a =>
(a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
wrap_EnginePropertyHideCallback a -> EngineFocusOutIdCallback
gi'cb Ptr Engine
gi'selfPtr CString
name Ptr ()
_ = do
    Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineFocusOutIdCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EnginePropertyHideCallback) -> m SignalHandlerId
onEnginePropertyHide :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => EngineFocusOutIdCallback) -> m SignalHandlerId
onEnginePropertyHide a
obj (?self::a) => EngineFocusOutIdCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineFocusOutIdCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineFocusOutIdCallback
EngineFocusOutIdCallback
cb
    let wrapped' :: C_EngineFocusOutIdCallback
wrapped' = (a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
forall a.
GObject a =>
(a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
wrap_EnginePropertyHideCallback a -> EngineFocusOutIdCallback
wrapped
    FunPtr C_EngineFocusOutIdCallback
wrapped'' <- C_EngineFocusOutIdCallback
-> IO (FunPtr C_EngineFocusOutIdCallback)
mk_EnginePropertyHideCallback C_EngineFocusOutIdCallback
wrapped'
    a
-> Text
-> FunPtr C_EngineFocusOutIdCallback
-> 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_EngineFocusOutIdCallback
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEnginePropertyHide :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EnginePropertyHideCallback) -> m SignalHandlerId
afterEnginePropertyHide :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => EngineFocusOutIdCallback) -> m SignalHandlerId
afterEnginePropertyHide a
obj (?self::a) => EngineFocusOutIdCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineFocusOutIdCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineFocusOutIdCallback
EngineFocusOutIdCallback
cb
    let wrapped' :: C_EngineFocusOutIdCallback
wrapped' = (a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
forall a.
GObject a =>
(a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
wrap_EnginePropertyHideCallback a -> EngineFocusOutIdCallback
wrapped
    FunPtr C_EngineFocusOutIdCallback
wrapped'' <- C_EngineFocusOutIdCallback
-> IO (FunPtr C_EngineFocusOutIdCallback)
mk_EnginePropertyHideCallback C_EngineFocusOutIdCallback
wrapped'
    a
-> Text
-> FunPtr C_EngineFocusOutIdCallback
-> 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_EngineFocusOutIdCallback
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::property-hide"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:propertyHide"})

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

type C_EnginePropertyShowCallback =
    Ptr Engine ->                           -- 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_EnginePropertyShowCallback :: 
    GObject a => (a -> EnginePropertyShowCallback) ->
    C_EnginePropertyShowCallback
wrap_EnginePropertyShowCallback :: forall a.
GObject a =>
(a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
wrap_EnginePropertyShowCallback a -> EngineFocusOutIdCallback
gi'cb Ptr Engine
gi'selfPtr CString
name Ptr ()
_ = do
    Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineFocusOutIdCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EnginePropertyShowCallback) -> m SignalHandlerId
onEnginePropertyShow :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => EngineFocusOutIdCallback) -> m SignalHandlerId
onEnginePropertyShow a
obj (?self::a) => EngineFocusOutIdCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineFocusOutIdCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineFocusOutIdCallback
EngineFocusOutIdCallback
cb
    let wrapped' :: C_EngineFocusOutIdCallback
wrapped' = (a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
forall a.
GObject a =>
(a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
wrap_EnginePropertyShowCallback a -> EngineFocusOutIdCallback
wrapped
    FunPtr C_EngineFocusOutIdCallback
wrapped'' <- C_EngineFocusOutIdCallback
-> IO (FunPtr C_EngineFocusOutIdCallback)
mk_EnginePropertyShowCallback C_EngineFocusOutIdCallback
wrapped'
    a
-> Text
-> FunPtr C_EngineFocusOutIdCallback
-> 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_EngineFocusOutIdCallback
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEnginePropertyShow :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EnginePropertyShowCallback) -> m SignalHandlerId
afterEnginePropertyShow :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => EngineFocusOutIdCallback) -> m SignalHandlerId
afterEnginePropertyShow a
obj (?self::a) => EngineFocusOutIdCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineFocusOutIdCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineFocusOutIdCallback
EngineFocusOutIdCallback
cb
    let wrapped' :: C_EngineFocusOutIdCallback
wrapped' = (a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
forall a.
GObject a =>
(a -> EngineFocusOutIdCallback) -> C_EngineFocusOutIdCallback
wrap_EnginePropertyShowCallback a -> EngineFocusOutIdCallback
wrapped
    FunPtr C_EngineFocusOutIdCallback
wrapped'' <- C_EngineFocusOutIdCallback
-> IO (FunPtr C_EngineFocusOutIdCallback)
mk_EnginePropertyShowCallback C_EngineFocusOutIdCallback
wrapped'
    a
-> Text
-> FunPtr C_EngineFocusOutIdCallback
-> 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_EngineFocusOutIdCallback
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::property-show"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:propertyShow"})

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

type C_EngineResetCallback =
    Ptr Engine ->                           -- 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_EngineResetCallback :: 
    GObject a => (a -> EngineResetCallback) ->
    C_EngineResetCallback
wrap_EngineResetCallback :: forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineResetCallback a -> IO ()
gi'cb Ptr Engine
gi'selfPtr Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> IO ()
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self) 


-- | 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 -> ((?self :: a) => EngineResetCallback) -> m SignalHandlerId
onEngineReset :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onEngineReset a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineResetCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineResetCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineReset :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineResetCallback) -> m SignalHandlerId
afterEngineReset :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterEngineReset a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_EngineCursorDownCallback
wrapped' = (a -> IO ()) -> C_EngineCursorDownCallback
forall a. GObject a => (a -> IO ()) -> C_EngineCursorDownCallback
wrap_EngineResetCallback a -> IO ()
wrapped
    FunPtr C_EngineCursorDownCallback
wrapped'' <- C_EngineCursorDownCallback
-> IO (FunPtr C_EngineCursorDownCallback)
mk_EngineResetCallback C_EngineCursorDownCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::reset"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:reset"})

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

type C_EngineSetCapabilitiesCallback =
    Ptr Engine ->                           -- 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_EngineSetCapabilitiesCallback :: 
    GObject a => (a -> EngineSetCapabilitiesCallback) ->
    C_EngineSetCapabilitiesCallback
wrap_EngineSetCapabilitiesCallback :: forall a.
GObject a =>
(a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback a -> EngineCancelHandWritingCallback
gi'cb Ptr Engine
gi'selfPtr Word32
caps Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineCancelHandWritingCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EngineSetCapabilitiesCallback) -> m SignalHandlerId
onEngineSetCapabilities :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineCancelHandWritingCallback)
-> m SignalHandlerId
onEngineSetCapabilities a
obj (?self::a) => EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineCancelHandWritingCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineCancelHandWritingCallback
EngineCancelHandWritingCallback
cb
    let wrapped' :: C_EngineCancelHandWritingCallback
wrapped' = (a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
forall a.
GObject a =>
(a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback a -> EngineCancelHandWritingCallback
wrapped
    FunPtr C_EngineCancelHandWritingCallback
wrapped'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineSetCapabilitiesCallback C_EngineCancelHandWritingCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineSetCapabilities :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineSetCapabilitiesCallback) -> m SignalHandlerId
afterEngineSetCapabilities :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineCancelHandWritingCallback)
-> m SignalHandlerId
afterEngineSetCapabilities a
obj (?self::a) => EngineCancelHandWritingCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineCancelHandWritingCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineCancelHandWritingCallback
EngineCancelHandWritingCallback
cb
    let wrapped' :: C_EngineCancelHandWritingCallback
wrapped' = (a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
forall a.
GObject a =>
(a -> EngineCancelHandWritingCallback)
-> C_EngineCancelHandWritingCallback
wrap_EngineSetCapabilitiesCallback a -> EngineCancelHandWritingCallback
wrapped
    FunPtr C_EngineCancelHandWritingCallback
wrapped'' <- C_EngineCancelHandWritingCallback
-> IO (FunPtr C_EngineCancelHandWritingCallback)
mk_EngineSetCapabilitiesCallback C_EngineCancelHandWritingCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::set-capabilities"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:setCapabilities"})

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

type C_EngineSetContentTypeCallback =
    Ptr Engine ->                           -- 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_EngineSetContentTypeCallback :: 
    GObject a => (a -> EngineSetContentTypeCallback) ->
    C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback :: forall a.
GObject a =>
(a -> EngineSetContentTypeCallback)
-> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback a -> EngineSetContentTypeCallback
gi'cb Ptr Engine
gi'selfPtr Word32
purpose Word32
hints Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineSetContentTypeCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EngineSetContentTypeCallback) -> m SignalHandlerId
onEngineSetContentType :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineSetContentTypeCallback)
-> m SignalHandlerId
onEngineSetContentType a
obj (?self::a) => EngineSetContentTypeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineSetContentTypeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineSetContentTypeCallback
EngineSetContentTypeCallback
cb
    let wrapped' :: C_EngineSetContentTypeCallback
wrapped' = (a -> EngineSetContentTypeCallback)
-> C_EngineSetContentTypeCallback
forall a.
GObject a =>
(a -> EngineSetContentTypeCallback)
-> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback a -> EngineSetContentTypeCallback
wrapped
    FunPtr C_EngineSetContentTypeCallback
wrapped'' <- C_EngineSetContentTypeCallback
-> IO (FunPtr C_EngineSetContentTypeCallback)
mk_EngineSetContentTypeCallback C_EngineSetContentTypeCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineSetContentType :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineSetContentTypeCallback) -> m SignalHandlerId
afterEngineSetContentType :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineSetContentTypeCallback)
-> m SignalHandlerId
afterEngineSetContentType a
obj (?self::a) => EngineSetContentTypeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineSetContentTypeCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineSetContentTypeCallback
EngineSetContentTypeCallback
cb
    let wrapped' :: C_EngineSetContentTypeCallback
wrapped' = (a -> EngineSetContentTypeCallback)
-> C_EngineSetContentTypeCallback
forall a.
GObject a =>
(a -> EngineSetContentTypeCallback)
-> C_EngineSetContentTypeCallback
wrap_EngineSetContentTypeCallback a -> EngineSetContentTypeCallback
wrapped
    FunPtr C_EngineSetContentTypeCallback
wrapped'' <- C_EngineSetContentTypeCallback
-> IO (FunPtr C_EngineSetContentTypeCallback)
mk_EngineSetContentTypeCallback C_EngineSetContentTypeCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::set-content-type"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:setContentType"})

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

type C_EngineSetCursorLocationCallback =
    Ptr Engine ->                           -- 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_EngineSetCursorLocationCallback :: 
    GObject a => (a -> EngineSetCursorLocationCallback) ->
    C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback :: forall a.
GObject a =>
(a -> EngineSetCursorLocationCallback)
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback a -> EngineSetCursorLocationCallback
gi'cb Ptr Engine
gi'selfPtr Int32
x Int32
y Int32
w Int32
h Ptr ()
_ = do
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineSetCursorLocationCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EngineSetCursorLocationCallback) -> m SignalHandlerId
onEngineSetCursorLocation :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineSetCursorLocationCallback)
-> m SignalHandlerId
onEngineSetCursorLocation a
obj (?self::a) => EngineSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineSetCursorLocationCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineSetCursorLocationCallback
EngineSetCursorLocationCallback
cb
    let wrapped' :: C_EngineSetCursorLocationCallback
wrapped' = (a -> EngineSetCursorLocationCallback)
-> C_EngineSetCursorLocationCallback
forall a.
GObject a =>
(a -> EngineSetCursorLocationCallback)
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback a -> EngineSetCursorLocationCallback
wrapped
    FunPtr C_EngineSetCursorLocationCallback
wrapped'' <- C_EngineSetCursorLocationCallback
-> IO (FunPtr C_EngineSetCursorLocationCallback)
mk_EngineSetCursorLocationCallback C_EngineSetCursorLocationCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineSetCursorLocation :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineSetCursorLocationCallback) -> m SignalHandlerId
afterEngineSetCursorLocation :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineSetCursorLocationCallback)
-> m SignalHandlerId
afterEngineSetCursorLocation a
obj (?self::a) => EngineSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineSetCursorLocationCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineSetCursorLocationCallback
EngineSetCursorLocationCallback
cb
    let wrapped' :: C_EngineSetCursorLocationCallback
wrapped' = (a -> EngineSetCursorLocationCallback)
-> C_EngineSetCursorLocationCallback
forall a.
GObject a =>
(a -> EngineSetCursorLocationCallback)
-> C_EngineSetCursorLocationCallback
wrap_EngineSetCursorLocationCallback a -> EngineSetCursorLocationCallback
wrapped
    FunPtr C_EngineSetCursorLocationCallback
wrapped'' <- C_EngineSetCursorLocationCallback
-> IO (FunPtr C_EngineSetCursorLocationCallback)
mk_EngineSetCursorLocationCallback C_EngineSetCursorLocationCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::set-cursor-location"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:setCursorLocation"})

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

type C_EngineSetSurroundingTextCallback =
    Ptr Engine ->                           -- 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_EngineSetSurroundingTextCallback :: 
    GObject a => (a -> EngineSetSurroundingTextCallback) ->
    C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback :: forall a.
GObject a =>
(a -> EngineSetSurroundingTextCallback)
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback a -> EngineSetSurroundingTextCallback
gi'cb Ptr Engine
gi'selfPtr 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
    Ptr Engine -> (Engine -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Engine
gi'selfPtr ((Engine -> IO ()) -> IO ()) -> (Engine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Engine
gi'self -> a -> EngineSetSurroundingTextCallback
gi'cb (Engine -> a
forall a b. Coercible a b => a -> b
Coerce.coerce Engine
gi'self)  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 -> ((?self :: a) => EngineSetSurroundingTextCallback) -> m SignalHandlerId
onEngineSetSurroundingText :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineSetSurroundingTextCallback)
-> m SignalHandlerId
onEngineSetSurroundingText a
obj (?self::a) => EngineSetSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineSetSurroundingTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineSetSurroundingTextCallback
EngineSetSurroundingTextCallback
cb
    let wrapped' :: C_EngineSetSurroundingTextCallback
wrapped' = (a -> EngineSetSurroundingTextCallback)
-> C_EngineSetSurroundingTextCallback
forall a.
GObject a =>
(a -> EngineSetSurroundingTextCallback)
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback a -> EngineSetSurroundingTextCallback
wrapped
    FunPtr C_EngineSetSurroundingTextCallback
wrapped'' <- C_EngineSetSurroundingTextCallback
-> IO (FunPtr C_EngineSetSurroundingTextCallback)
mk_EngineSetSurroundingTextCallback C_EngineSetSurroundingTextCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterEngineSetSurroundingText :: (IsEngine a, MonadIO m) => a -> ((?self :: a) => EngineSetSurroundingTextCallback) -> m SignalHandlerId
afterEngineSetSurroundingText :: forall a (m :: * -> *).
(IsEngine a, MonadIO m) =>
a
-> ((?self::a) => EngineSetSurroundingTextCallback)
-> m SignalHandlerId
afterEngineSetSurroundingText a
obj (?self::a) => EngineSetSurroundingTextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> EngineSetSurroundingTextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => EngineSetSurroundingTextCallback
EngineSetSurroundingTextCallback
cb
    let wrapped' :: C_EngineSetSurroundingTextCallback
wrapped' = (a -> EngineSetSurroundingTextCallback)
-> C_EngineSetSurroundingTextCallback
forall a.
GObject a =>
(a -> EngineSetSurroundingTextCallback)
-> C_EngineSetSurroundingTextCallback
wrap_EngineSetSurroundingTextCallback a -> EngineSetSurroundingTextCallback
wrapped
    FunPtr C_EngineSetSurroundingTextCallback
wrapped'' <- C_EngineSetSurroundingTextCallback
-> IO (FunPtr C_EngineSetSurroundingTextCallback)
mk_EngineSetSurroundingTextCallback C_EngineSetSurroundingTextCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine::set-surrounding-text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:signal:setSurroundingText"})

#endif

-- VVV Prop "active-surrounding-text"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@active-surrounding-text@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructEngineActiveSurroundingText :: (IsEngine o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructEngineActiveSurroundingText :: forall o (m :: * -> *).
(IsEngine o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructEngineActiveSurroundingText Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"active-surrounding-text" Bool
val

#if defined(ENABLE_OVERLOADING)
data EngineActiveSurroundingTextPropertyInfo
instance AttrInfo EngineActiveSurroundingTextPropertyInfo where
    type AttrAllowedOps EngineActiveSurroundingTextPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint EngineActiveSurroundingTextPropertyInfo = IsEngine
    type AttrSetTypeConstraint EngineActiveSurroundingTextPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint EngineActiveSurroundingTextPropertyInfo = (~) Bool
    type AttrTransferType EngineActiveSurroundingTextPropertyInfo = Bool
    type AttrGetType EngineActiveSurroundingTextPropertyInfo = Bool
    type AttrLabel EngineActiveSurroundingTextPropertyInfo = "active-surrounding-text"
    type AttrOrigin EngineActiveSurroundingTextPropertyInfo = Engine
    attrGet = getEngineActiveSurroundingText
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructEngineActiveSurroundingText
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.activeSurroundingText"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:attr:activeSurroundingText"
        })
#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 a. IO a -> m a
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 a. IO a -> m a
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 a. IO a -> IO a
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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineName"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:attr:engineName"
        })
#endif

-- VVV Prop "has-focus-id"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

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

-- | Construct a `GValueConstruct` with valid value for the “@has-focus-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructEngineHasFocusId :: (IsEngine o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructEngineHasFocusId :: forall o (m :: * -> *).
(IsEngine o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructEngineHasFocusId Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"has-focus-id" Bool
val

#if defined(ENABLE_OVERLOADING)
data EngineHasFocusIdPropertyInfo
instance AttrInfo EngineHasFocusIdPropertyInfo where
    type AttrAllowedOps EngineHasFocusIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint EngineHasFocusIdPropertyInfo = IsEngine
    type AttrSetTypeConstraint EngineHasFocusIdPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint EngineHasFocusIdPropertyInfo = (~) Bool
    type AttrTransferType EngineHasFocusIdPropertyInfo = Bool
    type AttrGetType EngineHasFocusIdPropertyInfo = Bool
    type AttrLabel EngineHasFocusIdPropertyInfo = "has-focus-id"
    type AttrOrigin EngineHasFocusIdPropertyInfo = Engine
    attrGet = getEngineHasFocusId
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructEngineHasFocusId
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.hasFocusId"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#g:attr:hasFocusId"
        })
#endif

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

#if defined(ENABLE_OVERLOADING)
engineActiveSurroundingText :: AttrLabelProxy "activeSurroundingText"
engineActiveSurroundingText = AttrLabelProxy

engineEngineName :: AttrLabelProxy "engineName"
engineEngineName = AttrLabelProxy

engineHasFocusId :: AttrLabelProxy "hasFocusId"
engineHasFocusId = 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), '("focusInId", EngineFocusInIdSignalInfo), '("focusOut", EngineFocusOutSignalInfo), '("focusOutId", EngineFocusOutIdSignalInfo), '("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, DK.Type)])

#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 a. IO a -> m a
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 a. a -> IO a
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 a. IO a -> m a
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 a. a -> IO a
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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineCommitText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineDeleteSurroundingText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineForwardKeyEvent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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: [Engine::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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineGetContentType",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineGetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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
-- [Engine::enable]("GI.IBus.Objects.Engine#g:signal:enable") handler, with both /@text@/ and /@cursor@/ set to
-- 'P.Nothing'.
-- 
-- See also: [Engine::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 a. IO a -> m a
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineGetSurroundingText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineHideAuxiliaryText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineHideLookupTable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineHidePreeditText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineRegisterProperties",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineShowAuxiliaryText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineShowLookupTable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineShowPreeditText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineUpdateAuxiliaryText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineUpdateLookupTable",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineUpdateLookupTableFast",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineUpdatePreeditText",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineUpdatePreeditTextWithMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/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 a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr 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 a. a -> IO a
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 = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.IBus.Objects.Engine.engineUpdateProperty",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ibus-1.5.7/docs/GI-IBus-Objects-Engine.html#v:engineUpdateProperty"
        })


#endif