{- |
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.CompletionContext
    ( 

-- * Exported types
    CompletionContext(..)                   ,
    IsCompletionContext                     ,
    toCompletionContext                     ,
    noCompletionContext                     ,


 -- * Methods
-- ** addProposals #method:addProposals#
    CompletionContextAddProposalsMethodInfo ,
    completionContextAddProposals           ,


-- ** getActivation #method:getActivation#
    CompletionContextGetActivationMethodInfo,
    completionContextGetActivation          ,


-- ** getIter #method:getIter#
    CompletionContextGetIterMethodInfo      ,
    completionContextGetIter                ,




 -- * Properties
-- ** activation #attr:activation#
    CompletionContextActivationPropertyInfo ,
    completionContextActivation             ,
    constructCompletionContextActivation    ,
    getCompletionContextActivation          ,
    setCompletionContextActivation          ,


-- ** completion #attr:completion#
    CompletionContextCompletionPropertyInfo ,
    completionContextCompletion             ,
    constructCompletionContextCompletion    ,
    getCompletionContextCompletion          ,


-- ** iter #attr:iter#
    CompletionContextIterPropertyInfo       ,
    clearCompletionContextIter              ,
    completionContextIter                   ,
    constructCompletionContextIter          ,
    getCompletionContextIter                ,
    setCompletionContextIter                ,




 -- * Signals
-- ** cancelled #signal:cancelled#
    C_CompletionContextCancelledCallback    ,
    CompletionContextCancelledCallback      ,
    CompletionContextCancelledSignalInfo    ,
    afterCompletionContextCancelled         ,
    genClosure_CompletionContextCancelled   ,
    mk_CompletionContextCancelledCallback   ,
    noCompletionContextCancelledCallback    ,
    onCompletionContextCancelled            ,
    wrap_CompletionContextCancelledCallback ,




    ) 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.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.GtkSource.Flags as GtkSource.Flags
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProposal as GtkSource.CompletionProposal
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProvider as GtkSource.CompletionProvider
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Completion as GtkSource.Completion

newtype CompletionContext = CompletionContext (ManagedPtr CompletionContext)
foreign import ccall "gtk_source_completion_context_get_type"
    c_gtk_source_completion_context_get_type :: IO GType

instance GObject CompletionContext where
    gobjectType _ = c_gtk_source_completion_context_get_type
    

class GObject o => IsCompletionContext o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError CompletionContext a) =>
    IsCompletionContext a
#endif
instance IsCompletionContext CompletionContext
instance GObject.Object.IsObject CompletionContext

toCompletionContext :: IsCompletionContext o => o -> IO CompletionContext
toCompletionContext = unsafeCastTo CompletionContext

noCompletionContext :: Maybe CompletionContext
noCompletionContext = Nothing

