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


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

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

module GI.GtkSource.Objects.CompletionContext
    ( 

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


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addProposals]("GI.GtkSource.Objects.CompletionContext#g:method:addProposals"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getActivation]("GI.GtkSource.Objects.CompletionContext#g:method:getActivation"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getIter]("GI.GtkSource.Objects.CompletionContext#g:method:getIter"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveCompletionContextMethod          ,
#endif

-- ** addProposals #method:addProposals#

#if defined(ENABLE_OVERLOADING)
    CompletionContextAddProposalsMethodInfo ,
#endif
    completionContextAddProposals           ,


-- ** getActivation #method:getActivation#

#if defined(ENABLE_OVERLOADING)
    CompletionContextGetActivationMethodInfo,
#endif
    completionContextGetActivation          ,


-- ** getIter #method:getIter#

#if defined(ENABLE_OVERLOADING)
    CompletionContextGetIterMethodInfo      ,
#endif
    completionContextGetIter                ,




 -- * Properties


-- ** activation #attr:activation#
-- | The completion activation

#if defined(ENABLE_OVERLOADING)
    CompletionContextActivationPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionContextActivation             ,
#endif
    constructCompletionContextActivation    ,
    getCompletionContextActivation          ,
    setCompletionContextActivation          ,


-- ** completion #attr:completion#
-- | The t'GI.GtkSource.Objects.Completion.Completion' associated with the context.

#if defined(ENABLE_OVERLOADING)
    CompletionContextCompletionPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
    completionContextCompletion             ,
#endif
    constructCompletionContextCompletion    ,
    getCompletionContextCompletion          ,


-- ** iter #attr:iter#
-- | The t'GI.Gtk.Structs.TextIter.TextIter' at which the completion is invoked.

#if defined(ENABLE_OVERLOADING)
    CompletionContextIterPropertyInfo       ,
#endif
    clearCompletionContextIter              ,
#if defined(ENABLE_OVERLOADING)
    completionContextIter                   ,
#endif
    constructCompletionContextIter          ,
    getCompletionContextIter                ,
    setCompletionContextIter                ,




 -- * Signals


-- ** cancelled #signal:cancelled#

    CompletionContextCancelledCallback      ,
#if defined(ENABLE_OVERLOADING)
    CompletionContextCancelledSignalInfo    ,
#endif
    afterCompletionContextCancelled         ,
    onCompletionContextCancelled            ,




    ) where

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

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

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

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

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

foreign import ccall "gtk_source_completion_context_get_type"
    c_gtk_source_completion_context_get_type :: IO B.Types.GType

instance B.Types.TypedObject CompletionContext where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_completion_context_get_type

instance B.Types.GObject CompletionContext

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

instance O.HasParentTypes CompletionContext
type instance O.ParentTypes CompletionContext = '[GObject.Object.Object]

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

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

#if defined(ENABLE_OVERLOADING)
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveCompletionContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCompletionContextMethod l o = O.MethodResolutionFailed l o

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

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

#endif

instance (info ~ ResolveCompletionContextMethod t CompletionContext, O.OverloadedMethodInfo info CompletionContext) => OL.IsLabel t (O.MethodProxy info CompletionContext) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal CompletionContext::cancelled
-- | Emitted when the current population of proposals has been cancelled.
-- Providers adding proposals asynchronously should connect to this signal
-- to know when to cancel running proposal queries.
type CompletionContextCancelledCallback =
    IO ()

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

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

wrap_CompletionContextCancelledCallback :: 
    GObject a => (a -> CompletionContextCancelledCallback) ->
    C_CompletionContextCancelledCallback
