{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.GtkSource.Objects.Completion
    ( 

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


 -- * Methods
-- ** addProvider #method:addProvider#
    CompletionAddProviderMethodInfo         ,
    completionAddProvider                   ,


-- ** blockInteractive #method:blockInteractive#
    CompletionBlockInteractiveMethodInfo    ,
    completionBlockInteractive              ,


-- ** createContext #method:createContext#
    CompletionCreateContextMethodInfo       ,
    completionCreateContext                 ,


-- ** getInfoWindow #method:getInfoWindow#
    CompletionGetInfoWindowMethodInfo       ,
    completionGetInfoWindow                 ,


-- ** getProviders #method:getProviders#
    CompletionGetProvidersMethodInfo        ,
    completionGetProviders                  ,


-- ** getView #method:getView#
    CompletionGetViewMethodInfo             ,
    completionGetView                       ,


-- ** hide #method:hide#
    CompletionHideMethodInfo                ,
    completionHide                          ,


-- ** moveWindow #method:moveWindow#
    CompletionMoveWindowMethodInfo          ,
    completionMoveWindow                    ,


-- ** removeProvider #method:removeProvider#
    CompletionRemoveProviderMethodInfo      ,
    completionRemoveProvider                ,


-- ** show #method:show#
    CompletionShowMethodInfo                ,
    completionShow                          ,


-- ** unblockInteractive #method:unblockInteractive#
    CompletionUnblockInteractiveMethodInfo  ,
    completionUnblockInteractive            ,




 -- * Properties
-- ** accelerators #attr:accelerators#
    CompletionAcceleratorsPropertyInfo      ,
    completionAccelerators                  ,
    constructCompletionAccelerators         ,
    getCompletionAccelerators               ,
    setCompletionAccelerators               ,


-- ** autoCompleteDelay #attr:autoCompleteDelay#
    CompletionAutoCompleteDelayPropertyInfo ,
    completionAutoCompleteDelay             ,
    constructCompletionAutoCompleteDelay    ,
    getCompletionAutoCompleteDelay          ,
    setCompletionAutoCompleteDelay          ,


-- ** proposalPageSize #attr:proposalPageSize#
    CompletionProposalPageSizePropertyInfo  ,
    completionProposalPageSize              ,
    constructCompletionProposalPageSize     ,
    getCompletionProposalPageSize           ,
    setCompletionProposalPageSize           ,


-- ** providerPageSize #attr:providerPageSize#
    CompletionProviderPageSizePropertyInfo  ,
    completionProviderPageSize              ,
    constructCompletionProviderPageSize     ,
    getCompletionProviderPageSize           ,
    setCompletionProviderPageSize           ,


-- ** rememberInfoVisibility #attr:rememberInfoVisibility#
    CompletionRememberInfoVisibilityPropertyInfo,
    completionRememberInfoVisibility        ,
    constructCompletionRememberInfoVisibility,
    getCompletionRememberInfoVisibility     ,
    setCompletionRememberInfoVisibility     ,


-- ** selectOnShow #attr:selectOnShow#
    CompletionSelectOnShowPropertyInfo      ,
    completionSelectOnShow                  ,
    constructCompletionSelectOnShow         ,
    getCompletionSelectOnShow               ,
    setCompletionSelectOnShow               ,


-- ** showHeaders #attr:showHeaders#
    CompletionShowHeadersPropertyInfo       ,
    completionShowHeaders                   ,
    constructCompletionShowHeaders          ,
    getCompletionShowHeaders                ,
    setCompletionShowHeaders                ,


-- ** showIcons #attr:showIcons#
    CompletionShowIconsPropertyInfo         ,
    completionShowIcons                     ,
    constructCompletionShowIcons            ,
    getCompletionShowIcons                  ,
    setCompletionShowIcons                  ,


-- ** view #attr:view#
    CompletionViewPropertyInfo              ,
    completionView                          ,
    constructCompletionView                 ,
    getCompletionView                       ,




 -- * Signals
-- ** activateProposal #signal:activateProposal#
    C_CompletionActivateProposalCallback    ,
    CompletionActivateProposalCallback      ,
    CompletionActivateProposalSignalInfo    ,
    afterCompletionActivateProposal         ,
    genClosure_CompletionActivateProposal   ,
    mk_CompletionActivateProposalCallback   ,
    noCompletionActivateProposalCallback    ,
    onCompletionActivateProposal            ,
    wrap_CompletionActivateProposalCallback ,


-- ** hide #signal:hide#
    C_CompletionHideCallback                ,
    CompletionHideCallback                  ,
    CompletionHideSignalInfo                ,
    afterCompletionHide                     ,
    genClosure_CompletionHide               ,
    mk_CompletionHideCallback               ,
    noCompletionHideCallback                ,
    onCompletionHide                        ,
    wrap_CompletionHideCallback             ,


-- ** moveCursor #signal:moveCursor#
    C_CompletionMoveCursorCallback          ,
    CompletionMoveCursorCallback            ,
    CompletionMoveCursorSignalInfo          ,
    afterCompletionMoveCursor               ,
    genClosure_CompletionMoveCursor         ,
    mk_CompletionMoveCursorCallback         ,
    noCompletionMoveCursorCallback          ,
    onCompletionMoveCursor                  ,
    wrap_CompletionMoveCursorCallback       ,


-- ** movePage #signal:movePage#
    C_CompletionMovePageCallback            ,
    CompletionMovePageCallback              ,
    CompletionMovePageSignalInfo            ,
    afterCompletionMovePage                 ,
    genClosure_CompletionMovePage           ,
    mk_CompletionMovePageCallback           ,
    noCompletionMovePageCallback            ,
    onCompletionMovePage                    ,
    wrap_CompletionMovePageCallback         ,


-- ** populateContext #signal:populateContext#
    C_CompletionPopulateContextCallback     ,
    CompletionPopulateContextCallback       ,
    CompletionPopulateContextSignalInfo     ,
    afterCompletionPopulateContext          ,
    genClosure_CompletionPopulateContext    ,
    mk_CompletionPopulateContextCallback    ,
    noCompletionPopulateContextCallback     ,
    onCompletionPopulateContext             ,
    wrap_CompletionPopulateContextCallback  ,


-- ** show #signal:show#
    C_CompletionShowCallback                ,
    CompletionShowCallback                  ,
    CompletionShowSignalInfo                ,
    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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 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

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
    

class GObject o => IsCompletion o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Completion a) =>
    IsCompletion a
#endif
instance IsCompletion Completion
instance GObject.Object.IsObject Completion
instance Gtk.Buildable.IsBuildable Completion

toCompletion :: IsCompletion o => o -> IO Completion
toCompletion = unsafeCastTo Completion

noCompletion :: Maybe Completion
noCompletion = Nothing

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 "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 "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveCompletionMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    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) => O.IsLabelProxy t (Completion -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

-- signal Completion::activate-proposal
type CompletionActivateProposalCallback =
    IO ()

noCompletionActivateProposalCallback :: Maybe CompletionActivateProposalCallback
noCompletionActivateProposalCallback = Nothing

type C_CompletionActivateProposalCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_CompletionActivateProposalCallback :: C_CompletionActivateProposalCallback -> IO (FunPtr C_CompletionActivateProposalCallback)

genClosure_CompletionActivateProposal :: CompletionActivateProposalCallback -> IO Closure
genClosure_CompletionActivateProposal cb = do
    let cb' = wrap_CompletionActivateProposalCallback cb
    mk_CompletionActivateProposalCallback cb' >>= newCClosure


wrap_CompletionActivateProposalCallback ::
    CompletionActivateProposalCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_CompletionActivateProposalCallback _cb _ _ = do
    _cb 


onCompletionActivateProposal :: (GObject a, MonadIO m) => a -> CompletionActivateProposalCallback -> m SignalHandlerId
onCompletionActivateProposal obj cb = liftIO $ connectCompletionActivateProposal obj cb SignalConnectBefore
afterCompletionActivateProposal :: (GObject a, MonadIO m) => a -> CompletionActivateProposalCallback -> m SignalHandlerId
afterCompletionActivateProposal obj cb = connectCompletionActivateProposal obj cb SignalConnectAfter

connectCompletionActivateProposal :: (GObject a, MonadIO m) =>
                                     a -> CompletionActivateProposalCallback -> SignalConnectMode -> m SignalHandlerId
connectCompletionActivateProposal obj cb after = liftIO $ do
    let cb' = wrap_CompletionActivateProposalCallback cb
    cb'' <- mk_CompletionActivateProposalCallback cb'
    connectSignalFunPtr obj "activate-proposal" cb'' after

-- signal Completion::hide
type CompletionHideCallback =
    IO ()

noCompletionHideCallback :: Maybe CompletionHideCallback
noCompletionHideCallback = Nothing

type C_CompletionHideCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_CompletionHideCallback :: C_CompletionHideCallback -> IO (FunPtr C_CompletionHideCallback)

genClosure_CompletionHide :: CompletionHideCallback -> IO Closure
genClosure_CompletionHide cb = do
    let cb' = wrap_CompletionHideCallback cb
    mk_CompletionHideCallback cb' >>= newCClosure


wrap_CompletionHideCallback ::
    CompletionHideCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_CompletionHideCallback _cb _ _ = do
    _cb 


onCompletionHide :: (GObject a, MonadIO m) => a -> CompletionHideCallback -> m SignalHandlerId
onCompletionHide obj cb = liftIO $ connectCompletionHide obj cb SignalConnectBefore
afterCompletionHide :: (GObject a, MonadIO m) => a -> CompletionHideCallback -> m SignalHandlerId
afterCompletionHide obj cb = connectCompletionHide obj cb SignalConnectAfter

connectCompletionHide :: (GObject a, MonadIO m) =>
                         a -> CompletionHideCallback -> SignalConnectMode -> m SignalHandlerId
connectCompletionHide obj cb after = liftIO $ do
    let cb' = wrap_CompletionHideCallback cb
    cb'' <- mk_CompletionHideCallback cb'
    connectSignalFunPtr obj "hide" cb'' after

-- signal Completion::move-cursor
type CompletionMoveCursorCallback =
    Gtk.Enums.ScrollStep ->
    Int32 ->
    IO ()

noCompletionMoveCursorCallback :: Maybe CompletionMoveCursorCallback
noCompletionMoveCursorCallback = Nothing

type C_CompletionMoveCursorCallback =
    Ptr () ->                               -- object
    CUInt ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_CompletionMoveCursorCallback :: C_CompletionMoveCursorCallback -> IO (FunPtr C_CompletionMoveCursorCallback)

genClosure_CompletionMoveCursor :: CompletionMoveCursorCallback -> IO Closure
genClosure_CompletionMoveCursor cb = do
    let cb' = wrap_CompletionMoveCursorCallback cb
    mk_CompletionMoveCursorCallback cb' >>= newCClosure


wrap_CompletionMoveCursorCallback ::
    CompletionMoveCursorCallback ->
    Ptr () ->
    CUInt ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_CompletionMoveCursorCallback _cb _ step num _ = do
    let step' = (toEnum . fromIntegral) step
    _cb  step' num


onCompletionMoveCursor :: (GObject a, MonadIO m) => a -> CompletionMoveCursorCallback -> m SignalHandlerId
onCompletionMoveCursor obj cb = liftIO $ connectCompletionMoveCursor obj cb SignalConnectBefore
afterCompletionMoveCursor :: (GObject a, MonadIO m) => a -> CompletionMoveCursorCallback -> m SignalHandlerId
afterCompletionMoveCursor obj cb = connectCompletionMoveCursor obj cb SignalConnectAfter

connectCompletionMoveCursor :: (GObject a, MonadIO m) =>
                               a -> CompletionMoveCursorCallback -> SignalConnectMode -> m SignalHandlerId
connectCompletionMoveCursor obj cb after = liftIO $ do
    let cb' = wrap_CompletionMoveCursorCallback cb
    cb'' <- mk_CompletionMoveCursorCallback cb'
    connectSignalFunPtr obj "move-cursor" cb'' after

-- signal Completion::move-page
type CompletionMovePageCallback =
    Gtk.Enums.ScrollStep ->
    Int32 ->
    IO ()

noCompletionMovePageCallback :: Maybe CompletionMovePageCallback
noCompletionMovePageCallback = Nothing

type C_CompletionMovePageCallback =
    Ptr () ->                               -- object
    CUInt ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_CompletionMovePageCallback :: C_CompletionMovePageCallback -> IO (FunPtr C_CompletionMovePageCallback)

genClosure_CompletionMovePage :: CompletionMovePageCallback -> IO Closure
genClosure_CompletionMovePage cb = do
    let cb' = wrap_CompletionMovePageCallback cb
    mk_CompletionMovePageCallback cb' >>= newCClosure


wrap_CompletionMovePageCallback ::
    CompletionMovePageCallback ->
    Ptr () ->
    CUInt ->
    Int32 ->
    Ptr () ->
    IO ()
wrap_CompletionMovePageCallback _cb _ step num _ = do
    let step' = (toEnum . fromIntegral) step
    _cb  step' num


onCompletionMovePage :: (GObject a, MonadIO m) => a -> CompletionMovePageCallback -> m SignalHandlerId
onCompletionMovePage obj cb = liftIO $ connectCompletionMovePage obj cb SignalConnectBefore
afterCompletionMovePage :: (GObject a, MonadIO m) => a -> CompletionMovePageCallback -> m SignalHandlerId
afterCompletionMovePage obj cb = connectCompletionMovePage obj cb SignalConnectAfter

connectCompletionMovePage :: (GObject a, MonadIO m) =>
                             a -> CompletionMovePageCallback -> SignalConnectMode -> m SignalHandlerId
connectCompletionMovePage obj cb after = liftIO $ do
    let cb' = wrap_CompletionMovePageCallback cb
    cb'' <- mk_CompletionMovePageCallback cb'
    connectSignalFunPtr obj "move-page" cb'' after

-- signal Completion::populate-context
type CompletionPopulateContextCallback =
    GtkSource.CompletionContext.CompletionContext ->
    IO ()

noCompletionPopulateContextCallback :: Maybe CompletionPopulateContextCallback
noCompletionPopulateContextCallback = Nothing

type C_CompletionPopulateContextCallback =
    Ptr () ->                               -- object
    Ptr GtkSource.CompletionContext.CompletionContext ->
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_CompletionPopulateContextCallback :: C_CompletionPopulateContextCallback -> IO (FunPtr C_CompletionPopulateContextCallback)

genClosure_CompletionPopulateContext :: CompletionPopulateContextCallback -> IO Closure
genClosure_CompletionPopulateContext cb = do
    let cb' = wrap_CompletionPopulateContextCallback cb
    mk_CompletionPopulateContextCallback cb' >>= newCClosure


wrap_CompletionPopulateContextCallback ::
    CompletionPopulateContextCallback ->
    Ptr () ->
    Ptr GtkSource.CompletionContext.CompletionContext ->
    Ptr () ->
    IO ()
wrap_CompletionPopulateContextCallback _cb _ context _ = do
    context' <- (newObject GtkSource.CompletionContext.CompletionContext) context
    _cb  context'


onCompletionPopulateContext :: (GObject a, MonadIO m) => a -> CompletionPopulateContextCallback -> m SignalHandlerId
onCompletionPopulateContext obj cb = liftIO $ connectCompletionPopulateContext obj cb SignalConnectBefore
afterCompletionPopulateContext :: (GObject a, MonadIO m) => a -> CompletionPopulateContextCallback -> m SignalHandlerId
afterCompletionPopulateContext obj cb = connectCompletionPopulateContext obj cb SignalConnectAfter

connectCompletionPopulateContext :: (GObject a, MonadIO m) =>
                                    a -> CompletionPopulateContextCallback -> SignalConnectMode -> m SignalHandlerId
connectCompletionPopulateContext obj cb after = liftIO $ do
    let cb' = wrap_CompletionPopulateContextCallback cb
    cb'' <- mk_CompletionPopulateContextCallback cb'
    connectSignalFunPtr obj "populate-context" cb'' after

-- signal Completion::show
type CompletionShowCallback =
    IO ()

noCompletionShowCallback :: Maybe CompletionShowCallback
noCompletionShowCallback = Nothing

type C_CompletionShowCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

foreign import ccall "wrapper"
    mk_CompletionShowCallback :: C_CompletionShowCallback -> IO (FunPtr C_CompletionShowCallback)

genClosure_CompletionShow :: CompletionShowCallback -> IO Closure
genClosure_CompletionShow cb = do
    let cb' = wrap_CompletionShowCallback cb
    mk_CompletionShowCallback cb' >>= newCClosure


wrap_CompletionShowCallback ::
    CompletionShowCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_CompletionShowCallback _cb _ _ = do
    _cb 


onCompletionShow :: (GObject a, MonadIO m) => a -> CompletionShowCallback -> m SignalHandlerId
onCompletionShow obj cb = liftIO $ connectCompletionShow obj cb SignalConnectBefore
afterCompletionShow :: (GObject a, MonadIO m) => a -> CompletionShowCallback -> m SignalHandlerId
afterCompletionShow obj cb = connectCompletionShow obj cb SignalConnectAfter

connectCompletionShow :: (GObject a, MonadIO m) =>
                         a -> CompletionShowCallback -> SignalConnectMode -> m SignalHandlerId
connectCompletionShow obj cb after = liftIO $ do
    let cb' = wrap_CompletionShowCallback cb
    cb'' <- mk_CompletionShowCallback cb'
    connectSignalFunPtr obj "show" cb'' after

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

getCompletionAccelerators :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionAccelerators obj = liftIO $ getObjectPropertyUInt32 obj "accelerators"

setCompletionAccelerators :: (MonadIO m, IsCompletion o) => o -> Word32 -> m ()
setCompletionAccelerators obj val = liftIO $ setObjectPropertyUInt32 obj "accelerators" val

constructCompletionAccelerators :: (IsCompletion o) => Word32 -> IO (GValueConstruct o)
constructCompletionAccelerators val = constructObjectPropertyUInt32 "accelerators" val

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

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

getCompletionAutoCompleteDelay :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionAutoCompleteDelay obj = liftIO $ getObjectPropertyUInt32 obj "auto-complete-delay"

setCompletionAutoCompleteDelay :: (MonadIO m, IsCompletion o) => o -> Word32 -> m ()
setCompletionAutoCompleteDelay obj val = liftIO $ setObjectPropertyUInt32 obj "auto-complete-delay" val

constructCompletionAutoCompleteDelay :: (IsCompletion o) => Word32 -> IO (GValueConstruct o)
constructCompletionAutoCompleteDelay val = constructObjectPropertyUInt32 "auto-complete-delay" val

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

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

getCompletionProposalPageSize :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionProposalPageSize obj = liftIO $ getObjectPropertyUInt32 obj "proposal-page-size"

setCompletionProposalPageSize :: (MonadIO m, IsCompletion o) => o -> Word32 -> m ()
setCompletionProposalPageSize obj val = liftIO $ setObjectPropertyUInt32 obj "proposal-page-size" val

constructCompletionProposalPageSize :: (IsCompletion o) => Word32 -> IO (GValueConstruct o)
constructCompletionProposalPageSize val = constructObjectPropertyUInt32 "proposal-page-size" val

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

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

getCompletionProviderPageSize :: (MonadIO m, IsCompletion o) => o -> m Word32
getCompletionProviderPageSize obj = liftIO $ getObjectPropertyUInt32 obj "provider-page-size"

setCompletionProviderPageSize :: (MonadIO m, IsCompletion o) => o -> Word32 -> m ()
setCompletionProviderPageSize obj val = liftIO $ setObjectPropertyUInt32 obj "provider-page-size" val

constructCompletionProviderPageSize :: (IsCompletion o) => Word32 -> IO (GValueConstruct o)
constructCompletionProviderPageSize val = constructObjectPropertyUInt32 "provider-page-size" val

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

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

getCompletionRememberInfoVisibility :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionRememberInfoVisibility obj = liftIO $ getObjectPropertyBool obj "remember-info-visibility"

setCompletionRememberInfoVisibility :: (MonadIO m, IsCompletion o) => o -> Bool -> m ()
setCompletionRememberInfoVisibility obj val = liftIO $ setObjectPropertyBool obj "remember-info-visibility" val

constructCompletionRememberInfoVisibility :: (IsCompletion o) => Bool -> IO (GValueConstruct o)
constructCompletionRememberInfoVisibility val = constructObjectPropertyBool "remember-info-visibility" val

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

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

getCompletionSelectOnShow :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionSelectOnShow obj = liftIO $ getObjectPropertyBool obj "select-on-show"

setCompletionSelectOnShow :: (MonadIO m, IsCompletion o) => o -> Bool -> m ()
setCompletionSelectOnShow obj val = liftIO $ setObjectPropertyBool obj "select-on-show" val

constructCompletionSelectOnShow :: (IsCompletion o) => Bool -> IO (GValueConstruct o)
constructCompletionSelectOnShow val = constructObjectPropertyBool "select-on-show" val

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

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

getCompletionShowHeaders :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionShowHeaders obj = liftIO $ getObjectPropertyBool obj "show-headers"

setCompletionShowHeaders :: (MonadIO m, IsCompletion o) => o -> Bool -> m ()
setCompletionShowHeaders obj val = liftIO $ setObjectPropertyBool obj "show-headers" val

constructCompletionShowHeaders :: (IsCompletion o) => Bool -> IO (GValueConstruct o)
constructCompletionShowHeaders val = constructObjectPropertyBool "show-headers" val

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

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

getCompletionShowIcons :: (MonadIO m, IsCompletion o) => o -> m Bool
getCompletionShowIcons obj = liftIO $ getObjectPropertyBool obj "show-icons"

setCompletionShowIcons :: (MonadIO m, IsCompletion o) => o -> Bool -> m ()
setCompletionShowIcons obj val = liftIO $ setObjectPropertyBool obj "show-icons" val

constructCompletionShowIcons :: (IsCompletion o) => Bool -> IO (GValueConstruct o)
constructCompletionShowIcons val = constructObjectPropertyBool "show-icons" val

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

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

getCompletionView :: (MonadIO m, IsCompletion o) => o -> m (Maybe GtkSource.View.View)
getCompletionView obj = liftIO $ getObjectPropertyObject obj "view" GtkSource.View.View

constructCompletionView :: (IsCompletion o, GtkSource.View.IsView a) => a -> IO (GValueConstruct o)
constructCompletionView val = constructObjectPropertyObject "view" (Just val)

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

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, *)])

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

