{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An IBusPanelService is a base class for UI services.
-- Developers can \"extend\" this class for panel UI development.

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

module GI.IBus.Objects.PanelService
    ( 
#if defined(ENABLE_OVERLOADING)
    PanelServiceHidePreeditTextReceivedMethodInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    PanelServiceShowPreeditTextReceivedMethodInfo,
#endif

-- * Exported types
    PanelService(..)                        ,
    IsPanelService                          ,
    toPanelService                          ,


 -- * 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"), [candidateClicked]("GI.IBus.Objects.PanelService#g:method:candidateClicked"), [commitText]("GI.IBus.Objects.PanelService#g:method:commitText"), [cursorDown]("GI.IBus.Objects.PanelService#g:method:cursorDown"), [cursorUp]("GI.IBus.Objects.PanelService#g:method:cursorUp"), [destroy]("GI.IBus.Objects.Object#g:method:destroy"), [emitSignal]("GI.IBus.Objects.Service#g:method:emitSignal"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hidePreeditTextReceived]("GI.IBus.Objects.PanelService#g:method:hidePreeditTextReceived"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [pageDown]("GI.IBus.Objects.PanelService#g:method:pageDown"), [pageUp]("GI.IBus.Objects.PanelService#g:method:pageUp"), [panelExtension]("GI.IBus.Objects.PanelService#g:method:panelExtension"), [propertyActivate]("GI.IBus.Objects.PanelService#g:method:propertyActivate"), [propertyHide]("GI.IBus.Objects.PanelService#g:method:propertyHide"), [propertyShow]("GI.IBus.Objects.PanelService#g:method:propertyShow"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [register]("GI.IBus.Objects.Service#g:method:register"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [showPreeditTextReceived]("GI.IBus.Objects.PanelService#g:method:showPreeditTextReceived"), [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"), [updateAuxiliaryTextReceived]("GI.IBus.Objects.PanelService#g:method:updateAuxiliaryTextReceived"), [updateLookupTableReceived]("GI.IBus.Objects.PanelService#g:method:updateLookupTableReceived"), [updatePreeditTextReceived]("GI.IBus.Objects.PanelService#g:method:updatePreeditTextReceived"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getConnection]("GI.IBus.Objects.Service#g:method:getConnection"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getObjectPath]("GI.IBus.Objects.Service#g:method:getObjectPath"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== 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)
    ResolvePanelServiceMethod               ,
#endif

-- ** candidateClicked #method:candidateClicked#

#if defined(ENABLE_OVERLOADING)
    PanelServiceCandidateClickedMethodInfo  ,
#endif
    panelServiceCandidateClicked            ,


-- ** commitText #method:commitText#

#if defined(ENABLE_OVERLOADING)
    PanelServiceCommitTextMethodInfo        ,
#endif
    panelServiceCommitText                  ,


-- ** cursorDown #method:cursorDown#

#if defined(ENABLE_OVERLOADING)
    PanelServiceCursorDownMethodInfo        ,
#endif
    panelServiceCursorDown                  ,


-- ** cursorUp #method:cursorUp#

#if defined(ENABLE_OVERLOADING)
    PanelServiceCursorUpMethodInfo          ,
#endif
    panelServiceCursorUp                    ,


-- ** new #method:new#

    panelServiceNew                         ,


-- ** pageDown #method:pageDown#

#if defined(ENABLE_OVERLOADING)
    PanelServicePageDownMethodInfo          ,
#endif
    panelServicePageDown                    ,


-- ** pageUp #method:pageUp#

#if defined(ENABLE_OVERLOADING)
    PanelServicePageUpMethodInfo            ,
#endif
    panelServicePageUp                      ,


-- ** panelExtension #method:panelExtension#

#if defined(ENABLE_OVERLOADING)
    PanelServicePanelExtensionMethodInfo    ,
#endif
    panelServicePanelExtension              ,


-- ** propertyActivate #method:propertyActivate#

#if defined(ENABLE_OVERLOADING)
    PanelServicePropertyActivateMethodInfo  ,
#endif
    panelServicePropertyActivate            ,


-- ** propertyHide #method:propertyHide#

#if defined(ENABLE_OVERLOADING)
    PanelServicePropertyHideMethodInfo      ,
#endif
    panelServicePropertyHide                ,


-- ** propertyShow #method:propertyShow#

#if defined(ENABLE_OVERLOADING)
    PanelServicePropertyShowMethodInfo      ,
#endif
    panelServicePropertyShow                ,


-- ** updateAuxiliaryTextReceived #method:updateAuxiliaryTextReceived#

#if defined(ENABLE_OVERLOADING)
    PanelServiceUpdateAuxiliaryTextReceivedMethodInfo,
#endif
    panelServiceUpdateAuxiliaryTextReceived ,


-- ** updateLookupTableReceived #method:updateLookupTableReceived#

#if defined(ENABLE_OVERLOADING)
    PanelServiceUpdateLookupTableReceivedMethodInfo,
#endif
    panelServiceUpdateLookupTableReceived   ,


-- ** updatePreeditTextReceived #method:updatePreeditTextReceived#

#if defined(ENABLE_OVERLOADING)
    PanelServiceUpdatePreeditTextReceivedMethodInfo,
#endif
    panelServiceUpdatePreeditTextReceived   ,




 -- * Signals


-- ** candidateClickedLookupTable #signal:candidateClickedLookupTable#

    C_PanelServiceCandidateClickedLookupTableCallback,
    PanelServiceCandidateClickedLookupTableCallback,
#if defined(ENABLE_OVERLOADING)
    PanelServiceCandidateClickedLookupTableSignalInfo,
#endif
    afterPanelServiceCandidateClickedLookupTable,
    genClosure_PanelServiceCandidateClickedLookupTable,
    mk_PanelServiceCandidateClickedLookupTableCallback,
    noPanelServiceCandidateClickedLookupTableCallback,
    onPanelServiceCandidateClickedLookupTable,
    wrap_PanelServiceCandidateClickedLookupTableCallback,


-- ** commitTextReceived #signal:commitTextReceived#

    C_PanelServiceCommitTextReceivedCallback,
    PanelServiceCommitTextReceivedCallback  ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceCommitTextReceivedSignalInfo,
#endif
    afterPanelServiceCommitTextReceived     ,
    genClosure_PanelServiceCommitTextReceived,
    mk_PanelServiceCommitTextReceivedCallback,
    noPanelServiceCommitTextReceivedCallback,
    onPanelServiceCommitTextReceived        ,
    wrap_PanelServiceCommitTextReceivedCallback,


-- ** cursorDownLookupTable #signal:cursorDownLookupTable#

    C_PanelServiceCursorDownLookupTableCallback,
    PanelServiceCursorDownLookupTableCallback,
#if defined(ENABLE_OVERLOADING)
    PanelServiceCursorDownLookupTableSignalInfo,
#endif
    afterPanelServiceCursorDownLookupTable  ,
    genClosure_PanelServiceCursorDownLookupTable,
    mk_PanelServiceCursorDownLookupTableCallback,
    noPanelServiceCursorDownLookupTableCallback,
    onPanelServiceCursorDownLookupTable     ,
    wrap_PanelServiceCursorDownLookupTableCallback,


-- ** cursorUpLookupTable #signal:cursorUpLookupTable#

    C_PanelServiceCursorUpLookupTableCallback,
    PanelServiceCursorUpLookupTableCallback ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceCursorUpLookupTableSignalInfo,
#endif
    afterPanelServiceCursorUpLookupTable    ,
    genClosure_PanelServiceCursorUpLookupTable,
    mk_PanelServiceCursorUpLookupTableCallback,
    noPanelServiceCursorUpLookupTableCallback,
    onPanelServiceCursorUpLookupTable       ,
    wrap_PanelServiceCursorUpLookupTableCallback,


-- ** destroyContext #signal:destroyContext#

    C_PanelServiceDestroyContextCallback    ,
    PanelServiceDestroyContextCallback      ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceDestroyContextSignalInfo    ,
#endif
    afterPanelServiceDestroyContext         ,
    genClosure_PanelServiceDestroyContext   ,
    mk_PanelServiceDestroyContextCallback   ,
    noPanelServiceDestroyContextCallback    ,
    onPanelServiceDestroyContext            ,
    wrap_PanelServiceDestroyContextCallback ,


-- ** focusIn #signal:focusIn#

    C_PanelServiceFocusInCallback           ,
    PanelServiceFocusInCallback             ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceFocusInSignalInfo           ,
#endif
    afterPanelServiceFocusIn                ,
    genClosure_PanelServiceFocusIn          ,
    mk_PanelServiceFocusInCallback          ,
    noPanelServiceFocusInCallback           ,
    onPanelServiceFocusIn                   ,
    wrap_PanelServiceFocusInCallback        ,


-- ** focusOut #signal:focusOut#

    C_PanelServiceFocusOutCallback          ,
    PanelServiceFocusOutCallback            ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceFocusOutSignalInfo          ,
#endif
    afterPanelServiceFocusOut               ,
    genClosure_PanelServiceFocusOut         ,
    mk_PanelServiceFocusOutCallback         ,
    noPanelServiceFocusOutCallback          ,
    onPanelServiceFocusOut                  ,
    wrap_PanelServiceFocusOutCallback       ,


-- ** hideAuxiliaryText #signal:hideAuxiliaryText#

    C_PanelServiceHideAuxiliaryTextCallback ,
    PanelServiceHideAuxiliaryTextCallback   ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceHideAuxiliaryTextSignalInfo ,
#endif
    afterPanelServiceHideAuxiliaryText      ,
    genClosure_PanelServiceHideAuxiliaryText,
    mk_PanelServiceHideAuxiliaryTextCallback,
    noPanelServiceHideAuxiliaryTextCallback ,
    onPanelServiceHideAuxiliaryText         ,
    wrap_PanelServiceHideAuxiliaryTextCallback,


-- ** hideLanguageBar #signal:hideLanguageBar#

    C_PanelServiceHideLanguageBarCallback   ,
    PanelServiceHideLanguageBarCallback     ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceHideLanguageBarSignalInfo   ,
#endif
    afterPanelServiceHideLanguageBar        ,
    genClosure_PanelServiceHideLanguageBar  ,
    mk_PanelServiceHideLanguageBarCallback  ,
    noPanelServiceHideLanguageBarCallback   ,
    onPanelServiceHideLanguageBar           ,
    wrap_PanelServiceHideLanguageBarCallback,


-- ** hideLookupTable #signal:hideLookupTable#

    C_PanelServiceHideLookupTableCallback   ,
    PanelServiceHideLookupTableCallback     ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceHideLookupTableSignalInfo   ,
#endif
    afterPanelServiceHideLookupTable        ,
    genClosure_PanelServiceHideLookupTable  ,
    mk_PanelServiceHideLookupTableCallback  ,
    noPanelServiceHideLookupTableCallback   ,
    onPanelServiceHideLookupTable           ,
    wrap_PanelServiceHideLookupTableCallback,


-- ** hidePreeditText #signal:hidePreeditText#

    C_PanelServiceHidePreeditTextCallback   ,
    PanelServiceHidePreeditTextCallback     ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceHidePreeditTextSignalInfo   ,
#endif
    afterPanelServiceHidePreeditText        ,
    genClosure_PanelServiceHidePreeditText  ,
    mk_PanelServiceHidePreeditTextCallback  ,
    noPanelServiceHidePreeditTextCallback   ,
    onPanelServiceHidePreeditText           ,
    wrap_PanelServiceHidePreeditTextCallback,


-- ** pageDownLookupTable #signal:pageDownLookupTable#

    C_PanelServicePageDownLookupTableCallback,
    PanelServicePageDownLookupTableCallback ,
#if defined(ENABLE_OVERLOADING)
    PanelServicePageDownLookupTableSignalInfo,
#endif
    afterPanelServicePageDownLookupTable    ,
    genClosure_PanelServicePageDownLookupTable,
    mk_PanelServicePageDownLookupTableCallback,
    noPanelServicePageDownLookupTableCallback,
    onPanelServicePageDownLookupTable       ,
    wrap_PanelServicePageDownLookupTableCallback,


-- ** pageUpLookupTable #signal:pageUpLookupTable#

    C_PanelServicePageUpLookupTableCallback ,
    PanelServicePageUpLookupTableCallback   ,
#if defined(ENABLE_OVERLOADING)
    PanelServicePageUpLookupTableSignalInfo ,
#endif
    afterPanelServicePageUpLookupTable      ,
    genClosure_PanelServicePageUpLookupTable,
    mk_PanelServicePageUpLookupTableCallback,
    noPanelServicePageUpLookupTableCallback ,
    onPanelServicePageUpLookupTable         ,
    wrap_PanelServicePageUpLookupTableCallback,


-- ** panelExtensionReceived #signal:panelExtensionReceived#

    C_PanelServicePanelExtensionReceivedCallback,
    PanelServicePanelExtensionReceivedCallback,
#if defined(ENABLE_OVERLOADING)
    PanelServicePanelExtensionReceivedSignalInfo,
#endif
    afterPanelServicePanelExtensionReceived ,
    genClosure_PanelServicePanelExtensionReceived,
    mk_PanelServicePanelExtensionReceivedCallback,
    noPanelServicePanelExtensionReceivedCallback,
    onPanelServicePanelExtensionReceived    ,
    wrap_PanelServicePanelExtensionReceivedCallback,


-- ** processKeyEvent #signal:processKeyEvent#

    C_PanelServiceProcessKeyEventCallback   ,
    PanelServiceProcessKeyEventCallback     ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceProcessKeyEventSignalInfo   ,
#endif
    afterPanelServiceProcessKeyEvent        ,
    genClosure_PanelServiceProcessKeyEvent  ,
    mk_PanelServiceProcessKeyEventCallback  ,
    noPanelServiceProcessKeyEventCallback   ,
    onPanelServiceProcessKeyEvent           ,
    wrap_PanelServiceProcessKeyEventCallback,


-- ** registerProperties #signal:registerProperties#

    C_PanelServiceRegisterPropertiesCallback,
    PanelServiceRegisterPropertiesCallback  ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceRegisterPropertiesSignalInfo,
#endif
    afterPanelServiceRegisterProperties     ,
    genClosure_PanelServiceRegisterProperties,
    mk_PanelServiceRegisterPropertiesCallback,
    noPanelServiceRegisterPropertiesCallback,
    onPanelServiceRegisterProperties        ,
    wrap_PanelServiceRegisterPropertiesCallback,


-- ** reset #signal:reset#

    C_PanelServiceResetCallback             ,
    PanelServiceResetCallback               ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceResetSignalInfo             ,
#endif
    afterPanelServiceReset                  ,
    genClosure_PanelServiceReset            ,
    mk_PanelServiceResetCallback            ,
    noPanelServiceResetCallback             ,
    onPanelServiceReset                     ,
    wrap_PanelServiceResetCallback          ,


-- ** setContentType #signal:setContentType#

    C_PanelServiceSetContentTypeCallback    ,
    PanelServiceSetContentTypeCallback      ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceSetContentTypeSignalInfo    ,
#endif
    afterPanelServiceSetContentType         ,
    genClosure_PanelServiceSetContentType   ,
    mk_PanelServiceSetContentTypeCallback   ,
    noPanelServiceSetContentTypeCallback    ,
    onPanelServiceSetContentType            ,
    wrap_PanelServiceSetContentTypeCallback ,


-- ** setCursorLocation #signal:setCursorLocation#

    C_PanelServiceSetCursorLocationCallback ,
    PanelServiceSetCursorLocationCallback   ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceSetCursorLocationSignalInfo ,
#endif
    afterPanelServiceSetCursorLocation      ,
    genClosure_PanelServiceSetCursorLocation,
    mk_PanelServiceSetCursorLocationCallback,
    noPanelServiceSetCursorLocationCallback ,
    onPanelServiceSetCursorLocation         ,
    wrap_PanelServiceSetCursorLocationCallback,


-- ** setCursorLocationRelative #signal:setCursorLocationRelative#

    C_PanelServiceSetCursorLocationRelativeCallback,
    PanelServiceSetCursorLocationRelativeCallback,
#if defined(ENABLE_OVERLOADING)
    PanelServiceSetCursorLocationRelativeSignalInfo,
#endif
    afterPanelServiceSetCursorLocationRelative,
    genClosure_PanelServiceSetCursorLocationRelative,
    mk_PanelServiceSetCursorLocationRelativeCallback,
    noPanelServiceSetCursorLocationRelativeCallback,
    onPanelServiceSetCursorLocationRelative ,
    wrap_PanelServiceSetCursorLocationRelativeCallback,


-- ** showAuxiliaryText #signal:showAuxiliaryText#

    C_PanelServiceShowAuxiliaryTextCallback ,
    PanelServiceShowAuxiliaryTextCallback   ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceShowAuxiliaryTextSignalInfo ,
#endif
    afterPanelServiceShowAuxiliaryText      ,
    genClosure_PanelServiceShowAuxiliaryText,
    mk_PanelServiceShowAuxiliaryTextCallback,
    noPanelServiceShowAuxiliaryTextCallback ,
    onPanelServiceShowAuxiliaryText         ,
    wrap_PanelServiceShowAuxiliaryTextCallback,


-- ** showLanguageBar #signal:showLanguageBar#

    C_PanelServiceShowLanguageBarCallback   ,
    PanelServiceShowLanguageBarCallback     ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceShowLanguageBarSignalInfo   ,
#endif
    afterPanelServiceShowLanguageBar        ,
    genClosure_PanelServiceShowLanguageBar  ,
    mk_PanelServiceShowLanguageBarCallback  ,
    noPanelServiceShowLanguageBarCallback   ,
    onPanelServiceShowLanguageBar           ,
    wrap_PanelServiceShowLanguageBarCallback,


-- ** showLookupTable #signal:showLookupTable#

    C_PanelServiceShowLookupTableCallback   ,
    PanelServiceShowLookupTableCallback     ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceShowLookupTableSignalInfo   ,
#endif
    afterPanelServiceShowLookupTable        ,
    genClosure_PanelServiceShowLookupTable  ,
    mk_PanelServiceShowLookupTableCallback  ,
    noPanelServiceShowLookupTableCallback   ,
    onPanelServiceShowLookupTable           ,
    wrap_PanelServiceShowLookupTableCallback,


-- ** showPreeditText #signal:showPreeditText#

    C_PanelServiceShowPreeditTextCallback   ,
    PanelServiceShowPreeditTextCallback     ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceShowPreeditTextSignalInfo   ,
#endif
    afterPanelServiceShowPreeditText        ,
    genClosure_PanelServiceShowPreeditText  ,
    mk_PanelServiceShowPreeditTextCallback  ,
    noPanelServiceShowPreeditTextCallback   ,
    onPanelServiceShowPreeditText           ,
    wrap_PanelServiceShowPreeditTextCallback,


-- ** startSetup #signal:startSetup#

    C_PanelServiceStartSetupCallback        ,
    PanelServiceStartSetupCallback          ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceStartSetupSignalInfo        ,
#endif
    afterPanelServiceStartSetup             ,
    genClosure_PanelServiceStartSetup       ,
    mk_PanelServiceStartSetupCallback       ,
    noPanelServiceStartSetupCallback        ,
    onPanelServiceStartSetup                ,
    wrap_PanelServiceStartSetupCallback     ,


-- ** stateChanged #signal:stateChanged#

    C_PanelServiceStateChangedCallback      ,
    PanelServiceStateChangedCallback        ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceStateChangedSignalInfo      ,
#endif
    afterPanelServiceStateChanged           ,
    genClosure_PanelServiceStateChanged     ,
    mk_PanelServiceStateChangedCallback     ,
    noPanelServiceStateChangedCallback      ,
    onPanelServiceStateChanged              ,
    wrap_PanelServiceStateChangedCallback   ,


-- ** updateAuxiliaryText #signal:updateAuxiliaryText#

    C_PanelServiceUpdateAuxiliaryTextCallback,
    PanelServiceUpdateAuxiliaryTextCallback ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceUpdateAuxiliaryTextSignalInfo,
#endif
    afterPanelServiceUpdateAuxiliaryText    ,
    genClosure_PanelServiceUpdateAuxiliaryText,
    mk_PanelServiceUpdateAuxiliaryTextCallback,
    noPanelServiceUpdateAuxiliaryTextCallback,
    onPanelServiceUpdateAuxiliaryText       ,
    wrap_PanelServiceUpdateAuxiliaryTextCallback,


-- ** updateLookupTable #signal:updateLookupTable#

    C_PanelServiceUpdateLookupTableCallback ,
    PanelServiceUpdateLookupTableCallback   ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceUpdateLookupTableSignalInfo ,
#endif
    afterPanelServiceUpdateLookupTable      ,
    genClosure_PanelServiceUpdateLookupTable,
    mk_PanelServiceUpdateLookupTableCallback,
    noPanelServiceUpdateLookupTableCallback ,
    onPanelServiceUpdateLookupTable         ,
    wrap_PanelServiceUpdateLookupTableCallback,


-- ** updatePreeditText #signal:updatePreeditText#

    C_PanelServiceUpdatePreeditTextCallback ,
    PanelServiceUpdatePreeditTextCallback   ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceUpdatePreeditTextSignalInfo ,
#endif
    afterPanelServiceUpdatePreeditText      ,
    genClosure_PanelServiceUpdatePreeditText,
    mk_PanelServiceUpdatePreeditTextCallback,
    noPanelServiceUpdatePreeditTextCallback ,
    onPanelServiceUpdatePreeditText         ,
    wrap_PanelServiceUpdatePreeditTextCallback,


-- ** updateProperty #signal:updateProperty#

    C_PanelServiceUpdatePropertyCallback    ,
    PanelServiceUpdatePropertyCallback      ,
#if defined(ENABLE_OVERLOADING)
    PanelServiceUpdatePropertySignalInfo    ,
#endif
    afterPanelServiceUpdateProperty         ,
    genClosure_PanelServiceUpdateProperty   ,
    mk_PanelServiceUpdatePropertyCallback   ,
    noPanelServiceUpdatePropertyCallback    ,
    onPanelServiceUpdateProperty            ,
    wrap_PanelServiceUpdatePropertyCallback ,




    ) where

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

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

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Objects.DBusConnection as Gio.DBusConnection
import {-# SOURCE #-} qualified GI.IBus.Objects.ExtensionEvent as IBus.ExtensionEvent
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 PanelService = PanelService (SP.ManagedPtr PanelService)
    deriving (PanelService -> PanelService -> Bool
(PanelService -> PanelService -> Bool)
-> (PanelService -> PanelService -> Bool) -> Eq PanelService
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PanelService -> PanelService -> Bool
$c/= :: PanelService -> PanelService -> Bool
== :: PanelService -> PanelService -> Bool
$c== :: PanelService -> PanelService -> Bool
Eq)

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

foreign import ccall "ibus_panel_service_get_type"
    c_ibus_panel_service_get_type :: IO B.Types.GType

instance B.Types.TypedObject PanelService where
    glibType :: IO GType
glibType = IO GType
c_ibus_panel_service_get_type

instance B.Types.GObject PanelService

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

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

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolvePanelServiceMethod (t :: Symbol) (o :: *) :: * where
    ResolvePanelServiceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolvePanelServiceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolvePanelServiceMethod "candidateClicked" o = PanelServiceCandidateClickedMethodInfo
    ResolvePanelServiceMethod "commitText" o = PanelServiceCommitTextMethodInfo
    ResolvePanelServiceMethod "cursorDown" o = PanelServiceCursorDownMethodInfo
    ResolvePanelServiceMethod "cursorUp" o = PanelServiceCursorUpMethodInfo
    ResolvePanelServiceMethod "destroy" o = IBus.Object.ObjectDestroyMethodInfo
    ResolvePanelServiceMethod "emitSignal" o = IBus.Service.ServiceEmitSignalMethodInfo
    ResolvePanelServiceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolvePanelServiceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolvePanelServiceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolvePanelServiceMethod "hidePreeditTextReceived" o = PanelServiceHidePreeditTextReceivedMethodInfo
    ResolvePanelServiceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolvePanelServiceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolvePanelServiceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolvePanelServiceMethod "pageDown" o = PanelServicePageDownMethodInfo
    ResolvePanelServiceMethod "pageUp" o = PanelServicePageUpMethodInfo
    ResolvePanelServiceMethod "panelExtension" o = PanelServicePanelExtensionMethodInfo
    ResolvePanelServiceMethod "propertyActivate" o = PanelServicePropertyActivateMethodInfo
    ResolvePanelServiceMethod "propertyHide" o = PanelServicePropertyHideMethodInfo
    ResolvePanelServiceMethod "propertyShow" o = PanelServicePropertyShowMethodInfo
    ResolvePanelServiceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolvePanelServiceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolvePanelServiceMethod "register" o = IBus.Service.ServiceRegisterMethodInfo
    ResolvePanelServiceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolvePanelServiceMethod "showPreeditTextReceived" o = PanelServiceShowPreeditTextReceivedMethodInfo
    ResolvePanelServiceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolvePanelServiceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolvePanelServiceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolvePanelServiceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolvePanelServiceMethod "unregister" o = IBus.Service.ServiceUnregisterMethodInfo
    ResolvePanelServiceMethod "updateAuxiliaryTextReceived" o = PanelServiceUpdateAuxiliaryTextReceivedMethodInfo
    ResolvePanelServiceMethod "updateLookupTableReceived" o = PanelServiceUpdateLookupTableReceivedMethodInfo
    ResolvePanelServiceMethod "updatePreeditTextReceived" o = PanelServiceUpdatePreeditTextReceivedMethodInfo
    ResolvePanelServiceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolvePanelServiceMethod "getConnection" o = IBus.Service.ServiceGetConnectionMethodInfo
    ResolvePanelServiceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolvePanelServiceMethod "getObjectPath" o = IBus.Service.ServiceGetObjectPathMethodInfo
    ResolvePanelServiceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolvePanelServiceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolvePanelServiceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolvePanelServiceMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolvePanelServiceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolvePanelServiceMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

-- signal PanelService::candidate-clicked-lookup-table
-- | /No description available in the introspection data./
type PanelServiceCandidateClickedLookupTableCallback =
    Word32
    -> Word32
    -> Word32
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceCandidateClickedLookupTableCallback`@.
noPanelServiceCandidateClickedLookupTableCallback :: Maybe PanelServiceCandidateClickedLookupTableCallback
noPanelServiceCandidateClickedLookupTableCallback :: Maybe PanelServiceCandidateClickedLookupTableCallback
noPanelServiceCandidateClickedLookupTableCallback = Maybe PanelServiceCandidateClickedLookupTableCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceCandidateClickedLookupTable :: MonadIO m => PanelServiceCandidateClickedLookupTableCallback -> m (GClosure C_PanelServiceCandidateClickedLookupTableCallback)
genClosure_PanelServiceCandidateClickedLookupTable :: forall (m :: * -> *).
MonadIO m =>
PanelServiceCandidateClickedLookupTableCallback
-> m (GClosure C_PanelServiceCandidateClickedLookupTableCallback)
genClosure_PanelServiceCandidateClickedLookupTable PanelServiceCandidateClickedLookupTableCallback
cb = IO (GClosure C_PanelServiceCandidateClickedLookupTableCallback)
-> m (GClosure C_PanelServiceCandidateClickedLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCandidateClickedLookupTableCallback)
 -> m (GClosure C_PanelServiceCandidateClickedLookupTableCallback))
-> IO (GClosure C_PanelServiceCandidateClickedLookupTableCallback)
-> m (GClosure C_PanelServiceCandidateClickedLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCandidateClickedLookupTableCallback
cb' = PanelServiceCandidateClickedLookupTableCallback
-> C_PanelServiceCandidateClickedLookupTableCallback
wrap_PanelServiceCandidateClickedLookupTableCallback PanelServiceCandidateClickedLookupTableCallback
cb
    C_PanelServiceCandidateClickedLookupTableCallback
-> IO (FunPtr C_PanelServiceCandidateClickedLookupTableCallback)
mk_PanelServiceCandidateClickedLookupTableCallback C_PanelServiceCandidateClickedLookupTableCallback
cb' IO (FunPtr C_PanelServiceCandidateClickedLookupTableCallback)
-> (FunPtr C_PanelServiceCandidateClickedLookupTableCallback
    -> IO (GClosure C_PanelServiceCandidateClickedLookupTableCallback))
-> IO (GClosure C_PanelServiceCandidateClickedLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCandidateClickedLookupTableCallback
-> IO (GClosure C_PanelServiceCandidateClickedLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceCandidateClickedLookupTableCallback` into a `C_PanelServiceCandidateClickedLookupTableCallback`.
wrap_PanelServiceCandidateClickedLookupTableCallback ::
    PanelServiceCandidateClickedLookupTableCallback ->
    C_PanelServiceCandidateClickedLookupTableCallback
wrap_PanelServiceCandidateClickedLookupTableCallback :: PanelServiceCandidateClickedLookupTableCallback
-> C_PanelServiceCandidateClickedLookupTableCallback
wrap_PanelServiceCandidateClickedLookupTableCallback PanelServiceCandidateClickedLookupTableCallback
_cb Ptr ()
_ Word32
object Word32
p0 Word32
p1 Ptr ()
_ = do
    PanelServiceCandidateClickedLookupTableCallback
_cb  Word32
object Word32
p0 Word32
p1


-- | Connect a signal handler for the [candidateClickedLookupTable](#signal:candidateClickedLookupTable) 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' panelService #candidateClickedLookupTable callback
-- @
-- 
-- 
onPanelServiceCandidateClickedLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceCandidateClickedLookupTableCallback -> m SignalHandlerId
onPanelServiceCandidateClickedLookupTable :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a
-> PanelServiceCandidateClickedLookupTableCallback
-> m SignalHandlerId
onPanelServiceCandidateClickedLookupTable a
obj PanelServiceCandidateClickedLookupTableCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCandidateClickedLookupTableCallback
cb' = PanelServiceCandidateClickedLookupTableCallback
-> C_PanelServiceCandidateClickedLookupTableCallback
wrap_PanelServiceCandidateClickedLookupTableCallback PanelServiceCandidateClickedLookupTableCallback
cb
    FunPtr C_PanelServiceCandidateClickedLookupTableCallback
cb'' <- C_PanelServiceCandidateClickedLookupTableCallback
-> IO (FunPtr C_PanelServiceCandidateClickedLookupTableCallback)
mk_PanelServiceCandidateClickedLookupTableCallback C_PanelServiceCandidateClickedLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCandidateClickedLookupTableCallback
-> 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-lookup-table" FunPtr C_PanelServiceCandidateClickedLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [candidateClickedLookupTable](#signal:candidateClickedLookupTable) 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' panelService #candidateClickedLookupTable callback
-- @
-- 
-- 
afterPanelServiceCandidateClickedLookupTable :: (IsPanelService a, MonadIO m) => a -> PanelServiceCandidateClickedLookupTableCallback -> m SignalHandlerId
afterPanelServiceCandidateClickedLookupTable :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a
-> PanelServiceCandidateClickedLookupTableCallback
-> m SignalHandlerId
afterPanelServiceCandidateClickedLookupTable a
obj PanelServiceCandidateClickedLookupTableCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCandidateClickedLookupTableCallback
cb' = PanelServiceCandidateClickedLookupTableCallback
-> C_PanelServiceCandidateClickedLookupTableCallback
wrap_PanelServiceCandidateClickedLookupTableCallback PanelServiceCandidateClickedLookupTableCallback
cb
    FunPtr C_PanelServiceCandidateClickedLookupTableCallback
cb'' <- C_PanelServiceCandidateClickedLookupTableCallback
-> IO (FunPtr C_PanelServiceCandidateClickedLookupTableCallback)
mk_PanelServiceCandidateClickedLookupTableCallback C_PanelServiceCandidateClickedLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCandidateClickedLookupTableCallback
-> 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-lookup-table" FunPtr C_PanelServiceCandidateClickedLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceCandidateClickedLookupTableSignalInfo
instance SignalInfo PanelServiceCandidateClickedLookupTableSignalInfo where
    type HaskellCallbackType PanelServiceCandidateClickedLookupTableSignalInfo = PanelServiceCandidateClickedLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceCandidateClickedLookupTableCallback cb
        cb'' <- mk_PanelServiceCandidateClickedLookupTableCallback cb'
        connectSignalFunPtr obj "candidate-clicked-lookup-table" cb'' connectMode detail

#endif

-- signal PanelService::commit-text-received
-- | Emitted when the client application get the [commitTextReceived](#g:signal:commitTextReceived).
-- Implement the member function
-- IBusPanelServiceClass[commit_text_received](#g:signal:commit_text_received) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceCommitTextReceivedCallback =
    IBus.Text.Text
    -- ^ /@text@/: A t'GI.IBus.Objects.Text.Text'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceCommitTextReceivedCallback`@.
noPanelServiceCommitTextReceivedCallback :: Maybe PanelServiceCommitTextReceivedCallback
noPanelServiceCommitTextReceivedCallback :: Maybe PanelServiceCommitTextReceivedCallback
noPanelServiceCommitTextReceivedCallback = Maybe PanelServiceCommitTextReceivedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceCommitTextReceived :: MonadIO m => PanelServiceCommitTextReceivedCallback -> m (GClosure C_PanelServiceCommitTextReceivedCallback)
genClosure_PanelServiceCommitTextReceived :: forall (m :: * -> *).
MonadIO m =>
PanelServiceCommitTextReceivedCallback
-> m (GClosure C_PanelServiceCommitTextReceivedCallback)
genClosure_PanelServiceCommitTextReceived PanelServiceCommitTextReceivedCallback
cb = IO (GClosure C_PanelServiceCommitTextReceivedCallback)
-> m (GClosure C_PanelServiceCommitTextReceivedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCommitTextReceivedCallback)
 -> m (GClosure C_PanelServiceCommitTextReceivedCallback))
-> IO (GClosure C_PanelServiceCommitTextReceivedCallback)
-> m (GClosure C_PanelServiceCommitTextReceivedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCommitTextReceivedCallback
cb' = PanelServiceCommitTextReceivedCallback
-> C_PanelServiceCommitTextReceivedCallback
wrap_PanelServiceCommitTextReceivedCallback PanelServiceCommitTextReceivedCallback
cb
    C_PanelServiceCommitTextReceivedCallback
-> IO (FunPtr C_PanelServiceCommitTextReceivedCallback)
mk_PanelServiceCommitTextReceivedCallback C_PanelServiceCommitTextReceivedCallback
cb' IO (FunPtr C_PanelServiceCommitTextReceivedCallback)
-> (FunPtr C_PanelServiceCommitTextReceivedCallback
    -> IO (GClosure C_PanelServiceCommitTextReceivedCallback))
-> IO (GClosure C_PanelServiceCommitTextReceivedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCommitTextReceivedCallback
-> IO (GClosure C_PanelServiceCommitTextReceivedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [commitTextReceived](#signal:commitTextReceived) 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' panelService #commitTextReceived callback
-- @
-- 
-- 
onPanelServiceCommitTextReceived :: (IsPanelService a, MonadIO m) => a -> PanelServiceCommitTextReceivedCallback -> m SignalHandlerId
onPanelServiceCommitTextReceived :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceCommitTextReceivedCallback -> m SignalHandlerId
onPanelServiceCommitTextReceived a
obj PanelServiceCommitTextReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCommitTextReceivedCallback
cb' = PanelServiceCommitTextReceivedCallback
-> C_PanelServiceCommitTextReceivedCallback
wrap_PanelServiceCommitTextReceivedCallback PanelServiceCommitTextReceivedCallback
cb
    FunPtr C_PanelServiceCommitTextReceivedCallback
cb'' <- C_PanelServiceCommitTextReceivedCallback
-> IO (FunPtr C_PanelServiceCommitTextReceivedCallback)
mk_PanelServiceCommitTextReceivedCallback C_PanelServiceCommitTextReceivedCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCommitTextReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"commit-text-received" FunPtr C_PanelServiceCommitTextReceivedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [commitTextReceived](#signal:commitTextReceived) 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' panelService #commitTextReceived callback
-- @
-- 
-- 
afterPanelServiceCommitTextReceived :: (IsPanelService a, MonadIO m) => a -> PanelServiceCommitTextReceivedCallback -> m SignalHandlerId
afterPanelServiceCommitTextReceived :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceCommitTextReceivedCallback -> m SignalHandlerId
afterPanelServiceCommitTextReceived a
obj PanelServiceCommitTextReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCommitTextReceivedCallback
cb' = PanelServiceCommitTextReceivedCallback
-> C_PanelServiceCommitTextReceivedCallback
wrap_PanelServiceCommitTextReceivedCallback PanelServiceCommitTextReceivedCallback
cb
    FunPtr C_PanelServiceCommitTextReceivedCallback
cb'' <- C_PanelServiceCommitTextReceivedCallback
-> IO (FunPtr C_PanelServiceCommitTextReceivedCallback)
mk_PanelServiceCommitTextReceivedCallback C_PanelServiceCommitTextReceivedCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCommitTextReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"commit-text-received" FunPtr C_PanelServiceCommitTextReceivedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceCommitTextReceivedSignalInfo
instance SignalInfo PanelServiceCommitTextReceivedSignalInfo where
    type HaskellCallbackType PanelServiceCommitTextReceivedSignalInfo = PanelServiceCommitTextReceivedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceCommitTextReceivedCallback cb
        cb'' <- mk_PanelServiceCommitTextReceivedCallback cb'
        connectSignalFunPtr obj "commit-text-received" cb'' connectMode detail

#endif

-- signal PanelService::cursor-down-lookup-table
-- | Emitted when the client application get the [cursorDownLookupTable](#g:signal:cursorDownLookupTable).
-- Implement the member function
-- IBusPanelServiceClass[cursor_down_lookup_table](#g:signal:cursor_down_lookup_table) in extended
-- class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceCursorDownLookupTableCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceCursorDownLookupTable :: MonadIO m => PanelServiceCursorDownLookupTableCallback -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceCursorDownLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceCursorDownLookupTable IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceCursorDownLookupTableCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceCursorDownLookupTableCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceCursorDownLookupTableCallback` into a `C_PanelServiceCursorDownLookupTableCallback`.
wrap_PanelServiceCursorDownLookupTableCallback ::
    PanelServiceCursorDownLookupTableCallback ->
    C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceCursorDownLookupTableCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceCursorDownLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceCursorDownLookupTableSignalInfo
instance SignalInfo PanelServiceCursorDownLookupTableSignalInfo where
    type HaskellCallbackType PanelServiceCursorDownLookupTableSignalInfo = PanelServiceCursorDownLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceCursorDownLookupTableCallback cb
        cb'' <- mk_PanelServiceCursorDownLookupTableCallback cb'
        connectSignalFunPtr obj "cursor-down-lookup-table" cb'' connectMode detail

#endif

-- signal PanelService::cursor-up-lookup-table
-- | Emitted when the client application get the [cursorUpLookupTable](#g:signal:cursorUpLookupTable).
-- Implement the member function
-- IBusPanelServiceClass[cursor_up_lookup_table](#g:signal:cursor_up_lookup_table) in extended
-- class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceCursorUpLookupTableCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceCursorUpLookupTable :: MonadIO m => PanelServiceCursorUpLookupTableCallback -> m (GClosure C_PanelServiceCursorUpLookupTableCallback)
genClosure_PanelServiceCursorUpLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceCursorUpLookupTable IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceCursorUpLookupTableCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceCursorUpLookupTableCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceCursorUpLookupTableCallback` into a `C_PanelServiceCursorUpLookupTableCallback`.
wrap_PanelServiceCursorUpLookupTableCallback ::
    PanelServiceCursorUpLookupTableCallback ->
    C_PanelServiceCursorUpLookupTableCallback
wrap_PanelServiceCursorUpLookupTableCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceCursorUpLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceCursorUpLookupTableSignalInfo
instance SignalInfo PanelServiceCursorUpLookupTableSignalInfo where
    type HaskellCallbackType PanelServiceCursorUpLookupTableSignalInfo = PanelServiceCursorUpLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceCursorUpLookupTableCallback cb
        cb'' <- mk_PanelServiceCursorUpLookupTableCallback cb'
        connectSignalFunPtr obj "cursor-up-lookup-table" cb'' connectMode detail

#endif

-- signal PanelService::destroy-context
-- | Emitted when the client application destroys.
-- Implement the member function
-- IBusPanelServiceClass[destroy_context](#g:signal:destroy_context) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceDestroyContextCallback =
    T.Text
    -- ^ /@inputContextPath@/: Object path of InputContext.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceDestroyContextCallback`@.
noPanelServiceDestroyContextCallback :: Maybe PanelServiceDestroyContextCallback
noPanelServiceDestroyContextCallback :: Maybe PanelServiceDestroyContextCallback
noPanelServiceDestroyContextCallback = Maybe PanelServiceDestroyContextCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceDestroyContext :: MonadIO m => PanelServiceDestroyContextCallback -> m (GClosure C_PanelServiceDestroyContextCallback)
genClosure_PanelServiceDestroyContext :: forall (m :: * -> *).
MonadIO m =>
PanelServiceDestroyContextCallback
-> m (GClosure C_PanelServiceDestroyContextCallback)
genClosure_PanelServiceDestroyContext PanelServiceDestroyContextCallback
cb = IO (GClosure C_PanelServiceDestroyContextCallback)
-> m (GClosure C_PanelServiceDestroyContextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceDestroyContextCallback)
 -> m (GClosure C_PanelServiceDestroyContextCallback))
-> IO (GClosure C_PanelServiceDestroyContextCallback)
-> m (GClosure C_PanelServiceDestroyContextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceDestroyContextCallback
cb' = PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceDestroyContextCallback PanelServiceDestroyContextCallback
cb
    C_PanelServiceDestroyContextCallback
-> IO (FunPtr C_PanelServiceDestroyContextCallback)
mk_PanelServiceDestroyContextCallback C_PanelServiceDestroyContextCallback
cb' IO (FunPtr C_PanelServiceDestroyContextCallback)
-> (FunPtr C_PanelServiceDestroyContextCallback
    -> IO (GClosure C_PanelServiceDestroyContextCallback))
-> IO (GClosure C_PanelServiceDestroyContextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceDestroyContextCallback
-> IO (GClosure C_PanelServiceDestroyContextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceDestroyContextCallback` into a `C_PanelServiceDestroyContextCallback`.
wrap_PanelServiceDestroyContextCallback ::
    PanelServiceDestroyContextCallback ->
    C_PanelServiceDestroyContextCallback
wrap_PanelServiceDestroyContextCallback :: PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceDestroyContextCallback PanelServiceDestroyContextCallback
_cb Ptr ()
_ CString
inputContextPath Ptr ()
_ = do
    Text
inputContextPath' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
inputContextPath
    PanelServiceDestroyContextCallback
_cb  Text
inputContextPath'


-- | Connect a signal handler for the [destroyContext](#signal:destroyContext) 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' panelService #destroyContext callback
-- @
-- 
-- 
onPanelServiceDestroyContext :: (IsPanelService a, MonadIO m) => a -> PanelServiceDestroyContextCallback -> m SignalHandlerId
onPanelServiceDestroyContext :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceDestroyContextCallback -> m SignalHandlerId
onPanelServiceDestroyContext a
obj PanelServiceDestroyContextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceDestroyContextCallback
cb' = PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceDestroyContextCallback PanelServiceDestroyContextCallback
cb
    FunPtr C_PanelServiceDestroyContextCallback
cb'' <- C_PanelServiceDestroyContextCallback
-> IO (FunPtr C_PanelServiceDestroyContextCallback)
mk_PanelServiceDestroyContextCallback C_PanelServiceDestroyContextCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceDestroyContextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"destroy-context" FunPtr C_PanelServiceDestroyContextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [destroyContext](#signal:destroyContext) 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' panelService #destroyContext callback
-- @
-- 
-- 
afterPanelServiceDestroyContext :: (IsPanelService a, MonadIO m) => a -> PanelServiceDestroyContextCallback -> m SignalHandlerId
afterPanelServiceDestroyContext :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceDestroyContextCallback -> m SignalHandlerId
afterPanelServiceDestroyContext a
obj PanelServiceDestroyContextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceDestroyContextCallback
cb' = PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceDestroyContextCallback PanelServiceDestroyContextCallback
cb
    FunPtr C_PanelServiceDestroyContextCallback
cb'' <- C_PanelServiceDestroyContextCallback
-> IO (FunPtr C_PanelServiceDestroyContextCallback)
mk_PanelServiceDestroyContextCallback C_PanelServiceDestroyContextCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceDestroyContextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"destroy-context" FunPtr C_PanelServiceDestroyContextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceDestroyContextSignalInfo
instance SignalInfo PanelServiceDestroyContextSignalInfo where
    type HaskellCallbackType PanelServiceDestroyContextSignalInfo = PanelServiceDestroyContextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceDestroyContextCallback cb
        cb'' <- mk_PanelServiceDestroyContextCallback cb'
        connectSignalFunPtr obj "destroy-context" cb'' connectMode detail

#endif

-- signal PanelService::focus-in
-- | Emitted when the client application get the [focusIn](#g:signal:focusIn).
-- Implement the member function
-- IBusPanelServiceClass[focus_in](#g:signal:focus_in) in extended class to receive
-- this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceFocusInCallback =
    T.Text
    -- ^ /@inputContextPath@/: Object path of InputContext.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceFocusInCallback`@.
noPanelServiceFocusInCallback :: Maybe PanelServiceFocusInCallback
noPanelServiceFocusInCallback :: Maybe PanelServiceDestroyContextCallback
noPanelServiceFocusInCallback = Maybe PanelServiceDestroyContextCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceFocusIn :: MonadIO m => PanelServiceFocusInCallback -> m (GClosure C_PanelServiceFocusInCallback)
genClosure_PanelServiceFocusIn :: forall (m :: * -> *).
MonadIO m =>
PanelServiceDestroyContextCallback
-> m (GClosure C_PanelServiceDestroyContextCallback)
genClosure_PanelServiceFocusIn PanelServiceDestroyContextCallback
cb = IO (GClosure C_PanelServiceDestroyContextCallback)
-> m (GClosure C_PanelServiceDestroyContextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceDestroyContextCallback)
 -> m (GClosure C_PanelServiceDestroyContextCallback))
-> IO (GClosure C_PanelServiceDestroyContextCallback)
-> m (GClosure C_PanelServiceDestroyContextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceDestroyContextCallback
cb' = PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceFocusInCallback PanelServiceDestroyContextCallback
cb
    C_PanelServiceDestroyContextCallback
-> IO (FunPtr C_PanelServiceDestroyContextCallback)
mk_PanelServiceFocusInCallback C_PanelServiceDestroyContextCallback
cb' IO (FunPtr C_PanelServiceDestroyContextCallback)
-> (FunPtr C_PanelServiceDestroyContextCallback
    -> IO (GClosure C_PanelServiceDestroyContextCallback))
-> IO (GClosure C_PanelServiceDestroyContextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceDestroyContextCallback
-> IO (GClosure C_PanelServiceDestroyContextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceFocusInCallback` into a `C_PanelServiceFocusInCallback`.
wrap_PanelServiceFocusInCallback ::
    PanelServiceFocusInCallback ->
    C_PanelServiceFocusInCallback
wrap_PanelServiceFocusInCallback :: PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceFocusInCallback PanelServiceDestroyContextCallback
_cb Ptr ()
_ CString
inputContextPath Ptr ()
_ = do
    Text
inputContextPath' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
inputContextPath
    PanelServiceDestroyContextCallback
_cb  Text
inputContextPath'


-- | 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' panelService #focusIn callback
-- @
-- 
-- 
onPanelServiceFocusIn :: (IsPanelService a, MonadIO m) => a -> PanelServiceFocusInCallback -> m SignalHandlerId
onPanelServiceFocusIn :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceDestroyContextCallback -> m SignalHandlerId
onPanelServiceFocusIn a
obj PanelServiceDestroyContextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceDestroyContextCallback
cb' = PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceFocusInCallback PanelServiceDestroyContextCallback
cb
    FunPtr C_PanelServiceDestroyContextCallback
cb'' <- C_PanelServiceDestroyContextCallback
-> IO (FunPtr C_PanelServiceDestroyContextCallback)
mk_PanelServiceFocusInCallback C_PanelServiceDestroyContextCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceDestroyContextCallback
-> 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_PanelServiceDestroyContextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [focusIn](#signal:focusIn) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' panelService #focusIn callback
-- @
-- 
-- 
afterPanelServiceFocusIn :: (IsPanelService a, MonadIO m) => a -> PanelServiceFocusInCallback -> m SignalHandlerId
afterPanelServiceFocusIn :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceDestroyContextCallback -> m SignalHandlerId
afterPanelServiceFocusIn a
obj PanelServiceDestroyContextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceDestroyContextCallback
cb' = PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceFocusInCallback PanelServiceDestroyContextCallback
cb
    FunPtr C_PanelServiceDestroyContextCallback
cb'' <- C_PanelServiceDestroyContextCallback
-> IO (FunPtr C_PanelServiceDestroyContextCallback)
mk_PanelServiceFocusInCallback C_PanelServiceDestroyContextCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceDestroyContextCallback
-> 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_PanelServiceDestroyContextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceFocusInSignalInfo
instance SignalInfo PanelServiceFocusInSignalInfo where
    type HaskellCallbackType PanelServiceFocusInSignalInfo = PanelServiceFocusInCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceFocusInCallback cb
        cb'' <- mk_PanelServiceFocusInCallback cb'
        connectSignalFunPtr obj "focus-in" cb'' connectMode detail

#endif

-- signal PanelService::focus-out
-- | Emitted when the client application get the [focusOut](#g:signal:focusOut).
-- Implement the member function
-- IBusPanelServiceClass[focus_out](#g:signal:focus_out) in extended class to receive
-- this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceFocusOutCallback =
    T.Text
    -- ^ /@inputContextPath@/: Object path of InputContext.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceFocusOutCallback`@.
noPanelServiceFocusOutCallback :: Maybe PanelServiceFocusOutCallback
noPanelServiceFocusOutCallback :: Maybe PanelServiceDestroyContextCallback
noPanelServiceFocusOutCallback = Maybe PanelServiceDestroyContextCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceFocusOut :: MonadIO m => PanelServiceFocusOutCallback -> m (GClosure C_PanelServiceFocusOutCallback)
genClosure_PanelServiceFocusOut :: forall (m :: * -> *).
MonadIO m =>
PanelServiceDestroyContextCallback
-> m (GClosure C_PanelServiceDestroyContextCallback)
genClosure_PanelServiceFocusOut PanelServiceDestroyContextCallback
cb = IO (GClosure C_PanelServiceDestroyContextCallback)
-> m (GClosure C_PanelServiceDestroyContextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceDestroyContextCallback)
 -> m (GClosure C_PanelServiceDestroyContextCallback))
-> IO (GClosure C_PanelServiceDestroyContextCallback)
-> m (GClosure C_PanelServiceDestroyContextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceDestroyContextCallback
cb' = PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceFocusOutCallback PanelServiceDestroyContextCallback
cb
    C_PanelServiceDestroyContextCallback
-> IO (FunPtr C_PanelServiceDestroyContextCallback)
mk_PanelServiceFocusOutCallback C_PanelServiceDestroyContextCallback
cb' IO (FunPtr C_PanelServiceDestroyContextCallback)
-> (FunPtr C_PanelServiceDestroyContextCallback
    -> IO (GClosure C_PanelServiceDestroyContextCallback))
-> IO (GClosure C_PanelServiceDestroyContextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceDestroyContextCallback
-> IO (GClosure C_PanelServiceDestroyContextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceFocusOutCallback` into a `C_PanelServiceFocusOutCallback`.
wrap_PanelServiceFocusOutCallback ::
    PanelServiceFocusOutCallback ->
    C_PanelServiceFocusOutCallback
wrap_PanelServiceFocusOutCallback :: PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceFocusOutCallback PanelServiceDestroyContextCallback
_cb Ptr ()
_ CString
inputContextPath Ptr ()
_ = do
    Text
inputContextPath' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
inputContextPath
    PanelServiceDestroyContextCallback
_cb  Text
inputContextPath'


-- | 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' panelService #focusOut callback
-- @
-- 
-- 
onPanelServiceFocusOut :: (IsPanelService a, MonadIO m) => a -> PanelServiceFocusOutCallback -> m SignalHandlerId
onPanelServiceFocusOut :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceDestroyContextCallback -> m SignalHandlerId
onPanelServiceFocusOut a
obj PanelServiceDestroyContextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceDestroyContextCallback
cb' = PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceFocusOutCallback PanelServiceDestroyContextCallback
cb
    FunPtr C_PanelServiceDestroyContextCallback
cb'' <- C_PanelServiceDestroyContextCallback
-> IO (FunPtr C_PanelServiceDestroyContextCallback)
mk_PanelServiceFocusOutCallback C_PanelServiceDestroyContextCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceDestroyContextCallback
-> 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_PanelServiceDestroyContextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [focusOut](#signal:focusOut) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' panelService #focusOut callback
-- @
-- 
-- 
afterPanelServiceFocusOut :: (IsPanelService a, MonadIO m) => a -> PanelServiceFocusOutCallback -> m SignalHandlerId
afterPanelServiceFocusOut :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceDestroyContextCallback -> m SignalHandlerId
afterPanelServiceFocusOut a
obj PanelServiceDestroyContextCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceDestroyContextCallback
cb' = PanelServiceDestroyContextCallback
-> C_PanelServiceDestroyContextCallback
wrap_PanelServiceFocusOutCallback PanelServiceDestroyContextCallback
cb
    FunPtr C_PanelServiceDestroyContextCallback
cb'' <- C_PanelServiceDestroyContextCallback
-> IO (FunPtr C_PanelServiceDestroyContextCallback)
mk_PanelServiceFocusOutCallback C_PanelServiceDestroyContextCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceDestroyContextCallback
-> 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_PanelServiceDestroyContextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceFocusOutSignalInfo
instance SignalInfo PanelServiceFocusOutSignalInfo where
    type HaskellCallbackType PanelServiceFocusOutSignalInfo = PanelServiceFocusOutCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceFocusOutCallback cb
        cb'' <- mk_PanelServiceFocusOutCallback cb'
        connectSignalFunPtr obj "focus-out" cb'' connectMode detail

#endif

-- signal PanelService::hide-auxiliary-text
-- | Emitted when the client application get the [hideAuxiliaryText](#g:signal:hideAuxiliaryText).
-- Implement the member function
-- IBusPanelServiceClass[hide_auxiliary_text](#g:signal:hide_auxiliary_text) in extended class
-- to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceHideAuxiliaryTextCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceHideAuxiliaryText :: MonadIO m => PanelServiceHideAuxiliaryTextCallback -> m (GClosure C_PanelServiceHideAuxiliaryTextCallback)
genClosure_PanelServiceHideAuxiliaryText :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceHideAuxiliaryText IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHideAuxiliaryTextCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceHideAuxiliaryTextCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceHideAuxiliaryTextCallback` into a `C_PanelServiceHideAuxiliaryTextCallback`.
wrap_PanelServiceHideAuxiliaryTextCallback ::
    PanelServiceHideAuxiliaryTextCallback ->
    C_PanelServiceHideAuxiliaryTextCallback
wrap_PanelServiceHideAuxiliaryTextCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHideAuxiliaryTextCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceHideAuxiliaryTextSignalInfo
instance SignalInfo PanelServiceHideAuxiliaryTextSignalInfo where
    type HaskellCallbackType PanelServiceHideAuxiliaryTextSignalInfo = PanelServiceHideAuxiliaryTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceHideAuxiliaryTextCallback cb
        cb'' <- mk_PanelServiceHideAuxiliaryTextCallback cb'
        connectSignalFunPtr obj "hide-auxiliary-text" cb'' connectMode detail

#endif

-- signal PanelService::hide-language-bar
-- | Emitted when the client application get the [hideLanguageBar](#g:signal:hideLanguageBar).
-- Implement the member function
-- IBusPanelServiceClass[hide_language_bar](#g:signal:hide_language_bar) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceHideLanguageBarCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceHideLanguageBar :: MonadIO m => PanelServiceHideLanguageBarCallback -> m (GClosure C_PanelServiceHideLanguageBarCallback)
genClosure_PanelServiceHideLanguageBar :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceHideLanguageBar IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHideLanguageBarCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceHideLanguageBarCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceHideLanguageBarCallback` into a `C_PanelServiceHideLanguageBarCallback`.
wrap_PanelServiceHideLanguageBarCallback ::
    PanelServiceHideLanguageBarCallback ->
    C_PanelServiceHideLanguageBarCallback
wrap_PanelServiceHideLanguageBarCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHideLanguageBarCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [hideLanguageBar](#signal:hideLanguageBar) 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' panelService #hideLanguageBar callback
-- @
-- 
-- 
onPanelServiceHideLanguageBar :: (IsPanelService a, MonadIO m) => a -> PanelServiceHideLanguageBarCallback -> m SignalHandlerId
onPanelServiceHideLanguageBar :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onPanelServiceHideLanguageBar a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHideLanguageBarCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceHideLanguageBarCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide-language-bar" FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [hideLanguageBar](#signal:hideLanguageBar) 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' panelService #hideLanguageBar callback
-- @
-- 
-- 
afterPanelServiceHideLanguageBar :: (IsPanelService a, MonadIO m) => a -> PanelServiceHideLanguageBarCallback -> m SignalHandlerId
afterPanelServiceHideLanguageBar :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterPanelServiceHideLanguageBar a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHideLanguageBarCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceHideLanguageBarCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide-language-bar" FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceHideLanguageBarSignalInfo
instance SignalInfo PanelServiceHideLanguageBarSignalInfo where
    type HaskellCallbackType PanelServiceHideLanguageBarSignalInfo = PanelServiceHideLanguageBarCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceHideLanguageBarCallback cb
        cb'' <- mk_PanelServiceHideLanguageBarCallback cb'
        connectSignalFunPtr obj "hide-language-bar" cb'' connectMode detail

#endif

-- signal PanelService::hide-lookup-table
-- | Emitted when the client application get the [hideLookupTable](#g:signal:hideLookupTable).
-- Implement the member function
-- IBusPanelServiceClass[hide_lookup_table](#g:signal:hide_lookup_table) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceHideLookupTableCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceHideLookupTable :: MonadIO m => PanelServiceHideLookupTableCallback -> m (GClosure C_PanelServiceHideLookupTableCallback)
genClosure_PanelServiceHideLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceHideLookupTable IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHideLookupTableCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceHideLookupTableCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceHideLookupTableCallback` into a `C_PanelServiceHideLookupTableCallback`.
wrap_PanelServiceHideLookupTableCallback ::
    PanelServiceHideLookupTableCallback ->
    C_PanelServiceHideLookupTableCallback
wrap_PanelServiceHideLookupTableCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHideLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceHideLookupTableSignalInfo
instance SignalInfo PanelServiceHideLookupTableSignalInfo where
    type HaskellCallbackType PanelServiceHideLookupTableSignalInfo = PanelServiceHideLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceHideLookupTableCallback cb
        cb'' <- mk_PanelServiceHideLookupTableCallback cb'
        connectSignalFunPtr obj "hide-lookup-table" cb'' connectMode detail

#endif

-- signal PanelService::hide-preedit-text
-- | Emitted when the client application get the [hidePreeditText](#g:signal:hidePreeditText).
-- Implement the member function
-- IBusPanelServiceClass[hide_preedit_text](#g:signal:hide_preedit_text) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceHidePreeditTextCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceHidePreeditText :: MonadIO m => PanelServiceHidePreeditTextCallback -> m (GClosure C_PanelServiceHidePreeditTextCallback)
genClosure_PanelServiceHidePreeditText :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceHidePreeditText IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHidePreeditTextCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceHidePreeditTextCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceHidePreeditTextCallback` into a `C_PanelServiceHidePreeditTextCallback`.
wrap_PanelServiceHidePreeditTextCallback ::
    PanelServiceHidePreeditTextCallback ->
    C_PanelServiceHidePreeditTextCallback
wrap_PanelServiceHidePreeditTextCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceHidePreeditTextCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceHidePreeditTextSignalInfo
instance SignalInfo PanelServiceHidePreeditTextSignalInfo where
    type HaskellCallbackType PanelServiceHidePreeditTextSignalInfo = PanelServiceHidePreeditTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceHidePreeditTextCallback cb
        cb'' <- mk_PanelServiceHidePreeditTextCallback cb'
        connectSignalFunPtr obj "hide-preedit-text" cb'' connectMode detail

#endif

-- signal PanelService::page-down-lookup-table
-- | Emitted when the client application get the [pageDownLookupTable](#g:signal:pageDownLookupTable).
-- Implement the member function
-- IBusPanelServiceClass[page_down_lookup_table](#g:signal:page_down_lookup_table) in extended
-- class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServicePageDownLookupTableCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServicePageDownLookupTable :: MonadIO m => PanelServicePageDownLookupTableCallback -> m (GClosure C_PanelServicePageDownLookupTableCallback)
genClosure_PanelServicePageDownLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServicePageDownLookupTable IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServicePageDownLookupTableCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServicePageDownLookupTableCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServicePageDownLookupTableCallback` into a `C_PanelServicePageDownLookupTableCallback`.
wrap_PanelServicePageDownLookupTableCallback ::
    PanelServicePageDownLookupTableCallback ->
    C_PanelServicePageDownLookupTableCallback
wrap_PanelServicePageDownLookupTableCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServicePageDownLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServicePageDownLookupTableSignalInfo
instance SignalInfo PanelServicePageDownLookupTableSignalInfo where
    type HaskellCallbackType PanelServicePageDownLookupTableSignalInfo = PanelServicePageDownLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServicePageDownLookupTableCallback cb
        cb'' <- mk_PanelServicePageDownLookupTableCallback cb'
        connectSignalFunPtr obj "page-down-lookup-table" cb'' connectMode detail

#endif

-- signal PanelService::page-up-lookup-table
-- | Emitted when the client application get the [pageUpLookupTable](#g:signal:pageUpLookupTable).
-- Implement the member function
-- IBusPanelServiceClass[page_up_lookup_table](#g:signal:page_up_lookup_table) in extended class
-- to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServicePageUpLookupTableCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServicePageUpLookupTable :: MonadIO m => PanelServicePageUpLookupTableCallback -> m (GClosure C_PanelServicePageUpLookupTableCallback)
genClosure_PanelServicePageUpLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServicePageUpLookupTable IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServicePageUpLookupTableCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServicePageUpLookupTableCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServicePageUpLookupTableCallback` into a `C_PanelServicePageUpLookupTableCallback`.
wrap_PanelServicePageUpLookupTableCallback ::
    PanelServicePageUpLookupTableCallback ->
    C_PanelServicePageUpLookupTableCallback
wrap_PanelServicePageUpLookupTableCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServicePageUpLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServicePageUpLookupTableSignalInfo
instance SignalInfo PanelServicePageUpLookupTableSignalInfo where
    type HaskellCallbackType PanelServicePageUpLookupTableSignalInfo = PanelServicePageUpLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServicePageUpLookupTableCallback cb
        cb'' <- mk_PanelServicePageUpLookupTableCallback cb'
        connectSignalFunPtr obj "page-up-lookup-table" cb'' connectMode detail

#endif

-- signal PanelService::panel-extension-received
-- | Emitted when the client application get the [panelExtensionReceived](#g:signal:panelExtensionReceived).
-- Implement the member function
-- IBusPanelServiceClass[panel_extension_received](#g:signal:panel_extension_received) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServicePanelExtensionReceivedCallback =
    IBus.ExtensionEvent.ExtensionEvent
    -- ^ /@data@/: A t'GVariant'
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServicePanelExtensionReceivedCallback`@.
noPanelServicePanelExtensionReceivedCallback :: Maybe PanelServicePanelExtensionReceivedCallback
noPanelServicePanelExtensionReceivedCallback :: Maybe PanelServicePanelExtensionReceivedCallback
noPanelServicePanelExtensionReceivedCallback = Maybe PanelServicePanelExtensionReceivedCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServicePanelExtensionReceived :: MonadIO m => PanelServicePanelExtensionReceivedCallback -> m (GClosure C_PanelServicePanelExtensionReceivedCallback)
genClosure_PanelServicePanelExtensionReceived :: forall (m :: * -> *).
MonadIO m =>
PanelServicePanelExtensionReceivedCallback
-> m (GClosure C_PanelServicePanelExtensionReceivedCallback)
genClosure_PanelServicePanelExtensionReceived PanelServicePanelExtensionReceivedCallback
cb = IO (GClosure C_PanelServicePanelExtensionReceivedCallback)
-> m (GClosure C_PanelServicePanelExtensionReceivedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServicePanelExtensionReceivedCallback)
 -> m (GClosure C_PanelServicePanelExtensionReceivedCallback))
-> IO (GClosure C_PanelServicePanelExtensionReceivedCallback)
-> m (GClosure C_PanelServicePanelExtensionReceivedCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServicePanelExtensionReceivedCallback
cb' = PanelServicePanelExtensionReceivedCallback
-> C_PanelServicePanelExtensionReceivedCallback
wrap_PanelServicePanelExtensionReceivedCallback PanelServicePanelExtensionReceivedCallback
cb
    C_PanelServicePanelExtensionReceivedCallback
-> IO (FunPtr C_PanelServicePanelExtensionReceivedCallback)
mk_PanelServicePanelExtensionReceivedCallback C_PanelServicePanelExtensionReceivedCallback
cb' IO (FunPtr C_PanelServicePanelExtensionReceivedCallback)
-> (FunPtr C_PanelServicePanelExtensionReceivedCallback
    -> IO (GClosure C_PanelServicePanelExtensionReceivedCallback))
-> IO (GClosure C_PanelServicePanelExtensionReceivedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServicePanelExtensionReceivedCallback
-> IO (GClosure C_PanelServicePanelExtensionReceivedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServicePanelExtensionReceivedCallback` into a `C_PanelServicePanelExtensionReceivedCallback`.
wrap_PanelServicePanelExtensionReceivedCallback ::
    PanelServicePanelExtensionReceivedCallback ->
    C_PanelServicePanelExtensionReceivedCallback
wrap_PanelServicePanelExtensionReceivedCallback :: PanelServicePanelExtensionReceivedCallback
-> C_PanelServicePanelExtensionReceivedCallback
wrap_PanelServicePanelExtensionReceivedCallback PanelServicePanelExtensionReceivedCallback
_cb Ptr ()
_ Ptr ExtensionEvent
data_ Ptr ()
_ = do
    ExtensionEvent
data_' <- ((ManagedPtr ExtensionEvent -> ExtensionEvent)
-> Ptr ExtensionEvent -> IO ExtensionEvent
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr ExtensionEvent -> ExtensionEvent
IBus.ExtensionEvent.ExtensionEvent) Ptr ExtensionEvent
data_
    PanelServicePanelExtensionReceivedCallback
_cb  ExtensionEvent
data_'


-- | Connect a signal handler for the [panelExtensionReceived](#signal:panelExtensionReceived) 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' panelService #panelExtensionReceived callback
-- @
-- 
-- 
onPanelServicePanelExtensionReceived :: (IsPanelService a, MonadIO m) => a -> PanelServicePanelExtensionReceivedCallback -> m SignalHandlerId
onPanelServicePanelExtensionReceived :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a
-> PanelServicePanelExtensionReceivedCallback -> m SignalHandlerId
onPanelServicePanelExtensionReceived a
obj PanelServicePanelExtensionReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServicePanelExtensionReceivedCallback
cb' = PanelServicePanelExtensionReceivedCallback
-> C_PanelServicePanelExtensionReceivedCallback
wrap_PanelServicePanelExtensionReceivedCallback PanelServicePanelExtensionReceivedCallback
cb
    FunPtr C_PanelServicePanelExtensionReceivedCallback
cb'' <- C_PanelServicePanelExtensionReceivedCallback
-> IO (FunPtr C_PanelServicePanelExtensionReceivedCallback)
mk_PanelServicePanelExtensionReceivedCallback C_PanelServicePanelExtensionReceivedCallback
cb'
    a
-> Text
-> FunPtr C_PanelServicePanelExtensionReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"panel-extension-received" FunPtr C_PanelServicePanelExtensionReceivedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [panelExtensionReceived](#signal:panelExtensionReceived) 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' panelService #panelExtensionReceived callback
-- @
-- 
-- 
afterPanelServicePanelExtensionReceived :: (IsPanelService a, MonadIO m) => a -> PanelServicePanelExtensionReceivedCallback -> m SignalHandlerId
afterPanelServicePanelExtensionReceived :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a
-> PanelServicePanelExtensionReceivedCallback -> m SignalHandlerId
afterPanelServicePanelExtensionReceived a
obj PanelServicePanelExtensionReceivedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServicePanelExtensionReceivedCallback
cb' = PanelServicePanelExtensionReceivedCallback
-> C_PanelServicePanelExtensionReceivedCallback
wrap_PanelServicePanelExtensionReceivedCallback PanelServicePanelExtensionReceivedCallback
cb
    FunPtr C_PanelServicePanelExtensionReceivedCallback
cb'' <- C_PanelServicePanelExtensionReceivedCallback
-> IO (FunPtr C_PanelServicePanelExtensionReceivedCallback)
mk_PanelServicePanelExtensionReceivedCallback C_PanelServicePanelExtensionReceivedCallback
cb'
    a
-> Text
-> FunPtr C_PanelServicePanelExtensionReceivedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"panel-extension-received" FunPtr C_PanelServicePanelExtensionReceivedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServicePanelExtensionReceivedSignalInfo
instance SignalInfo PanelServicePanelExtensionReceivedSignalInfo where
    type HaskellCallbackType PanelServicePanelExtensionReceivedSignalInfo = PanelServicePanelExtensionReceivedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServicePanelExtensionReceivedCallback cb
        cb'' <- mk_PanelServicePanelExtensionReceivedCallback cb'
        connectSignalFunPtr obj "panel-extension-received" cb'' connectMode detail

#endif

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

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceProcessKeyEventCallback`@.
noPanelServiceProcessKeyEventCallback :: Maybe PanelServiceProcessKeyEventCallback
noPanelServiceProcessKeyEventCallback :: Maybe PanelServiceProcessKeyEventCallback
noPanelServiceProcessKeyEventCallback = Maybe PanelServiceProcessKeyEventCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceProcessKeyEvent :: MonadIO m => PanelServiceProcessKeyEventCallback -> m (GClosure C_PanelServiceProcessKeyEventCallback)
genClosure_PanelServiceProcessKeyEvent :: forall (m :: * -> *).
MonadIO m =>
PanelServiceProcessKeyEventCallback
-> m (GClosure C_PanelServiceProcessKeyEventCallback)
genClosure_PanelServiceProcessKeyEvent PanelServiceProcessKeyEventCallback
cb = IO (GClosure C_PanelServiceProcessKeyEventCallback)
-> m (GClosure C_PanelServiceProcessKeyEventCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceProcessKeyEventCallback)
 -> m (GClosure C_PanelServiceProcessKeyEventCallback))
-> IO (GClosure C_PanelServiceProcessKeyEventCallback)
-> m (GClosure C_PanelServiceProcessKeyEventCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceProcessKeyEventCallback
cb' = PanelServiceProcessKeyEventCallback
-> C_PanelServiceProcessKeyEventCallback
wrap_PanelServiceProcessKeyEventCallback PanelServiceProcessKeyEventCallback
cb
    C_PanelServiceProcessKeyEventCallback
-> IO (FunPtr C_PanelServiceProcessKeyEventCallback)
mk_PanelServiceProcessKeyEventCallback C_PanelServiceProcessKeyEventCallback
cb' IO (FunPtr C_PanelServiceProcessKeyEventCallback)
-> (FunPtr C_PanelServiceProcessKeyEventCallback
    -> IO (GClosure C_PanelServiceProcessKeyEventCallback))
-> IO (GClosure C_PanelServiceProcessKeyEventCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceProcessKeyEventCallback
-> IO (GClosure C_PanelServiceProcessKeyEventCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


-- | Connect a signal handler for the [processKeyEvent](#signal:processKeyEvent) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' panelService #processKeyEvent callback
-- @
-- 
-- 
onPanelServiceProcessKeyEvent :: (IsPanelService a, MonadIO m) => a -> PanelServiceProcessKeyEventCallback -> m SignalHandlerId
onPanelServiceProcessKeyEvent :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceProcessKeyEventCallback -> m SignalHandlerId
onPanelServiceProcessKeyEvent a
obj PanelServiceProcessKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceProcessKeyEventCallback
cb' = PanelServiceProcessKeyEventCallback
-> C_PanelServiceProcessKeyEventCallback
wrap_PanelServiceProcessKeyEventCallback PanelServiceProcessKeyEventCallback
cb
    FunPtr C_PanelServiceProcessKeyEventCallback
cb'' <- C_PanelServiceProcessKeyEventCallback
-> IO (FunPtr C_PanelServiceProcessKeyEventCallback)
mk_PanelServiceProcessKeyEventCallback C_PanelServiceProcessKeyEventCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceProcessKeyEventCallback
-> 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_PanelServiceProcessKeyEventCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [processKeyEvent](#signal:processKeyEvent) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' panelService #processKeyEvent callback
-- @
-- 
-- 
afterPanelServiceProcessKeyEvent :: (IsPanelService a, MonadIO m) => a -> PanelServiceProcessKeyEventCallback -> m SignalHandlerId
afterPanelServiceProcessKeyEvent :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceProcessKeyEventCallback -> m SignalHandlerId
afterPanelServiceProcessKeyEvent a
obj PanelServiceProcessKeyEventCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceProcessKeyEventCallback
cb' = PanelServiceProcessKeyEventCallback
-> C_PanelServiceProcessKeyEventCallback
wrap_PanelServiceProcessKeyEventCallback PanelServiceProcessKeyEventCallback
cb
    FunPtr C_PanelServiceProcessKeyEventCallback
cb'' <- C_PanelServiceProcessKeyEventCallback
-> IO (FunPtr C_PanelServiceProcessKeyEventCallback)
mk_PanelServiceProcessKeyEventCallback C_PanelServiceProcessKeyEventCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceProcessKeyEventCallback
-> 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_PanelServiceProcessKeyEventCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceProcessKeyEventSignalInfo
instance SignalInfo PanelServiceProcessKeyEventSignalInfo where
    type HaskellCallbackType PanelServiceProcessKeyEventSignalInfo = PanelServiceProcessKeyEventCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceProcessKeyEventCallback cb
        cb'' <- mk_PanelServiceProcessKeyEventCallback cb'
        connectSignalFunPtr obj "process-key-event" cb'' connectMode detail

#endif

-- signal PanelService::register-properties
-- | Emitted when the client application get the [registerProperties](#g:signal:registerProperties).
-- Implement the member function
-- IBusPanelServiceClass[register_properties](#g:signal:register_properties) in extended class
-- to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceRegisterPropertiesCallback =
    IBus.PropList.PropList
    -- ^ /@propList@/: An IBusPropList that contains properties.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceRegisterPropertiesCallback`@.
noPanelServiceRegisterPropertiesCallback :: Maybe PanelServiceRegisterPropertiesCallback
noPanelServiceRegisterPropertiesCallback :: Maybe PanelServiceRegisterPropertiesCallback
noPanelServiceRegisterPropertiesCallback = Maybe PanelServiceRegisterPropertiesCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceRegisterProperties :: MonadIO m => PanelServiceRegisterPropertiesCallback -> m (GClosure C_PanelServiceRegisterPropertiesCallback)
genClosure_PanelServiceRegisterProperties :: forall (m :: * -> *).
MonadIO m =>
PanelServiceRegisterPropertiesCallback
-> m (GClosure C_PanelServiceRegisterPropertiesCallback)
genClosure_PanelServiceRegisterProperties PanelServiceRegisterPropertiesCallback
cb = IO (GClosure C_PanelServiceRegisterPropertiesCallback)
-> m (GClosure C_PanelServiceRegisterPropertiesCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceRegisterPropertiesCallback)
 -> m (GClosure C_PanelServiceRegisterPropertiesCallback))
-> IO (GClosure C_PanelServiceRegisterPropertiesCallback)
-> m (GClosure C_PanelServiceRegisterPropertiesCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceRegisterPropertiesCallback
cb' = PanelServiceRegisterPropertiesCallback
-> C_PanelServiceRegisterPropertiesCallback
wrap_PanelServiceRegisterPropertiesCallback PanelServiceRegisterPropertiesCallback
cb
    C_PanelServiceRegisterPropertiesCallback
-> IO (FunPtr C_PanelServiceRegisterPropertiesCallback)
mk_PanelServiceRegisterPropertiesCallback C_PanelServiceRegisterPropertiesCallback
cb' IO (FunPtr C_PanelServiceRegisterPropertiesCallback)
-> (FunPtr C_PanelServiceRegisterPropertiesCallback
    -> IO (GClosure C_PanelServiceRegisterPropertiesCallback))
-> IO (GClosure C_PanelServiceRegisterPropertiesCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceRegisterPropertiesCallback
-> IO (GClosure C_PanelServiceRegisterPropertiesCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceRegisterPropertiesCallback` into a `C_PanelServiceRegisterPropertiesCallback`.
wrap_PanelServiceRegisterPropertiesCallback ::
    PanelServiceRegisterPropertiesCallback ->
    C_PanelServiceRegisterPropertiesCallback
wrap_PanelServiceRegisterPropertiesCallback :: PanelServiceRegisterPropertiesCallback
-> C_PanelServiceRegisterPropertiesCallback
wrap_PanelServiceRegisterPropertiesCallback PanelServiceRegisterPropertiesCallback
_cb Ptr ()
_ Ptr PropList
propList Ptr ()
_ = do
    PropList
propList' <- ((ManagedPtr PropList -> PropList) -> Ptr PropList -> IO PropList
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PropList -> PropList
IBus.PropList.PropList) Ptr PropList
propList
    PanelServiceRegisterPropertiesCallback
_cb  PropList
propList'


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceRegisterPropertiesSignalInfo
instance SignalInfo PanelServiceRegisterPropertiesSignalInfo where
    type HaskellCallbackType PanelServiceRegisterPropertiesSignalInfo = PanelServiceRegisterPropertiesCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceRegisterPropertiesCallback cb
        cb'' <- mk_PanelServiceRegisterPropertiesCallback cb'
        connectSignalFunPtr obj "register-properties" cb'' connectMode detail

#endif

-- signal PanelService::reset
-- | Emitted when the client application get the [reset](#g:signal:reset).
-- Implement the member function
-- IBusPanelServiceClass[reset](#g:signal:reset) in extended class to receive this
-- signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceResetCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceReset :: MonadIO m => PanelServiceResetCallback -> m (GClosure C_PanelServiceResetCallback)
genClosure_PanelServiceReset :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceReset IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceResetCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceResetCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceResetCallback` into a `C_PanelServiceResetCallback`.
wrap_PanelServiceResetCallback ::
    PanelServiceResetCallback ->
    C_PanelServiceResetCallback
wrap_PanelServiceResetCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceResetCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [reset](#signal:reset) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' panelService #reset callback
-- @
-- 
-- 
onPanelServiceReset :: (IsPanelService a, MonadIO m) => a -> PanelServiceResetCallback -> m SignalHandlerId
onPanelServiceReset :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onPanelServiceReset a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceResetCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceResetCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> 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_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [reset](#signal:reset) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' panelService #reset callback
-- @
-- 
-- 
afterPanelServiceReset :: (IsPanelService a, MonadIO m) => a -> PanelServiceResetCallback -> m SignalHandlerId
afterPanelServiceReset :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterPanelServiceReset a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceResetCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceResetCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> 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_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceResetSignalInfo
instance SignalInfo PanelServiceResetSignalInfo where
    type HaskellCallbackType PanelServiceResetSignalInfo = PanelServiceResetCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceResetCallback cb
        cb'' <- mk_PanelServiceResetCallback cb'
        connectSignalFunPtr obj "reset" cb'' connectMode detail

#endif

-- signal PanelService::set-content-type
-- | Emitted when the client application get the [setContentType](#g:signal:setContentType).
-- Implement the member function
-- IBusPanelServiceClass[set_content_type](#g:signal:set_content_type) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceSetContentTypeCallback =
    Word32
    -- ^ /@purpose@/: Input purpose.
    -> Word32
    -- ^ /@hints@/: Input hints.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceSetContentTypeCallback`@.
noPanelServiceSetContentTypeCallback :: Maybe PanelServiceSetContentTypeCallback
noPanelServiceSetContentTypeCallback :: Maybe PanelServiceSetContentTypeCallback
noPanelServiceSetContentTypeCallback = Maybe PanelServiceSetContentTypeCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceSetContentType :: MonadIO m => PanelServiceSetContentTypeCallback -> m (GClosure C_PanelServiceSetContentTypeCallback)
genClosure_PanelServiceSetContentType :: forall (m :: * -> *).
MonadIO m =>
PanelServiceSetContentTypeCallback
-> m (GClosure C_PanelServiceSetContentTypeCallback)
genClosure_PanelServiceSetContentType PanelServiceSetContentTypeCallback
cb = IO (GClosure C_PanelServiceSetContentTypeCallback)
-> m (GClosure C_PanelServiceSetContentTypeCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceSetContentTypeCallback)
 -> m (GClosure C_PanelServiceSetContentTypeCallback))
-> IO (GClosure C_PanelServiceSetContentTypeCallback)
-> m (GClosure C_PanelServiceSetContentTypeCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceSetContentTypeCallback
cb' = PanelServiceSetContentTypeCallback
-> C_PanelServiceSetContentTypeCallback
wrap_PanelServiceSetContentTypeCallback PanelServiceSetContentTypeCallback
cb
    C_PanelServiceSetContentTypeCallback
-> IO (FunPtr C_PanelServiceSetContentTypeCallback)
mk_PanelServiceSetContentTypeCallback C_PanelServiceSetContentTypeCallback
cb' IO (FunPtr C_PanelServiceSetContentTypeCallback)
-> (FunPtr C_PanelServiceSetContentTypeCallback
    -> IO (GClosure C_PanelServiceSetContentTypeCallback))
-> IO (GClosure C_PanelServiceSetContentTypeCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceSetContentTypeCallback
-> IO (GClosure C_PanelServiceSetContentTypeCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceSetContentTypeCallback` into a `C_PanelServiceSetContentTypeCallback`.
wrap_PanelServiceSetContentTypeCallback ::
    PanelServiceSetContentTypeCallback ->
    C_PanelServiceSetContentTypeCallback
wrap_PanelServiceSetContentTypeCallback :: PanelServiceSetContentTypeCallback
-> C_PanelServiceSetContentTypeCallback
wrap_PanelServiceSetContentTypeCallback PanelServiceSetContentTypeCallback
_cb Ptr ()
_ Word32
purpose Word32
hints Ptr ()
_ = do
    PanelServiceSetContentTypeCallback
_cb  Word32
purpose Word32
hints


-- | Connect a signal handler for the [setContentType](#signal:setContentType) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' panelService #setContentType callback
-- @
-- 
-- 
onPanelServiceSetContentType :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetContentTypeCallback -> m SignalHandlerId
onPanelServiceSetContentType :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceSetContentTypeCallback -> m SignalHandlerId
onPanelServiceSetContentType a
obj PanelServiceSetContentTypeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceSetContentTypeCallback
cb' = PanelServiceSetContentTypeCallback
-> C_PanelServiceSetContentTypeCallback
wrap_PanelServiceSetContentTypeCallback PanelServiceSetContentTypeCallback
cb
    FunPtr C_PanelServiceSetContentTypeCallback
cb'' <- C_PanelServiceSetContentTypeCallback
-> IO (FunPtr C_PanelServiceSetContentTypeCallback)
mk_PanelServiceSetContentTypeCallback C_PanelServiceSetContentTypeCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceSetContentTypeCallback
-> 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_PanelServiceSetContentTypeCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [setContentType](#signal:setContentType) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' panelService #setContentType callback
-- @
-- 
-- 
afterPanelServiceSetContentType :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetContentTypeCallback -> m SignalHandlerId
afterPanelServiceSetContentType :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceSetContentTypeCallback -> m SignalHandlerId
afterPanelServiceSetContentType a
obj PanelServiceSetContentTypeCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceSetContentTypeCallback
cb' = PanelServiceSetContentTypeCallback
-> C_PanelServiceSetContentTypeCallback
wrap_PanelServiceSetContentTypeCallback PanelServiceSetContentTypeCallback
cb
    FunPtr C_PanelServiceSetContentTypeCallback
cb'' <- C_PanelServiceSetContentTypeCallback
-> IO (FunPtr C_PanelServiceSetContentTypeCallback)
mk_PanelServiceSetContentTypeCallback C_PanelServiceSetContentTypeCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceSetContentTypeCallback
-> 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_PanelServiceSetContentTypeCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceSetContentTypeSignalInfo
instance SignalInfo PanelServiceSetContentTypeSignalInfo where
    type HaskellCallbackType PanelServiceSetContentTypeSignalInfo = PanelServiceSetContentTypeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceSetContentTypeCallback cb
        cb'' <- mk_PanelServiceSetContentTypeCallback cb'
        connectSignalFunPtr obj "set-content-type" cb'' connectMode detail

#endif

-- signal PanelService::set-cursor-location
-- | Emitted when the client application get the [setCursorLocation](#g:signal:setCursorLocation).
-- Implement the member function
-- IBusPanelServiceClass[set_cursor_location](#g:signal:set_cursor_location) in extended class
-- to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceSetCursorLocationCallback =
    Int32
    -- ^ /@x@/: X coordinate of the cursor.
    -> Int32
    -- ^ /@y@/: Y coordinate of the cursor.
    -> Int32
    -- ^ /@w@/: Width of the cursor.
    -> Int32
    -- ^ /@h@/: Height of the cursor.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceSetCursorLocationCallback`@.
noPanelServiceSetCursorLocationCallback :: Maybe PanelServiceSetCursorLocationCallback
noPanelServiceSetCursorLocationCallback :: Maybe PanelServiceSetCursorLocationCallback
noPanelServiceSetCursorLocationCallback = Maybe PanelServiceSetCursorLocationCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceSetCursorLocation :: MonadIO m => PanelServiceSetCursorLocationCallback -> m (GClosure C_PanelServiceSetCursorLocationCallback)
genClosure_PanelServiceSetCursorLocation :: forall (m :: * -> *).
MonadIO m =>
PanelServiceSetCursorLocationCallback
-> m (GClosure C_PanelServiceSetCursorLocationCallback)
genClosure_PanelServiceSetCursorLocation PanelServiceSetCursorLocationCallback
cb = IO (GClosure C_PanelServiceSetCursorLocationCallback)
-> m (GClosure C_PanelServiceSetCursorLocationCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceSetCursorLocationCallback)
 -> m (GClosure C_PanelServiceSetCursorLocationCallback))
-> IO (GClosure C_PanelServiceSetCursorLocationCallback)
-> m (GClosure C_PanelServiceSetCursorLocationCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceSetCursorLocationCallback
cb' = PanelServiceSetCursorLocationCallback
-> C_PanelServiceSetCursorLocationCallback
wrap_PanelServiceSetCursorLocationCallback PanelServiceSetCursorLocationCallback
cb
    C_PanelServiceSetCursorLocationCallback
-> IO (FunPtr C_PanelServiceSetCursorLocationCallback)
mk_PanelServiceSetCursorLocationCallback C_PanelServiceSetCursorLocationCallback
cb' IO (FunPtr C_PanelServiceSetCursorLocationCallback)
-> (FunPtr C_PanelServiceSetCursorLocationCallback
    -> IO (GClosure C_PanelServiceSetCursorLocationCallback))
-> IO (GClosure C_PanelServiceSetCursorLocationCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceSetCursorLocationCallback
-> IO (GClosure C_PanelServiceSetCursorLocationCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceSetCursorLocationCallback` into a `C_PanelServiceSetCursorLocationCallback`.
wrap_PanelServiceSetCursorLocationCallback ::
    PanelServiceSetCursorLocationCallback ->
    C_PanelServiceSetCursorLocationCallback
wrap_PanelServiceSetCursorLocationCallback :: PanelServiceSetCursorLocationCallback
-> C_PanelServiceSetCursorLocationCallback
wrap_PanelServiceSetCursorLocationCallback PanelServiceSetCursorLocationCallback
_cb Ptr ()
_ Int32
x Int32
y Int32
w Int32
h Ptr ()
_ = do
    PanelServiceSetCursorLocationCallback
_cb  Int32
x Int32
y Int32
w Int32
h


-- | Connect a signal handler for the [setCursorLocation](#signal:setCursorLocation) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' panelService #setCursorLocation callback
-- @
-- 
-- 
onPanelServiceSetCursorLocation :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetCursorLocationCallback -> m SignalHandlerId
onPanelServiceSetCursorLocation :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceSetCursorLocationCallback -> m SignalHandlerId
onPanelServiceSetCursorLocation a
obj PanelServiceSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceSetCursorLocationCallback
cb' = PanelServiceSetCursorLocationCallback
-> C_PanelServiceSetCursorLocationCallback
wrap_PanelServiceSetCursorLocationCallback PanelServiceSetCursorLocationCallback
cb
    FunPtr C_PanelServiceSetCursorLocationCallback
cb'' <- C_PanelServiceSetCursorLocationCallback
-> IO (FunPtr C_PanelServiceSetCursorLocationCallback)
mk_PanelServiceSetCursorLocationCallback C_PanelServiceSetCursorLocationCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceSetCursorLocationCallback
-> 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_PanelServiceSetCursorLocationCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [setCursorLocation](#signal:setCursorLocation) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' panelService #setCursorLocation callback
-- @
-- 
-- 
afterPanelServiceSetCursorLocation :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetCursorLocationCallback -> m SignalHandlerId
afterPanelServiceSetCursorLocation :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceSetCursorLocationCallback -> m SignalHandlerId
afterPanelServiceSetCursorLocation a
obj PanelServiceSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceSetCursorLocationCallback
cb' = PanelServiceSetCursorLocationCallback
-> C_PanelServiceSetCursorLocationCallback
wrap_PanelServiceSetCursorLocationCallback PanelServiceSetCursorLocationCallback
cb
    FunPtr C_PanelServiceSetCursorLocationCallback
cb'' <- C_PanelServiceSetCursorLocationCallback
-> IO (FunPtr C_PanelServiceSetCursorLocationCallback)
mk_PanelServiceSetCursorLocationCallback C_PanelServiceSetCursorLocationCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceSetCursorLocationCallback
-> 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_PanelServiceSetCursorLocationCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceSetCursorLocationSignalInfo
instance SignalInfo PanelServiceSetCursorLocationSignalInfo where
    type HaskellCallbackType PanelServiceSetCursorLocationSignalInfo = PanelServiceSetCursorLocationCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceSetCursorLocationCallback cb
        cb'' <- mk_PanelServiceSetCursorLocationCallback cb'
        connectSignalFunPtr obj "set-cursor-location" cb'' connectMode detail

#endif

-- signal PanelService::set-cursor-location-relative
-- | Emitted when the client application get the set-cursor-location-relative.
-- Implement the member function @/set_cursor_location_relative()/@ in
-- extended class to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceSetCursorLocationRelativeCallback =
    Int32
    -- ^ /@x@/: X coordinate of the cursor.
    -> Int32
    -- ^ /@y@/: Y coordinate of the cursor.
    -> Int32
    -- ^ /@w@/: Width of the cursor.
    -> Int32
    -- ^ /@h@/: Height of the cursor.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceSetCursorLocationRelativeCallback`@.
noPanelServiceSetCursorLocationRelativeCallback :: Maybe PanelServiceSetCursorLocationRelativeCallback
noPanelServiceSetCursorLocationRelativeCallback :: Maybe PanelServiceSetCursorLocationCallback
noPanelServiceSetCursorLocationRelativeCallback = Maybe PanelServiceSetCursorLocationCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceSetCursorLocationRelative :: MonadIO m => PanelServiceSetCursorLocationRelativeCallback -> m (GClosure C_PanelServiceSetCursorLocationRelativeCallback)
genClosure_PanelServiceSetCursorLocationRelative :: forall (m :: * -> *).
MonadIO m =>
PanelServiceSetCursorLocationCallback
-> m (GClosure C_PanelServiceSetCursorLocationCallback)
genClosure_PanelServiceSetCursorLocationRelative PanelServiceSetCursorLocationCallback
cb = IO (GClosure C_PanelServiceSetCursorLocationCallback)
-> m (GClosure C_PanelServiceSetCursorLocationCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceSetCursorLocationCallback)
 -> m (GClosure C_PanelServiceSetCursorLocationCallback))
-> IO (GClosure C_PanelServiceSetCursorLocationCallback)
-> m (GClosure C_PanelServiceSetCursorLocationCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceSetCursorLocationCallback
cb' = PanelServiceSetCursorLocationCallback
-> C_PanelServiceSetCursorLocationCallback
wrap_PanelServiceSetCursorLocationRelativeCallback PanelServiceSetCursorLocationCallback
cb
    C_PanelServiceSetCursorLocationCallback
-> IO (FunPtr C_PanelServiceSetCursorLocationCallback)
mk_PanelServiceSetCursorLocationRelativeCallback C_PanelServiceSetCursorLocationCallback
cb' IO (FunPtr C_PanelServiceSetCursorLocationCallback)
-> (FunPtr C_PanelServiceSetCursorLocationCallback
    -> IO (GClosure C_PanelServiceSetCursorLocationCallback))
-> IO (GClosure C_PanelServiceSetCursorLocationCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceSetCursorLocationCallback
-> IO (GClosure C_PanelServiceSetCursorLocationCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceSetCursorLocationRelativeCallback` into a `C_PanelServiceSetCursorLocationRelativeCallback`.
wrap_PanelServiceSetCursorLocationRelativeCallback ::
    PanelServiceSetCursorLocationRelativeCallback ->
    C_PanelServiceSetCursorLocationRelativeCallback
wrap_PanelServiceSetCursorLocationRelativeCallback :: PanelServiceSetCursorLocationCallback
-> C_PanelServiceSetCursorLocationCallback
wrap_PanelServiceSetCursorLocationRelativeCallback PanelServiceSetCursorLocationCallback
_cb Ptr ()
_ Int32
x Int32
y Int32
w Int32
h Ptr ()
_ = do
    PanelServiceSetCursorLocationCallback
_cb  Int32
x Int32
y Int32
w Int32
h


-- | Connect a signal handler for the [setCursorLocationRelative](#signal:setCursorLocationRelative) 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' panelService #setCursorLocationRelative callback
-- @
-- 
-- 
onPanelServiceSetCursorLocationRelative :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetCursorLocationRelativeCallback -> m SignalHandlerId
onPanelServiceSetCursorLocationRelative :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceSetCursorLocationCallback -> m SignalHandlerId
onPanelServiceSetCursorLocationRelative a
obj PanelServiceSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceSetCursorLocationCallback
cb' = PanelServiceSetCursorLocationCallback
-> C_PanelServiceSetCursorLocationCallback
wrap_PanelServiceSetCursorLocationRelativeCallback PanelServiceSetCursorLocationCallback
cb
    FunPtr C_PanelServiceSetCursorLocationCallback
cb'' <- C_PanelServiceSetCursorLocationCallback
-> IO (FunPtr C_PanelServiceSetCursorLocationCallback)
mk_PanelServiceSetCursorLocationRelativeCallback C_PanelServiceSetCursorLocationCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceSetCursorLocationCallback
-> 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-relative" FunPtr C_PanelServiceSetCursorLocationCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [setCursorLocationRelative](#signal:setCursorLocationRelative) 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' panelService #setCursorLocationRelative callback
-- @
-- 
-- 
afterPanelServiceSetCursorLocationRelative :: (IsPanelService a, MonadIO m) => a -> PanelServiceSetCursorLocationRelativeCallback -> m SignalHandlerId
afterPanelServiceSetCursorLocationRelative :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> PanelServiceSetCursorLocationCallback -> m SignalHandlerId
afterPanelServiceSetCursorLocationRelative a
obj PanelServiceSetCursorLocationCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceSetCursorLocationCallback
cb' = PanelServiceSetCursorLocationCallback
-> C_PanelServiceSetCursorLocationCallback
wrap_PanelServiceSetCursorLocationRelativeCallback PanelServiceSetCursorLocationCallback
cb
    FunPtr C_PanelServiceSetCursorLocationCallback
cb'' <- C_PanelServiceSetCursorLocationCallback
-> IO (FunPtr C_PanelServiceSetCursorLocationCallback)
mk_PanelServiceSetCursorLocationRelativeCallback C_PanelServiceSetCursorLocationCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceSetCursorLocationCallback
-> 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-relative" FunPtr C_PanelServiceSetCursorLocationCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceSetCursorLocationRelativeSignalInfo
instance SignalInfo PanelServiceSetCursorLocationRelativeSignalInfo where
    type HaskellCallbackType PanelServiceSetCursorLocationRelativeSignalInfo = PanelServiceSetCursorLocationRelativeCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceSetCursorLocationRelativeCallback cb
        cb'' <- mk_PanelServiceSetCursorLocationRelativeCallback cb'
        connectSignalFunPtr obj "set-cursor-location-relative" cb'' connectMode detail

#endif

-- signal PanelService::show-auxiliary-text
-- | Emitted when the client application get the [showAuxiliaryText](#g:signal:showAuxiliaryText).
-- Implement the member function
-- IBusPanelServiceClass[show_auxiliary_text](#g:signal:show_auxiliary_text) in extended class
-- to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceShowAuxiliaryTextCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceShowAuxiliaryText :: MonadIO m => PanelServiceShowAuxiliaryTextCallback -> m (GClosure C_PanelServiceShowAuxiliaryTextCallback)
genClosure_PanelServiceShowAuxiliaryText :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceShowAuxiliaryText IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowAuxiliaryTextCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceShowAuxiliaryTextCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceShowAuxiliaryTextCallback` into a `C_PanelServiceShowAuxiliaryTextCallback`.
wrap_PanelServiceShowAuxiliaryTextCallback ::
    PanelServiceShowAuxiliaryTextCallback ->
    C_PanelServiceShowAuxiliaryTextCallback
wrap_PanelServiceShowAuxiliaryTextCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowAuxiliaryTextCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceShowAuxiliaryTextSignalInfo
instance SignalInfo PanelServiceShowAuxiliaryTextSignalInfo where
    type HaskellCallbackType PanelServiceShowAuxiliaryTextSignalInfo = PanelServiceShowAuxiliaryTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceShowAuxiliaryTextCallback cb
        cb'' <- mk_PanelServiceShowAuxiliaryTextCallback cb'
        connectSignalFunPtr obj "show-auxiliary-text" cb'' connectMode detail

#endif

-- signal PanelService::show-language-bar
-- | Emitted when the client application get the [showLanguageBar](#g:signal:showLanguageBar).
-- Implement the member function
-- IBusPanelServiceClass[show_language_bar](#g:signal:show_language_bar) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceShowLanguageBarCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceShowLanguageBar :: MonadIO m => PanelServiceShowLanguageBarCallback -> m (GClosure C_PanelServiceShowLanguageBarCallback)
genClosure_PanelServiceShowLanguageBar :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceShowLanguageBar IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowLanguageBarCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceShowLanguageBarCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceShowLanguageBarCallback` into a `C_PanelServiceShowLanguageBarCallback`.
wrap_PanelServiceShowLanguageBarCallback ::
    PanelServiceShowLanguageBarCallback ->
    C_PanelServiceShowLanguageBarCallback
wrap_PanelServiceShowLanguageBarCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowLanguageBarCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [showLanguageBar](#signal:showLanguageBar) 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' panelService #showLanguageBar callback
-- @
-- 
-- 
onPanelServiceShowLanguageBar :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowLanguageBarCallback -> m SignalHandlerId
onPanelServiceShowLanguageBar :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onPanelServiceShowLanguageBar a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowLanguageBarCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceShowLanguageBarCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-language-bar" FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [showLanguageBar](#signal:showLanguageBar) 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' panelService #showLanguageBar callback
-- @
-- 
-- 
afterPanelServiceShowLanguageBar :: (IsPanelService a, MonadIO m) => a -> PanelServiceShowLanguageBarCallback -> m SignalHandlerId
afterPanelServiceShowLanguageBar :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterPanelServiceShowLanguageBar a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowLanguageBarCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceShowLanguageBarCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-language-bar" FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceShowLanguageBarSignalInfo
instance SignalInfo PanelServiceShowLanguageBarSignalInfo where
    type HaskellCallbackType PanelServiceShowLanguageBarSignalInfo = PanelServiceShowLanguageBarCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceShowLanguageBarCallback cb
        cb'' <- mk_PanelServiceShowLanguageBarCallback cb'
        connectSignalFunPtr obj "show-language-bar" cb'' connectMode detail

#endif

-- signal PanelService::show-lookup-table
-- | Emitted when the client application get the [showLookupTable](#g:signal:showLookupTable).
-- Implement the member function
-- IBusPanelServiceClass[show_lookup_table](#g:signal:show_lookup_table) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceShowLookupTableCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceShowLookupTable :: MonadIO m => PanelServiceShowLookupTableCallback -> m (GClosure C_PanelServiceShowLookupTableCallback)
genClosure_PanelServiceShowLookupTable :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceShowLookupTable IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowLookupTableCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceShowLookupTableCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceShowLookupTableCallback` into a `C_PanelServiceShowLookupTableCallback`.
wrap_PanelServiceShowLookupTableCallback ::
    PanelServiceShowLookupTableCallback ->
    C_PanelServiceShowLookupTableCallback
wrap_PanelServiceShowLookupTableCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowLookupTableCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceShowLookupTableSignalInfo
instance SignalInfo PanelServiceShowLookupTableSignalInfo where
    type HaskellCallbackType PanelServiceShowLookupTableSignalInfo = PanelServiceShowLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceShowLookupTableCallback cb
        cb'' <- mk_PanelServiceShowLookupTableCallback cb'
        connectSignalFunPtr obj "show-lookup-table" cb'' connectMode detail

#endif

-- signal PanelService::show-preedit-text
-- | Emitted when the client application get the [showPreeditText](#g:signal:showPreeditText).
-- Implement the member function
-- IBusPanelServiceClass[show_preedit_text](#g:signal:show_preedit_text) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceShowPreeditTextCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceShowPreeditText :: MonadIO m => PanelServiceShowPreeditTextCallback -> m (GClosure C_PanelServiceShowPreeditTextCallback)
genClosure_PanelServiceShowPreeditText :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceShowPreeditText IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowPreeditTextCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceShowPreeditTextCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceShowPreeditTextCallback` into a `C_PanelServiceShowPreeditTextCallback`.
wrap_PanelServiceShowPreeditTextCallback ::
    PanelServiceShowPreeditTextCallback ->
    C_PanelServiceShowPreeditTextCallback
wrap_PanelServiceShowPreeditTextCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceShowPreeditTextCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceShowPreeditTextSignalInfo
instance SignalInfo PanelServiceShowPreeditTextSignalInfo where
    type HaskellCallbackType PanelServiceShowPreeditTextSignalInfo = PanelServiceShowPreeditTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceShowPreeditTextCallback cb
        cb'' <- mk_PanelServiceShowPreeditTextCallback cb'
        connectSignalFunPtr obj "show-preedit-text" cb'' connectMode detail

#endif

-- signal PanelService::start-setup
-- | Emitted when the client application get the [startSetup](#g:signal:startSetup).
-- Implement the member function
-- IBusPanelServiceClass[start_setup](#g:signal:start_setup) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceStartSetupCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceStartSetup :: MonadIO m => PanelServiceStartSetupCallback -> m (GClosure C_PanelServiceStartSetupCallback)
genClosure_PanelServiceStartSetup :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceStartSetup IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceStartSetupCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceStartSetupCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceStartSetupCallback` into a `C_PanelServiceStartSetupCallback`.
wrap_PanelServiceStartSetupCallback ::
    PanelServiceStartSetupCallback ->
    C_PanelServiceStartSetupCallback
wrap_PanelServiceStartSetupCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceStartSetupCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [startSetup](#signal:startSetup) 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' panelService #startSetup callback
-- @
-- 
-- 
onPanelServiceStartSetup :: (IsPanelService a, MonadIO m) => a -> PanelServiceStartSetupCallback -> m SignalHandlerId
onPanelServiceStartSetup :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onPanelServiceStartSetup a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceStartSetupCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceStartSetupCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"start-setup" FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [startSetup](#signal:startSetup) 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' panelService #startSetup callback
-- @
-- 
-- 
afterPanelServiceStartSetup :: (IsPanelService a, MonadIO m) => a -> PanelServiceStartSetupCallback -> m SignalHandlerId
afterPanelServiceStartSetup :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterPanelServiceStartSetup a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceStartSetupCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceStartSetupCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"start-setup" FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceStartSetupSignalInfo
instance SignalInfo PanelServiceStartSetupSignalInfo where
    type HaskellCallbackType PanelServiceStartSetupSignalInfo = PanelServiceStartSetupCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceStartSetupCallback cb
        cb'' <- mk_PanelServiceStartSetupCallback cb'
        connectSignalFunPtr obj "start-setup" cb'' connectMode detail

#endif

-- signal PanelService::state-changed
-- | Emitted when the client application get the [stateChanged](#g:signal:stateChanged).
-- Implement the member function
-- IBusPanelServiceClass[state_changed](#g:signal:state_changed) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceStateChangedCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceStateChanged :: MonadIO m => PanelServiceStateChangedCallback -> m (GClosure C_PanelServiceStateChangedCallback)
genClosure_PanelServiceStateChanged :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
genClosure_PanelServiceStateChanged IO ()
cb = IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
 -> m (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
-> m (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceStateChangedCallback IO ()
cb
    C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceStateChangedCallback C_PanelServiceCursorDownLookupTableCallback
cb' IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
-> (FunPtr C_PanelServiceCursorDownLookupTableCallback
    -> IO (GClosure C_PanelServiceCursorDownLookupTableCallback))
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceCursorDownLookupTableCallback
-> IO (GClosure C_PanelServiceCursorDownLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `PanelServiceStateChangedCallback` into a `C_PanelServiceStateChangedCallback`.
wrap_PanelServiceStateChangedCallback ::
    PanelServiceStateChangedCallback ->
    C_PanelServiceStateChangedCallback
wrap_PanelServiceStateChangedCallback :: IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceStateChangedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [stateChanged](#signal:stateChanged) 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' panelService #stateChanged callback
-- @
-- 
-- 
onPanelServiceStateChanged :: (IsPanelService a, MonadIO m) => a -> PanelServiceStateChangedCallback -> m SignalHandlerId
onPanelServiceStateChanged :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onPanelServiceStateChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceStateChangedCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceStateChangedCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"state-changed" FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [stateChanged](#signal:stateChanged) 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' panelService #stateChanged callback
-- @
-- 
-- 
afterPanelServiceStateChanged :: (IsPanelService a, MonadIO m) => a -> PanelServiceStateChangedCallback -> m SignalHandlerId
afterPanelServiceStateChanged :: forall a (m :: * -> *).
(IsPanelService a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterPanelServiceStateChanged a
obj IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceCursorDownLookupTableCallback
cb' = IO () -> C_PanelServiceCursorDownLookupTableCallback
wrap_PanelServiceStateChangedCallback IO ()
cb
    FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' <- C_PanelServiceCursorDownLookupTableCallback
-> IO (FunPtr C_PanelServiceCursorDownLookupTableCallback)
mk_PanelServiceStateChangedCallback C_PanelServiceCursorDownLookupTableCallback
cb'
    a
-> Text
-> FunPtr C_PanelServiceCursorDownLookupTableCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"state-changed" FunPtr C_PanelServiceCursorDownLookupTableCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data PanelServiceStateChangedSignalInfo
instance SignalInfo PanelServiceStateChangedSignalInfo where
    type HaskellCallbackType PanelServiceStateChangedSignalInfo = PanelServiceStateChangedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceStateChangedCallback cb
        cb'' <- mk_PanelServiceStateChangedCallback cb'
        connectSignalFunPtr obj "state-changed" cb'' connectMode detail

#endif

-- signal PanelService::update-auxiliary-text
-- | Emitted when the client application get the [updateAuxiliaryText](#g:signal:updateAuxiliaryText).
-- Implement the member function
-- IBusPanelServiceClass[update_auxiliary_text](#g:signal:update_auxiliary_text) in extended class
-- to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceUpdateAuxiliaryTextCallback =
    IBus.Text.Text
    -- ^ /@text@/: A preedit text to be updated.
    -> Bool
    -- ^ /@visible@/: Whether the update is visible.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceUpdateAuxiliaryTextCallback`@.
noPanelServiceUpdateAuxiliaryTextCallback :: Maybe PanelServiceUpdateAuxiliaryTextCallback
noPanelServiceUpdateAuxiliaryTextCallback :: Maybe PanelServiceUpdateAuxiliaryTextCallback
noPanelServiceUpdateAuxiliaryTextCallback = Maybe PanelServiceUpdateAuxiliaryTextCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceUpdateAuxiliaryText :: MonadIO m => PanelServiceUpdateAuxiliaryTextCallback -> m (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)
genClosure_PanelServiceUpdateAuxiliaryText :: forall (m :: * -> *).
MonadIO m =>
PanelServiceUpdateAuxiliaryTextCallback
-> m (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)
genClosure_PanelServiceUpdateAuxiliaryText PanelServiceUpdateAuxiliaryTextCallback
cb = IO (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)
-> m (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)
 -> m (GClosure C_PanelServiceUpdateAuxiliaryTextCallback))
-> IO (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)
-> m (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceUpdateAuxiliaryTextCallback
cb' = PanelServiceUpdateAuxiliaryTextCallback
-> C_PanelServiceUpdateAuxiliaryTextCallback
wrap_PanelServiceUpdateAuxiliaryTextCallback PanelServiceUpdateAuxiliaryTextCallback
cb
    C_PanelServiceUpdateAuxiliaryTextCallback
-> IO (FunPtr C_PanelServiceUpdateAuxiliaryTextCallback)
mk_PanelServiceUpdateAuxiliaryTextCallback C_PanelServiceUpdateAuxiliaryTextCallback
cb' IO (FunPtr C_PanelServiceUpdateAuxiliaryTextCallback)
-> (FunPtr C_PanelServiceUpdateAuxiliaryTextCallback
    -> IO (GClosure C_PanelServiceUpdateAuxiliaryTextCallback))
-> IO (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceUpdateAuxiliaryTextCallback
-> IO (GClosure C_PanelServiceUpdateAuxiliaryTextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceUpdateAuxiliaryTextSignalInfo
instance SignalInfo PanelServiceUpdateAuxiliaryTextSignalInfo where
    type HaskellCallbackType PanelServiceUpdateAuxiliaryTextSignalInfo = PanelServiceUpdateAuxiliaryTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceUpdateAuxiliaryTextCallback cb
        cb'' <- mk_PanelServiceUpdateAuxiliaryTextCallback cb'
        connectSignalFunPtr obj "update-auxiliary-text" cb'' connectMode detail

#endif

-- signal PanelService::update-lookup-table
-- | Emitted when the client application get the [updateLookupTable](#g:signal:updateLookupTable).
-- Implement the member function
-- IBusPanelServiceClass[update_lookup_table](#g:signal:update_lookup_table) in extended class
-- to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceUpdateLookupTableCallback =
    IBus.LookupTable.LookupTable
    -- ^ /@lookupTable@/: A lookup table to be updated.
    -> Bool
    -- ^ /@visible@/: Whether the update is visible.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceUpdateLookupTableCallback`@.
noPanelServiceUpdateLookupTableCallback :: Maybe PanelServiceUpdateLookupTableCallback
noPanelServiceUpdateLookupTableCallback :: Maybe PanelServiceUpdateLookupTableCallback
noPanelServiceUpdateLookupTableCallback = Maybe PanelServiceUpdateLookupTableCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceUpdateLookupTable :: MonadIO m => PanelServiceUpdateLookupTableCallback -> m (GClosure C_PanelServiceUpdateLookupTableCallback)
genClosure_PanelServiceUpdateLookupTable :: forall (m :: * -> *).
MonadIO m =>
PanelServiceUpdateLookupTableCallback
-> m (GClosure C_PanelServiceUpdateLookupTableCallback)
genClosure_PanelServiceUpdateLookupTable PanelServiceUpdateLookupTableCallback
cb = IO (GClosure C_PanelServiceUpdateLookupTableCallback)
-> m (GClosure C_PanelServiceUpdateLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceUpdateLookupTableCallback)
 -> m (GClosure C_PanelServiceUpdateLookupTableCallback))
-> IO (GClosure C_PanelServiceUpdateLookupTableCallback)
-> m (GClosure C_PanelServiceUpdateLookupTableCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceUpdateLookupTableCallback
cb' = PanelServiceUpdateLookupTableCallback
-> C_PanelServiceUpdateLookupTableCallback
wrap_PanelServiceUpdateLookupTableCallback PanelServiceUpdateLookupTableCallback
cb
    C_PanelServiceUpdateLookupTableCallback
-> IO (FunPtr C_PanelServiceUpdateLookupTableCallback)
mk_PanelServiceUpdateLookupTableCallback C_PanelServiceUpdateLookupTableCallback
cb' IO (FunPtr C_PanelServiceUpdateLookupTableCallback)
-> (FunPtr C_PanelServiceUpdateLookupTableCallback
    -> IO (GClosure C_PanelServiceUpdateLookupTableCallback))
-> IO (GClosure C_PanelServiceUpdateLookupTableCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceUpdateLookupTableCallback
-> IO (GClosure C_PanelServiceUpdateLookupTableCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceUpdateLookupTableSignalInfo
instance SignalInfo PanelServiceUpdateLookupTableSignalInfo where
    type HaskellCallbackType PanelServiceUpdateLookupTableSignalInfo = PanelServiceUpdateLookupTableCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceUpdateLookupTableCallback cb
        cb'' <- mk_PanelServiceUpdateLookupTableCallback cb'
        connectSignalFunPtr obj "update-lookup-table" cb'' connectMode detail

#endif

-- signal PanelService::update-preedit-text
-- | Emitted when the client application get the [updatePreeditText](#g:signal:updatePreeditText).
-- Implement the member function
-- IBusPanelServiceClass[update_preedit_text](#g:signal:update_preedit_text) in extended class
-- to receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceUpdatePreeditTextCallback =
    IBus.Text.Text
    -- ^ /@text@/: A preedit text to be updated.
    -> Word32
    -- ^ /@cursorPos@/: The cursor position of the text.
    -> Bool
    -- ^ /@visible@/: Whether the update is visible.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceUpdatePreeditTextCallback`@.
noPanelServiceUpdatePreeditTextCallback :: Maybe PanelServiceUpdatePreeditTextCallback
noPanelServiceUpdatePreeditTextCallback :: Maybe PanelServiceUpdatePreeditTextCallback
noPanelServiceUpdatePreeditTextCallback = Maybe PanelServiceUpdatePreeditTextCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceUpdatePreeditText :: MonadIO m => PanelServiceUpdatePreeditTextCallback -> m (GClosure C_PanelServiceUpdatePreeditTextCallback)
genClosure_PanelServiceUpdatePreeditText :: forall (m :: * -> *).
MonadIO m =>
PanelServiceUpdatePreeditTextCallback
-> m (GClosure C_PanelServiceUpdatePreeditTextCallback)
genClosure_PanelServiceUpdatePreeditText PanelServiceUpdatePreeditTextCallback
cb = IO (GClosure C_PanelServiceUpdatePreeditTextCallback)
-> m (GClosure C_PanelServiceUpdatePreeditTextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceUpdatePreeditTextCallback)
 -> m (GClosure C_PanelServiceUpdatePreeditTextCallback))
-> IO (GClosure C_PanelServiceUpdatePreeditTextCallback)
-> m (GClosure C_PanelServiceUpdatePreeditTextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceUpdatePreeditTextCallback
cb' = PanelServiceUpdatePreeditTextCallback
-> C_PanelServiceUpdatePreeditTextCallback
wrap_PanelServiceUpdatePreeditTextCallback PanelServiceUpdatePreeditTextCallback
cb
    C_PanelServiceUpdatePreeditTextCallback
-> IO (FunPtr C_PanelServiceUpdatePreeditTextCallback)
mk_PanelServiceUpdatePreeditTextCallback C_PanelServiceUpdatePreeditTextCallback
cb' IO (FunPtr C_PanelServiceUpdatePreeditTextCallback)
-> (FunPtr C_PanelServiceUpdatePreeditTextCallback
    -> IO (GClosure C_PanelServiceUpdatePreeditTextCallback))
-> IO (GClosure C_PanelServiceUpdatePreeditTextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceUpdatePreeditTextCallback
-> IO (GClosure C_PanelServiceUpdatePreeditTextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceUpdatePreeditTextSignalInfo
instance SignalInfo PanelServiceUpdatePreeditTextSignalInfo where
    type HaskellCallbackType PanelServiceUpdatePreeditTextSignalInfo = PanelServiceUpdatePreeditTextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceUpdatePreeditTextCallback cb
        cb'' <- mk_PanelServiceUpdatePreeditTextCallback cb'
        connectSignalFunPtr obj "update-preedit-text" cb'' connectMode detail

#endif

-- signal PanelService::update-property
-- | Emitted when the client application get the [updateProperty](#g:signal:updateProperty).
-- Implement the member function
-- IBusPanelServiceClass[update_property](#g:signal:update_property) in extended class to
-- receive this signal.
-- 
-- \<note>\<para>Argument /@userData@/ is ignored in this function.\<\/para>
-- \<\/note>
type PanelServiceUpdatePropertyCallback =
    IBus.Property.Property
    -- ^ /@prop@/: The IBusProperty to be updated.
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `PanelServiceUpdatePropertyCallback`@.
noPanelServiceUpdatePropertyCallback :: Maybe PanelServiceUpdatePropertyCallback
noPanelServiceUpdatePropertyCallback :: Maybe PanelServiceUpdatePropertyCallback
noPanelServiceUpdatePropertyCallback = Maybe PanelServiceUpdatePropertyCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_PanelServiceUpdateProperty :: MonadIO m => PanelServiceUpdatePropertyCallback -> m (GClosure C_PanelServiceUpdatePropertyCallback)
genClosure_PanelServiceUpdateProperty :: forall (m :: * -> *).
MonadIO m =>
PanelServiceUpdatePropertyCallback
-> m (GClosure C_PanelServiceUpdatePropertyCallback)
genClosure_PanelServiceUpdateProperty PanelServiceUpdatePropertyCallback
cb = IO (GClosure C_PanelServiceUpdatePropertyCallback)
-> m (GClosure C_PanelServiceUpdatePropertyCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_PanelServiceUpdatePropertyCallback)
 -> m (GClosure C_PanelServiceUpdatePropertyCallback))
-> IO (GClosure C_PanelServiceUpdatePropertyCallback)
-> m (GClosure C_PanelServiceUpdatePropertyCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_PanelServiceUpdatePropertyCallback
cb' = PanelServiceUpdatePropertyCallback
-> C_PanelServiceUpdatePropertyCallback
wrap_PanelServiceUpdatePropertyCallback PanelServiceUpdatePropertyCallback
cb
    C_PanelServiceUpdatePropertyCallback
-> IO (FunPtr C_PanelServiceUpdatePropertyCallback)
mk_PanelServiceUpdatePropertyCallback C_PanelServiceUpdatePropertyCallback
cb' IO (FunPtr C_PanelServiceUpdatePropertyCallback)
-> (FunPtr C_PanelServiceUpdatePropertyCallback
    -> IO (GClosure C_PanelServiceUpdatePropertyCallback))
-> IO (GClosure C_PanelServiceUpdatePropertyCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_PanelServiceUpdatePropertyCallback
-> IO (GClosure C_PanelServiceUpdatePropertyCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


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


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

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


#if defined(ENABLE_OVERLOADING)
data PanelServiceUpdatePropertySignalInfo
instance SignalInfo PanelServiceUpdatePropertySignalInfo where
    type HaskellCallbackType PanelServiceUpdatePropertySignalInfo = PanelServiceUpdatePropertyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_PanelServiceUpdatePropertyCallback cb
        cb'' <- mk_PanelServiceUpdatePropertyCallback cb'
        connectSignalFunPtr obj "update-property" cb'' connectMode detail

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList PanelService = PanelServiceSignalList
type PanelServiceSignalList = ('[ '("candidateClickedLookupTable", PanelServiceCandidateClickedLookupTableSignalInfo), '("commitTextReceived", PanelServiceCommitTextReceivedSignalInfo), '("cursorDownLookupTable", PanelServiceCursorDownLookupTableSignalInfo), '("cursorUpLookupTable", PanelServiceCursorUpLookupTableSignalInfo), '("destroy", IBus.Object.ObjectDestroySignalInfo), '("destroyContext", PanelServiceDestroyContextSignalInfo), '("focusIn", PanelServiceFocusInSignalInfo), '("focusOut", PanelServiceFocusOutSignalInfo), '("hideAuxiliaryText", PanelServiceHideAuxiliaryTextSignalInfo), '("hideLanguageBar", PanelServiceHideLanguageBarSignalInfo), '("hideLookupTable", PanelServiceHideLookupTableSignalInfo), '("hidePreeditText", PanelServiceHidePreeditTextSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pageDownLookupTable", PanelServicePageDownLookupTableSignalInfo), '("pageUpLookupTable", PanelServicePageUpLookupTableSignalInfo), '("panelExtensionReceived", PanelServicePanelExtensionReceivedSignalInfo), '("processKeyEvent", PanelServiceProcessKeyEventSignalInfo), '("registerProperties", PanelServiceRegisterPropertiesSignalInfo), '("reset", PanelServiceResetSignalInfo), '("setContentType", PanelServiceSetContentTypeSignalInfo), '("setCursorLocation", PanelServiceSetCursorLocationSignalInfo), '("setCursorLocationRelative", PanelServiceSetCursorLocationRelativeSignalInfo), '("showAuxiliaryText", PanelServiceShowAuxiliaryTextSignalInfo), '("showLanguageBar", PanelServiceShowLanguageBarSignalInfo), '("showLookupTable", PanelServiceShowLookupTableSignalInfo), '("showPreeditText", PanelServiceShowPreeditTextSignalInfo), '("startSetup", PanelServiceStartSetupSignalInfo), '("stateChanged", PanelServiceStateChangedSignalInfo), '("updateAuxiliaryText", PanelServiceUpdateAuxiliaryTextSignalInfo), '("updateLookupTable", PanelServiceUpdateLookupTableSignalInfo), '("updatePreeditText", PanelServiceUpdatePreeditTextSignalInfo), '("updateProperty", PanelServiceUpdatePropertySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "ibus_panel_service_new" ibus_panel_service_new :: 
    Ptr Gio.DBusConnection.DBusConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "DBusConnection"})
    IO (Ptr PanelService)

-- | Creates a new t'GI.IBus.Objects.PanelService.PanelService' from an t'GI.Gio.Objects.DBusConnection.DBusConnection'.
panelServiceNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.DBusConnection.IsDBusConnection a) =>
    a
    -- ^ /@connection@/: An GDBusConnection.
    -> m PanelService
    -- ^ __Returns:__ A newly allocated t'GI.IBus.Objects.PanelService.PanelService'.
panelServiceNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDBusConnection a) =>
a -> m PanelService
panelServiceNew a
connection = IO PanelService -> m PanelService
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PanelService -> m PanelService)
-> IO PanelService -> m PanelService
forall a b. (a -> b) -> a -> b
$ do
    Ptr DBusConnection
connection' <- a -> IO (Ptr DBusConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
connection
    Ptr PanelService
result <- Ptr DBusConnection -> IO (Ptr PanelService)
ibus_panel_service_new Ptr DBusConnection
connection'
    Text -> Ptr PanelService -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"panelServiceNew" Ptr PanelService
result
    PanelService
result' <- ((ManagedPtr PanelService -> PanelService)
-> Ptr PanelService -> IO PanelService
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PanelService -> PanelService
PanelService) Ptr PanelService
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
connection
    PanelService -> IO PanelService
forall (m :: * -> *) a. Monad m => a -> m a
return PanelService
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method PanelService::candidate_clicked
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "panel"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PanelService" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusPanelService"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "index"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Index in the Lookup table"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "button"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GdkEventButton::button (1: left button, etc.)"
--                 , 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 "GdkEventButton::state (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_panel_service_candidate_clicked" ibus_panel_service_candidate_clicked :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    Word32 ->                               -- index : TBasicType TUInt
    Word32 ->                               -- button : TBasicType TUInt
    Word32 ->                               -- state : TBasicType TUInt
    IO ()

-- | Notify that a candidate is clicked
-- by sending a \"CandidateClicked\" to IBus service.
panelServiceCandidateClicked ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a) =>
    a
    -- ^ /@panel@/: An IBusPanelService
    -> Word32
    -- ^ /@index@/: Index in the Lookup table
    -> Word32
    -- ^ /@button@/: GdkEventButton[button](#g:signal:button) (1: left button, etc.)
    -> Word32
    -- ^ /@state@/: GdkEventButton[state](#g:signal:state) (key modifier flags)
    -> m ()
panelServiceCandidateClicked :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanelService a) =>
a -> Word32 -> Word32 -> Word32 -> m ()
panelServiceCandidateClicked a
panel Word32
index Word32
button Word32
state = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    Ptr PanelService -> PanelServiceCandidateClickedLookupTableCallback
ibus_panel_service_candidate_clicked Ptr PanelService
panel' Word32
index Word32
button Word32
state
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanelServiceCandidateClickedMethodInfo
instance (signature ~ (Word32 -> Word32 -> Word32 -> m ()), MonadIO m, IsPanelService a) => O.OverloadedMethod PanelServiceCandidateClickedMethodInfo a signature where
    overloadedMethod = panelServiceCandidateClicked

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


#endif

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

foreign import ccall "ibus_panel_service_commit_text" ibus_panel_service_commit_text :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    Ptr IBus.Text.Text ->                   -- text : TInterface (Name {namespace = "IBus", name = "Text"})
    IO ()

-- | Notify that a text is sent
-- by sending a \"CommitText\" message to IBus service.
panelServiceCommitText ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a, IBus.Text.IsText b) =>
    a
    -- ^ /@panel@/: An t'GI.IBus.Objects.PanelService.PanelService'
    -> b
    -- ^ /@text@/: An t'GI.IBus.Objects.Text.Text'
    -> m ()
panelServiceCommitText :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPanelService a, IsText b) =>
a -> b -> m ()
panelServiceCommitText a
panel b
text = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
    Ptr PanelService -> Ptr Text -> IO ()
ibus_panel_service_commit_text Ptr PanelService
panel' Ptr Text
text'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

foreign import ccall "ibus_panel_service_cursor_down" ibus_panel_service_cursor_down :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    IO ()

-- | Notify that the cursor is down
-- by sending a \"CursorDown\" to IBus service.
panelServiceCursorDown ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a) =>
    a
    -- ^ /@panel@/: An IBusPanelService
    -> m ()
panelServiceCursorDown :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanelService a) =>
a -> m ()
panelServiceCursorDown a
panel = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    Ptr PanelService -> IO ()
ibus_panel_service_cursor_down Ptr PanelService
panel'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanelServiceCursorDownMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPanelService a) => O.OverloadedMethod PanelServiceCursorDownMethodInfo a signature where
    overloadedMethod = panelServiceCursorDown

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


#endif

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

foreign import ccall "ibus_panel_service_cursor_up" ibus_panel_service_cursor_up :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    IO ()

-- | Notify that the cursor is up
-- by sending a \"CursorUp\" to IBus service.
panelServiceCursorUp ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a) =>
    a
    -- ^ /@panel@/: An IBusPanelService
    -> m ()
panelServiceCursorUp :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanelService a) =>
a -> m ()
panelServiceCursorUp a
panel = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    Ptr PanelService -> IO ()
ibus_panel_service_cursor_up Ptr PanelService
panel'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanelServiceCursorUpMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPanelService a) => O.OverloadedMethod PanelServiceCursorUpMethodInfo a signature where
    overloadedMethod = panelServiceCursorUp

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


#endif

-- XXX Could not generate method PanelService::hide_preedit_text_received
-- Bad introspection data: Could not resolve the symbol “ibus_panel_service_hide_preedit_text_received” in the “IBus” namespace, ignoring.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data PanelServiceHidePreeditTextReceivedMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "hidePreeditTextReceived" PanelService) => O.OverloadedMethod PanelServiceHidePreeditTextReceivedMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "hidePreeditTextReceived" PanelService) => O.OverloadedMethodInfo PanelServiceHidePreeditTextReceivedMethodInfo o where
    overloadedMethodInfo = undefined

#endif

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

foreign import ccall "ibus_panel_service_page_down" ibus_panel_service_page_down :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    IO ()

-- | Notify that the page is down
-- by sending a \"PageDown\" to IBus service.
panelServicePageDown ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a) =>
    a
    -- ^ /@panel@/: An IBusPanelService
    -> m ()
panelServicePageDown :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanelService a) =>
a -> m ()
panelServicePageDown a
panel = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    Ptr PanelService -> IO ()
ibus_panel_service_page_down Ptr PanelService
panel'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanelServicePageDownMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPanelService a) => O.OverloadedMethod PanelServicePageDownMethodInfo a signature where
    overloadedMethod = panelServicePageDown

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


#endif

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

foreign import ccall "ibus_panel_service_page_up" ibus_panel_service_page_up :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    IO ()

-- | Notify that the page is up
-- by sending a \"PageUp\" to IBus service.
panelServicePageUp ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a) =>
    a
    -- ^ /@panel@/: An IBusPanelService
    -> m ()
panelServicePageUp :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanelService a) =>
a -> m ()
panelServicePageUp a
panel = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    Ptr PanelService -> IO ()
ibus_panel_service_page_up Ptr PanelService
panel'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanelServicePageUpMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPanelService a) => O.OverloadedMethod PanelServicePageUpMethodInfo a signature where
    overloadedMethod = panelServicePageUp

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


#endif

-- method PanelService::panel_extension
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "panel"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PanelService" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusPanelService"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "event"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "ExtensionEvent" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "A #PanelExtensionEvent which is sent to a\n                         panel extension."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_panel_service_panel_extension" ibus_panel_service_panel_extension :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    Ptr IBus.ExtensionEvent.ExtensionEvent -> -- event : TInterface (Name {namespace = "IBus", name = "ExtensionEvent"})
    IO ()

-- | Enable or disable a panel extension with t'GI.IBus.Objects.ExtensionEvent.ExtensionEvent'.
-- Notify that a data is sent
-- by sending a \"PanelExtension\" message to IBus panel extension service.
panelServicePanelExtension ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a, IBus.ExtensionEvent.IsExtensionEvent b) =>
    a
    -- ^ /@panel@/: An t'GI.IBus.Objects.PanelService.PanelService'
    -> b
    -- ^ /@event@/: A @/PanelExtensionEvent/@ which is sent to a
    --                          panel extension.
    -> m ()
panelServicePanelExtension :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPanelService a, IsExtensionEvent b) =>
a -> b -> m ()
panelServicePanelExtension a
panel b
event = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    Ptr ExtensionEvent
event' <- b -> IO (Ptr ExtensionEvent)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject b
event
    Ptr PanelService -> Ptr ExtensionEvent -> IO ()
ibus_panel_service_panel_extension Ptr PanelService
panel' Ptr ExtensionEvent
event'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
event
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PanelServicePanelExtensionMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsPanelService a, IBus.ExtensionEvent.IsExtensionEvent b) => O.OverloadedMethod PanelServicePanelExtensionMethodInfo a signature where
    overloadedMethod = panelServicePanelExtension

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


#endif

-- method PanelService::property_activate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "panel"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PanelService" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusPanelService"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A property name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop_state"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "State of the property"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_panel_service_property_activate" ibus_panel_service_property_activate :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    CString ->                              -- prop_name : TBasicType TUTF8
    Word32 ->                               -- prop_state : TBasicType TUInt
    IO ()

-- | Notify that a property is active
-- by sending a \"PropertyActivate\" message to IBus service.
panelServicePropertyActivate ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a) =>
    a
    -- ^ /@panel@/: An IBusPanelService
    -> T.Text
    -- ^ /@propName@/: A property name
    -> Word32
    -- ^ /@propState@/: State of the property
    -> m ()
panelServicePropertyActivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanelService a) =>
a -> Text -> Word32 -> m ()
panelServicePropertyActivate a
panel Text
propName Word32
propState = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    CString
propName' <- Text -> IO CString
textToCString Text
propName
    Ptr PanelService -> CString -> Word32 -> IO ()
ibus_panel_service_property_activate Ptr PanelService
panel' CString
propName' Word32
propState
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method PanelService::property_hide
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "panel"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PanelService" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusPanelService"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A property name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_panel_service_property_hide" ibus_panel_service_property_hide :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    CString ->                              -- prop_name : TBasicType TUTF8
    IO ()

-- | Notify that a property is hidden
-- by sending a \"ValueChanged\" message to IBus service.
panelServicePropertyHide ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a) =>
    a
    -- ^ /@panel@/: An IBusPanelService
    -> T.Text
    -- ^ /@propName@/: A property name
    -> m ()
panelServicePropertyHide :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanelService a) =>
a -> Text -> m ()
panelServicePropertyHide a
panel Text
propName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    CString
propName' <- Text -> IO CString
textToCString Text
propName
    Ptr PanelService -> CString -> IO ()
ibus_panel_service_property_hide Ptr PanelService
panel' CString
propName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method PanelService::property_show
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "panel"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PanelService" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An IBusPanelService"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "prop_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A property name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ibus_panel_service_property_show" ibus_panel_service_property_show :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    CString ->                              -- prop_name : TBasicType TUTF8
    IO ()

-- | Notify that a property is shown
-- by sending a \"ValueChanged\" message to IBus service.
panelServicePropertyShow ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a) =>
    a
    -- ^ /@panel@/: An IBusPanelService
    -> T.Text
    -- ^ /@propName@/: A property name
    -> m ()
panelServicePropertyShow :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPanelService a) =>
a -> Text -> m ()
panelServicePropertyShow a
panel Text
propName = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    CString
propName' <- Text -> IO CString
textToCString Text
propName
    Ptr PanelService -> CString -> IO ()
ibus_panel_service_property_show Ptr PanelService
panel' CString
propName'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
propName'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- XXX Could not generate method PanelService::show_preedit_text_received
-- Bad introspection data: Could not resolve the symbol “ibus_panel_service_show_preedit_text_received” in the “IBus” namespace, ignoring.
#if defined(ENABLE_OVERLOADING)
-- XXX: Dummy instance, since code generation failed.
-- Please file a bug at http://github.com/haskell-gi/haskell-gi.
data PanelServiceShowPreeditTextReceivedMethodInfo
instance (p ~ (), o ~ O.UnsupportedMethodError "showPreeditTextReceived" PanelService) => O.OverloadedMethod PanelServiceShowPreeditTextReceivedMethodInfo o p where
    overloadedMethod = undefined

instance (o ~ O.UnsupportedMethodError "showPreeditTextReceived" PanelService) => O.OverloadedMethodInfo PanelServiceShowPreeditTextReceivedMethodInfo o where
    overloadedMethodInfo = undefined

#endif

-- method PanelService::update_auxiliary_text_received
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "panel"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PanelService" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusPanelService"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TInterface Name { namespace = "IBus" , name = "Text" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusText" , 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 auxilirary text 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_panel_service_update_auxiliary_text_received" ibus_panel_service_update_auxiliary_text_received :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    Ptr IBus.Text.Text ->                   -- text : TInterface (Name {namespace = "IBus", name = "Text"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

-- | Notify that the auxilirary is updated by the panel extension.
-- 
-- (Note: The table object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
panelServiceUpdateAuxiliaryTextReceived ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a, IBus.Text.IsText b) =>
    a
    -- ^ /@panel@/: An t'GI.IBus.Objects.PanelService.PanelService'
    -> b
    -- ^ /@text@/: An t'GI.IBus.Objects.Text.Text'
    -> Bool
    -- ^ /@visible@/: Whether the auxilirary text is visible.
    -> m ()
panelServiceUpdateAuxiliaryTextReceived :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPanelService a, IsText b) =>
a -> b -> Bool -> m ()
panelServiceUpdateAuxiliaryTextReceived a
panel b
text Bool
visible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    Ptr Text
text' <- b -> IO (Ptr Text)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
text
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    Ptr PanelService -> Ptr Text -> CInt -> IO ()
ibus_panel_service_update_auxiliary_text_received Ptr PanelService
panel' Ptr Text
text' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
text
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method PanelService::update_lookup_table_received
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "panel"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PanelService" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusPanelService"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "table"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "LookupTable" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusLookupTable"
--                 , 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_panel_service_update_lookup_table_received" ibus_panel_service_update_lookup_table_received :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    Ptr IBus.LookupTable.LookupTable ->     -- table : TInterface (Name {namespace = "IBus", name = "LookupTable"})
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

-- | Notify that the lookup table is updated by the panel extension.
-- 
-- (Note: The table object will be released, if it is floating.
--  If caller want to keep the object, caller should make the object
--  sink by g_object_ref_sink.)
panelServiceUpdateLookupTableReceived ::
    (B.CallStack.HasCallStack, MonadIO m, IsPanelService a, IBus.LookupTable.IsLookupTable b) =>
    a
    -- ^ /@panel@/: An t'GI.IBus.Objects.PanelService.PanelService'
    -> b
    -- ^ /@table@/: An t'GI.IBus.Objects.LookupTable.LookupTable'
    -> Bool
    -- ^ /@visible@/: Whether the lookup table is visible.
    -> m ()
panelServiceUpdateLookupTableReceived :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPanelService a, IsLookupTable b) =>
a -> b -> Bool -> m ()
panelServiceUpdateLookupTableReceived a
panel b
table Bool
visible = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr PanelService
panel' <- a -> IO (Ptr PanelService)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
panel
    Ptr LookupTable
table' <- b -> IO (Ptr LookupTable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
table
    let visible' :: CInt
visible' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
visible
    Ptr PanelService -> Ptr LookupTable -> CInt -> IO ()
ibus_panel_service_update_lookup_table_received Ptr PanelService
panel' Ptr LookupTable
table' CInt
visible'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
panel
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
table
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method PanelService::update_preedit_text_received
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "panel"
--           , argType =
--               TInterface Name { namespace = "IBus" , name = "PanelService" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "An #IBusPanelService"
--                 , 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_panel_service_update_preedit_text_received" ibus_panel_service_update_preedit_text_received :: 
    Ptr PanelService ->                     -- panel : TInterface (Name {namespace = "IBus", name = "PanelService"})
    Ptr IBus.Text.Text ->                   -- text : TInterface (Name {namespace = "IBus", name = "Text"})
    Word32 ->                               -- cursor_pos : TBasicType TUInt
    CInt ->                                 -- visible : TBasicType TBoolean
    IO ()

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

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

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


#endif