wrap_CompletionContextCancelledCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_CompletionContextCancelledCallback
wrap_CompletionContextCancelledCallback a -> IO ()
gi'cb Ptr CompletionContext
gi'selfPtr Ptr ()
_ = do
    Ptr CompletionContext -> (CompletionContext -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr CompletionContext
gi'selfPtr ((CompletionContext -> IO ()) -> IO ())
-> (CompletionContext -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \CompletionContext
gi'self -> a -> IO ()
gi'cb (CompletionContext -> a
forall a b. Coercible a b => a -> b
Coerce.coerce CompletionContext
gi'self) 


-- | Connect a signal handler for the [cancelled](#signal:cancelled) 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' completionContext #cancelled callback
-- @
-- 
-- 
onCompletionContextCancelled :: (IsCompletionContext a, MonadIO m) => a -> ((?self :: a) => CompletionContextCancelledCallback) -> m SignalHandlerId
onCompletionContextCancelled :: forall a (m :: * -> *).
(IsCompletionContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onCompletionContextCancelled a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_CompletionContextCancelledCallback
wrapped' = (a -> IO ()) -> C_CompletionContextCancelledCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionContextCancelledCallback
wrap_CompletionContextCancelledCallback a -> IO ()
wrapped
    FunPtr C_CompletionContextCancelledCallback
wrapped'' <- C_CompletionContextCancelledCallback
-> IO (FunPtr C_CompletionContextCancelledCallback)
mk_CompletionContextCancelledCallback C_CompletionContextCancelledCallback
wrapped'
    a
-> Text
-> FunPtr C_CompletionContextCancelledCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancelled" FunPtr C_CompletionContextCancelledCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [cancelled](#signal:cancelled) 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' completionContext #cancelled callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterCompletionContextCancelled :: (IsCompletionContext a, MonadIO m) => a -> ((?self :: a) => CompletionContextCancelledCallback) -> m SignalHandlerId
afterCompletionContextCancelled :: forall a (m :: * -> *).
(IsCompletionContext a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterCompletionContextCancelled a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_CompletionContextCancelledCallback
wrapped' = (a -> IO ()) -> C_CompletionContextCancelledCallback
forall a.
GObject a =>
(a -> IO ()) -> C_CompletionContextCancelledCallback
wrap_CompletionContextCancelledCallback a -> IO ()
wrapped
    FunPtr C_CompletionContextCancelledCallback
wrapped'' <- C_CompletionContextCancelledCallback
-> IO (FunPtr C_CompletionContextCancelledCallback)
mk_CompletionContextCancelledCallback C_CompletionContextCancelledCallback
wrapped'
    a
-> Text
-> FunPtr C_CompletionContextCancelledCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"cancelled" FunPtr C_CompletionContextCancelledCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data CompletionContextCancelledSignalInfo
instance SignalInfo CompletionContextCancelledSignalInfo where
    type HaskellCallbackType CompletionContextCancelledSignalInfo = CompletionContextCancelledCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_CompletionContextCancelledCallback cb
        cb'' <- mk_CompletionContextCancelledCallback cb'
        connectSignalFunPtr obj "cancelled" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext::cancelled"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-CompletionContext.html#g:signal:cancelled"})

#endif

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

-- | Get the value of the “@activation@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' completionContext #activation
-- @
getCompletionContextActivation :: (MonadIO m, IsCompletionContext o) => o -> m [GtkSource.Flags.CompletionActivation]
getCompletionContextActivation :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> m [CompletionActivation]
getCompletionContextActivation o
obj = IO [CompletionActivation] -> m [CompletionActivation]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [CompletionActivation] -> m [CompletionActivation])
-> IO [CompletionActivation] -> m [CompletionActivation]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [CompletionActivation]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"activation"

-- | Set the value of the “@activation@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completionContext [ #activation 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionContextActivation :: (MonadIO m, IsCompletionContext o) => o -> [GtkSource.Flags.CompletionActivation] -> m ()
setCompletionContextActivation :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> [CompletionActivation] -> m ()
setCompletionContextActivation o
obj [CompletionActivation]
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> [CompletionActivation] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"activation" [CompletionActivation]
val

-- | Construct a `GValueConstruct` with valid value for the “@activation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionContextActivation :: (IsCompletionContext o, MIO.MonadIO m) => [GtkSource.Flags.CompletionActivation] -> m (GValueConstruct o)
constructCompletionContextActivation :: forall o (m :: * -> *).
(IsCompletionContext o, MonadIO m) =>
[CompletionActivation] -> m (GValueConstruct o)
constructCompletionContextActivation [CompletionActivation]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> [CompletionActivation] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"activation" [CompletionActivation]
val

#if defined(ENABLE_OVERLOADING)
data CompletionContextActivationPropertyInfo
instance AttrInfo CompletionContextActivationPropertyInfo where
    type AttrAllowedOps CompletionContextActivationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint CompletionContextActivationPropertyInfo = IsCompletionContext
    type AttrSetTypeConstraint CompletionContextActivationPropertyInfo = (~) [GtkSource.Flags.CompletionActivation]
    type AttrTransferTypeConstraint CompletionContextActivationPropertyInfo = (~) [GtkSource.Flags.CompletionActivation]
    type AttrTransferType CompletionContextActivationPropertyInfo = [GtkSource.Flags.CompletionActivation]
    type AttrGetType CompletionContextActivationPropertyInfo = [GtkSource.Flags.CompletionActivation]
    type AttrLabel CompletionContextActivationPropertyInfo = "activation"
    type AttrOrigin CompletionContextActivationPropertyInfo = CompletionContext
    attrGet = getCompletionContextActivation
    attrSet = setCompletionContextActivation
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionContextActivation
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext.activation"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-CompletionContext.html#g:attr:activation"
        })
#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data CompletionContextCompletionPropertyInfo
instance AttrInfo CompletionContextCompletionPropertyInfo where
    type AttrAllowedOps CompletionContextCompletionPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint CompletionContextCompletionPropertyInfo = IsCompletionContext
    type AttrSetTypeConstraint CompletionContextCompletionPropertyInfo = GtkSource.Completion.IsCompletion
    type AttrTransferTypeConstraint CompletionContextCompletionPropertyInfo = GtkSource.Completion.IsCompletion
    type AttrTransferType CompletionContextCompletionPropertyInfo = GtkSource.Completion.Completion
    type AttrGetType CompletionContextCompletionPropertyInfo = (Maybe GtkSource.Completion.Completion)
    type AttrLabel CompletionContextCompletionPropertyInfo = "completion"
    type AttrOrigin CompletionContextCompletionPropertyInfo = CompletionContext
    attrGet = getCompletionContextCompletion
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo GtkSource.Completion.Completion v
    attrConstruct = constructCompletionContextCompletion
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext.completion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-CompletionContext.html#g:attr:completion"
        })
