{-# LANGUAGE 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.Interfaces.CompletionProvider
    ( 

-- * Exported types
    CompletionProvider(..)                  ,
    IsCompletionProvider                    ,
    toCompletionProvider                    ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [activateProposal]("GI.GtkSource.Interfaces.CompletionProvider#g:method:activateProposal"), [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"), [match]("GI.GtkSource.Interfaces.CompletionProvider#g:method:match"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [populate]("GI.GtkSource.Interfaces.CompletionProvider#g:method:populate"), [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"), [updateInfo]("GI.GtkSource.Interfaces.CompletionProvider#g:method:updateInfo"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getActivation]("GI.GtkSource.Interfaces.CompletionProvider#g:method:getActivation"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGicon]("GI.GtkSource.Interfaces.CompletionProvider#g:method:getGicon"), [getIcon]("GI.GtkSource.Interfaces.CompletionProvider#g:method:getIcon"), [getIconName]("GI.GtkSource.Interfaces.CompletionProvider#g:method:getIconName"), [getInfoWidget]("GI.GtkSource.Interfaces.CompletionProvider#g:method:getInfoWidget"), [getInteractiveDelay]("GI.GtkSource.Interfaces.CompletionProvider#g:method:getInteractiveDelay"), [getName]("GI.GtkSource.Interfaces.CompletionProvider#g:method:getName"), [getPriority]("GI.GtkSource.Interfaces.CompletionProvider#g:method:getPriority"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getStartIter]("GI.GtkSource.Interfaces.CompletionProvider#g:method:getStartIter").
-- 
-- ==== 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)
    ResolveCompletionProviderMethod         ,
#endif

-- ** activateProposal #method:activateProposal#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderActivateProposalMethodInfo,
#endif
    completionProviderActivateProposal      ,


-- ** getActivation #method:getActivation#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderGetActivationMethodInfo,
#endif
    completionProviderGetActivation         ,


-- ** getGicon #method:getGicon#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderGetGiconMethodInfo    ,
#endif
    completionProviderGetGicon              ,


-- ** getIcon #method:getIcon#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderGetIconMethodInfo     ,
#endif
    completionProviderGetIcon               ,


-- ** getIconName #method:getIconName#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderGetIconNameMethodInfo ,
#endif
    completionProviderGetIconName           ,


-- ** getInfoWidget #method:getInfoWidget#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderGetInfoWidgetMethodInfo,
#endif
    completionProviderGetInfoWidget         ,


-- ** getInteractiveDelay #method:getInteractiveDelay#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderGetInteractiveDelayMethodInfo,
#endif
    completionProviderGetInteractiveDelay   ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderGetNameMethodInfo     ,
#endif
    completionProviderGetName               ,


-- ** getPriority #method:getPriority#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderGetPriorityMethodInfo ,
#endif
    completionProviderGetPriority           ,


-- ** getStartIter #method:getStartIter#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderGetStartIterMethodInfo,
#endif
    completionProviderGetStartIter          ,


-- ** match #method:match#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderMatchMethodInfo       ,
#endif
    completionProviderMatch                 ,


-- ** populate #method:populate#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderPopulateMethodInfo    ,
#endif
    completionProviderPopulate              ,


-- ** updateInfo #method:updateInfo#

#if defined(ENABLE_OVERLOADING)
    CompletionProviderUpdateInfoMethodInfo  ,
#endif
    completionProviderUpdateInfo            ,




    ) 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.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gio.Interfaces.Icon as Gio.Icon
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
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.Objects.CompletionContext as GtkSource.CompletionContext
import {-# SOURCE #-} qualified GI.GtkSource.Objects.CompletionInfo as GtkSource.CompletionInfo

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

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

foreign import ccall "gtk_source_completion_provider_get_type"
    c_gtk_source_completion_provider_get_type :: IO B.Types.GType

instance B.Types.TypedObject CompletionProvider where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_completion_provider_get_type

instance B.Types.GObject CompletionProvider

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

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

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

-- | Convert 'CompletionProvider' 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 CompletionProvider) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_source_completion_provider_get_type
    gvalueSet_ :: Ptr GValue -> Maybe CompletionProvider -> IO ()
gvalueSet_ Ptr GValue
gv Maybe CompletionProvider
P.Nothing = Ptr GValue -> Ptr CompletionProvider -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr CompletionProvider
forall a. Ptr a
FP.nullPtr :: FP.Ptr CompletionProvider)
    gvalueSet_ Ptr GValue
