gi-gtksource-3.0.18: GI/GtkSource/Objects/Completion.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

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

module GI.GtkSource.Objects.Completion
    ( 

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


 -- * Methods
-- ** addProvider #method:addProvider#

#if ENABLE_OVERLOADING
    CompletionAddProviderMethodInfo         ,
#endif
    completionAddProvider                   ,


-- ** blockInteractive #method:blockInteractive#

#if ENABLE_OVERLOADING
    CompletionBlockInteractiveMethodInfo    ,
#endif
    completionBlockInteractive              ,


-- ** createContext #method:createContext#

#if ENABLE_OVERLOADING
    CompletionCreateContextMethodInfo       ,
#endif
    completionCreateContext                 ,


-- ** getInfoWindow #method:getInfoWindow#

#if ENABLE_OVERLOADING
    CompletionGetInfoWindowMethodInfo       ,
#endif
    completionGetInfoWindow                 ,


-- ** getProviders #method:getProviders#

#if ENABLE_OVERLOADING
    CompletionGetProvidersMethodInfo        ,
#endif
    completionGetProviders                  ,


-- ** getView #method:getView#

#if ENABLE_OVERLOADING
    CompletionGetViewMethodInfo             ,
#endif
    completionGetView                       ,


-- ** hide #method:hide#

#if ENABLE_OVERLOADING
    CompletionHideMethodInfo                ,
#endif
    completionHide                          ,


-- ** moveWindow #method:moveWindow#

#if ENABLE_OVERLOADING
    CompletionMoveWindowMethodInfo          ,
#endif
    completionMoveWindow                    ,


-- ** removeProvider #method:removeProvider#

#if ENABLE_OVERLOADING
    CompletionRemoveProviderMethodInfo      ,
#endif
    completionRemoveProvider                ,


-- ** show #method:show#

#if ENABLE_OVERLOADING
    CompletionShowMethodInfo                ,
#endif
    completionShow                          ,


-- ** unblockInteractive #method:unblockInteractive#

#if 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 ENABLE_OVERLOADING
    CompletionAcceleratorsPropertyInfo      ,
#endif
#if 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 ENABLE_OVERLOADING
    CompletionAutoCompleteDelayPropertyInfo ,
#endif
#if 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 'GI.GtkSource.Objects.Completion.Completion'::@/move-cursor/@ signal.
-}
#if ENABLE_OVERLOADING
    CompletionProposalPageSizePropertyInfo  ,
#endif
#if ENABLE_OVERLOADING
    completionProposalPageSize              ,
#endif
    constructCompletionProposalPageSize     ,
    getCompletionProposalPageSize           ,
    setCompletionProposalPageSize           ,


-- ** providerPageSize #attr:providerPageSize#
{- | The scroll page size of the provider pages in the completion window.

See the 'GI.GtkSource.Objects.Completion.Completion'::@/move-page/@ signal.
-}
#if ENABLE_OVERLOADING
    CompletionProviderPageSizePropertyInfo  ,
#endif
#if 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 ENABLE_OVERLOADING
    CompletionRememberInfoVisibilityPropertyInfo,
#endif
#if 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 ENABLE_OVERLOADING
    CompletionSelectOnShowPropertyInfo      ,
#endif
#if 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 ENABLE_OVERLOADING
    CompletionShowHeadersPropertyInfo       ,
#endif
#if ENABLE_OVERLOADING
    completionShowHeaders                   ,
#endif
    constructCompletionShowHeaders          ,
    getCompletionShowHeaders                ,
    setCompletionShowHeaders                ,


-- ** showIcons #attr:showIcons#
{- | Determines whether provider and proposal icons should be shown in
the completion popup.
-}
#if ENABLE_OVERLOADING
    CompletionShowIconsPropertyInfo         ,
#endif
#if ENABLE_OVERLOADING
    completionShowIcons                     ,
#endif
    constructCompletionShowIcons            ,
    getCompletionShowIcons                  ,
    setCompletionShowIcons                  ,


-- ** view #attr:view#
{- | The 'GI.GtkSource.Objects.View.View' bound to the completion object.
-}
#if ENABLE_OVERLOADING
    CompletionViewPropertyInfo              ,
#endif
#if ENABLE_OVERLOADING
    completionView                          ,
#endif
    constructCompletionView                 ,
    getCompletionView                       ,




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

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


-- ** hide #signal:hide#

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


