{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.GtkSource.Objects.Completion
    ( 

-- * Exported types
    Completion(..)                          ,
    IsCompletion                            ,
    toCompletion                            ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveCompletionMethod                 ,
#endif


-- ** addProvider #method:addProvider#

#if defined(ENABLE_OVERLOADING)
    CompletionAddProviderMethodInfo         ,
#endif
    completionAddProvider                   ,


-- ** blockInteractive #method:blockInteractive#

#if defined(ENABLE_OVERLOADING)
    CompletionBlockInteractiveMethodInfo    ,
#endif
    completionBlockInteractive              ,


-- ** createContext #method:createContext#

#if defined(ENABLE_OVERLOADING)
    CompletionCreateContextMethodInfo       ,
#endif
    completionCreateContext                 ,


-- ** getInfoWindow #method:getInfoWindow#

#if defined(ENABLE_OVERLOADING)
    CompletionGetInfoWindowMethodInfo       ,
#endif
    completionGetInfoWindow                 ,


-- ** getProviders #method:getProviders#

#if defined(ENABLE_OVERLOADING)
    CompletionGetProvidersMethodInfo        ,
#endif
    completionGetProviders                  ,


-- ** getView #method:getView#

#if defined(ENABLE_OVERLOADING)
    CompletionGetViewMethodInfo             ,
#endif
    completionGetView                       ,


-- ** hide #method:hide#

#if defined(ENABLE_OVERLOADING)
    CompletionHideMethodInfo                ,
#endif
    completionHide                          ,


-- ** moveWindow #method:moveWindow#

#if defined(ENABLE_OVERLOADING)
    CompletionMoveWindowMethodInfo          ,
#endif
    completionMoveWindow                    ,


-- ** removeProvider #method:removeProvider#

#if defined(ENABLE_OVERLOADING)
    CompletionRemoveProviderMethodInfo      ,
#endif
    completionRemoveProvider                ,


-- ** show #method:show#

#if defined(ENABLE_OVERLOADING)
    CompletionShowMethodInfo                ,
#endif
    completionShow                          ,


-- ** unblockInteractive #method:unblockInteractive#

#if defined(ENABLE_OVERLOADING)
    CompletionUnblockInteractiveMethodInfo  ,
#endif
    completionUnblockInteractive            ,




 -- * Properties
-- ** accelerators #attr:accelerators#
-- | Number of keyboard accelerators to show for the first proposals. For
-- example, to activate the first proposal, the user can press
-- \<keycombo>\<keycap>Alt\<\/keycap>\<keycap>1\<\/keycap>\<\/keycombo>.

#if defined(ENABLE_OVERLOADING)
    CompletionAcceleratorsPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionAccelerators                  ,
#endif
    constructCompletionAccelerators         ,
    getCompletionAccelerators               ,
    setCompletionAccelerators               ,


-- ** autoCompleteDelay #attr:autoCompleteDelay#
-- | Determines the popup delay (in milliseconds) at which the completion
-- will be shown for interactive completion.

#if defined(ENABLE_OVERLOADING)
    CompletionAutoCompleteDelayPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionAutoCompleteDelay             ,
#endif
    constructCompletionAutoCompleteDelay    ,
    getCompletionAutoCompleteDelay          ,
    setCompletionAutoCompleteDelay          ,


-- ** proposalPageSize #attr:proposalPageSize#
-- | The scroll page size of the proposals in the completion window. In
-- other words, when \<keycap>PageDown\<\/keycap> or
-- \<keycap>PageUp\<\/keycap> is pressed, the selected
-- proposal becomes the one which is located one page size backward or
-- forward.
-- 
-- See also the [moveCursor]("GI.GtkSource.Objects.Completion#g:signal:moveCursor") signal.

#if defined(ENABLE_OVERLOADING)
    CompletionProposalPageSizePropertyInfo  ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionProposalPageSize              ,
#endif
    constructCompletionProposalPageSize     ,
    getCompletionProposalPageSize           ,
    setCompletionProposalPageSize           ,


-- ** providerPageSize #attr:providerPageSize#
-- | The scroll page size of the provider pages in the completion window.
-- 
-- See the [movePage]("GI.GtkSource.Objects.Completion#g:signal:movePage") signal.

#if defined(ENABLE_OVERLOADING)
    CompletionProviderPageSizePropertyInfo  ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionProviderPageSize              ,
#endif
    constructCompletionProviderPageSize     ,
    getCompletionProviderPageSize           ,
    setCompletionProviderPageSize           ,


-- ** rememberInfoVisibility #attr:rememberInfoVisibility#
-- | Determines whether the visibility of the info window should be
-- saved when the completion is hidden, and restored when the completion
-- is shown again.

#if defined(ENABLE_OVERLOADING)
    CompletionRememberInfoVisibilityPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING)
    completionRememberInfoVisibility        ,
#endif
    constructCompletionRememberInfoVisibility,
    getCompletionRememberInfoVisibility     ,
    setCompletionRememberInfoVisibility     ,


-- ** selectOnShow #attr:selectOnShow#
-- | Determines whether the first proposal should be selected when the
-- completion is first shown.

#if defined(ENABLE_OVERLOADING)
    CompletionSelectOnShowPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionSelectOnShow                  ,
#endif
    constructCompletionSelectOnShow         ,
    getCompletionSelectOnShow               ,
    setCompletionSelectOnShow               ,


-- ** showHeaders #attr:showHeaders#
-- | Determines whether provider headers should be shown in the proposal
-- list. It can be useful to disable when there is only one provider.

#if defined(ENABLE_OVERLOADING)
    CompletionShowHeadersPropertyInfo       ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionShowHeaders                   ,
#endif
    constructCompletionShowHeaders          ,
    getCompletionShowHeaders                ,
    setCompletionShowHeaders                ,


-- ** showIcons #attr:showIcons#
-- | Determines whether provider and proposal icons should be shown in
-- the completion popup.

#if defined(ENABLE_OVERLOADING)
    CompletionShowIconsPropertyInfo         ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionShowIcons                     ,
#endif
    constructCompletionShowIcons            ,
    getCompletionShowIcons                  ,
    setCompletionShowIcons                  ,


-- ** view #attr:view#
-- | The t'GI.GtkSource.Objects.View.View' bound to the completion object.

#if defined(ENABLE_OVERLOADING)
    CompletionViewPropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionView                          ,
#endif
    constructCompletionView                 ,
    getCompletionView                       ,




 -- * Signals
-- ** activateProposal #signal:activateProposal#

    C_CompletionActivateProposalCallback    ,
    CompletionActivateProposalCallback      ,
#if defined(ENABLE_OVERLOADING)
    CompletionActivateProposalSignalInfo    ,
#endif
    afterCompletionActivateProposal         ,
    genClosure_CompletionActivateProposal   ,
    mk_CompletionActivateProposalCallback   ,
    noCompletionActivateProposalCallback    ,
    onCompletionActivateProposal            ,
    wrap_CompletionActivateProposalCallback ,


-- ** hide #signal:hide#

    C_CompletionHideCallback                ,
    CompletionHideCallback                  ,
#if defined(ENABLE_OVERLOADING)
    CompletionHideSignalInfo                ,
#endif
    afterCompletionHide                     ,
    genClosure_CompletionHide               ,
    mk_CompletionHideCallback               ,
    noCompletionHideCallback                ,
    onCompletionHide                        ,
    wrap_CompletionHideCallback             ,


-- ** moveCursor #signal:moveCursor#

    C_CompletionMoveCursorCallback          ,
    CompletionMoveCursorCallback            ,
#if defined(ENABLE_OVERLOADING)
    CompletionMoveCursorSignalInfo          ,
#endif
    afterCompletionMoveCursor               ,
    genClosure_CompletionMoveCursor         ,
    mk_CompletionMoveCursorCallback         ,
    noCompletionMoveCursorCallback          ,
    onCompletionMoveCursor                  ,
    wrap_CompletionMoveCursorCallback       ,


-- ** movePage #signal:movePage#

    C_CompletionMovePageCallback            ,
    CompletionMovePageCallback              ,
#if defined(ENABLE_OVERLOADING)
    CompletionMovePageSignalInfo            ,
#endif
    afterCompletionMovePage                 ,
    genClosure_CompletionMovePage           ,
    mk_CompletionMovePageCallback           ,
    noCompletionMovePageCallback            ,
    onCompletionMovePage                    ,
    wrap_CompletionMovePageCallback         ,


-- ** populateContext #signal:populateContext#

    C_CompletionPopulateContextCallback     ,
    CompletionPopulateContextCallback       ,
#if defined(ENABLE_OVERLOADING)
    CompletionPopulateContextSignalInfo     ,
#endif
    afterCompletionPopulateContext          ,
    genClosure_CompletionPopulateContext    ,
    mk_CompletionPopulateContextCallback    ,
    noCompletionPopulateContextCallback     ,
    onCompletionPopulateContext             ,
    wrap_CompletionPopulateContextCallback  ,


-- ** show #signal:show#

    C_CompletionShowCallback                ,
    CompletionShowCallback                  ,
#if defined(ENABLE_OVERLOADING)
    CompletionShowSignalInfo                ,
#endif
    afterCompletionShow                     ,
    genClosure_CompletionShow               ,
    mk_CompletionShowCallback               ,
    noCompletionShowCallback                ,
    onCompletionShow                        ,
    wrap_CompletionShowCallback             ,




    ) 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.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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProvider as GtkSource.CompletionProvider