gv (P.Just CompletionProvider
obj) = CompletionProvider -> (Ptr CompletionProvider -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CompletionProvider
obj (Ptr GValue -> Ptr CompletionProvider -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe CompletionProvider)
gvalueGet_ Ptr GValue
gv = do
        Ptr CompletionProvider
ptr <- Ptr GValue -> IO (Ptr CompletionProvider)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr CompletionProvider)
        if Ptr CompletionProvider
ptr Ptr CompletionProvider -> Ptr CompletionProvider -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr CompletionProvider
forall a. Ptr a
FP.nullPtr
        then CompletionProvider -> Maybe CompletionProvider
forall a. a -> Maybe a
P.Just (CompletionProvider -> Maybe CompletionProvider)
-> IO CompletionProvider -> IO (Maybe CompletionProvider)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr CompletionProvider -> CompletionProvider)
-> Ptr CompletionProvider -> IO CompletionProvider
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr CompletionProvider -> CompletionProvider
CompletionProvider Ptr CompletionProvider
ptr
        else Maybe CompletionProvider -> IO (Maybe CompletionProvider)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CompletionProvider
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList CompletionProvider
type instance O.AttributeList CompletionProvider = CompletionProviderAttributeList
type CompletionProviderAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveCompletionProviderMethod (t :: Symbol) (o :: *) :: * where
    ResolveCompletionProviderMethod "activateProposal" o = CompletionProviderActivateProposalMethodInfo
    ResolveCompletionProviderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCompletionProviderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCompletionProviderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCompletionProviderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCompletionProviderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveCompletionProviderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCompletionProviderMethod "match" o = CompletionProviderMatchMethodInfo
    ResolveCompletionProviderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCompletionProviderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCompletionProviderMethod "populate" o = CompletionProviderPopulateMethodInfo
    ResolveCompletionProviderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCompletionProviderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCompletionProviderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCompletionProviderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCompletionProviderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCompletionProviderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCompletionProviderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCompletionProviderMethod "updateInfo" o = CompletionProviderUpdateInfoMethodInfo
    ResolveCompletionProviderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCompletionProviderMethod "getActivation" o = CompletionProviderGetActivationMethodInfo
    ResolveCompletionProviderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCompletionProviderMethod "getGicon" o = CompletionProviderGetGiconMethodInfo
    ResolveCompletionProviderMethod "getIcon" o = CompletionProviderGetIconMethodInfo
    ResolveCompletionProviderMethod "getIconName" o = CompletionProviderGetIconNameMethodInfo
    ResolveCompletionProviderMethod "getInfoWidget" o = CompletionProviderGetInfoWidgetMethodInfo
    ResolveCompletionProviderMethod "getInteractiveDelay" o = CompletionProviderGetInteractiveDelayMethodInfo
    ResolveCompletionProviderMethod "getName" o = CompletionProviderGetNameMethodInfo
    ResolveCompletionProviderMethod "getPriority" o = CompletionProviderGetPriorityMethodInfo
    ResolveCompletionProviderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCompletionProviderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCompletionProviderMethod "getStartIter" o = CompletionProviderGetStartIterMethodInfo
    ResolveCompletionProviderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCompletionProviderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveCompletionProviderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCompletionProviderMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveCompletionProviderMethod t CompletionProvider, O.OverloadedMethod info CompletionProvider p) => OL.IsLabel t (CompletionProvider -> 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 ~ ResolveCompletionProviderMethod t CompletionProvider, O.OverloadedMethod info CompletionProvider p, R.HasField t CompletionProvider p) => R.HasField t CompletionProvider p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- method CompletionProvider::activate_proposal