-- ** moveCursor #signal:moveCursor#

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


-- ** movePage #signal:movePage#

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


-- ** populateContext #signal:populateContext#

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


-- ** show #signal:show#

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




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProvider as GtkSource.CompletionProvider
import {-# SOURCE #-} qualified GI.GtkSource.Objects.CompletionContext as GtkSource.CompletionContext
import {-# SOURCE #-} qualified GI.GtkSource.Objects.CompletionInfo as GtkSource.CompletionInfo
import {-# SOURCE #-} qualified GI.GtkSource.Objects.View as GtkSource.View

-- | Memory-managed wrapper type.
newtype Completion = Completion (ManagedPtr Completion)
foreign import ccall "gtk_source_completion_get_type"
    c_gtk_source_completion_get_type :: IO GType

instance GObject Completion where
    gobjectType = c_gtk_source_completion_get_type
    

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

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

-- | Cast to `Completion`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toCompletion :: (MonadIO m, IsCompletion o) => o -> m Completion
toCompletion = liftIO . unsafeCastTo Completion

-- | A convenience alias for `Nothing` :: `Maybe` `Completion`.
noCompletion :: Maybe Completion
noCompletion = Nothing

#if 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 "setName" o = Gtk.Buildable.BuildableSetNameMethodInfo
    ResolveCompletionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCompletionMethod l o = O.MethodResolutionFailed l o

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

#endif

-- signal Completion::activate-proposal
{- |
The 'GI.GtkSource.Objects.Completion.Completion'::@/activate-proposal/@ signal is a
keybinding signal which gets emitted when the user initiates
a proposal activation.

Applications should not connect to it, but may emit it with
@/g_signal_emit_by_name()/@ if they need to control the proposal
activation programmatically.
-}
type CompletionActivateProposalCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionActivateProposalCallback`@.
noCompletionActivateProposalCallback :: Maybe CompletionActivateProposalCallback
noCompletionActivateProposalCallback = Nothing

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

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

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


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


{- |
Connect a signal handler for the “@activate-proposal@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' completion #activateProposal callback
@
-}
onCompletionActivateProposal :: (IsCompletion a, MonadIO m) => a -> CompletionActivateProposalCallback -> m SignalHandlerId
onCompletionActivateProposal obj cb = liftIO $ do
    let cb' = wrap_CompletionActivateProposalCallback cb
    cb'' <- mk_CompletionActivateProposalCallback cb'
    connectSignalFunPtr obj "activate-proposal" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@activate-proposal@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' completion #activateProposal callback
@
-}
afterCompletionActivateProposal :: (IsCompletion a, MonadIO m) => a -> CompletionActivateProposalCallback -> m SignalHandlerId
afterCompletionActivateProposal obj cb = liftIO $ do
    let cb' = wrap_CompletionActivateProposalCallback cb
    cb'' <- mk_CompletionActivateProposalCallback cb'
    connectSignalFunPtr obj "activate-proposal" cb'' SignalConnectAfter


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

-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionHideCallback`@.
noCompletionHideCallback :: Maybe CompletionHideCallback
noCompletionHideCallback = Nothing

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

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

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


-- | Wrap a `CompletionHideCallback` into a `C_CompletionHideCallback`.
wrap_CompletionHideCallback ::
    CompletionHideCallback ->
    C_CompletionHideCallback
wrap_CompletionHideCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@hide@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' completion #hide callback
@
-}
onCompletionHide :: (IsCompletion a, MonadIO m) => a -> CompletionHideCallback -> m SignalHandlerId
onCompletionHide obj cb = liftIO $ do
    let cb' = wrap_CompletionHideCallback cb
    cb'' <- mk_CompletionHideCallback cb'
    connectSignalFunPtr obj "hide" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@hide@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' completion #hide callback
@
-}
afterCompletionHide :: (IsCompletion a, MonadIO m) => a -> CompletionHideCallback -> m SignalHandlerId
afterCompletionHide obj cb = liftIO $ do
    let cb' = wrap_CompletionHideCallback cb
    cb'' <- mk_CompletionHideCallback cb'
    connectSignalFunPtr obj "hide" cb'' SignalConnectAfter


-- signal Completion::move-cursor
{- |
The 'GI.GtkSource.Objects.Completion.Completion'::@/move-cursor/@ 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 '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 'GI.Gtk.Enums.ScrollStep' by which to move the cursor -}
    -> Int32
    {- ^ /@num@/: The amount of steps to move the cursor -}
    -> IO ()

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

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

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

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


-- | Wrap a `CompletionMoveCursorCallback` into a `C_CompletionMoveCursorCallback`.
wrap_CompletionMoveCursorCallback ::
    CompletionMoveCursorCallback ->
    C_CompletionMoveCursorCallback
wrap_CompletionMoveCursorCallback _cb _ step num _ = do
    let step' = (toEnum . fromIntegral) step
    _cb  step' num


{- |
Connect a signal handler for the “@move-cursor@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' completion #moveCursor callback
@
-}
onCompletionMoveCursor :: (IsCompletion a, MonadIO m) => a -> CompletionMoveCursorCallback -> m SignalHandlerId
onCompletionMoveCursor obj cb = liftIO $ do
    let cb' = wrap_CompletionMoveCursorCallback cb
    cb'' <- mk_CompletionMoveCursorCallback cb'
    connectSignalFunPtr obj "move-cursor" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@move-cursor@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' completion #moveCursor callback
@
-}
afterCompletionMoveCursor :: (IsCompletion a, MonadIO m) => a -> CompletionMoveCursorCallback -> m SignalHandlerId
afterCompletionMoveCursor obj cb = liftIO $ do
    let cb' = wrap_CompletionMoveCursorCallback cb
    cb'' <- mk_CompletionMoveCursorCallback cb'
    connectSignalFunPtr obj "move-cursor" cb'' SignalConnectAfter


-- signal Completion::move-page
{- |
The 'GI.GtkSource.Objects.Completion.Completion'::@/move-page/@ 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 '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 'GI.Gtk.Enums.ScrollStep' by which to move the page -}
    -> Int32
    {- ^ /@num@/: The amount of steps to move the page -}
    -> IO ()

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

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

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

-- | Wrap the callback into a `GClosure`.
genClosure_CompletionMovePage :: MonadIO m => CompletionMovePageCallback -> m (GClosure C_CompletionMovePageCallback)
genClosure_CompletionMovePage cb = liftIO $ do
    let cb' = wrap_CompletionMovePageCallback cb
    mk_CompletionMovePageCallback cb' >>= B.GClosure.newGClosure


-- | Wrap a `CompletionMovePageCallback` into a `C_CompletionMovePageCallback`.
wrap_CompletionMovePageCallback ::
    CompletionMovePageCallback ->
    C_CompletionMovePageCallback
wrap_CompletionMovePageCallback _cb _ step num _ = do
    let step' = (toEnum . fromIntegral) step
    _cb  step' num


{- |
Connect a signal handler for the “@move-page@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' completion #movePage callback
@
-}
onCompletionMovePage :: (IsCompletion a, MonadIO m) => a -> CompletionMovePageCallback -> m SignalHandlerId
onCompletionMovePage obj cb = liftIO $ do
    let cb' = wrap_CompletionMovePageCallback cb
    cb'' <- mk_CompletionMovePageCallback cb'
    connectSignalFunPtr obj "move-page" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@move-page@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' completion #movePage callback
@
-}
afterCompletionMovePage :: (IsCompletion a, MonadIO m) => a -> CompletionMovePageCallback -> m SignalHandlerId
afterCompletionMovePage obj cb = liftIO $ do
    let cb' = wrap_CompletionMovePageCallback cb
    cb'' <- mk_CompletionMovePageCallback cb'
    connectSignalFunPtr obj "move-page" cb'' SignalConnectAfter


-- 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 'GI.GtkSource.Objects.CompletionContext.CompletionContext' for the current completion -}
    -> IO ()

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

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

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

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


