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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addChild]("GI.Gtk.Interfaces.Buildable#g:method:addChild"), [addProvider]("GI.GtkSource.Objects.Completion#g:method:addProvider"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [blockInteractive]("GI.GtkSource.Objects.Completion#g:method:blockInteractive"), [constructChild]("GI.Gtk.Interfaces.Buildable#g:method:constructChild"), [createContext]("GI.GtkSource.Objects.Completion#g:method:createContext"), [customFinished]("GI.Gtk.Interfaces.Buildable#g:method:customFinished"), [customTagEnd]("GI.Gtk.Interfaces.Buildable#g:method:customTagEnd"), [customTagStart]("GI.Gtk.Interfaces.Buildable#g:method:customTagStart"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hide]("GI.GtkSource.Objects.Completion#g:method:hide"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [moveWindow]("GI.GtkSource.Objects.Completion#g:method:moveWindow"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [parserFinished]("GI.Gtk.Interfaces.Buildable#g:method:parserFinished"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeProvider]("GI.GtkSource.Objects.Completion#g:method:removeProvider"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [show]("GI.GtkSource.Objects.Completion#g:method:show"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unblockInteractive]("GI.GtkSource.Objects.Completion#g:method:unblockInteractive"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getInfoWindow]("GI.GtkSource.Objects.Completion#g:method:getInfoWindow"), [getInternalChild]("GI.Gtk.Interfaces.Buildable#g:method:getInternalChild"), [getName]("GI.Gtk.Interfaces.Buildable#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getProviders]("GI.GtkSource.Objects.Completion#g:method:getProviders"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getView]("GI.GtkSource.Objects.Completion#g:method:getView").
-- 
-- ==== Setters
-- [setBuildableProperty]("GI.Gtk.Interfaces.Buildable#g:method:setBuildableProperty"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setName]("GI.Gtk.Interfaces.Buildable#g:method:setName"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

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

    CompletionActivateProposalCallback      ,
#if defined(ENABLE_OVERLOADING)
    CompletionActivateProposalSignalInfo    ,
#endif
    afterCompletionActivateProposal         ,
    onCompletionActivateProposal            ,


-- ** hide #signal:hide#

    CompletionHideCallback                  ,
#if defined(ENABLE_OVERLOADING)
    CompletionHideSignalInfo                ,
#endif
    afterCompletionHide                     ,
    onCompletionHide                        ,


-- ** moveCursor #signal:moveCursor#

    CompletionMoveCursorCallback            ,
#if defined(ENABLE_OVERLOADING)
    CompletionMoveCursorSignalInfo          ,
#endif
    afterCompletionMoveCursor               ,
    onCompletionMoveCursor                  ,


-- ** movePage #signal:movePage#

    CompletionMovePageCallback              ,
#if defined(ENABLE_OVERLOADING)
    CompletionMovePageSignalInfo            ,
#endif
    afterCompletionMovePage                 ,
    onCompletionMovePage                    ,


-- ** populateContext #signal:populateContext#

    CompletionPopulateContextCallback       ,
#if defined(ENABLE_OVERLOADING)
    CompletionPopulateContextSignalInfo     ,
#endif
    afterCompletionPopulateContext          ,
    onCompletionPopulateContext             ,


-- ** show #signal:show#

    CompletionShowCallback                  ,
#if defined(ENABLE_OVERLOADING)
    CompletionShowSignalInfo                ,
#endif
    afterCompletionShow                     ,
    onCompletionShow                        ,




    ) where

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

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

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.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

-- | 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 :: (MIO.MonadIO m, IsCompletion o) => o -> m Completion
toCompletion :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> m Completion
toCompletion = IO Completion -> m Completion
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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'
B.ManagedPtr.unsafeCastTo ManagedPtr Completion -> Completion
Completion

-- | Convert 'Completion' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Completion) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_source_completion_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Completion -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Completion
P.Nothing = Ptr GValue -> Ptr Completion -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Completion
forall a. Ptr a
FP.nullPtr :: FP.Ptr Completion)
    gvalueSet_ Ptr GValue
gv (P.Just Completion
obj) = Completion -> (Ptr Completion -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Completion
obj (Ptr GValue -> Ptr Completion -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Completion)
gvalueGet_ Ptr GValue
gv = do
        Ptr Completion
ptr <- Ptr GValue -> IO (Ptr Completion)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Completion)
        if Ptr Completion
ptr Ptr Completion -> Ptr Completion -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Completion
forall a. Ptr a
FP.nullPtr
        then Completion -> Maybe Completion
forall a. a -> Maybe a
P.Just (Completion -> Maybe Completion)
-> IO Completion -> IO (Maybe Completion)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
        else Maybe Completion -> IO (Maybe Completion)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Completion
forall a. Maybe a
P.Nothing
        
    

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveCompletionMethod t Completion, O.OverloadedMethod info Completion p, R.HasField t Completion p) => R.HasField t Completion p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveCompletionMethod t Completion, O.OverloadedMethodInfo info Completion) => OL.IsLabel t (O.MethodProxy info Completion) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#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 ()

type C_CompletionActivateProposalCallback =
    Ptr Completion ->                       -- 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_CompletionActivateProposalCallback :: 
    GObject a => (a -> CompletionActivateProposalCallback) ->
    C_CompletionActivateProposalCallback
wrap_CompletionActivateProposalCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_CompletionActivateProposalCallback
wrap_CompletionActivateProposalCallback a -> IO ()
gi'cb Ptr Completion
gi'selfPtr Ptr ()
_ = do
    Ptr Completion -> (Completion -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Completion
gi'selfPtr ((Completion -> IO ()) -> IO ()) -> (Completion -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Completion
gi'self -> a -> IO ()
gi'cb (Completion -> a
Coerce.coerce Completion
gi'self) 


-- | 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 -> ((?self :: a) => CompletionActivateProposalCallback) -> m SignalHandlerId
onCompletionActivateProposal :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onCompletionActivateProposal a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_CompletionActivateProposalCallback
wrapped' = (a -> IO ()) -> C_CompletionActivateProposalCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionActivateProposalCallback
wrap_CompletionActivateProposalCallback a -> IO ()
wrapped
    FunPtr C_CompletionActivateProposalCallback
wrapped'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionActivateProposalCallback C_CompletionActivateProposalCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterCompletionActivateProposal :: (IsCompletion a, MonadIO m) => a -> ((?self :: a) => CompletionActivateProposalCallback) -> m SignalHandlerId
afterCompletionActivateProposal :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterCompletionActivateProposal a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_CompletionActivateProposalCallback
wrapped' = (a -> IO ()) -> C_CompletionActivateProposalCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionActivateProposalCallback
wrap_CompletionActivateProposalCallback a -> IO ()
wrapped
    FunPtr C_CompletionActivateProposalCallback
wrapped'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionActivateProposalCallback C_CompletionActivateProposalCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion::activate-proposal"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:signal:activateProposal"})

#endif

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

type C_CompletionHideCallback =
    Ptr Completion ->                       -- 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_CompletionHideCallback :: 
    GObject a => (a -> CompletionHideCallback) ->
    C_CompletionHideCallback
wrap_CompletionHideCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_CompletionActivateProposalCallback
wrap_CompletionHideCallback a -> IO ()
gi'cb Ptr Completion
gi'selfPtr Ptr ()
_ = do
    Ptr Completion -> (Completion -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Completion
gi'selfPtr ((Completion -> IO ()) -> IO ()) -> (Completion -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Completion
gi'self -> a -> IO ()
gi'cb (Completion -> a
Coerce.coerce Completion
gi'self) 


-- | 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 -> ((?self :: a) => CompletionHideCallback) -> m SignalHandlerId
onCompletionHide :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onCompletionHide a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_CompletionActivateProposalCallback
wrapped' = (a -> IO ()) -> C_CompletionActivateProposalCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionActivateProposalCallback
wrap_CompletionHideCallback a -> IO ()
wrapped
    FunPtr C_CompletionActivateProposalCallback
wrapped'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionHideCallback C_CompletionActivateProposalCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterCompletionHide :: (IsCompletion a, MonadIO m) => a -> ((?self :: a) => CompletionHideCallback) -> m SignalHandlerId
afterCompletionHide :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterCompletionHide a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_CompletionActivateProposalCallback
wrapped' = (a -> IO ()) -> C_CompletionActivateProposalCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionActivateProposalCallback
wrap_CompletionHideCallback a -> IO ()
wrapped
    FunPtr C_CompletionActivateProposalCallback
wrapped'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionHideCallback C_CompletionActivateProposalCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion::hide"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:signal:hide"})

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

type C_CompletionMoveCursorCallback =
    Ptr Completion ->                       -- 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_CompletionMoveCursorCallback :: 
    GObject a => (a -> CompletionMoveCursorCallback) ->
    C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback :: forall a.
GObject a =>
(a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback a -> CompletionMoveCursorCallback
gi'cb Ptr Completion
gi'selfPtr 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
    Ptr Completion -> (Completion -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Completion
gi'selfPtr ((Completion -> IO ()) -> IO ()) -> (Completion -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Completion
gi'self -> a -> CompletionMoveCursorCallback
gi'cb (Completion -> a
Coerce.coerce Completion
gi'self)  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 -> ((?self :: a) => CompletionMoveCursorCallback) -> m SignalHandlerId
onCompletionMoveCursor :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a
-> ((?self::a) => CompletionMoveCursorCallback)
-> m SignalHandlerId
onCompletionMoveCursor a
obj (?self::a) => 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 wrapped :: a -> CompletionMoveCursorCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CompletionMoveCursorCallback
CompletionMoveCursorCallback
cb
    let wrapped' :: C_CompletionMoveCursorCallback
wrapped' = (a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
forall a.
GObject a =>
(a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback a -> CompletionMoveCursorCallback
wrapped
    FunPtr C_CompletionMoveCursorCallback
wrapped'' <- C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMoveCursorCallback C_CompletionMoveCursorCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterCompletionMoveCursor :: (IsCompletion a, MonadIO m) => a -> ((?self :: a) => CompletionMoveCursorCallback) -> m SignalHandlerId
afterCompletionMoveCursor :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a
-> ((?self::a) => CompletionMoveCursorCallback)
-> m SignalHandlerId
afterCompletionMoveCursor a
obj (?self::a) => 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 wrapped :: a -> CompletionMoveCursorCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CompletionMoveCursorCallback
CompletionMoveCursorCallback
cb
    let wrapped' :: C_CompletionMoveCursorCallback
wrapped' = (a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
forall a.
GObject a =>
(a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback a -> CompletionMoveCursorCallback
wrapped
    FunPtr C_CompletionMoveCursorCallback
wrapped'' <- C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMoveCursorCallback C_CompletionMoveCursorCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion::move-cursor"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:signal:moveCursor"})

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

type C_CompletionMovePageCallback =
    Ptr Completion ->                       -- 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_CompletionMovePageCallback :: 
    GObject a => (a -> CompletionMovePageCallback) ->
    C_CompletionMovePageCallback
wrap_CompletionMovePageCallback :: forall a.
GObject a =>
(a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
wrap_CompletionMovePageCallback a -> CompletionMoveCursorCallback
gi'cb Ptr Completion
gi'selfPtr 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
    Ptr Completion -> (Completion -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Completion
gi'selfPtr ((Completion -> IO ()) -> IO ()) -> (Completion -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Completion
gi'self -> a -> CompletionMoveCursorCallback
gi'cb (Completion -> a
Coerce.coerce Completion
gi'self)  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 -> ((?self :: a) => CompletionMovePageCallback) -> m SignalHandlerId
onCompletionMovePage :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a
-> ((?self::a) => CompletionMoveCursorCallback)
-> m SignalHandlerId
onCompletionMovePage a
obj (?self::a) => 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 wrapped :: a -> CompletionMoveCursorCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CompletionMoveCursorCallback
CompletionMoveCursorCallback
cb
    let wrapped' :: C_CompletionMoveCursorCallback
wrapped' = (a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
forall a.
GObject a =>
(a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
wrap_CompletionMovePageCallback a -> CompletionMoveCursorCallback
wrapped
    FunPtr C_CompletionMoveCursorCallback
wrapped'' <- C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMovePageCallback C_CompletionMoveCursorCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterCompletionMovePage :: (IsCompletion a, MonadIO m) => a -> ((?self :: a) => CompletionMovePageCallback) -> m SignalHandlerId
afterCompletionMovePage :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a
-> ((?self::a) => CompletionMoveCursorCallback)
-> m SignalHandlerId
afterCompletionMovePage a
obj (?self::a) => 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 wrapped :: a -> CompletionMoveCursorCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CompletionMoveCursorCallback
CompletionMoveCursorCallback
cb
    let wrapped' :: C_CompletionMoveCursorCallback
wrapped' = (a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
forall a.
GObject a =>
(a -> CompletionMoveCursorCallback)
-> C_CompletionMoveCursorCallback
wrap_CompletionMovePageCallback a -> CompletionMoveCursorCallback
wrapped
    FunPtr C_CompletionMoveCursorCallback
wrapped'' <- C_CompletionMoveCursorCallback
-> IO (FunPtr C_CompletionMoveCursorCallback)
mk_CompletionMovePageCallback C_CompletionMoveCursorCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion::move-page"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:signal:movePage"})

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

type C_CompletionPopulateContextCallback =
    Ptr Completion ->                       -- 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_CompletionPopulateContextCallback :: 
    GObject a => (a -> CompletionPopulateContextCallback) ->
    C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback :: forall a.
GObject a =>
(a -> CompletionPopulateContextCallback)
-> C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback a -> CompletionPopulateContextCallback
gi'cb Ptr Completion
gi'selfPtr 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
    Ptr Completion -> (Completion -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Completion
gi'selfPtr ((Completion -> IO ()) -> IO ()) -> (Completion -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Completion
gi'self -> a -> CompletionPopulateContextCallback
gi'cb (Completion -> a
Coerce.coerce Completion
gi'self)  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 -> ((?self :: a) => CompletionPopulateContextCallback) -> m SignalHandlerId
onCompletionPopulateContext :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a
-> ((?self::a) => CompletionPopulateContextCallback)
-> m SignalHandlerId
onCompletionPopulateContext a
obj (?self::a) => 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 wrapped :: a -> CompletionPopulateContextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CompletionPopulateContextCallback
CompletionPopulateContextCallback
cb
    let wrapped' :: C_CompletionPopulateContextCallback
wrapped' = (a -> CompletionPopulateContextCallback)
-> C_CompletionPopulateContextCallback
forall a.
GObject a =>
(a -> CompletionPopulateContextCallback)
-> C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback a -> CompletionPopulateContextCallback
wrapped
    FunPtr C_CompletionPopulateContextCallback
wrapped'' <- C_CompletionPopulateContextCallback
-> IO (FunPtr C_CompletionPopulateContextCallback)
mk_CompletionPopulateContextCallback C_CompletionPopulateContextCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterCompletionPopulateContext :: (IsCompletion a, MonadIO m) => a -> ((?self :: a) => CompletionPopulateContextCallback) -> m SignalHandlerId
afterCompletionPopulateContext :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a
-> ((?self::a) => CompletionPopulateContextCallback)
-> m SignalHandlerId
afterCompletionPopulateContext a
obj (?self::a) => 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 wrapped :: a -> CompletionPopulateContextCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => CompletionPopulateContextCallback
CompletionPopulateContextCallback
cb
    let wrapped' :: C_CompletionPopulateContextCallback
wrapped' = (a -> CompletionPopulateContextCallback)
-> C_CompletionPopulateContextCallback
forall a.
GObject a =>
(a -> CompletionPopulateContextCallback)
-> C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback a -> CompletionPopulateContextCallback
wrapped
    FunPtr C_CompletionPopulateContextCallback
wrapped'' <- C_CompletionPopulateContextCallback
-> IO (FunPtr C_CompletionPopulateContextCallback)
mk_CompletionPopulateContextCallback C_CompletionPopulateContextCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion::populate-context"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:signal:populateContext"})

#endif

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

type C_CompletionShowCallback =
    Ptr Completion ->                       -- 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_CompletionShowCallback :: 
    GObject a => (a -> CompletionShowCallback) ->
    C_CompletionShowCallback
wrap_CompletionShowCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_CompletionActivateProposalCallback
wrap_CompletionShowCallback a -> IO ()
gi'cb Ptr Completion
gi'selfPtr Ptr ()
_ = do
    Ptr Completion -> (Completion -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Completion
gi'selfPtr ((Completion -> IO ()) -> IO ()) -> (Completion -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Completion
gi'self -> a -> IO ()
gi'cb (Completion -> a
Coerce.coerce Completion
gi'self) 


-- | 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 -> ((?self :: a) => CompletionShowCallback) -> m SignalHandlerId
onCompletionShow :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onCompletionShow a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_CompletionActivateProposalCallback
wrapped' = (a -> IO ()) -> C_CompletionActivateProposalCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionActivateProposalCallback
wrap_CompletionShowCallback a -> IO ()
wrapped
    FunPtr C_CompletionActivateProposalCallback
wrapped'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionShowCallback C_CompletionActivateProposalCallback
wrapped'
    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
wrapped'' 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterCompletionShow :: (IsCompletion a, MonadIO m) => a -> ((?self :: a) => CompletionShowCallback) -> m SignalHandlerId
afterCompletionShow :: forall a (m :: * -> *).
(IsCompletion a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterCompletionShow a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_CompletionActivateProposalCallback
wrapped' = (a -> IO ()) -> C_CompletionActivateProposalCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionActivateProposalCallback
wrap_CompletionShowCallback a -> IO ()
wrapped
    FunPtr C_CompletionActivateProposalCallback
wrapped'' <- C_CompletionActivateProposalCallback
-> IO (FunPtr C_CompletionActivateProposalCallback)
mk_CompletionShowCallback C_CompletionActivateProposalCallback
wrapped'
    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
wrapped'' 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
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion::show"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:signal:show"})

#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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> m Word32
getCompletionAccelerators o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> Word32 -> m ()
setCompletionAccelerators o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *).
(IsCompletion o, MonadIO m) =>
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.accelerators"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:attr:accelerators"
        })
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> m Word32
getCompletionAutoCompleteDelay o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> Word32 -> m ()
setCompletionAutoCompleteDelay o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *).
(IsCompletion o, MonadIO m) =>
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.autoCompleteDelay"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:attr:autoCompleteDelay"
        })
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> m Word32
getCompletionProposalPageSize o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> Word32 -> m ()
setCompletionProposalPageSize o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *).
(IsCompletion o, MonadIO m) =>
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.proposalPageSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:attr:proposalPageSize"
        })
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> m Word32
getCompletionProviderPageSize o
obj = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> Word32 -> m ()
setCompletionProviderPageSize o
obj Word32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *).
(IsCompletion o, MonadIO m) =>
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.providerPageSize"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:attr:providerPageSize"
        })