-- method type : OrdinaryMethod
-- Args: [ 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 = "proposal"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionProposal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletionProposal."
--                 , 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: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_activate_proposal" gtk_source_completion_provider_activate_proposal :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    Ptr GtkSource.CompletionProposal.CompletionProposal -> -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO CInt

-- | Activate /@proposal@/ at /@iter@/. When this functions returns 'P.False', the default
-- activation of /@proposal@/ will take place which replaces the word at /@iter@/
-- with the text of /@proposal@/ (see 'GI.GtkSource.Interfaces.CompletionProposal.completionProposalGetText').
-- 
-- Here is how the default activation selects the boundaries of the word to
-- replace. The end of the word is /@iter@/. For the start of the word, it depends
-- on whether a start iter is defined for /@proposal@/ (see
-- 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderGetStartIter'). If a start iter is defined,
-- the start of the word is the start iter. Else, the word (as long as possible)
-- will contain only alphanumerical and the \"_\" characters.
completionProviderActivateProposal ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> b
    -- ^ /@proposal@/: a t'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' to indicate that the proposal activation has been handled,
    --          'P.False' otherwise.
completionProviderActivateProposal :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCompletionProvider a,
 IsCompletionProposal b) =>
a -> b -> TextIter -> m Bool
completionProviderActivateProposal a
provider b
proposal TextIter
iter = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr CompletionProposal
proposal' <- b -> IO (Ptr CompletionProposal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
proposal
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    CInt
result <- Ptr CompletionProvider
-> Ptr CompletionProposal -> Ptr TextIter -> IO CInt
gtk_source_completion_provider_activate_proposal Ptr CompletionProvider
provider' Ptr CompletionProposal
proposal' Ptr TextIter
iter'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
proposal
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CompletionProviderActivateProposalMethodInfo
instance (signature ~ (b -> Gtk.TextIter.TextIter -> m Bool), MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b) => O.OverloadedMethod CompletionProviderActivateProposalMethodInfo a signature where
    overloadedMethod = completionProviderActivateProposal

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


#endif

-- method CompletionProvider::get_activation
-- method type : OrdinaryMethod
-- Args: [ 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
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "CompletionActivation" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_get_activation" gtk_source_completion_provider_get_activation :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    IO CUInt

-- | Get with what kind of activation the provider should be activated.
completionProviderGetActivation ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> m [GtkSource.Flags.CompletionActivation]
    -- ^ __Returns:__ a combination of t'GI.GtkSource.Flags.CompletionActivation'.
completionProviderGetActivation :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionProvider a) =>
a -> m [CompletionActivation]
completionProviderGetActivation a
provider = 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 CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    CUInt
result <- Ptr CompletionProvider -> IO CUInt
gtk_source_completion_provider_get_activation Ptr CompletionProvider
provider'
    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
provider
    [CompletionActivation] -> IO [CompletionActivation]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [CompletionActivation]
result'

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

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


#endif

-- method CompletionProvider::get_gicon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GtkSourceCompletionProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Icon" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_get_gicon" gtk_source_completion_provider_get_gicon :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    IO (Ptr Gio.Icon.Icon)

-- | Gets the t'GI.Gio.Interfaces.Icon.Icon' for the icon of /@provider@/.
-- 
-- /Since: 3.18/
completionProviderGetGicon ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>
    a
    -- ^ /@provider@/: The t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'
    -> m (Maybe Gio.Icon.Icon)
    -- ^ __Returns:__ The icon to be used for the provider,
    --          or 'P.Nothing' if the provider does not have a special icon.
completionProviderGetGicon :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionProvider a) =>
a -> m (Maybe Icon)
completionProviderGetGicon a
provider = IO (Maybe Icon) -> m (Maybe Icon)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Icon) -> m (Maybe Icon))
-> IO (Maybe Icon) -> m (Maybe Icon)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr Icon
result <- Ptr CompletionProvider -> IO (Ptr Icon)
gtk_source_completion_provider_get_gicon Ptr CompletionProvider
provider'
    Maybe Icon
maybeResult <- Ptr Icon -> (Ptr Icon -> IO Icon) -> IO (Maybe Icon)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Icon
result ((Ptr Icon -> IO Icon) -> IO (Maybe Icon))
-> (Ptr Icon -> IO Icon) -> IO (Maybe Icon)
forall a b. (a -> b) -> a -> b
$ \Ptr Icon
result' -> do
        Icon
result'' <- ((ManagedPtr Icon -> Icon) -> Ptr Icon -> IO Icon
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Icon -> Icon
Gio.Icon.Icon) Ptr Icon
result'
        Icon -> IO Icon
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Icon
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Maybe Icon -> IO (Maybe Icon)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Icon
maybeResult

#if defined(ENABLE_OVERLOADING)
data CompletionProviderGetGiconMethodInfo
instance (signature ~ (m (Maybe Gio.Icon.Icon)), MonadIO m, IsCompletionProvider a) => O.OverloadedMethod CompletionProviderGetGiconMethodInfo a signature where
    overloadedMethod = completionProviderGetGicon

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