-- | Wrap a `CompletionPopulateContextCallback` into a `C_CompletionPopulateContextCallback`.
wrap_CompletionPopulateContextCallback ::
    CompletionPopulateContextCallback ->
    C_CompletionPopulateContextCallback
wrap_CompletionPopulateContextCallback _cb _ context _ = do
    context' <- (newObject GtkSource.CompletionContext.CompletionContext) context
    _cb  context'


{- |
Connect a signal handler for the “@populate-context@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' completion #populateContext callback
@
-}
onCompletionPopulateContext :: (IsCompletion a, MonadIO m) => a -> CompletionPopulateContextCallback -> m SignalHandlerId
onCompletionPopulateContext obj cb = liftIO $ do
    let cb' = wrap_CompletionPopulateContextCallback cb
    cb'' <- mk_CompletionPopulateContextCallback cb'
    connectSignalFunPtr obj "populate-context" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@populate-context@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' completion #populateContext callback
@
-}
afterCompletionPopulateContext :: (IsCompletion a, MonadIO m) => a -> CompletionPopulateContextCallback -> m SignalHandlerId
afterCompletionPopulateContext obj cb = liftIO $ do
    let cb' = wrap_CompletionPopulateContextCallback cb
    cb'' <- mk_CompletionPopulateContextCallback cb'
    connectSignalFunPtr obj "populate-context" cb'' SignalConnectAfter


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