#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 :: forall (m :: * -> *) o. (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionRememberInfoVisibility o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> Bool -> m ()
setCompletionRememberInfoVisibility o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *).
(IsCompletion o, MonadIO m) =>
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.rememberInfoVisibility"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:attr:rememberInfoVisibility"
        })
#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 :: forall (m :: * -> *) o. (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionSelectOnShow o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> Bool -> m ()
setCompletionSelectOnShow o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *).
(IsCompletion o, MonadIO m) =>
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.selectOnShow"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:attr:selectOnShow"
        })
#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 :: forall (m :: * -> *) o. (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionShowHeaders o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> Bool -> m ()
setCompletionShowHeaders o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *).
(IsCompletion o, MonadIO m) =>
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.showHeaders"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:attr:showHeaders"
        })
#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 :: forall (m :: * -> *) o. (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionShowIcons o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> Bool -> m ()
setCompletionShowIcons o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    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 :: forall o (m :: * -> *).
(IsCompletion o, MonadIO m) =>
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> 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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.showIcons"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:attr:showIcons"
        })
#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 :: forall (m :: * -> *) o.
(MonadIO m, IsCompletion o) =>
o -> m (Maybe View)
getCompletionView o
obj = IO (Maybe View) -> m (Maybe View)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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 :: forall o (m :: * -> *) a.
(IsCompletion o, MonadIO m, IsView a) =>
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
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe 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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.view"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#g:attr:view"
        })