#endif

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

-- | Get the value of the “@iter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' completionContext #iter
-- @
getCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> m (Maybe Gtk.TextIter.TextIter)
getCompletionContextIter :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> m (Maybe TextIter)
getCompletionContextIter o
obj = IO (Maybe TextIter) -> m (Maybe TextIter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe TextIter) -> m (Maybe TextIter))
-> IO (Maybe TextIter) -> m (Maybe TextIter)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr TextIter -> TextIter)
-> IO (Maybe TextIter)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"iter" ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter

-- | Set the value of the “@iter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' completionContext [ #iter 'Data.GI.Base.Attributes.:=' value ]
-- @
setCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> Gtk.TextIter.TextIter -> m ()
setCompletionContextIter :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> TextIter -> m ()
setCompletionContextIter o
obj TextIter
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe TextIter -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"iter" (TextIter -> Maybe TextIter
forall a. a -> Maybe a
Just TextIter
val)

-- | Construct a `GValueConstruct` with valid value for the “@iter@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructCompletionContextIter :: (IsCompletionContext o, MIO.MonadIO m) => Gtk.TextIter.TextIter -> m (GValueConstruct o)
constructCompletionContextIter :: forall o (m :: * -> *).
(IsCompletionContext o, MonadIO m) =>
TextIter -> m (GValueConstruct o)
constructCompletionContextIter TextIter
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe TextIter -> IO (GValueConstruct o)
forall a o. GBoxed a => String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBoxed String
"iter" (TextIter -> Maybe TextIter
forall a. a -> Maybe a
P.Just TextIter
val)

-- | Set the value of the “@iter@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #iter
-- @
clearCompletionContextIter :: (MonadIO m, IsCompletionContext o) => o -> m ()
clearCompletionContextIter :: forall (m :: * -> *) o.
(MonadIO m, IsCompletionContext o) =>
o -> m ()
clearCompletionContextIter o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe TextIter -> IO ()
forall a b.
(GObject a, GBoxed b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyBoxed o
obj String
"iter" (Maybe TextIter
forall a. Maybe a
Nothing :: Maybe Gtk.TextIter.TextIter)

#if defined(ENABLE_OVERLOADING)
data CompletionContextIterPropertyInfo
instance AttrInfo CompletionContextIterPropertyInfo where
    type AttrAllowedOps CompletionContextIterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint CompletionContextIterPropertyInfo = IsCompletionContext
    type AttrSetTypeConstraint CompletionContextIterPropertyInfo = (~) Gtk.TextIter.TextIter
    type AttrTransferTypeConstraint CompletionContextIterPropertyInfo = (~) Gtk.TextIter.TextIter
    type AttrTransferType CompletionContextIterPropertyInfo = Gtk.TextIter.TextIter
    type AttrGetType CompletionContextIterPropertyInfo = (Maybe Gtk.TextIter.TextIter)
    type AttrLabel CompletionContextIterPropertyInfo = "iter"
    type AttrOrigin CompletionContextIterPropertyInfo = CompletionContext
    attrGet = getCompletionContextIter
    attrSet = setCompletionContextIter
    attrTransfer _ v = do
        return v
    attrConstruct = constructCompletionContextIter
    attrClear = clearCompletionContextIter
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.CompletionContext.iter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.26/docs/GI-GtkSource-Objects-CompletionContext.html#g:attr:iter"
        })
#endif

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

#if defined(ENABLE_OVERLOADING)
completionContextActivation :: AttrLabelProxy "activation"
completionContextActivation = AttrLabelProxy