-- | A convenience synonym for @`Nothing` :: `Maybe` `CompletionShowCallback`@.
noCompletionShowCallback :: Maybe CompletionShowCallback
noCompletionShowCallback = Nothing

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

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

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


-- | Wrap a `CompletionShowCallback` into a `C_CompletionShowCallback`.
wrap_CompletionShowCallback ::
    CompletionShowCallback ->
    C_CompletionShowCallback
wrap_CompletionShowCallback _cb _ _ = do
    _cb 


{- |
Connect a signal handler for the “@show@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' completion #show callback
@
-}
onCompletionShow :: (IsCompletion a, MonadIO m) => a -> CompletionShowCallback -> m SignalHandlerId
onCompletionShow obj cb = liftIO $ do
    let cb' = wrap_CompletionShowCallback cb
    cb'' <- mk_CompletionShowCallback cb'
    connectSignalFunPtr obj "show" cb'' SignalConnectBefore

{- |
Connect a signal handler for the “@show@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' completion #show callback
@
-}
afterCompletionShow :: (IsCompletion a, MonadIO m) => a -> CompletionShowCallback -> m SignalHandlerId
afterCompletionShow obj cb = liftIO $ do
    let cb' = wrap_CompletionShowCallback cb
    cb'' <- mk_CompletionShowCallback cb'
    connectSignalFunPtr obj "show" cb'' SignalConnectAfter


-- 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 obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "accelerators" 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) => Word32 -> IO (GValueConstruct o)
constructCompletionAccelerators val = B.Properties.constructObjectPropertyUInt32 "accelerators" val

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

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

{- |
Get the value of the “@auto-complete-delay@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completion #autoCompleteDelay
@
-}
getCompletionAutoCompleteDelay :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionAutoCompleteDelay obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "auto-complete-delay" 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) => Word32 -> IO (GValueConstruct o)
constructCompletionAutoCompleteDelay val = B.Properties.constructObjectPropertyUInt32 "auto-complete-delay" val

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

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

{- |
Get the value of the “@proposal-page-size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completion #proposalPageSize
@
-}
getCompletionProposalPageSize :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionProposalPageSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "proposal-page-size" 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) => Word32 -> IO (GValueConstruct o)
constructCompletionProposalPageSize val = B.Properties.constructObjectPropertyUInt32 "proposal-page-size" val

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

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

{- |
Get the value of the “@provider-page-size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completion #providerPageSize
@
-}
getCompletionProviderPageSize :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionProviderPageSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "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 obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "provider-page-size" 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) => Word32 -> IO (GValueConstruct o)
constructCompletionProviderPageSize val = B.Properties.constructObjectPropertyUInt32 "provider-page-size" val

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

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

{- |
Get the value of the “@remember-info-visibility@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completion #rememberInfoVisibility
@
-}
getCompletionRememberInfoVisibility :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionRememberInfoVisibility obj = liftIO $ B.Properties.getObjectPropertyBool obj "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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "remember-info-visibility" 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) => Bool -> IO (GValueConstruct o)
constructCompletionRememberInfoVisibility val = B.Properties.constructObjectPropertyBool "remember-info-visibility" val

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

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

{- |
Get the value of the “@select-on-show@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completion #selectOnShow
@
-}
getCompletionSelectOnShow :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionSelectOnShow obj = liftIO $ B.Properties.getObjectPropertyBool obj "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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "select-on-show" 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) => Bool -> IO (GValueConstruct o)
constructCompletionSelectOnShow val = B.Properties.constructObjectPropertyBool "select-on-show" val

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

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