#endif

-- method CompletionProvider::get_icon
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GtkSourceCompletionProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GdkPixbuf" , name = "Pixbuf" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_get_icon" gtk_source_completion_provider_get_icon :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)

-- | Get the t'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf' for the icon of the /@provider@/.
completionProviderGetIcon ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>
    a
    -- ^ /@provider@/: The t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'
    -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)
    -- ^ __Returns:__ The icon to be used for the provider,
    --          or 'P.Nothing' if the provider does not have a special icon.
completionProviderGetIcon :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionProvider a) =>
a -> m (Maybe Pixbuf)
completionProviderGetIcon a
provider = IO (Maybe Pixbuf) -> m (Maybe Pixbuf)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pixbuf) -> m (Maybe Pixbuf))
-> IO (Maybe Pixbuf) -> m (Maybe Pixbuf)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr Pixbuf
result <- Ptr CompletionProvider -> IO (Ptr Pixbuf)
gtk_source_completion_provider_get_icon Ptr CompletionProvider
provider'
    Maybe Pixbuf
maybeResult <- Ptr Pixbuf -> (Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pixbuf
result ((Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf))
-> (Ptr Pixbuf -> IO Pixbuf) -> IO (Maybe Pixbuf)
forall a b. (a -> b) -> a -> b
$ \Ptr Pixbuf
result' -> do
        Pixbuf
result'' <- ((ManagedPtr Pixbuf -> Pixbuf) -> Ptr Pixbuf -> IO Pixbuf
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pixbuf -> Pixbuf
GdkPixbuf.Pixbuf.Pixbuf) Ptr Pixbuf
result'
        Pixbuf -> IO Pixbuf
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Pixbuf
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Maybe Pixbuf -> IO (Maybe Pixbuf)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pixbuf
maybeResult

#if defined(ENABLE_OVERLOADING)
data CompletionProviderGetIconMethodInfo
instance (signature ~ (m (Maybe GdkPixbuf.Pixbuf.Pixbuf)), MonadIO m, IsCompletionProvider a) => O.OverloadedMethod CompletionProviderGetIconMethodInfo a signature where
    overloadedMethod = completionProviderGetIcon

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


#endif

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

foreign import ccall "gtk_source_completion_provider_get_icon_name" gtk_source_completion_provider_get_icon_name :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    IO CString

-- | Gets the icon name of /@provider@/.
-- 
-- /Since: 3.18/
completionProviderGetIconName ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>
    a
    -- ^ /@provider@/: The t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ The icon name to be used for the provider,
    --          or 'P.Nothing' if the provider does not have a special icon.
completionProviderGetIconName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionProvider a) =>
a -> m (Maybe Text)
completionProviderGetIconName a
provider = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    CString
result <- Ptr CompletionProvider -> IO CString
gtk_source_completion_provider_get_icon_name Ptr CompletionProvider
provider'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data CompletionProviderGetIconNameMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsCompletionProvider a) => O.OverloadedMethod CompletionProviderGetIconNameMethodInfo a signature where
    overloadedMethod = completionProviderGetIconName

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


#endif

-- method CompletionProvider::get_info_widget
-- method type : OrdinaryMethod
-- Args: [ 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 = "proposal"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionProposal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a currently selected #GtkSourceCompletionProposal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gtk" , name = "Widget" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_get_info_widget" gtk_source_completion_provider_get_info_widget :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    Ptr GtkSource.CompletionProposal.CompletionProposal -> -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})
    IO (Ptr Gtk.Widget.Widget)

-- | Get a customized info widget to show extra information of a proposal.
-- This allows for customized widgets on a proposal basis, although in general
-- providers will have the same custom widget for all their proposals and
-- /@proposal@/ can be ignored. The implementation of this function is optional.
-- 
-- If this function is not implemented, the default widget is a t'GI.Gtk.Objects.Label.Label'. The
-- return value of 'GI.GtkSource.Interfaces.CompletionProposal.completionProposalGetInfo' is used as the
-- content of the t'GI.Gtk.Objects.Label.Label'.
-- 
-- \<note>
--   \<para>
--     If implemented, 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderUpdateInfo'
--     \<emphasis>must\<\/emphasis> also be implemented.
--   \<\/para>
-- \<\/note>
completionProviderGetInfoWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> b
    -- ^ /@proposal@/: a currently selected t'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'.
    -> m (Maybe Gtk.Widget.Widget)
    -- ^ __Returns:__ a custom t'GI.Gtk.Objects.Widget.Widget' to show extra
    -- information about /@proposal@/, or 'P.Nothing' if the provider does not have a special
    -- info widget.
completionProviderGetInfoWidget :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCompletionProvider a,
 IsCompletionProposal b) =>