#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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCompletion a,
 IsCompletionProvider b) =>
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.OverloadedMethod CompletionAddProviderMethodInfo a signature where
    overloadedMethod = completionAddProvider

instance O.OverloadedMethodInfo CompletionAddProviderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionAddProvider",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletion a) =>
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.OverloadedMethod CompletionBlockInteractiveMethodInfo a signature where
    overloadedMethod = completionBlockInteractive

instance O.OverloadedMethodInfo CompletionBlockInteractiveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionBlockInteractive",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletion a) =>
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.OverloadedMethod CompletionCreateContextMethodInfo a signature where
    overloadedMethod = completionCreateContext

instance O.OverloadedMethodInfo CompletionCreateContextMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionCreateContext",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletion a) =>
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.OverloadedMethod CompletionGetInfoWindowMethodInfo a signature where
    overloadedMethod = completionGetInfoWindow

instance O.OverloadedMethodInfo CompletionGetInfoWindowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionGetInfoWindow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletion a) =>
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.OverloadedMethod CompletionGetProvidersMethodInfo a signature where
    overloadedMethod = completionGetProviders

instance O.OverloadedMethodInfo CompletionGetProvidersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionGetProviders",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletion a) =>
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.OverloadedMethod CompletionGetViewMethodInfo a signature where
    overloadedMethod = completionGetView