{- |
Get the value of the “@show-headers@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completion #showHeaders
@
-}
getCompletionShowHeaders :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionShowHeaders obj = liftIO $ B.Properties.getObjectPropertyBool obj "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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-headers" 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) => Bool -> IO (GValueConstruct o)
constructCompletionShowHeaders val = B.Properties.constructObjectPropertyBool "show-headers" val

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

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

{- |
Get the value of the “@show-icons@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completion #showIcons
@
-}
getCompletionShowIcons :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionShowIcons obj = liftIO $ B.Properties.getObjectPropertyBool obj "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 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "show-icons" 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) => Bool -> IO (GValueConstruct o)
constructCompletionShowIcons val = B.Properties.constructObjectPropertyBool "show-icons" val

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

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

{- |
Get the value of the “@view@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completion #view
@
-}
getCompletionView :: (MonadIO m, IsCompletion o) => o -> m (Maybe GtkSource.View.View)
getCompletionView obj = liftIO $ B.Properties.getObjectPropertyObject obj "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, GtkSource.View.IsView a) => a -> IO (GValueConstruct o)
constructCompletionView val = B.Properties.constructObjectPropertyObject "view" (Just val)

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

#if 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 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 ENABLE_OVERLOADING
data CompletionActivateProposalSignalInfo
instance SignalInfo CompletionActivateProposalSignalInfo where
    type HaskellCallbackType CompletionActivateProposalSignalInfo = CompletionActivateProposalCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_CompletionActivateProposalCallback cb
        cb'' <- mk_CompletionActivateProposalCallback cb'
        connectSignalFunPtr obj "activate-proposal" cb'' connectMode

data CompletionHideSignalInfo
instance SignalInfo CompletionHideSignalInfo where
    type HaskellCallbackType CompletionHideSignalInfo = CompletionHideCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_CompletionHideCallback cb
        cb'' <- mk_CompletionHideCallback cb'
        connectSignalFunPtr obj "hide" cb'' connectMode

data CompletionMoveCursorSignalInfo
instance SignalInfo CompletionMoveCursorSignalInfo where
    type HaskellCallbackType CompletionMoveCursorSignalInfo = CompletionMoveCursorCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_CompletionMoveCursorCallback cb
        cb'' <- mk_CompletionMoveCursorCallback cb'
        connectSignalFunPtr obj "move-cursor" cb'' connectMode

data CompletionMovePageSignalInfo
instance SignalInfo CompletionMovePageSignalInfo where
    type HaskellCallbackType CompletionMovePageSignalInfo = CompletionMovePageCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_CompletionMovePageCallback cb
        cb'' <- mk_CompletionMovePageCallback cb'
        connectSignalFunPtr obj "move-page" cb'' connectMode

data CompletionPopulateContextSignalInfo
instance SignalInfo CompletionPopulateContextSignalInfo where
    type HaskellCallbackType CompletionPopulateContextSignalInfo = CompletionPopulateContextCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_CompletionPopulateContextCallback cb
        cb'' <- mk_CompletionPopulateContextCallback cb'
        connectSignalFunPtr obj "populate-context" cb'' connectMode

data CompletionShowSignalInfo
instance SignalInfo CompletionShowSignalInfo where
    type HaskellCallbackType CompletionShowSignalInfo = CompletionShowCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_CompletionShowCallback cb
        cb'' <- mk_CompletionShowCallback cb'
        connectSignalFunPtr obj "show" cb'' connectMode

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 '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 'GI.GtkSource.Objects.Completion.Completion'. -}
    -> b
    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
completionAddProvider completion provider = liftIO $ do
    completion' <- unsafeManagedPtrCastPtr completion
    provider' <- unsafeManagedPtrCastPtr provider
    onException (do
        _ <- propagateGError $ gtk_source_completion_add_provider completion' provider'
        touchManagedPtr completion
        touchManagedPtr provider
        return ()
     ) (do
        return ()
     )

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

#endif

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

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

{- |
Block interactive completion. This can be used to disable interactive
completion when inserting or deleting text from the buffer associated with
the completion. Use 'GI.GtkSource.Objects.Completion.completionUnblockInteractive' to enable
interactive completion again.

This function may be called multiple times. It will continue to block
interactive completion until 'GI.GtkSource.Objects.Completion.completionUnblockInteractive'
has been called the same number of times.
-}
completionBlockInteractive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -}
    -> m ()
completionBlockInteractive completion = liftIO $ do
    completion' <- unsafeManagedPtrCastPtr completion
    gtk_source_completion_block_interactive completion'
    touchManagedPtr completion
    return ()

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