a -> b -> m (Maybe Widget)
completionProviderGetInfoWidget a
provider b
proposal = IO (Maybe Widget) -> m (Maybe Widget)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Widget) -> m (Maybe Widget))
-> IO (Maybe Widget) -> m (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr CompletionProposal
proposal' <- b -> IO (Ptr CompletionProposal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
proposal
    Ptr Widget
result <- Ptr CompletionProvider -> Ptr CompletionProposal -> IO (Ptr Widget)
gtk_source_completion_provider_get_info_widget Ptr CompletionProvider
provider' Ptr CompletionProposal
proposal'
    Maybe Widget
maybeResult <- Ptr Widget -> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Widget
result ((Ptr Widget -> IO Widget) -> IO (Maybe Widget))
-> (Ptr Widget -> IO Widget) -> IO (Maybe Widget)
forall a b. (a -> b) -> a -> b
$ \Ptr Widget
result' -> do
        Widget
result'' <- ((ManagedPtr Widget -> Widget) -> Ptr Widget -> IO Widget
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Widget -> Widget
Gtk.Widget.Widget) Ptr Widget
result'
        Widget -> IO Widget
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Widget
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
proposal
    Maybe Widget -> IO (Maybe Widget)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Widget
maybeResult

#if defined(ENABLE_OVERLOADING)
data CompletionProviderGetInfoWidgetMethodInfo
instance (signature ~ (b -> m (Maybe Gtk.Widget.Widget)), MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b) => O.OverloadedMethod CompletionProviderGetInfoWidgetMethodInfo a signature where
    overloadedMethod = completionProviderGetInfoWidget

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


#endif

-- method CompletionProvider::get_interactive_delay
-- method type : OrdinaryMethod
-- Args: [ 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 TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_get_interactive_delay" gtk_source_completion_provider_get_interactive_delay :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    IO Int32

-- | Get the delay in milliseconds before starting interactive completion for
-- this provider. A value of -1 indicates to use the default value as set
-- by the [Completion:autoCompleteDelay]("GI.GtkSource.Objects.Completion#g:attr:autoCompleteDelay") property.
completionProviderGetInteractiveDelay ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> m Int32
    -- ^ __Returns:__ the interactive delay in milliseconds.
completionProviderGetInteractiveDelay :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionProvider a) =>
a -> m Int32
completionProviderGetInteractiveDelay a
provider = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Int32
result <- Ptr CompletionProvider -> IO Int32
gtk_source_completion_provider_get_interactive_delay Ptr CompletionProvider
provider'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data CompletionProviderGetInteractiveDelayMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsCompletionProvider a) => O.OverloadedMethod CompletionProviderGetInteractiveDelayMethodInfo a signature where
    overloadedMethod = completionProviderGetInteractiveDelay

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


#endif

-- method CompletionProvider::get_name
-- method type : OrdinaryMethod
-- Args: [ 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 TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_get_name" gtk_source_completion_provider_get_name :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    IO CString

-- | Get the name of the provider. This should be a translatable name for
-- display to the user. For example: _(\"Document word completion provider\"). The
-- returned string must be freed with 'GI.GLib.Functions.free'.
completionProviderGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> m T.Text
    -- ^ __Returns:__ a new string containing the name of the provider.
completionProviderGetName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionProvider a) =>
a -> m Text
completionProviderGetName a
provider = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    CString
result <- Ptr CompletionProvider -> IO CString
gtk_source_completion_provider_get_name Ptr CompletionProvider
provider'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"completionProviderGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data CompletionProviderGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsCompletionProvider a) => O.OverloadedMethod CompletionProviderGetNameMethodInfo a signature where
    overloadedMethod = completionProviderGetName

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


#endif

-- method CompletionProvider::get_priority
-- method type : OrdinaryMethod
-- Args: [ 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 TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_get_priority" gtk_source_completion_provider_get_priority :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    IO Int32

-- | Get the provider priority. The priority determines the order in which
-- proposals appear in the completion popup. Higher priorities are sorted
-- before lower priorities. The default priority is 0.
completionProviderGetPriority ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> m Int32
    -- ^ __Returns:__ the provider priority.
completionProviderGetPriority :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCompletionProvider a) =>
a -> m Int32
completionProviderGetPriority a
provider = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Int32
result <- Ptr CompletionProvider -> IO Int32
gtk_source_completion_provider_get_priority Ptr CompletionProvider
provider'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data CompletionProviderGetPriorityMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsCompletionProvider a) => O.OverloadedMethod CompletionProviderGetPriorityMethodInfo a signature where
    overloadedMethod = completionProviderGetPriority

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


#endif

-- method CompletionProvider::get_start_iter
-- method type : OrdinaryMethod
-- Args: [ 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 = "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 = "proposal"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionProposal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletionProposal."
--                 , 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_provider_get_start_iter" gtk_source_completion_provider_get_start_iter :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    Ptr GtkSource.CompletionContext.CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})
    Ptr GtkSource.CompletionProposal.CompletionProposal -> -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO CInt

-- | Get the t'GI.Gtk.Structs.TextIter.TextIter' at which the completion for /@proposal@/ starts. When
-- implemented, this information is used to position the completion window
-- accordingly when a proposal is selected in the completion window. The
-- /@proposal@/ text inside the completion window is aligned on /@iter@/.
-- 
-- If this function is not implemented, the word boundary is taken to position
-- the completion window. See 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderActivateProposal'
-- for an explanation on the word boundaries.
-- 
-- When the /@proposal@/ is activated, the default handler uses /@iter@/ as the start
-- of the word to replace. See
-- 'GI.GtkSource.Interfaces.CompletionProvider.completionProviderActivateProposal' for more information.
completionProviderGetStartIter ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b, GtkSource.CompletionProposal.IsCompletionProposal c) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> b
    -- ^ /@context@/: a t'GI.GtkSource.Objects.CompletionContext.CompletionContext'.
    -> c
    -- ^ /@proposal@/: a t'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'.
    -> m ((Bool, Gtk.TextIter.TextIter))
    -- ^ __Returns:__ 'P.True' if /@iter@/ was set for /@proposal@/, 'P.False' otherwise.
completionProviderGetStartIter :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsCompletionProvider a,
 IsCompletionContext b, IsCompletionProposal c) =>
a -> b -> c -> m (Bool, TextIter)
completionProviderGetStartIter a
provider b
context c
proposal = 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 CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr CompletionContext
context' <- b -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
    Ptr CompletionProposal
proposal' <- c -> IO (Ptr CompletionProposal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
proposal
    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 CompletionProvider
-> Ptr CompletionContext
-> Ptr CompletionProposal
-> Ptr TextIter
-> IO CInt
gtk_source_completion_provider_get_start_iter Ptr CompletionProvider
provider' Ptr CompletionContext
context' Ptr CompletionProposal
proposal' 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
provider
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
proposal
    (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 CompletionProviderGetStartIterMethodInfo
instance (signature ~ (b -> c -> m ((Bool, Gtk.TextIter.TextIter))), MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b, GtkSource.CompletionProposal.IsCompletionProposal c) => O.OverloadedMethod CompletionProviderGetStartIterMethodInfo a signature where
    overloadedMethod = completionProviderGetStartIter

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


#endif

-- method CompletionProvider::match
-- method type : OrdinaryMethod
-- Args: [ 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 = "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 (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_match" gtk_source_completion_provider_match :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    Ptr GtkSource.CompletionContext.CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})
    IO CInt

-- | Get whether the provider match the context of completion detailed in
-- /@context@/.
completionProviderMatch ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> b
    -- ^ /@context@/: a t'GI.GtkSource.Objects.CompletionContext.CompletionContext'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@provider@/ matches the completion context, 'P.False' otherwise.
completionProviderMatch :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCompletionProvider a,
 IsCompletionContext b) =>