import {-# SOURCE #-} qualified GI.GtkSource.Objects.CompletionContext as GtkSource.CompletionContext
import {-# SOURCE #-} qualified GI.GtkSource.Objects.CompletionInfo as GtkSource.CompletionInfo
import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View

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

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

foreign import ccall "gtk_source_completion_get_type"
    c_gtk_source_completion_get_type :: IO B.Types.GType

instance B.Types.TypedObject Completion where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_completion_get_type

instance B.Types.GObject Completion

-- | Convert 'Completion' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Completion where
    toGValue :: Completion -> IO GValue
toGValue Completion
o = do
        GType
gtype <- IO GType
c_gtk_source_completion_get_type
        Completion -> (Ptr Completion -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Completion
o (GType
-> (GValue -> Ptr Completion -> IO ())
-> Ptr Completion
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Completion -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO Completion
fromGValue GValue
gv = do
        Ptr Completion
ptr <- GValue -> IO (Ptr Completion)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Completion)
        (ManagedPtr Completion -> Completion)
-> Ptr Completion -> IO Completion
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Completion -> Completion
Completion Ptr Completion
ptr
        
    

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

instance O.HasParentTypes Completion
type instance O.ParentTypes Completion = '[GObject.Object.Object, Gtk.Buildable.Buildable]

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

#if defined(ENABLE_OVERLOADING)
type family ResolveCompletionMethod (t :: Symbol) (o :: *) :: * where
    ResolveCompletionMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
    ResolveCompletionMethod "addProvider" o = CompletionAddProviderMethodInfo
    ResolveCompletionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCompletionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCompletionMethod "blockInteractive" o = CompletionBlockInteractiveMethodInfo
    ResolveCompletionMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
    ResolveCompletionMethod "createContext" o = CompletionCreateContextMethodInfo
    ResolveCompletionMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
    ResolveCompletionMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
    ResolveCompletionMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
    ResolveCompletionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCompletionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCompletionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveCompletionMethod "hide" o = CompletionHideMethodInfo
    ResolveCompletionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCompletionMethod "moveWindow" o = CompletionMoveWindowMethodInfo
    ResolveCompletionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCompletionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCompletionMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
    ResolveCompletionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCompletionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCompletionMethod "removeProvider" o = CompletionRemoveProviderMethodInfo
    ResolveCompletionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCompletionMethod "show" o = CompletionShowMethodInfo
    ResolveCompletionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCompletionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCompletionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCompletionMethod "unblockInteractive" o = CompletionUnblockInteractiveMethodInfo
    ResolveCompletionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCompletionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCompletionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCompletionMethod "getInfoWindow" o = CompletionGetInfoWindowMethodInfo
    ResolveCompletionMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
    ResolveCompletionMethod "getName" o = Gtk.Buildable.BuildableGetNameMethodInfo
    ResolveCompletionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCompletionMethod "getProviders" o = CompletionGetProvidersMethodInfo
    ResolveCompletionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCompletionMethod "getView" o = CompletionGetViewMethodInfo
    ResolveCompletionMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
    ResolveCompletionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCompletionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveCompletionMethod "setName" o = Gtk.Buildable.BuildableSetNameMethodInfo
    ResolveCompletionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCompletionMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal Completion::activate-proposal
-- | The [activateProposal]("GI.GtkSource.Objects.Completion#g:signal:activateProposal") signal is a
-- keybinding signal which gets emitted when the user initiates
-- a proposal activation.
-- 
-- Applications should not connect to it, but may emit it with
-- @/g_signal_emit_by_name()/@ if they need to control the proposal
-- activation programmatically.
type CompletionActivateProposalCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_CompletionActivateProposal :: MonadIO m => CompletionActivateProposalCallback -> m (GClosure C_CompletionActivateProposalCallback)
genClosure_CompletionActivateProposal :: IO () -> m (GClosure C_CompletionActivateProposalCallback)
genClosure_CompletionActivateProposal IO ()
cb = IO (GClosure C_CompletionActivateProposalCallback)
-> m (GClosure C_CompletionActivateProposalCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CompletionActivateProposalCallback)
 -> m (GClosure C_CompletionActivateProposalCallback))
-> IO (GClosure C_CompletionActivateProposalCallback)
-> m (GClosure C_CompletionActivateProposalCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CompletionActivateProposalCallback
cb' = IO () -> C_CompletionActivateProposalCallback
wrap_CompletionActivateProposalCallback IO ()
cb
    C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionActivateProposalCallback C_CompletionActivateProposalCallback
cb' IO (FunPtr C_CompletionActivateProposalCallback)
-> (FunPtr C_CompletionActivateProposalCallback
    -> IO (GClosure C_CompletionActivateProposalCallback))
-> IO (GClosure C_CompletionActivateProposalCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CompletionActivateProposalCallback
-> IO (GClosure C_CompletionActivateProposalCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `CompletionActivateProposalCallback` into a `C_CompletionActivateProposalCallback`.
wrap_CompletionActivateProposalCallback ::
    CompletionActivateProposalCallback ->
    C_CompletionActivateProposalCallback
wrap_CompletionActivateProposalCallback :: IO () -> C_CompletionActivateProposalCallback
wrap_CompletionActivateProposalCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [activateProposal](#signal:activateProposal) 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' completion #activateProposal callback
-- @
-- 
-- 
onCompletionActivateProposal :: (IsCompletion a, MonadIO m) => a -> CompletionActivateProposalCallback -> m SignalHandlerId
onCompletionActivateProposal :: a -> IO () -> m SignalHandlerId
onCompletionActivateProposal 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_CompletionActivateProposalCallback
cb' = IO () -> C_CompletionActivateProposalCallback
wrap_CompletionActivateProposalCallback IO ()
cb
    FunPtr C_CompletionActivateProposalCallback
cb'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionActivateProposalCallback C_CompletionActivateProposalCallback
cb'
    a
-> Text
-> FunPtr C_CompletionActivateProposalCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate-proposal" FunPtr C_CompletionActivateProposalCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [activateProposal](#signal:activateProposal) 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' completion #activateProposal callback
-- @
-- 
-- 
afterCompletionActivateProposal :: (IsCompletion a, MonadIO m) => a -> CompletionActivateProposalCallback -> m SignalHandlerId
afterCompletionActivateProposal :: a -> IO () -> m SignalHandlerId
afterCompletionActivateProposal 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_CompletionActivateProposalCallback
cb' = IO () -> C_CompletionActivateProposalCallback
wrap_CompletionActivateProposalCallback IO ()
cb
    FunPtr C_CompletionActivateProposalCallback
cb'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionActivateProposalCallback C_CompletionActivateProposalCallback
cb'
    a
-> Text
-> FunPtr C_CompletionActivateProposalCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"activate-proposal" FunPtr C_CompletionActivateProposalCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CompletionActivateProposalSignalInfo
instance SignalInfo CompletionActivateProposalSignalInfo where
    type HaskellCallbackType CompletionActivateProposalSignalInfo = CompletionActivateProposalCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CompletionActivateProposalCallback cb
        cb'' <- mk_CompletionActivateProposalCallback cb'
        connectSignalFunPtr obj "activate-proposal" cb'' connectMode detail

#endif

-- signal Completion::hide
-- | Emitted when the completion window is hidden. The default handler
-- will actually hide the window.
type CompletionHideCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_CompletionHide :: MonadIO m => CompletionHideCallback -> m (GClosure C_CompletionHideCallback)
genClosure_CompletionHide :: IO () -> m (GClosure C_CompletionActivateProposalCallback)
genClosure_CompletionHide IO ()
cb = IO (GClosure C_CompletionActivateProposalCallback)
-> m (GClosure C_CompletionActivateProposalCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CompletionActivateProposalCallback)
 -> m (GClosure C_CompletionActivateProposalCallback))
-> IO (GClosure C_CompletionActivateProposalCallback)
-> m (GClosure C_CompletionActivateProposalCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CompletionActivateProposalCallback
cb' = IO () -> C_CompletionActivateProposalCallback
wrap_CompletionHideCallback IO ()
cb
    C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionHideCallback C_CompletionActivateProposalCallback
cb' IO (FunPtr C_CompletionActivateProposalCallback)
-> (FunPtr C_CompletionActivateProposalCallback
    -> IO (GClosure C_CompletionActivateProposalCallback))
-> IO (GClosure C_CompletionActivateProposalCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CompletionActivateProposalCallback
-> IO (GClosure C_CompletionActivateProposalCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `CompletionHideCallback` into a `C_CompletionHideCallback`.
wrap_CompletionHideCallback ::
    CompletionHideCallback ->
    C_CompletionHideCallback
wrap_CompletionHideCallback :: IO () -> C_CompletionActivateProposalCallback
wrap_CompletionHideCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [hide](#signal:hide) 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' completion #hide callback
-- @
-- 
-- 
onCompletionHide :: (IsCompletion a, MonadIO m) => a -> CompletionHideCallback -> m SignalHandlerId
onCompletionHide :: a -> IO () -> m SignalHandlerId
onCompletionHide 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_CompletionActivateProposalCallback
cb' = IO () -> C_CompletionActivateProposalCallback
wrap_CompletionHideCallback IO ()
cb
    FunPtr C_CompletionActivateProposalCallback
cb'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionHideCallback C_CompletionActivateProposalCallback
cb'
    a
-> Text
-> FunPtr C_CompletionActivateProposalCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide" FunPtr C_CompletionActivateProposalCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [hide](#signal:hide) 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' completion #hide callback
-- @
-- 
-- 
afterCompletionHide :: (IsCompletion a, MonadIO m) => a -> CompletionHideCallback -> m SignalHandlerId
afterCompletionHide :: a -> IO () -> m SignalHandlerId
afterCompletionHide 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_CompletionActivateProposalCallback
cb' = IO () -> C_CompletionActivateProposalCallback
wrap_CompletionHideCallback IO ()
cb
    FunPtr C_CompletionActivateProposalCallback
cb'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionHideCallback C_CompletionActivateProposalCallback
cb'
    a
-> Text
-> FunPtr C_CompletionActivateProposalCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"hide" FunPtr C_CompletionActivateProposalCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CompletionHideSignalInfo
instance SignalInfo CompletionHideSignalInfo where
    type HaskellCallbackType CompletionHideSignalInfo = CompletionHideCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CompletionHideCallback cb
        cb'' <- mk_CompletionHideCallback cb'
        connectSignalFunPtr obj "hide" cb'' connectMode detail

#endif

-- signal Completion::move-cursor
-- | The [moveCursor]("GI.GtkSource.Objects.Completion#g:signal:moveCursor") signal is a keybinding
-- signal which gets emitted when the user initiates a cursor
-- movement.
-- 
-- The \<keycap>Up\<\/keycap>, \<keycap>Down\<\/keycap>,
-- \<keycap>PageUp\<\/keycap>, \<keycap>PageDown\<\/keycap>,
-- \<keycap>Home\<\/keycap> and \<keycap>End\<\/keycap> keys are bound to the
-- normal behavior expected by those keys.
-- 
-- When /@step@/ is equal to 'GI.Gtk.Enums.ScrollStepPages', the page size is defined by
-- the t'GI.GtkSource.Objects.Completion.Completion':@/proposal-page-size/@ property. It is used for
-- the \<keycap>PageDown\<\/keycap> and \<keycap>PageUp\<\/keycap> keys.
-- 
-- Applications should not connect to it, but may emit it with
-- @/g_signal_emit_by_name()/@ if they need to control the cursor
-- programmatically.
type CompletionMoveCursorCallback =
    Gtk.Enums.ScrollStep
    -- ^ /@step@/: The t'GI.Gtk.Enums.ScrollStep' by which to move the cursor
    -> Int32
    -- ^ /@num@/: The amount of steps to move the cursor
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionMoveCursorCallback`@.
noCompletionMoveCursorCallback :: Maybe CompletionMoveCursorCallback
noCompletionMoveCursorCallback :: Maybe CompletionMoveCursorCallback
noCompletionMoveCursorCallback = Maybe CompletionMoveCursorCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_CompletionMoveCursor :: MonadIO m => CompletionMoveCursorCallback -> m (GClosure C_CompletionMoveCursorCallback)
genClosure_CompletionMoveCursor :: CompletionMoveCursorCallback
-> m (GClosure C_CompletionMoveCursorCallback)
genClosure_CompletionMoveCursor CompletionMoveCursorCallback
cb = IO (GClosure C_CompletionMoveCursorCallback)
-> m (GClosure C_CompletionMoveCursorCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CompletionMoveCursorCallback)
 -> m (GClosure C_CompletionMoveCursorCallback))
-> IO (GClosure C_CompletionMoveCursorCallback)
-> m (GClosure C_CompletionMoveCursorCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CompletionMoveCursorCallback
cb' = CompletionMoveCursorCallback -> C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback CompletionMoveCursorCallback
cb
    C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMoveCursorCallback C_CompletionMoveCursorCallback
cb' IO (FunPtr C_CompletionMoveCursorCallback)
-> (FunPtr C_CompletionMoveCursorCallback
    -> IO (GClosure C_CompletionMoveCursorCallback))
-> IO (GClosure C_CompletionMoveCursorCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CompletionMoveCursorCallback
-> IO (GClosure C_CompletionMoveCursorCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `CompletionMoveCursorCallback` into a `C_CompletionMoveCursorCallback`.
wrap_CompletionMoveCursorCallback ::
    CompletionMoveCursorCallback ->
    C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback :: CompletionMoveCursorCallback -> C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback CompletionMoveCursorCallback
_cb Ptr ()
_ CUInt
step Int32
num Ptr ()
_ = do
    let step' :: ScrollStep
step' = (Int -> ScrollStep
forall a. Enum a => Int -> a
toEnum (Int -> ScrollStep) -> (CUInt -> Int) -> CUInt -> ScrollStep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
step
    CompletionMoveCursorCallback
_cb  ScrollStep
step' Int32
num


-- | Connect a signal handler for the [moveCursor](#signal:moveCursor) 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' completion #moveCursor callback
-- @
-- 
-- 
onCompletionMoveCursor :: (IsCompletion a, MonadIO m) => a -> CompletionMoveCursorCallback -> m SignalHandlerId
onCompletionMoveCursor :: a -> CompletionMoveCursorCallback -> m SignalHandlerId
onCompletionMoveCursor a
obj CompletionMoveCursorCallback
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_CompletionMoveCursorCallback
cb' = CompletionMoveCursorCallback -> C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback CompletionMoveCursorCallback
cb
    FunPtr C_CompletionMoveCursorCallback
cb'' <- C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMoveCursorCallback C_CompletionMoveCursorCallback
cb'
    a
-> Text
-> FunPtr C_CompletionMoveCursorCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-cursor" FunPtr C_CompletionMoveCursorCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [moveCursor](#signal:moveCursor) 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' completion #moveCursor callback
-- @
-- 
-- 
afterCompletionMoveCursor :: (IsCompletion a, MonadIO m) => a -> CompletionMoveCursorCallback -> m SignalHandlerId
afterCompletionMoveCursor :: a -> CompletionMoveCursorCallback -> m SignalHandlerId
afterCompletionMoveCursor a
obj CompletionMoveCursorCallback
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_CompletionMoveCursorCallback
cb' = CompletionMoveCursorCallback -> C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback CompletionMoveCursorCallback
cb
    FunPtr C_CompletionMoveCursorCallback
cb'' <- C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMoveCursorCallback C_CompletionMoveCursorCallback
cb'
    a
-> Text
-> FunPtr C_CompletionMoveCursorCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-cursor" FunPtr C_CompletionMoveCursorCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CompletionMoveCursorSignalInfo
instance SignalInfo CompletionMoveCursorSignalInfo where
    type HaskellCallbackType CompletionMoveCursorSignalInfo = CompletionMoveCursorCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CompletionMoveCursorCallback cb
        cb'' <- mk_CompletionMoveCursorCallback cb'
        connectSignalFunPtr obj "move-cursor" cb'' connectMode detail

#endif

-- signal Completion::move-page
-- | The [movePage]("GI.GtkSource.Objects.Completion#g:signal:movePage") signal is a keybinding
-- signal which gets emitted when the user initiates a page
-- movement (i.e. switches between provider pages).
-- 
-- \<keycombo>\<keycap>Control\<\/keycap>\<keycap>Left\<\/keycap>\<\/keycombo>
-- is for going to the previous provider.
-- \<keycombo>\<keycap>Control\<\/keycap>\<keycap>Right\<\/keycap>\<\/keycombo>
-- is for going to the next provider.
-- \<keycombo>\<keycap>Control\<\/keycap>\<keycap>Home\<\/keycap>\<\/keycombo>
-- is for displaying all the providers.
-- \<keycombo>\<keycap>Control\<\/keycap>\<keycap>End\<\/keycap>\<\/keycombo>
-- is for going to the last provider.
-- 
-- When /@step@/ is equal to @/GTK_SCROLL_PAGES/@, the page size is defined by
-- the t'GI.GtkSource.Objects.Completion.Completion':@/provider-page-size/@ property.
-- 
-- Applications should not connect to it, but may emit it with
-- @/g_signal_emit_by_name()/@ if they need to control the page selection
-- programmatically.
type CompletionMovePageCallback =
    Gtk.Enums.ScrollStep
    -- ^ /@step@/: The t'GI.Gtk.Enums.ScrollStep' by which to move the page
    -> Int32
    -- ^ /@num@/: The amount of steps to move the page
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionMovePageCallback`@.
noCompletionMovePageCallback :: Maybe CompletionMovePageCallback
noCompletionMovePageCallback :: Maybe CompletionMoveCursorCallback
noCompletionMovePageCallback = Maybe CompletionMoveCursorCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_CompletionMovePage :: MonadIO m => CompletionMovePageCallback -> m (GClosure C_CompletionMovePageCallback)
genClosure_CompletionMovePage :: CompletionMoveCursorCallback
-> m (GClosure C_CompletionMoveCursorCallback)
genClosure_CompletionMovePage CompletionMoveCursorCallback
cb = IO (GClosure C_CompletionMoveCursorCallback)
-> m (GClosure C_CompletionMoveCursorCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CompletionMoveCursorCallback)
 -> m (GClosure C_CompletionMoveCursorCallback))
-> IO (GClosure C_CompletionMoveCursorCallback)
-> m (GClosure C_CompletionMoveCursorCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CompletionMoveCursorCallback
cb' = CompletionMoveCursorCallback -> C_CompletionMoveCursorCallback
wrap_CompletionMovePageCallback CompletionMoveCursorCallback
cb
    C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMovePageCallback C_CompletionMoveCursorCallback
cb' IO (FunPtr C_CompletionMoveCursorCallback)
-> (FunPtr C_CompletionMoveCursorCallback
    -> IO (GClosure C_CompletionMoveCursorCallback))
-> IO (GClosure C_CompletionMoveCursorCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CompletionMoveCursorCallback
-> IO (GClosure C_CompletionMoveCursorCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `CompletionMovePageCallback` into a `C_CompletionMovePageCallback`.
wrap_CompletionMovePageCallback ::
    CompletionMovePageCallback ->
    C_CompletionMovePageCallback
wrap_CompletionMovePageCallback :: CompletionMoveCursorCallback -> C_CompletionMoveCursorCallback
wrap_CompletionMovePageCallback CompletionMoveCursorCallback
_cb Ptr ()
_ CUInt
step Int32
num Ptr ()
_ = do
    let step' :: ScrollStep
step' = (Int -> ScrollStep
forall a. Enum a => Int -> a
toEnum (Int -> ScrollStep) -> (CUInt -> Int) -> CUInt -> ScrollStep
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
step
    CompletionMoveCursorCallback
_cb  ScrollStep
step' Int32
num


-- | Connect a signal handler for the [movePage](#signal:movePage) 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' completion #movePage callback
-- @
-- 
-- 
onCompletionMovePage :: (IsCompletion a, MonadIO m) => a -> CompletionMovePageCallback -> m SignalHandlerId
onCompletionMovePage :: a -> CompletionMoveCursorCallback -> m SignalHandlerId
onCompletionMovePage a
obj CompletionMoveCursorCallback
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_CompletionMoveCursorCallback
cb' = CompletionMoveCursorCallback -> C_CompletionMoveCursorCallback
wrap_CompletionMovePageCallback CompletionMoveCursorCallback
cb
    FunPtr C_CompletionMoveCursorCallback
cb'' <- C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMovePageCallback C_CompletionMoveCursorCallback
cb'
    a
-> Text
-> FunPtr C_CompletionMoveCursorCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-page" FunPtr C_CompletionMoveCursorCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [movePage](#signal:movePage) 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' completion #movePage callback
-- @
-- 
-- 
afterCompletionMovePage :: (IsCompletion a, MonadIO m) => a -> CompletionMovePageCallback -> m SignalHandlerId
afterCompletionMovePage :: a -> CompletionMoveCursorCallback -> m SignalHandlerId
afterCompletionMovePage a
obj CompletionMoveCursorCallback
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_CompletionMoveCursorCallback
cb' = CompletionMoveCursorCallback -> C_CompletionMoveCursorCallback
wrap_CompletionMovePageCallback CompletionMoveCursorCallback
cb
    FunPtr C_CompletionMoveCursorCallback
cb'' <- C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMovePageCallback C_CompletionMoveCursorCallback
cb'
    a
-> Text
-> FunPtr C_CompletionMoveCursorCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-page" FunPtr C_CompletionMoveCursorCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CompletionMovePageSignalInfo
instance SignalInfo CompletionMovePageSignalInfo where
    type HaskellCallbackType CompletionMovePageSignalInfo = CompletionMovePageCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CompletionMovePageCallback cb
        cb'' <- mk_CompletionMovePageCallback cb'
        connectSignalFunPtr obj "move-page" cb'' connectMode detail

#endif

-- signal Completion::populate-context
-- | Emitted just before starting to populate the completion with providers.
-- You can use this signal to add additional attributes in the context.
type CompletionPopulateContextCallback =
    GtkSource.CompletionContext.CompletionContext
    -- ^ /@context@/: The t'GI.GtkSource.Objects.CompletionContext.CompletionContext' for the current completion
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionPopulateContextCallback`@.
noCompletionPopulateContextCallback :: Maybe CompletionPopulateContextCallback
noCompletionPopulateContextCallback :: Maybe CompletionPopulateContextCallback
noCompletionPopulateContextCallback = Maybe CompletionPopulateContextCallback
forall a. Maybe a
Nothing

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_CompletionPopulateContext :: MonadIO m => CompletionPopulateContextCallback -> m (GClosure C_CompletionPopulateContextCallback)
genClosure_CompletionPopulateContext :: CompletionPopulateContextCallback
-> m (GClosure C_CompletionPopulateContextCallback)
genClosure_CompletionPopulateContext CompletionPopulateContextCallback
cb = IO (GClosure C_CompletionPopulateContextCallback)
-> m (GClosure C_CompletionPopulateContextCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CompletionPopulateContextCallback)
 -> m (GClosure C_CompletionPopulateContextCallback))
-> IO (GClosure C_CompletionPopulateContextCallback)
-> m (GClosure C_CompletionPopulateContextCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CompletionPopulateContextCallback
cb' = CompletionPopulateContextCallback
-> C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback CompletionPopulateContextCallback
cb
    C_CompletionPopulateContextCallback
-> IO (FunPtr C_CompletionPopulateContextCallback)
mk_CompletionPopulateContextCallback C_CompletionPopulateContextCallback
cb' IO (FunPtr C_CompletionPopulateContextCallback)
-> (FunPtr C_CompletionPopulateContextCallback
    -> IO (GClosure C_CompletionPopulateContextCallback))
-> IO (GClosure C_CompletionPopulateContextCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CompletionPopulateContextCallback
-> IO (GClosure C_CompletionPopulateContextCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `CompletionPopulateContextCallback` into a `C_CompletionPopulateContextCallback`.
wrap_CompletionPopulateContextCallback ::
    CompletionPopulateContextCallback ->
    C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback :: CompletionPopulateContextCallback
-> C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback CompletionPopulateContextCallback
_cb Ptr ()
_ Ptr CompletionContext
context Ptr ()
_ = do
    CompletionContext
context' <- ((ManagedPtr CompletionContext -> CompletionContext)
-> Ptr CompletionContext -> IO CompletionContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CompletionContext -> CompletionContext
GtkSource.CompletionContext.CompletionContext) Ptr CompletionContext
context
    CompletionPopulateContextCallback
_cb  CompletionContext
context'


-- | Connect a signal handler for the [populateContext](#signal:populateContext) 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' completion #populateContext callback
-- @
-- 
-- 
onCompletionPopulateContext :: (IsCompletion a, MonadIO m) => a -> CompletionPopulateContextCallback -> m SignalHandlerId
onCompletionPopulateContext :: a -> CompletionPopulateContextCallback -> m SignalHandlerId
onCompletionPopulateContext a
obj CompletionPopulateContextCallback
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_CompletionPopulateContextCallback
cb' = CompletionPopulateContextCallback
-> C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback CompletionPopulateContextCallback
cb
    FunPtr C_CompletionPopulateContextCallback
cb'' <- C_CompletionPopulateContextCallback
-> IO (FunPtr C_CompletionPopulateContextCallback)
mk_CompletionPopulateContextCallback C_CompletionPopulateContextCallback
cb'
    a
-> Text
-> FunPtr C_CompletionPopulateContextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"populate-context" FunPtr C_CompletionPopulateContextCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [populateContext](#signal:populateContext) 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' completion #populateContext callback
-- @
-- 
-- 
afterCompletionPopulateContext :: (IsCompletion a, MonadIO m) => a -> CompletionPopulateContextCallback -> m SignalHandlerId
afterCompletionPopulateContext :: a -> CompletionPopulateContextCallback -> m SignalHandlerId
afterCompletionPopulateContext a
obj CompletionPopulateContextCallback
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_CompletionPopulateContextCallback
cb' = CompletionPopulateContextCallback
-> C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback CompletionPopulateContextCallback
cb
    FunPtr C_CompletionPopulateContextCallback
cb'' <- C_CompletionPopulateContextCallback
-> IO (FunPtr C_CompletionPopulateContextCallback)
mk_CompletionPopulateContextCallback C_CompletionPopulateContextCallback
cb'
    a
-> Text
-> FunPtr C_CompletionPopulateContextCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"populate-context" FunPtr C_CompletionPopulateContextCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CompletionPopulateContextSignalInfo
instance SignalInfo CompletionPopulateContextSignalInfo where
    type HaskellCallbackType CompletionPopulateContextSignalInfo = CompletionPopulateContextCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CompletionPopulateContextCallback cb
        cb'' <- mk_CompletionPopulateContextCallback cb'
        connectSignalFunPtr obj "populate-context" cb'' connectMode detail

#endif

-- signal Completion::show
-- | Emitted when the completion window is shown. The default handler
-- will actually show the window.
type CompletionShowCallback =
    IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_CompletionShow :: MonadIO m => CompletionShowCallback -> m (GClosure C_CompletionShowCallback)
genClosure_CompletionShow :: IO () -> m (GClosure C_CompletionActivateProposalCallback)
genClosure_CompletionShow IO ()
cb = IO (GClosure C_CompletionActivateProposalCallback)
-> m (GClosure C_CompletionActivateProposalCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_CompletionActivateProposalCallback)
 -> m (GClosure C_CompletionActivateProposalCallback))
-> IO (GClosure C_CompletionActivateProposalCallback)
-> m (GClosure C_CompletionActivateProposalCallback)
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_CompletionActivateProposalCallback
cb' = IO () -> C_CompletionActivateProposalCallback
wrap_CompletionShowCallback IO ()
cb
    C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionShowCallback C_CompletionActivateProposalCallback
cb' IO (FunPtr C_CompletionActivateProposalCallback)
-> (FunPtr C_CompletionActivateProposalCallback
    -> IO (GClosure C_CompletionActivateProposalCallback))
-> IO (GClosure C_CompletionActivateProposalCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_CompletionActivateProposalCallback
-> IO (GClosure C_CompletionActivateProposalCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure


-- | Wrap a `CompletionShowCallback` into a `C_CompletionShowCallback`.
wrap_CompletionShowCallback ::
    CompletionShowCallback ->
    C_CompletionShowCallback
wrap_CompletionShowCallback :: IO () -> C_CompletionActivateProposalCallback
wrap_CompletionShowCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
    IO ()
_cb 


-- | Connect a signal handler for the [show](#signal:show) 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' completion #show callback
-- @
-- 
-- 
onCompletionShow :: (IsCompletion a, MonadIO m) => a -> CompletionShowCallback -> m SignalHandlerId
onCompletionShow :: a -> IO () -> m SignalHandlerId
onCompletionShow 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_CompletionActivateProposalCallback
cb' = IO () -> C_CompletionActivateProposalCallback
wrap_CompletionShowCallback IO ()
cb
    FunPtr C_CompletionActivateProposalCallback
cb'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionShowCallback C_CompletionActivateProposalCallback
cb'
    a
-> Text
-> FunPtr C_CompletionActivateProposalCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show" FunPtr C_CompletionActivateProposalCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [show](#signal:show) 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' completion #show callback
-- @
-- 
-- 
afterCompletionShow :: (IsCompletion a, MonadIO m) => a -> CompletionShowCallback -> m SignalHandlerId
afterCompletionShow :: a -> IO () -> m SignalHandlerId
afterCompletionShow 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_CompletionActivateProposalCallback
cb' = IO () -> C_CompletionActivateProposalCallback
wrap_CompletionShowCallback IO ()
cb
    FunPtr C_CompletionActivateProposalCallback
cb'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionShowCallback C_CompletionActivateProposalCallback
cb'
    a
-> Text
-> FunPtr C_CompletionActivateProposalCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show" FunPtr C_CompletionActivateProposalCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CompletionShowSignalInfo
instance SignalInfo CompletionShowSignalInfo where
    type HaskellCallbackType CompletionShowSignalInfo = CompletionShowCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CompletionShowCallback cb
        cb'' <- mk_CompletionShowCallback cb'
        connectSignalFunPtr obj "show" cb'' connectMode detail

#endif

-- VVV Prop "accelerators"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@accelerators@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' completion #accelerators
-- @
getCompletionAccelerators :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionAccelerators :: o -> m Word32
getCompletionAccelerators o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"accelerators"

-- | Set the value of the “@accelerators@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completion [ #accelerators 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionAccelerators :: (MonadIO m, IsCompletion o) => o -> Word32 -> m ()
setCompletionAccelerators :: o -> Word32 -> m ()
setCompletionAccelerators o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"accelerators" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@accelerators@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionAccelerators :: (IsCompletion o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructCompletionAccelerators :: Word32 -> m (GValueConstruct o)
constructCompletionAccelerators Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"accelerators" Word32
val

#if defined(ENABLE_OVERLOADING)
data CompletionAcceleratorsPropertyInfo
instance AttrInfo CompletionAcceleratorsPropertyInfo where
    type AttrAllowedOps CompletionAcceleratorsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CompletionAcceleratorsPropertyInfo = IsCompletion
    type AttrSetTypeConstraint CompletionAcceleratorsPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint CompletionAcceleratorsPropertyInfo = (~) Word32
    type AttrTransferType CompletionAcceleratorsPropertyInfo = Word32
    type AttrGetType CompletionAcceleratorsPropertyInfo = Word32
    type AttrLabel CompletionAcceleratorsPropertyInfo = "accelerators"
    type AttrOrigin CompletionAcceleratorsPropertyInfo = Completion
    attrGet = getCompletionAccelerators
    attrSet = setCompletionAccelerators
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionAccelerators
    attrClear = undefined
#endif

-- VVV Prop "auto-complete-delay"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@auto-complete-delay@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' completion #autoCompleteDelay
-- @
getCompletionAutoCompleteDelay :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionAutoCompleteDelay :: o -> m Word32
getCompletionAutoCompleteDelay o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"auto-complete-delay"

-- | Set the value of the “@auto-complete-delay@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completion [ #autoCompleteDelay 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionAutoCompleteDelay :: (MonadIO m, IsCompletion o) => o -> Word32 -> m ()
setCompletionAutoCompleteDelay :: o -> Word32 -> m ()
setCompletionAutoCompleteDelay o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"auto-complete-delay" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@auto-complete-delay@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionAutoCompleteDelay :: (IsCompletion o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructCompletionAutoCompleteDelay :: Word32 -> m (GValueConstruct o)
constructCompletionAutoCompleteDelay Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"auto-complete-delay" Word32
val

#if defined(ENABLE_OVERLOADING)
data CompletionAutoCompleteDelayPropertyInfo
instance AttrInfo CompletionAutoCompleteDelayPropertyInfo where
    type AttrAllowedOps CompletionAutoCompleteDelayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CompletionAutoCompleteDelayPropertyInfo = IsCompletion
    type AttrSetTypeConstraint CompletionAutoCompleteDelayPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint CompletionAutoCompleteDelayPropertyInfo = (~) Word32
    type AttrTransferType CompletionAutoCompleteDelayPropertyInfo = Word32
    type AttrGetType CompletionAutoCompleteDelayPropertyInfo = Word32
    type AttrLabel CompletionAutoCompleteDelayPropertyInfo = "auto-complete-delay"
    type AttrOrigin CompletionAutoCompleteDelayPropertyInfo = Completion
    attrGet = getCompletionAutoCompleteDelay
    attrSet = setCompletionAutoCompleteDelay
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionAutoCompleteDelay
    attrClear = undefined
#endif

-- VVV Prop "proposal-page-size"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@proposal-page-size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' completion #proposalPageSize
-- @
getCompletionProposalPageSize :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionProposalPageSize :: o -> m Word32
getCompletionProposalPageSize o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"proposal-page-size"

-- | Set the value of the “@proposal-page-size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completion [ #proposalPageSize 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionProposalPageSize :: (MonadIO m, IsCompletion o) => o -> Word32 -> m ()
setCompletionProposalPageSize :: o -> Word32 -> m ()
setCompletionProposalPageSize o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"proposal-page-size" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@proposal-page-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionProposalPageSize :: (IsCompletion o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructCompletionProposalPageSize :: Word32 -> m (GValueConstruct o)
constructCompletionProposalPageSize Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"proposal-page-size" Word32
val

#if defined(ENABLE_OVERLOADING)
data CompletionProposalPageSizePropertyInfo
instance AttrInfo CompletionProposalPageSizePropertyInfo where
    type AttrAllowedOps CompletionProposalPageSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CompletionProposalPageSizePropertyInfo = IsCompletion
    type AttrSetTypeConstraint CompletionProposalPageSizePropertyInfo = (~) Word32
    type AttrTransferTypeConstraint CompletionProposalPageSizePropertyInfo = (~) Word32
    type AttrTransferType CompletionProposalPageSizePropertyInfo = Word32
    type AttrGetType CompletionProposalPageSizePropertyInfo = Word32
    type AttrLabel CompletionProposalPageSizePropertyInfo = "proposal-page-size"
    type AttrOrigin CompletionProposalPageSizePropertyInfo = Completion
    attrGet = getCompletionProposalPageSize
    attrSet = setCompletionProposalPageSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionProposalPageSize
    attrClear = undefined
#endif

-- VVV Prop "provider-page-size"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@provider-page-size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' completion #providerPageSize
-- @
getCompletionProviderPageSize :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionProviderPageSize :: o -> m Word32
getCompletionProviderPageSize o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"provider-page-size"

-- | Set the value of the “@provider-page-size@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completion [ #providerPageSize 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionProviderPageSize :: (MonadIO m, IsCompletion o) => o -> Word32 -> m ()
setCompletionProviderPageSize :: o -> Word32 -> m ()
setCompletionProviderPageSize o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"provider-page-size" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@provider-page-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionProviderPageSize :: (IsCompletion o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructCompletionProviderPageSize :: Word32 -> m (GValueConstruct o)
constructCompletionProviderPageSize Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"provider-page-size" Word32
val

#if defined(ENABLE_OVERLOADING)
data CompletionProviderPageSizePropertyInfo
instance AttrInfo CompletionProviderPageSizePropertyInfo where
    type AttrAllowedOps CompletionProviderPageSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CompletionProviderPageSizePropertyInfo = IsCompletion
    type AttrSetTypeConstraint CompletionProviderPageSizePropertyInfo = (~) Word32
    type AttrTransferTypeConstraint CompletionProviderPageSizePropertyInfo = (~) Word32
    type AttrTransferType CompletionProviderPageSizePropertyInfo = Word32
    type AttrGetType CompletionProviderPageSizePropertyInfo = Word32
    type AttrLabel CompletionProviderPageSizePropertyInfo = "provider-page-size"
    type AttrOrigin CompletionProviderPageSizePropertyInfo = Completion
    attrGet = getCompletionProviderPageSize
    attrSet = setCompletionProviderPageSize
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionProviderPageSize
    attrClear = undefined
#endif

-- VVV Prop "remember-info-visibility"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@remember-info-visibility@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' completion #rememberInfoVisibility
-- @
getCompletionRememberInfoVisibility :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionRememberInfoVisibility :: o -> m Bool
getCompletionRememberInfoVisibility o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"remember-info-visibility"

-- | Set the value of the “@remember-info-visibility@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completion [ #rememberInfoVisibility 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionRememberInfoVisibility :: (MonadIO m, IsCompletion o) => o -> Bool -> m ()
setCompletionRememberInfoVisibility :: o -> Bool -> m ()
setCompletionRememberInfoVisibility o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"remember-info-visibility" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@remember-info-visibility@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionRememberInfoVisibility :: (IsCompletion o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructCompletionRememberInfoVisibility :: Bool -> m (GValueConstruct o)
constructCompletionRememberInfoVisibility Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"remember-info-visibility" Bool
val

#if defined(ENABLE_OVERLOADING)
data CompletionRememberInfoVisibilityPropertyInfo
instance AttrInfo CompletionRememberInfoVisibilityPropertyInfo where
    type AttrAllowedOps CompletionRememberInfoVisibilityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CompletionRememberInfoVisibilityPropertyInfo = IsCompletion
    type AttrSetTypeConstraint CompletionRememberInfoVisibilityPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CompletionRememberInfoVisibilityPropertyInfo = (~) Bool
    type AttrTransferType CompletionRememberInfoVisibilityPropertyInfo = Bool
    type AttrGetType CompletionRememberInfoVisibilityPropertyInfo = Bool
    type AttrLabel CompletionRememberInfoVisibilityPropertyInfo = "remember-info-visibility"
    type AttrOrigin CompletionRememberInfoVisibilityPropertyInfo = Completion
    attrGet = getCompletionRememberInfoVisibility
    attrSet = setCompletionRememberInfoVisibility
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionRememberInfoVisibility
    attrClear = undefined
#endif

-- VVV Prop "select-on-show"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@select-on-show@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' completion #selectOnShow
-- @
getCompletionSelectOnShow :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionSelectOnShow :: o -> m Bool
getCompletionSelectOnShow o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"select-on-show"

-- | Set the value of the “@select-on-show@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completion [ #selectOnShow 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionSelectOnShow :: (MonadIO m, IsCompletion o) => o -> Bool -> m ()
setCompletionSelectOnShow :: o -> Bool -> m ()
setCompletionSelectOnShow o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"select-on-show" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@select-on-show@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionSelectOnShow :: (IsCompletion o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructCompletionSelectOnShow :: Bool -> m (GValueConstruct o)
constructCompletionSelectOnShow Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"select-on-show" Bool
val

#if defined(ENABLE_OVERLOADING)
data CompletionSelectOnShowPropertyInfo
instance AttrInfo CompletionSelectOnShowPropertyInfo where
    type AttrAllowedOps CompletionSelectOnShowPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CompletionSelectOnShowPropertyInfo = IsCompletion
    type AttrSetTypeConstraint CompletionSelectOnShowPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CompletionSelectOnShowPropertyInfo = (~) Bool
    type AttrTransferType CompletionSelectOnShowPropertyInfo = Bool
    type AttrGetType CompletionSelectOnShowPropertyInfo = Bool
    type AttrLabel CompletionSelectOnShowPropertyInfo = "select-on-show"
    type AttrOrigin CompletionSelectOnShowPropertyInfo = Completion
    attrGet = getCompletionSelectOnShow
    attrSet = setCompletionSelectOnShow
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionSelectOnShow
    attrClear = undefined
#endif

-- VVV Prop "show-headers"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

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

-- | Set the value of the “@show-headers@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completion [ #showHeaders 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionShowHeaders :: (MonadIO m, IsCompletion o) => o -> Bool -> m ()
setCompletionShowHeaders :: o -> Bool -> m ()
setCompletionShowHeaders o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"show-headers" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@show-headers@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionShowHeaders :: (IsCompletion o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructCompletionShowHeaders :: Bool -> m (GValueConstruct o)
constructCompletionShowHeaders Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"show-headers" Bool
val

#if defined(ENABLE_OVERLOADING)
data CompletionShowHeadersPropertyInfo
instance AttrInfo CompletionShowHeadersPropertyInfo where
    type AttrAllowedOps CompletionShowHeadersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CompletionShowHeadersPropertyInfo = IsCompletion
    type AttrSetTypeConstraint CompletionShowHeadersPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CompletionShowHeadersPropertyInfo = (~) Bool
    type AttrTransferType CompletionShowHeadersPropertyInfo = Bool
    type AttrGetType CompletionShowHeadersPropertyInfo = Bool
    type AttrLabel CompletionShowHeadersPropertyInfo = "show-headers"
    type AttrOrigin CompletionShowHeadersPropertyInfo = Completion
    attrGet = getCompletionShowHeaders
    attrSet = setCompletionShowHeaders
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionShowHeaders
    attrClear = undefined
#endif

-- VVV Prop "show-icons"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

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

-- | Set the value of the “@show-icons@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completion [ #showIcons 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionShowIcons :: (MonadIO m, IsCompletion o) => o -> Bool -> m ()
setCompletionShowIcons :: o -> Bool -> m ()
setCompletionShowIcons o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"show-icons" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@show-icons@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionShowIcons :: (IsCompletion o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructCompletionShowIcons :: Bool -> m (GValueConstruct o)
constructCompletionShowIcons Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"show-icons" Bool
val

#if defined(ENABLE_OVERLOADING)
data CompletionShowIconsPropertyInfo
instance AttrInfo CompletionShowIconsPropertyInfo where
    type AttrAllowedOps CompletionShowIconsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CompletionShowIconsPropertyInfo = IsCompletion
    type AttrSetTypeConstraint CompletionShowIconsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint CompletionShowIconsPropertyInfo = (~) Bool
    type AttrTransferType CompletionShowIconsPropertyInfo = Bool
    type AttrGetType CompletionShowIconsPropertyInfo = Bool
    type AttrLabel CompletionShowIconsPropertyInfo = "show-icons"
    type AttrOrigin CompletionShowIconsPropertyInfo = Completion
    attrGet = getCompletionShowIcons
    attrSet = setCompletionShowIcons
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionShowIcons
    attrClear = undefined
#endif

-- VVV Prop "view"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "View"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@view@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' completion #view
-- @
getCompletionView :: (MonadIO m, IsCompletion o) => o -> m (Maybe GtkSource.View.View)
getCompletionView :: o -> m (Maybe View)
getCompletionView o
obj = IO (Maybe View) -> m (Maybe View)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe View) -> m (Maybe View))
-> IO (Maybe View) -> m (Maybe View)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr View -> View) -> IO (Maybe View)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"view" ManagedPtr View -> View
GtkSource.View.View

-- | Construct a `GValueConstruct` with valid value for the “@view@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionView :: (IsCompletion o, MIO.MonadIO m, GtkSource.View.IsView a) => a -> m (GValueConstruct o)
constructCompletionView :: a -> m (GValueConstruct o)
constructCompletionView a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"view" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data CompletionViewPropertyInfo
instance AttrInfo CompletionViewPropertyInfo where
    type AttrAllowedOps CompletionViewPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint CompletionViewPropertyInfo = IsCompletion
    type AttrSetTypeConstraint CompletionViewPropertyInfo = GtkSource.View.IsView
    type AttrTransferTypeConstraint CompletionViewPropertyInfo = GtkSource.View.IsView
    type AttrTransferType CompletionViewPropertyInfo = GtkSource.View.View
    type AttrGetType CompletionViewPropertyInfo = (Maybe GtkSource.View.View)
    type AttrLabel CompletionViewPropertyInfo = "view"
    type AttrOrigin CompletionViewPropertyInfo = Completion
    attrGet = getCompletionView
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo GtkSource.View.View v
    attrConstruct = constructCompletionView
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Completion
type instance O.AttributeList Completion = CompletionAttributeList
type CompletionAttributeList = ('[ '("accelerators", CompletionAcceleratorsPropertyInfo), '("autoCompleteDelay", CompletionAutoCompleteDelayPropertyInfo), '("proposalPageSize", CompletionProposalPageSizePropertyInfo), '("providerPageSize", CompletionProviderPageSizePropertyInfo), '("rememberInfoVisibility", CompletionRememberInfoVisibilityPropertyInfo), '("selectOnShow", CompletionSelectOnShowPropertyInfo), '("showHeaders", CompletionShowHeadersPropertyInfo), '("showIcons", CompletionShowIconsPropertyInfo), '("view", CompletionViewPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
completionAccelerators :: AttrLabelProxy "accelerators"
completionAccelerators = AttrLabelProxy

completionAutoCompleteDelay :: AttrLabelProxy "autoCompleteDelay"
completionAutoCompleteDelay = AttrLabelProxy

completionProposalPageSize :: AttrLabelProxy "proposalPageSize"
completionProposalPageSize = AttrLabelProxy

completionProviderPageSize :: AttrLabelProxy "providerPageSize"
completionProviderPageSize = AttrLabelProxy

completionRememberInfoVisibility :: AttrLabelProxy "rememberInfoVisibility"
completionRememberInfoVisibility = AttrLabelProxy

completionSelectOnShow :: AttrLabelProxy "selectOnShow"
completionSelectOnShow = AttrLabelProxy

completionShowHeaders :: AttrLabelProxy "showHeaders"
completionShowHeaders = AttrLabelProxy

completionShowIcons :: AttrLabelProxy "showIcons"
completionShowIcons = AttrLabelProxy

completionView :: AttrLabelProxy "view"
completionView = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Completion = CompletionSignalList
type CompletionSignalList = ('[ '("activateProposal", CompletionActivateProposalSignalInfo), '("hide", CompletionHideSignalInfo), '("moveCursor", CompletionMoveCursorSignalInfo), '("movePage", CompletionMovePageSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("populateContext", CompletionPopulateContextSignalInfo), '("show", CompletionShowSignalInfo)] :: [(Symbol, *)])

#endif

-- method Completion::add_provider
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "provider"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletionProvider."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "gtk_source_completion_add_provider" gtk_source_completion_add_provider :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    Ptr GtkSource.CompletionProvider.CompletionProvider -> -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Add a new t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider' to the completion object. This will
-- add a reference /@provider@/, so make sure to unref your own copy when you
-- no longer need it.
completionAddProvider ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> b
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
completionAddProvider :: a -> b -> m ()
completionAddProvider a
completion b
provider = 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 Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr CompletionProvider
provider' <- b -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
provider
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Completion
-> Ptr CompletionProvider -> Ptr (Ptr GError) -> IO CInt
gtk_source_completion_add_provider Ptr Completion
completion' Ptr CompletionProvider
provider'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
provider
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data CompletionAddProviderMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b) => O.MethodInfo CompletionAddProviderMethodInfo a signature where
    overloadedMethod = completionAddProvider

#endif

-- method Completion::block_interactive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_block_interactive" gtk_source_completion_block_interactive :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    IO ()

-- | Block interactive completion. This can be used to disable interactive
-- completion when inserting or deleting text from the buffer associated with
-- the completion. Use 'GI.GtkSource.Objects.Completion.completionUnblockInteractive' to enable
-- interactive completion again.
-- 
-- This function may be called multiple times. It will continue to block
-- interactive completion until 'GI.GtkSource.Objects.Completion.completionUnblockInteractive'
-- has been called the same number of times.
completionBlockInteractive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> m ()
completionBlockInteractive :: a -> m ()
completionBlockInteractive a
completion = 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 Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr Completion -> IO ()
gtk_source_completion_block_interactive Ptr Completion
completion'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CompletionBlockInteractiveMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCompletion a) => O.MethodInfo CompletionBlockInteractiveMethodInfo a signature where
    overloadedMethod = completionBlockInteractive

#endif

-- method Completion::create_context
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkTextIter, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "CompletionContext" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_create_context" gtk_source_completion_create_context :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    Ptr Gtk.TextIter.TextIter ->            -- position : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO (Ptr GtkSource.CompletionContext.CompletionContext)

-- | Create a new t'GI.GtkSource.Objects.CompletionContext.CompletionContext' for /@completion@/. The position where
-- the completion occurs can be specified by /@position@/. If /@position@/ is 'P.Nothing',
-- the current cursor position will be used.
completionCreateContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> Maybe (Gtk.TextIter.TextIter)
    -- ^ /@position@/: a t'GI.Gtk.Structs.TextIter.TextIter', or 'P.Nothing'.
    -> m GtkSource.CompletionContext.CompletionContext
    -- ^ __Returns:__ a new t'GI.GtkSource.Objects.CompletionContext.CompletionContext'.
    -- The reference being returned is a \'floating\' reference,
    -- so if you invoke 'GI.GtkSource.Objects.Completion.completionShow' with this context
    -- you don\'t need to unref it.
completionCreateContext :: a -> Maybe TextIter -> m CompletionContext
completionCreateContext a
completion Maybe TextIter
position = IO CompletionContext -> m CompletionContext
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CompletionContext -> m CompletionContext)
-> IO CompletionContext -> m CompletionContext
forall a b. (a -> b) -> a -> b
$ do
    Ptr Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr TextIter
maybePosition <- case Maybe TextIter
position of
        Maybe TextIter
Nothing -> Ptr TextIter -> IO (Ptr TextIter)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TextIter
forall a. Ptr a
nullPtr
        Just TextIter
jPosition -> do
            Ptr TextIter
jPosition' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
jPosition
            Ptr TextIter -> IO (Ptr TextIter)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TextIter
jPosition'
    Ptr CompletionContext
result <- Ptr Completion -> Ptr TextIter -> IO (Ptr CompletionContext)
gtk_source_completion_create_context Ptr Completion
completion' Ptr TextIter
maybePosition
    Text -> Ptr CompletionContext -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"completionCreateContext" Ptr CompletionContext
result
    CompletionContext
result' <- ((ManagedPtr CompletionContext -> CompletionContext)
-> Ptr CompletionContext -> IO CompletionContext
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CompletionContext -> CompletionContext
GtkSource.CompletionContext.CompletionContext) Ptr CompletionContext
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
    Maybe TextIter -> (TextIter -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TextIter
position TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CompletionContext -> IO CompletionContext
forall (m :: * -> *) a. Monad m => a -> m a
return CompletionContext
result'

#if defined(ENABLE_OVERLOADING)
data CompletionCreateContextMethodInfo
instance (signature ~ (Maybe (Gtk.TextIter.TextIter) -> m GtkSource.CompletionContext.CompletionContext), MonadIO m, IsCompletion a) => O.MethodInfo CompletionCreateContextMethodInfo a signature where
    overloadedMethod = completionCreateContext

#endif

-- method Completion::get_info_window
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "CompletionInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_get_info_window" gtk_source_completion_get_info_window :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    IO (Ptr GtkSource.CompletionInfo.CompletionInfo)

-- | The info widget is the window where the completion displays optional extra
-- information of the proposal.
completionGetInfoWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> m GtkSource.CompletionInfo.CompletionInfo
    -- ^ __Returns:__ The t'GI.GtkSource.Objects.CompletionInfo.CompletionInfo' window
    --                           associated with /@completion@/.
completionGetInfoWindow :: a -> m CompletionInfo
completionGetInfoWindow a
completion = IO CompletionInfo -> m CompletionInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CompletionInfo -> m CompletionInfo)
-> IO CompletionInfo -> m CompletionInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr CompletionInfo
result <- Ptr Completion -> IO (Ptr CompletionInfo)
gtk_source_completion_get_info_window Ptr Completion
completion'
    Text -> Ptr CompletionInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"completionGetInfoWindow" Ptr CompletionInfo
result
    CompletionInfo
result' <- ((ManagedPtr CompletionInfo -> CompletionInfo)
-> Ptr CompletionInfo -> IO CompletionInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CompletionInfo -> CompletionInfo
GtkSource.CompletionInfo.CompletionInfo) Ptr CompletionInfo
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
    CompletionInfo -> IO CompletionInfo
forall (m :: * -> *) a. Monad m => a -> m a
return CompletionInfo
result'

#if defined(ENABLE_OVERLOADING)
data CompletionGetInfoWindowMethodInfo
instance (signature ~ (m GtkSource.CompletionInfo.CompletionInfo), MonadIO m, IsCompletion a) => O.MethodInfo CompletionGetInfoWindowMethodInfo a signature where
    overloadedMethod = completionGetInfoWindow

#endif

-- method Completion::get_providers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface
--                     Name { namespace = "GtkSource" , name = "CompletionProvider" }))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_get_providers" gtk_source_completion_get_providers :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    IO (Ptr (GList (Ptr GtkSource.CompletionProvider.CompletionProvider)))

-- | Get list of providers registered on /@completion@/. The returned list is owned
-- by the completion and should not be freed.
completionGetProviders ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> m [GtkSource.CompletionProvider.CompletionProvider]
    -- ^ __Returns:__ 
    -- list of t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
completionGetProviders :: a -> m [CompletionProvider]
completionGetProviders a
completion = IO [CompletionProvider] -> m [CompletionProvider]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [CompletionProvider] -> m [CompletionProvider])
-> IO [CompletionProvider] -> m [CompletionProvider]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr (GList (Ptr CompletionProvider))
result <- Ptr Completion -> IO (Ptr (GList (Ptr CompletionProvider)))
gtk_source_completion_get_providers Ptr Completion
completion'
    [Ptr CompletionProvider]
result' <- Ptr (GList (Ptr CompletionProvider)) -> IO [Ptr CompletionProvider]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr CompletionProvider))
result
    [CompletionProvider]
result'' <- (Ptr CompletionProvider -> IO CompletionProvider)
-> [Ptr CompletionProvider] -> IO [CompletionProvider]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr CompletionProvider -> CompletionProvider)
-> Ptr CompletionProvider -> IO CompletionProvider
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr CompletionProvider -> CompletionProvider
GtkSource.CompletionProvider.CompletionProvider) [Ptr CompletionProvider]
result'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
    [CompletionProvider] -> IO [CompletionProvider]
forall (m :: * -> *) a. Monad m => a -> m a
return [CompletionProvider]
result''

#if defined(ENABLE_OVERLOADING)
data CompletionGetProvidersMethodInfo
instance (signature ~ (m [GtkSource.CompletionProvider.CompletionProvider]), MonadIO m, IsCompletion a) => O.MethodInfo CompletionGetProvidersMethodInfo a signature where
    overloadedMethod = completionGetProviders

#endif

-- method Completion::get_view
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GtkSource" , name = "View" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_get_view" gtk_source_completion_get_view :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    IO (Ptr GtkSource.View.View)

-- | The t'GI.GtkSource.Objects.View.View' associated with /@completion@/, or 'P.Nothing' if the view has been
-- destroyed.
completionGetView ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> m (Maybe GtkSource.View.View)
    -- ^ __Returns:__ The t'GI.GtkSource.Objects.View.View' associated with
    -- /@completion@/, or 'P.Nothing'.
completionGetView :: a -> m (Maybe View)
completionGetView a
completion = IO (Maybe View) -> m (Maybe View)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe View) -> m (Maybe View))
-> IO (Maybe View) -> m (Maybe View)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr View
result <- Ptr Completion -> IO (Ptr View)
gtk_source_completion_get_view Ptr Completion
completion'
    Maybe View
maybeResult <- Ptr View -> (Ptr View -> IO View) -> IO (Maybe View)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr View
result ((Ptr View -> IO View) -> IO (Maybe View))
-> (Ptr View -> IO View) -> IO (Maybe View)
forall a b. (a -> b) -> a -> b
$ \Ptr View
result' -> do
        View
result'' <- ((ManagedPtr View -> View) -> Ptr View -> IO View
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr View -> View
GtkSource.View.View) Ptr View
result'
        View -> IO View
forall (m :: * -> *) a. Monad m => a -> m a
return View
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
    Maybe View -> IO (Maybe View)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe View
maybeResult

#if defined(ENABLE_OVERLOADING)
data CompletionGetViewMethodInfo
instance (signature ~ (m (Maybe GtkSource.View.View)), MonadIO m, IsCompletion a) => O.MethodInfo CompletionGetViewMethodInfo a signature where
    overloadedMethod = completionGetView

#endif

-- method Completion::hide
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_hide" gtk_source_completion_hide :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    IO ()

-- | Hides the completion if it is active (visible).
completionHide ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> m ()
completionHide :: a -> m ()
completionHide a
completion = 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 Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr Completion -> IO ()
gtk_source_completion_hide Ptr Completion
completion'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CompletionHideMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCompletion a) => O.MethodInfo CompletionHideMethodInfo a signature where
    overloadedMethod = completionHide

#endif

-- method Completion::move_window
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkTextIter." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_move_window" gtk_source_completion_move_window :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

{-# DEPRECATED completionMoveWindow ["(Since version 3.8)","Use 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderGetStartIter' instead."] #-}
-- | Move the completion window to a specific iter.
completionMoveWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> m ()
completionMoveWindow :: a -> TextIter -> m ()
completionMoveWindow a
completion TextIter
iter = 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 Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Ptr Completion -> Ptr TextIter -> IO ()
gtk_source_completion_move_window Ptr Completion
completion' Ptr TextIter
iter'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CompletionMoveWindowMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> m ()), MonadIO m, IsCompletion a) => O.MethodInfo CompletionMoveWindowMethodInfo a signature where
    overloadedMethod = completionMoveWindow

#endif

-- method Completion::remove_provider
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "provider"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletionProvider."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "gtk_source_completion_remove_provider" gtk_source_completion_remove_provider :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    Ptr GtkSource.CompletionProvider.CompletionProvider -> -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Remove /@provider@/ from the completion.
completionRemoveProvider ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> b
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
completionRemoveProvider :: a -> b -> m ()
completionRemoveProvider a
completion b
provider = 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 Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr CompletionProvider
provider' <- b -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
provider
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Completion
-> Ptr CompletionProvider -> Ptr (Ptr GError) -> IO CInt
gtk_source_completion_remove_provider Ptr Completion
completion' Ptr CompletionProvider
provider'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
provider
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data CompletionRemoveProviderMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b) => O.MethodInfo CompletionRemoveProviderMethodInfo a signature where
    overloadedMethod = completionRemoveProvider

#endif

-- method Completion::show
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "providers"
--           , argType =
--               TGList
--                 (TInterface
--                    Name { namespace = "GtkSource" , name = "CompletionProvider" })
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "\na list of #GtkSourceCompletionProvider, or %NULL."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "context"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionContext" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The #GtkSourceCompletionContext\nwith which to start the completion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_show" gtk_source_completion_show :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    Ptr (GList (Ptr GtkSource.CompletionProvider.CompletionProvider)) -> -- providers : TGList (TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"}))
    Ptr GtkSource.CompletionContext.CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})
    IO CInt

-- | Starts a new completion with the specified t'GI.GtkSource.Objects.CompletionContext.CompletionContext' and
-- a list of potential candidate providers for completion.
-- 
-- It can be convenient for showing a completion on-the-fly, without the need to
-- add or remove providers to the t'GI.GtkSource.Objects.Completion.Completion'.
-- 
-- Another solution is to add providers with
-- 'GI.GtkSource.Objects.Completion.completionAddProvider', and implement
-- 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderMatch' for each provider.
completionShow ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionContext.IsCompletionContext c) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> [b]
    -- ^ /@providers@/: 
    -- a list of t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider', or 'P.Nothing'.
    -> c
    -- ^ /@context@/: The t'GI.GtkSource.Objects.CompletionContext.CompletionContext'
    -- with which to start the completion.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if it was possible to the show completion window.
completionShow :: a -> [b] -> c -> m Bool
completionShow a
completion [b]
providers c
context = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    [Ptr CompletionProvider]
providers' <- (b -> IO (Ptr CompletionProvider))
-> [b] -> IO [Ptr CompletionProvider]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM b -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [b]
providers
    Ptr (GList (Ptr CompletionProvider))
providers'' <- [Ptr CompletionProvider]
-> IO (Ptr (GList (Ptr CompletionProvider)))
forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [Ptr CompletionProvider]
providers'
    Ptr CompletionContext
context' <- c -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
context
    CInt
result <- Ptr Completion
-> Ptr (GList (Ptr CompletionProvider))
-> Ptr CompletionContext
-> IO CInt
gtk_source_completion_show Ptr Completion
completion' Ptr (GList (Ptr CompletionProvider))
providers'' Ptr CompletionContext
context'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
    (b -> IO ()) -> [b] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [b]
providers
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
context
    Ptr (GList (Ptr CompletionProvider)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr CompletionProvider))
providers''
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CompletionShowMethodInfo
instance (signature ~ ([b] -> c -> m Bool), MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionContext.IsCompletionContext c) => O.MethodInfo CompletionShowMethodInfo a signature where
    overloadedMethod = completionShow

#endif

-- method Completion::unblock_interactive
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "completion"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Completion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletion."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_unblock_interactive" gtk_source_completion_unblock_interactive :: 
    Ptr Completion ->                       -- completion : TInterface (Name {namespace = "GtkSource", name = "Completion"})
    IO ()

-- | Unblock interactive completion. This can be used after using
-- 'GI.GtkSource.Objects.Completion.completionBlockInteractive' to enable interactive completion
-- again.
completionUnblockInteractive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    -- ^ /@completion@/: a t'GI.GtkSource.Objects.Completion.Completion'.
    -> m ()
completionUnblockInteractive :: a -> m ()
completionUnblockInteractive a
completion = 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 Completion
completion' <- a -> IO (Ptr Completion)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
completion
    Ptr Completion -> IO ()
gtk_source_completion_unblock_interactive Ptr Completion
completion'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
completion
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CompletionUnblockInteractiveMethodInfo
instance (signature ~ (m ()), MonadIO m, IsCompletion a) => O.MethodInfo CompletionUnblockInteractiveMethodInfo a signature where
    overloadedMethod = completionUnblockInteractive

#endif