#endif

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

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

{- |
Create a new 'GI.GtkSource.Objects.CompletionContext.CompletionContext' for /@completion@/. The position where
the completion occurs can be specified by /@position@/. If /@position@/ is 'Nothing',
the current cursor position will be used.
-}
completionCreateContext ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -}
    -> Maybe (Gtk.TextIter.TextIter)
    {- ^ /@position@/: a 'GI.Gtk.Structs.TextIter.TextIter', or 'Nothing'. -}
    -> m GtkSource.CompletionContext.CompletionContext
    {- ^ __Returns:__ a new '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 completion position = liftIO $ do
    completion' <- unsafeManagedPtrCastPtr completion
    maybePosition <- case position of
        Nothing -> return nullPtr
        Just jPosition -> do
            jPosition' <- unsafeManagedPtrGetPtr jPosition
            return jPosition'
    result <- gtk_source_completion_create_context completion' maybePosition
    checkUnexpectedReturnNULL "completionCreateContext" result
    result' <- (newObject GtkSource.CompletionContext.CompletionContext) result
    touchManagedPtr completion
    whenJust position touchManagedPtr
    return result'

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

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

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

#endif

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

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

{- |
Hides the completion if it is active (visible).
-}
completionHide ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -}
    -> m ()
completionHide completion = liftIO $ do
    completion' <- unsafeManagedPtrCastPtr completion
    gtk_source_completion_hide completion'
    touchManagedPtr completion
    return ()

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

#endif

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

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

{-# DEPRECATED completionMoveWindow ["(Since version 3.8)","Use 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderGetStartIter' instead."] #-}
{- |
Move the completion window to a specific iter.
-}
completionMoveWindow ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -}
    -> Gtk.TextIter.TextIter
    {- ^ /@iter@/: a 'GI.Gtk.Structs.TextIter.TextIter'. -}
    -> m ()
completionMoveWindow completion iter = liftIO $ do
    completion' <- unsafeManagedPtrCastPtr completion
    iter' <- unsafeManagedPtrGetPtr iter
    gtk_source_completion_move_window completion' iter'
    touchManagedPtr completion
    touchManagedPtr iter
    return ()

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

#endif

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

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

{- |
Remove /@provider@/ from the completion.
-}
completionRemoveProvider ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a, GtkSource.CompletionProvider.IsCompletionProvider b) =>
    a
    {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -}
    -> b
    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
completionRemoveProvider completion provider = liftIO $ do
    completion' <- unsafeManagedPtrCastPtr completion
    provider' <- unsafeManagedPtrCastPtr provider
    onException (do
        _ <- propagateGError $ gtk_source_completion_remove_provider completion' provider'
        touchManagedPtr completion
        touchManagedPtr provider
        return ()
     ) (do
        return ()
     )

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

#endif

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

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

{- |
Starts a new completion with the specified '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 '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 'GI.GtkSource.Objects.Completion.Completion'. -}
    -> [b]
    {- ^ /@providers@/: 
a list of 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider', or 'Nothing'. -}
    -> c
    {- ^ /@context@/: The 'GI.GtkSource.Objects.CompletionContext.CompletionContext'
with which to start the completion. -}
    -> m Bool
    {- ^ __Returns:__ 'True' if it was possible to the show completion window. -}
completionShow completion providers context = liftIO $ do
    completion' <- unsafeManagedPtrCastPtr completion
    providers' <- mapM unsafeManagedPtrCastPtr providers
    providers'' <- packGList providers'
    context' <- unsafeManagedPtrCastPtr context
    result <- gtk_source_completion_show completion' providers'' context'
    let result' = (/= 0) result
    touchManagedPtr completion
    mapM_ touchManagedPtr providers
    touchManagedPtr context
    g_list_free providers''
    return result'

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

#endif

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

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

{- |
Unblock interactive completion. This can be used after using
'GI.GtkSource.Objects.Completion.completionBlockInteractive' to enable interactive completion
again.
-}
completionUnblockInteractive ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletion a) =>
    a
    {- ^ /@completion@/: a 'GI.GtkSource.Objects.Completion.Completion'. -}
    -> m ()
completionUnblockInteractive completion = liftIO $ do
    completion' <- unsafeManagedPtrCastPtr completion
    gtk_source_completion_unblock_interactive completion'
    touchManagedPtr completion
    return ()

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

#endif