a -> b -> m Bool
completionProviderMatch a
provider b
context = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr CompletionContext
context' <- b -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
    CInt
result <- Ptr CompletionProvider -> Ptr CompletionContext -> IO CInt
gtk_source_completion_provider_match Ptr CompletionProvider
provider' Ptr CompletionContext
context'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data CompletionProviderMatchMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b) => O.OverloadedMethod CompletionProviderMatchMethodInfo a signature where
    overloadedMethod = completionProviderMatch

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


#endif

-- method CompletionProvider::populate
-- method type : OrdinaryMethod
-- Args: [ 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 = "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: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_provider_populate" gtk_source_completion_provider_populate :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    Ptr GtkSource.CompletionContext.CompletionContext -> -- context : TInterface (Name {namespace = "GtkSource", name = "CompletionContext"})
    IO ()

-- | Populate /@context@/ with proposals from /@provider@/ added with the
-- 'GI.GtkSource.Objects.CompletionContext.completionContextAddProposals' function.
completionProviderPopulate ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> b
    -- ^ /@context@/: a t'GI.GtkSource.Objects.CompletionContext.CompletionContext'.
    -> m ()
completionProviderPopulate :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsCompletionProvider a,
 IsCompletionContext b) =>
a -> b -> m ()
completionProviderPopulate a
provider b
context = 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 CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr CompletionContext
context' <- b -> IO (Ptr CompletionContext)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
context
    Ptr CompletionProvider -> Ptr CompletionContext -> IO ()