instance O.OverloadedMethodInfo CompletionGetViewMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionGetView",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletion a) =>
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.OverloadedMethod CompletionHideMethodInfo a signature where
    overloadedMethod = completionHide

instance O.OverloadedMethodInfo CompletionHideMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionHide",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletion a) =>
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.OverloadedMethod CompletionMoveWindowMethodInfo a signature where
    overloadedMethod = completionMoveWindow

instance O.OverloadedMethodInfo CompletionMoveWindowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionMoveWindow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCompletion a,
 IsCompletionProvider b) =>
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.OverloadedMethod CompletionRemoveProviderMethodInfo a signature where
    overloadedMethod = completionRemoveProvider

instance O.OverloadedMethodInfo CompletionRemoveProviderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionRemoveProvider",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsCompletion a, IsCompletionProvider b,
 IsCompletionContext c) =>
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.OverloadedMethod CompletionShowMethodInfo a signature where
    overloadedMethod = completionShow

instance O.OverloadedMethodInfo CompletionShowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionShow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletion a) =>
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.OverloadedMethod CompletionUnblockInteractiveMethodInfo a signature where
    overloadedMethod = completionUnblockInteractive

instance O.OverloadedMethodInfo CompletionUnblockInteractiveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Completion.completionUnblockInteractive",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Completion.html#v:completionUnblockInteractive"
        })


#endif