completionContextCompletion :: AttrLabelProxy "completion"
completionContextCompletion = AttrLabelProxy

completionContextIter :: AttrLabelProxy "iter"
completionContextIter = AttrLabelProxy

#endif

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

#endif

-- 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 'P.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 t'GI.GtkSource.Objects.CompletionContext.CompletionContext'.
    -> b
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> [c]
    -- ^ /@proposals@/: The list of proposals to add.
    -> Bool
    -- ^ /@finished@/: Whether the provider is finished adding proposals.
    -> m ()
completionContextAddProposals :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsCompletionContext a,
 IsCompletionProvider b, IsCompletionProposal c) =>
a -> b -> [c] -> Bool -> m ()
completionContextAddProposals a
context b
provider [c]
proposals Bool
finished = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionContext
context' <- a -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr CompletionProvider
provider' <- b -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
provider
    [Ptr CompletionProposal]
proposals' <- (c -> IO (Ptr CompletionProposal))
-> [c] -> IO [Ptr CompletionProposal]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM c -> IO (Ptr CompletionProposal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr [c]
proposals
    Ptr (GList (Ptr CompletionProposal))
proposals'' <- [Ptr CompletionProposal]
-> IO (Ptr (GList (Ptr CompletionProposal)))
forall a. [Ptr a] -> IO (Ptr (GList (Ptr a)))
packGList [Ptr CompletionProposal]
proposals'
    let finished' :: CInt
finished' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
finished
    Ptr CompletionContext
-> Ptr CompletionProvider
-> Ptr (GList (Ptr CompletionProposal))
-> CInt
-> IO ()
gtk_source_completion_context_add_proposals Ptr CompletionContext
context' Ptr CompletionProvider
provider' Ptr (GList (Ptr CompletionProposal))
proposals'' CInt
finished'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
provider
    (c -> IO ()) -> [c] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [c]
proposals
    Ptr (GList (Ptr CompletionProposal)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr CompletionProposal))
proposals''
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- 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 t'GI.GtkSource.Objects.CompletionContext.CompletionContext'.
    -> m [GtkSource.Flags.CompletionActivation]
    -- ^ __Returns:__ The context activation.
completionContextGetActivation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionContext a) =>
a -> m [CompletionActivation]
completionContextGetActivation a
context = IO [CompletionActivation] -> m [CompletionActivation]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [CompletionActivation] -> m [CompletionActivation])
-> IO [CompletionActivation] -> m [CompletionActivation]
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionContext
context' <- a -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    CUInt
result <- Ptr CompletionContext -> IO CUInt
gtk_source_completion_context_get_activation Ptr CompletionContext
context'
    let result' :: [CompletionActivation]
result' = CUInt -> [CompletionActivation]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    [CompletionActivation] -> IO [CompletionActivation]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [CompletionActivation]
result'

#if defined(ENABLE_OVERLOADING)
data CompletionContextGetActivationMethodInfo
instance (signature ~ (m [GtkSource.Flags.CompletionActivation]), MonadIO m, IsCompletionContext a) => O.OverloadedMethod CompletionContextGetActivationMethodInfo a signature where
    overloadedMethod = completionContextGetActivation

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


#endif

-- 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 t'GI.GtkSource.Objects.CompletionContext.CompletionContext'.
    -> m ((Bool, Gtk.TextIter.TextIter))
    -- ^ __Returns:__ 'P.True' if /@iter@/ is correctly set, 'P.False' otherwise.
completionContextGetIter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionContext a) =>
a -> m (Bool, TextIter)
completionContextGetIter a
context = IO (Bool, TextIter) -> m (Bool, TextIter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, TextIter) -> m (Bool, TextIter))
-> IO (Bool, TextIter) -> m (Bool, TextIter)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionContext
context' <- a -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
context
    Ptr TextIter
iter <- Int -> IO (Ptr TextIter)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
80 :: IO (Ptr Gtk.TextIter.TextIter)
    CInt
result <- Ptr CompletionContext -> Ptr TextIter -> IO CInt
gtk_source_completion_context_get_iter Ptr CompletionContext
context' Ptr TextIter
iter
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    TextIter
iter' <- ((ManagedPtr TextIter -> TextIter) -> Ptr TextIter -> IO TextIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter) Ptr TextIter
iter
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
context
    (Bool, TextIter) -> IO (Bool, TextIter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', TextIter
iter')

#if defined(ENABLE_OVERLOADING)
data CompletionContextGetIterMethodInfo
instance (signature ~ (m ((Bool, Gtk.TextIter.TextIter))), MonadIO m, IsCompletionContext a) => O.OverloadedMethod CompletionContextGetIterMethodInfo a signature where
    overloadedMethod = completionContextGetIter

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


#endif