gtk_source_completion_provider_populate Ptr CompletionProvider
provider' Ptr CompletionContext
context'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
context
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CompletionProviderPopulateMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCompletionProvider a, GtkSource.CompletionContext.IsCompletionContext b) => O.OverloadedMethod CompletionProviderPopulateMethodInfo a signature where
    overloadedMethod = completionProviderPopulate

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


#endif

-- method CompletionProvider::update_info
-- method type : OrdinaryMethod
-- Args: [ 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 = "proposal"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionProposal" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletionProposal."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "info"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "CompletionInfo" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceCompletionInfo."
--                 , 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_provider_update_info" gtk_source_completion_provider_update_info :: 
    Ptr CompletionProvider ->               -- provider : TInterface (Name {namespace = "GtkSource", name = "CompletionProvider"})
    Ptr GtkSource.CompletionProposal.CompletionProposal -> -- proposal : TInterface (Name {namespace = "GtkSource", name = "CompletionProposal"})
    Ptr GtkSource.CompletionInfo.CompletionInfo -> -- info : TInterface (Name {namespace = "GtkSource", name = "CompletionInfo"})
    IO ()

-- | Update extra information shown in /@info@/ for /@proposal@/.
-- 
-- \<note>
--   \<para>
--     This function \<emphasis>must\<\/emphasis> be implemented when
--     'GI.GtkSource.Interfaces.CompletionProvider.completionProviderGetInfoWidget' is implemented.
--   \<\/para>
-- \<\/note>
completionProviderUpdateInfo ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b, GtkSource.CompletionInfo.IsCompletionInfo c) =>
    a
    -- ^ /@provider@/: a t'GI.GtkSource.Interfaces.CompletionProvider.CompletionProvider'.
    -> b
    -- ^ /@proposal@/: a t'GI.GtkSource.Interfaces.CompletionProposal.CompletionProposal'.
    -> c
    -- ^ /@info@/: a t'GI.GtkSource.Objects.CompletionInfo.CompletionInfo'.
    -> m ()
completionProviderUpdateInfo :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsCompletionProvider a,
 IsCompletionProposal b, IsCompletionInfo c) =>
a -> b -> c -> m ()
completionProviderUpdateInfo a
provider b
proposal c
info = 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 CompletionProvider
provider' <- a -> IO (Ptr CompletionProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr CompletionProposal
proposal' <- b -> IO (Ptr CompletionProposal)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
proposal
    Ptr CompletionInfo
info' <- c -> IO (Ptr CompletionInfo)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
info
    Ptr CompletionProvider
-> Ptr CompletionProposal -> Ptr CompletionInfo -> IO ()
gtk_source_completion_provider_update_info Ptr CompletionProvider
provider' Ptr CompletionProposal
proposal' Ptr CompletionInfo
info'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
proposal
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
info
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data CompletionProviderUpdateInfoMethodInfo
instance (signature ~ (b -> c -> m ()), MonadIO m, IsCompletionProvider a, GtkSource.CompletionProposal.IsCompletionProposal b, GtkSource.CompletionInfo.IsCompletionInfo c) => O.OverloadedMethod CompletionProviderUpdateInfoMethodInfo a signature where
    overloadedMethod = completionProviderUpdateInfo

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


#endif

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

#endif