type family ResolveCompletionContextMethod (t :: Symbol) (o :: *) :: * where
    ResolveCompletionContextMethod "addProposals" o = CompletionContextAddProposalsMethodInfo
    ResolveCompletionContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCompletionContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCompletionContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCompletionContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCompletionContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCompletionContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCompletionContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCompletionContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCompletionContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCompletionContextMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveCompletionContextMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveCompletionContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCompletionContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCompletionContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCompletionContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCompletionContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCompletionContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCompletionContextMethod "getActivation" o = CompletionContextGetActivationMethodInfo
    ResolveCompletionContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCompletionContextMethod "getIter" o = CompletionContextGetIterMethodInfo
    ResolveCompletionContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCompletionContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCompletionContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCompletionContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCompletionContextMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCompletionContextMethod t CompletionContext, O.MethodInfo info CompletionContext p) => O.IsLabelProxy t (CompletionContext -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

-- signal CompletionContext::cancelled
type CompletionContextCancelledCallback =
    IO ()

noCompletionContextCancelledCallback :: Maybe CompletionContextCancelledCallback
noCompletionContextCancelledCallback = Nothing

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

foreign import ccall "wrapper"
    mk_CompletionContextCancelledCallback :: C_CompletionContextCancelledCallback -> IO (FunPtr C_CompletionContextCancelledCallback)

genClosure_CompletionContextCancelled :: CompletionContextCancelledCallback -> IO Closure
genClosure_CompletionContextCancelled cb = do
    let cb' = wrap_CompletionContextCancelledCallback cb
    mk_CompletionContextCancelledCallback cb' >>= newCClosure


wrap_CompletionContextCancelledCallback ::
    CompletionContextCancelledCallback ->
    Ptr () ->
    Ptr () ->
    IO ()
wrap_CompletionContextCancelledCallback _cb _ _ = do
    _cb 


onCompletionContextCancelled :: (IsCompletionContext a, MonadIO m) => a -> CompletionContextCancelledCallback -> m SignalHandlerId
onCompletionContextCancelled obj cb = liftIO $ do
    let cb' = wrap_CompletionContextCancelledCallback cb
    cb'' <- mk_CompletionContextCancelledCallback cb'
    connectSignalFunPtr obj "cancelled" cb'' SignalConnectBefore

afterCompletionContextCancelled :: (IsCompletionContext a, MonadIO m) => a -> CompletionContextCancelledCallback -> m SignalHandlerId
afterCompletionContextCancelled obj cb = liftIO $ do
    let cb' = wrap_CompletionContextCancelledCallback cb
    cb'' <- mk_CompletionContextCancelledCallback cb'
    connectSignalFunPtr obj "cancelled" cb'' SignalConnectAfter


-- VVV Prop "activation"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "CompletionActivation"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Nothing)

getCompletionContextActivation :: (MonadIO m, IsCompletionContext o) => o -> m [GtkSource.Flags.CompletionActivation]
getCompletionContextActivation obj = liftIO $ getObjectPropertyFlags obj "activation"

setCompletionContextActivation :: (MonadIO m, IsCompletionContext o) => o -> [GtkSource.Flags.CompletionActivation] -> m ()
setCompletionContextActivation obj val = liftIO $ setObjectPropertyFlags obj "activation" val

constructCompletionContextActivation :: (IsCompletionContext o) => [GtkSource.Flags.CompletionActivation] -> IO (GValueConstruct o)
constructCompletionContextActivation val = constructObjectPropertyFlags "activation" val

data CompletionContextActivationPropertyInfo
instance AttrInfo CompletionContextActivationPropertyInfo where
    type AttrAllowedOps CompletionContextActivationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CompletionContextActivationPropertyInfo = (~) [GtkSource.Flags.CompletionActivation]
    type AttrBaseTypeConstraint CompletionContextActivationPropertyInfo = IsCompletionContext
    type AttrGetType CompletionContextActivationPropertyInfo = [GtkSource.Flags.CompletionActivation]
    type AttrLabel CompletionContextActivationPropertyInfo = "activation"
    type AttrOrigin CompletionContextActivationPropertyInfo = CompletionContext
    attrGet _ = getCompletionContextActivation
    attrSet _ = setCompletionContextActivation
    attrConstruct _ = constructCompletionContextActivation
    attrClear _ = undefined

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

getCompletionContextCompletion :: (MonadIO m, IsCompletionContext o) => o -> m (Maybe GtkSource.Completion.Completion)
getCompletionContextCompletion obj = liftIO $ getObjectPropertyObject obj "completion" GtkSource.Completion.Completion

constructCompletionContextCompletion :: (IsCompletionContext o, GtkSource.Completion.IsCompletion a) => a -> IO (GValueConstruct o)
constructCompletionContextCompletion val = constructObjectPropertyObject "completion" (Just val)

