{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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(..)                  ,
    noCompletionProvider                    ,
    IsCompletionProvider                    ,
    toCompletionProvider                    ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.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 (ManagedPtr CompletionProvider)
    deriving (CompletionProvider -> CompletionProvider -> Bool
(CompletionProvider -> CompletionProvider -> Bool)
-> (CompletionProvider -> CompletionProvider -> Bool)
-> Eq CompletionProvider
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompletionProvider -> CompletionProvider -> Bool
$c/= :: CompletionProvider -> CompletionProvider -> Bool
== :: CompletionProvider -> CompletionProvider -> Bool
$c== :: CompletionProvider -> CompletionProvider -> Bool
Eq)
-- | A convenience alias for `Nothing` :: `Maybe` `CompletionProvider`.
noCompletionProvider :: Maybe CompletionProvider
noCompletionProvider :: Maybe CompletionProvider
noCompletionProvider = Maybe CompletionProvider
forall a. Maybe a
Nothing

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

#endif

foreign import ccall "gtk_source_completion_provider_get_type"
    c_gtk_source_completion_provider_get_type :: IO GType

instance GObject CompletionProvider where
    gobjectType :: IO GType
gobjectType = IO GType
c_gtk_source_completion_provider_get_type
    

-- | Convert 'CompletionProvider' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue CompletionProvider where
    toGValue :: CompletionProvider -> IO GValue
toGValue o :: CompletionProvider
o = do
        GType
gtype <- IO GType
c_gtk_source_completion_provider_get_type
        CompletionProvider
-> (Ptr CompletionProvider -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr CompletionProvider
o (GType
-> (GValue -> Ptr CompletionProvider -> IO ())
-> Ptr CompletionProvider
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr CompletionProvider -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO CompletionProvider
fromGValue gv :: GValue
gv = do
        Ptr CompletionProvider
ptr <- GValue -> IO (Ptr CompletionProvider)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr CompletionProvider)
        (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
        
    

-- | Type class for types which can be safely cast to `CompletionProvider`, for instance with `toCompletionProvider`.
class (GObject o, O.IsDescendantOf CompletionProvider o) => IsCompletionProvider o
instance (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 :: (MonadIO m, IsCompletionProvider o) => o -> m CompletionProvider
toCompletionProvider :: o -> m CompletionProvider
toCompletionProvider = IO CompletionProvider -> m CompletionProvider
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr CompletionProvider -> CompletionProvider
CompletionProvider

#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.MethodInfo 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

#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 :: a -> b -> TextIter -> m Bool
completionProviderActivateProposal provider :: a
provider proposal :: b
proposal iter :: TextIter
iter = IO Bool -> m Bool
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
/= 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 (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.MethodInfo CompletionProviderActivateProposalMethodInfo a signature where
    overloadedMethod = 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 :: a -> m [CompletionActivation]
completionProviderGetActivation provider :: a
provider = IO [CompletionActivation] -> m [CompletionActivation]
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 (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.MethodInfo CompletionProviderGetActivationMethodInfo a signature where
    overloadedMethod = 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 :: a -> m (Maybe Icon)
completionProviderGetGicon provider :: a
provider = IO (Maybe Icon) -> m (Maybe Icon)
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
$ \result' :: 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 (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 (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.MethodInfo CompletionProviderGetGiconMethodInfo a signature where
    overloadedMethod = 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 :: a -> m (Maybe Pixbuf)
completionProviderGetIcon provider :: a
provider = IO (Maybe Pixbuf) -> m (Maybe Pixbuf)
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
$ \result' :: 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 (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 (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.MethodInfo CompletionProviderGetIconMethodInfo a signature where
    overloadedMethod = 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 :: a -> m (Maybe Text)
completionProviderGetIconName provider :: a
provider = IO (Maybe Text) -> m (Maybe Text)
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
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
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 (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.MethodInfo CompletionProviderGetIconNameMethodInfo a signature where
    overloadedMethod = 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 :: a -> b -> m (Maybe Widget)
completionProviderGetInfoWidget provider :: a
provider proposal :: b
proposal = IO (Maybe Widget) -> m (Maybe Widget)
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
$ \result' :: 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 (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 (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.MethodInfo CompletionProviderGetInfoWidgetMethodInfo a signature where
    overloadedMethod = 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 t'GI.GtkSource.Objects.Completion.Completion':@/auto-complete-delay/@ 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 :: a -> m Int32
completionProviderGetInteractiveDelay provider :: a
provider = IO Int32 -> m Int32
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 (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.MethodInfo CompletionProviderGetInteractiveDelayMethodInfo a signature where
    overloadedMethod = 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 :: a -> m Text
completionProviderGetName provider :: a
provider = IO Text -> m Text
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 "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 (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.MethodInfo CompletionProviderGetNameMethodInfo a signature where
    overloadedMethod = 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 :: a -> m Int32
completionProviderGetPriority provider :: a
provider = IO Int32 -> m Int32
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 (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.MethodInfo CompletionProviderGetPriorityMethodInfo a signature where
    overloadedMethod = 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 :: a -> b -> c -> m (Bool, TextIter)
completionProviderGetStartIter provider :: a
provider context :: b
context proposal :: c
proposal = IO (Bool, TextIter) -> m (Bool, TextIter)
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. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 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
/= 0) CInt
result
    TextIter
iter' <- ((ManagedPtr TextIter -> TextIter) -> Ptr TextIter -> IO TextIter
forall a.
(HasCallStack, BoxedObject 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 (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.MethodInfo CompletionProviderGetStartIterMethodInfo a signature where
    overloadedMethod = 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 :: a -> b -> m Bool
completionProviderMatch provider :: a
provider context :: b
context = IO Bool -> m Bool
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
/= 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 (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.MethodInfo CompletionProviderMatchMethodInfo a signature where
    overloadedMethod = 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 :: a -> b -> m ()
completionProviderPopulate provider :: a
provider context :: b
context = IO () -> m ()
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 (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.MethodInfo CompletionProviderPopulateMethodInfo a signature where
    overloadedMethod = 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 :: a -> b -> c -> m ()
completionProviderUpdateInfo provider :: a
provider proposal :: b
proposal info :: c
info = IO () -> m ()
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 (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.MethodInfo CompletionProviderUpdateInfoMethodInfo a signature where
    overloadedMethod = completionProviderUpdateInfo

#endif