data CompletionActivateProposalSignalInfo
instance SignalInfo CompletionActivateProposalSignalInfo where
    type HaskellCallbackType CompletionActivateProposalSignalInfo = CompletionActivateProposalCallback
    connectSignal _ = connectCompletionActivateProposal

data CompletionHideSignalInfo
instance SignalInfo CompletionHideSignalInfo where
    type HaskellCallbackType CompletionHideSignalInfo = CompletionHideCallback
    connectSignal _ = connectCompletionHide

data CompletionMoveCursorSignalInfo
instance SignalInfo CompletionMoveCursorSignalInfo where
    type HaskellCallbackType CompletionMoveCursorSignalInfo = CompletionMoveCursorCallback
    connectSignal _ = connectCompletionMoveCursor

data CompletionMovePageSignalInfo
instance SignalInfo CompletionMovePageSignalInfo where
    type HaskellCallbackType CompletionMovePageSignalInfo = CompletionMovePageCallback
    connectSignal _ = connectCompletionMovePage

data CompletionPopulateContextSignalInfo
instance SignalInfo CompletionPopulateContextSignalInfo where
    type HaskellCallbackType CompletionPopulateContextSignalInfo = CompletionPopulateContextCallback
    connectSignal _ = connectCompletionPopulateContext

data CompletionShowSignalInfo
instance SignalInfo CompletionShowSignalInfo where
    type HaskellCallbackType CompletionShowSignalInfo = CompletionShowCallback
    connectSignal _ = connectCompletionShow

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, *)])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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