data CompletionContextCompletionPropertyInfo
instance AttrInfo CompletionContextCompletionPropertyInfo where
    type AttrAllowedOps CompletionContextCompletionPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionContextCompletionPropertyInfo = GtkSource.Completion.IsCompletion
    type AttrBaseTypeConstraint CompletionContextCompletionPropertyInfo = IsCompletionContext
    type AttrGetType CompletionContextCompletionPropertyInfo = (Maybe GtkSource.Completion.Completion)
    type AttrLabel CompletionContextCompletionPropertyInfo = "completion"
    type AttrOrigin CompletionContextCompletionPropertyInfo = CompletionContext
    attrGet _ = getCompletionContextCompletion
    attrSet _ = undefined
    attrConstruct _ = constructCompletionContextCompletion
    attrClear _ = undefined

-- VVV Prop "iter"
   -- Type: TInterface (Name {namespace = "Gtk", name = "TextIter"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> m (Maybe Gtk.TextIter.TextIter)
getCompletionContextIter obj = liftIO $ getObjectPropertyBoxed obj "iter" Gtk.TextIter.TextIter

setCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> Gtk.TextIter.TextIter -> m ()
setCompletionContextIter obj val = liftIO $ setObjectPropertyBoxed obj "iter" (Just val)

constructCompletionContextIter :: (IsCompletionContext o) => Gtk.TextIter.TextIter -> IO (GValueConstruct o)
constructCompletionContextIter val = constructObjectPropertyBoxed "iter" (Just val)

clearCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> m ()
clearCompletionContextIter obj = liftIO $ setObjectPropertyBoxed obj "iter" (Nothing :: Maybe Gtk.TextIter.TextIter)

data CompletionContextIterPropertyInfo
instance AttrInfo CompletionContextIterPropertyInfo where
    type AttrAllowedOps CompletionContextIterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionContextIterPropertyInfo = (~) Gtk.TextIter.TextIter
    type AttrBaseTypeConstraint CompletionContextIterPropertyInfo = IsCompletionContext
    type AttrGetType CompletionContextIterPropertyInfo = (Maybe Gtk.TextIter.TextIter)
    type AttrLabel CompletionContextIterPropertyInfo = "iter"
    type AttrOrigin CompletionContextIterPropertyInfo = CompletionContext
    attrGet _ = getCompletionContextIter
    attrSet _ = setCompletionContextIter
    attrConstruct _ = constructCompletionContextIter
    attrClear _ = clearCompletionContextIter

instance O.HasAttributeList CompletionContext
type instance O.AttributeList CompletionContext = CompletionContextAttributeList
type CompletionContextAttributeList = ('[ '("activation", CompletionContextActivationPropertyInfo), '("completion", CompletionContextCompletionPropertyInfo), '("iter", CompletionContextIterPropertyInfo)] :: [(Symbol, *)])

completionContextActivation :: AttrLabelProxy "activation"
completionContextActivation = AttrLabelProxy

completionContextCompletion :: AttrLabelProxy "completion"
completionContextCompletion = AttrLabelProxy

completionContextIter :: AttrLabelProxy "iter"
completionContextIter = AttrLabelProxy

data CompletionContextCancelledSignalInfo
instance SignalInfo CompletionContextCancelledSignalInfo where
    type HaskellCallbackType CompletionContextCancelledSignalInfo = CompletionContextCancelledCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_CompletionContextCancelledCallback cb
        cb'' <- mk_CompletionContextCancelledCallback cb'
        connectSignalFunPtr obj "cancelled" cb'' connectMode

type instance O.SignalList CompletionContext = CompletionContextSignalList
type CompletionContextSignalList = ('[ '("cancelled", CompletionContextCancelledSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method CompletionContext::add_proposals
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "context", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionContext"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionContext.", 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},Arg {argCName = "proposals", argType = TGList (TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The list of proposals to add.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "finished", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether the provider is finished adding proposals.", 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_context_add_proposals" gtk_source_completion_context_add_proposals :: 
    Ptr CompletionContext ->                -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})
    Ptr GtkSource.CompletionProvider.CompletionProvider -> -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    Ptr (GList (Ptr GtkSource.CompletionProposal.CompletionProposal)) -> -- proposals : TGList (TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"}))
    CInt ->                                 -- finished : TBasicType TBoolean
    IO ()

{- |
Providers can use this function to add proposals to the completion. They
can do so asynchronously by means of the /@finished@/ argument. Providers must
ensure that they always call this function with /@finished@/ set to 'True'
once each population (even if no proposals need to be added).
Population occurs when the 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderPopulate'
function is called.
-}
completionContextAddProposals ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionContext a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionProposal.IsCompletionProposal c) =>
    a
    {- ^ /@context@/: a 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. -}
    -> b
    {- ^ /@provider@/: a 'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'. -}
    -> [c]
    {- ^ /@proposals@/: The list of proposals to add. -}
    -> Bool
    {- ^ /@finished@/: Whether the provider is finished adding proposals. -}
    -> m ()
completionContextAddProposals context provider proposals finished = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    provider' <- unsafeManagedPtrCastPtr provider
    proposals' <- mapM unsafeManagedPtrCastPtr proposals
    proposals'' <- packGList proposals'
    let finished' = (fromIntegral . fromEnum) finished
    gtk_source_completion_context_add_proposals context' provider' proposals'' finished'
    touchManagedPtr context
    touchManagedPtr provider
    mapM_ touchManagedPtr proposals
    g_list_free proposals''
    return ()

data CompletionContextAddProposalsMethodInfo
instance (signature ~ (b -> [c] -> Bool -> m ()), MonadIO m, IsCompletionContext a, GtkSource.CompletionProvider.IsCompletionProvider b, GtkSource.CompletionProposal.IsCompletionProposal c) => O.MethodInfo CompletionContextAddProposalsMethodInfo a signature where
    overloadedMethod _ = completionContextAddProposals

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

foreign import ccall "gtk_source_completion_context_get_activation" gtk_source_completion_context_get_activation :: 
    Ptr CompletionContext ->                -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})
    IO CUInt

{- |
Get the context activation.
-}
completionContextGetActivation ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionContext a) =>
    a
    {- ^ /@context@/: a 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. -}
    -> m [GtkSource.Flags.CompletionActivation]
    {- ^ __Returns:__ The context activation. -}
completionContextGetActivation context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    result <- gtk_source_completion_context_get_activation context'
    let result' = wordToGFlags result
    touchManagedPtr context
    return result'

data CompletionContextGetActivationMethodInfo
instance (signature ~ (m [GtkSource.Flags.CompletionActivation]), MonadIO m, IsCompletionContext a) => O.MethodInfo CompletionContextGetActivationMethodInfo a signature where
    overloadedMethod _ = completionContextGetActivation

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

foreign import ccall "gtk_source_completion_context_get_iter" gtk_source_completion_context_get_iter :: 
    Ptr CompletionContext ->                -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO CInt

{- |
Get the iter at which the completion was invoked. Providers can use this
to determine how and if to match proposals.
-}
completionContextGetIter ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionContext a) =>
    a
    {- ^ /@context@/: a 'GI.GtkSource.Objects.CompletionContext.CompletionContext'. -}
    -> m (Bool,Gtk.TextIter.TextIter)
    {- ^ __Returns:__ 'True' if /@iter@/ is correctly set, 'False' otherwise. -}
completionContextGetIter context = liftIO $ do
    context' <- unsafeManagedPtrCastPtr context
    iter <- callocBoxedBytes 80 :: IO (Ptr Gtk.TextIter.TextIter)
    result <- gtk_source_completion_context_get_iter context' iter
    let result' = (/= 0) result
    iter' <- (wrapBoxed Gtk.TextIter.TextIter) iter
    touchManagedPtr context
    return (result', iter')

data CompletionContextGetIterMethodInfo
instance (signature ~ (m (Bool,Gtk.TextIter.TextIter)), MonadIO m, IsCompletionContext a) => O.MethodInfo CompletionContextGetIterMethodInfo a signature where
    overloadedMethod _ = completionContextGetIter