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

module GI.GtkSource.Objects.CompletionWords
    ( 

-- * Exported types
    CompletionWords(..)                     ,
    IsCompletionWords                       ,
    toCompletionWords                       ,
    noCompletionWords                       ,


 -- * Methods
-- ** new #method:new#
    completionWordsNew                      ,


-- ** register #method:register#
    CompletionWordsRegisterMethodInfo       ,
    completionWordsRegister                 ,


-- ** unregister #method:unregister#
    CompletionWordsUnregisterMethodInfo     ,
    completionWordsUnregister               ,




 -- * Properties
-- ** activation #attr:activation#
    CompletionWordsActivationPropertyInfo   ,
    completionWordsActivation               ,
    constructCompletionWordsActivation      ,
    getCompletionWordsActivation            ,
    setCompletionWordsActivation            ,


-- ** icon #attr:icon#
    CompletionWordsIconPropertyInfo         ,
    clearCompletionWordsIcon                ,
    completionWordsIcon                     ,
    constructCompletionWordsIcon            ,
    getCompletionWordsIcon                  ,
    setCompletionWordsIcon                  ,


-- ** interactiveDelay #attr:interactiveDelay#
    CompletionWordsInteractiveDelayPropertyInfo,
    completionWordsInteractiveDelay         ,
    constructCompletionWordsInteractiveDelay,
    getCompletionWordsInteractiveDelay      ,
    setCompletionWordsInteractiveDelay      ,


-- ** minimumWordSize #attr:minimumWordSize#
    CompletionWordsMinimumWordSizePropertyInfo,
    completionWordsMinimumWordSize          ,
    constructCompletionWordsMinimumWordSize ,
    getCompletionWordsMinimumWordSize       ,
    setCompletionWordsMinimumWordSize       ,


-- ** name #attr:name#
    CompletionWordsNamePropertyInfo         ,
    clearCompletionWordsName                ,
    completionWordsName                     ,
    constructCompletionWordsName            ,
    getCompletionWordsName                  ,
    setCompletionWordsName                  ,


-- ** priority #attr:priority#
    CompletionWordsPriorityPropertyInfo     ,
    completionWordsPriority                 ,
    constructCompletionWordsPriority        ,
    getCompletionWordsPriority              ,
    setCompletionWordsPriority              ,


-- ** proposalsBatchSize #attr:proposalsBatchSize#
    CompletionWordsProposalsBatchSizePropertyInfo,
    completionWordsProposalsBatchSize       ,
    constructCompletionWordsProposalsBatchSize,
    getCompletionWordsProposalsBatchSize    ,
    setCompletionWordsProposalsBatchSize    ,


-- ** scanBatchSize #attr:scanBatchSize#
    CompletionWordsScanBatchSizePropertyInfo,
    completionWordsScanBatchSize            ,
    constructCompletionWordsScanBatchSize   ,
    getCompletionWordsScanBatchSize         ,
    setCompletionWordsScanBatchSize         ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
import qualified GI.Gtk.Objects.TextBuffer as Gtk.TextBuffer
import {-# SOURCE #-} qualified GI.GtkSource.Flags as GtkSource.Flags
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProvider as GtkSource.CompletionProvider

newtype CompletionWords = CompletionWords (ManagedPtr CompletionWords)
foreign import ccall "gtk_source_completion_words_get_type"
    c_gtk_source_completion_words_get_type :: IO GType

instance GObject CompletionWords where
    gobjectType _ = c_gtk_source_completion_words_get_type
    

class GObject o => IsCompletionWords o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError CompletionWords a) =>
    IsCompletionWords a
#endif
instance IsCompletionWords CompletionWords
instance GObject.Object.IsObject CompletionWords
instance GtkSource.CompletionProvider.IsCompletionProvider CompletionWords

toCompletionWords :: IsCompletionWords o => o -> IO CompletionWords
toCompletionWords = unsafeCastTo CompletionWords

noCompletionWords :: Maybe CompletionWords
noCompletionWords = Nothing

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

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

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

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

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

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

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

data CompletionWordsActivationPropertyInfo
instance AttrInfo CompletionWordsActivationPropertyInfo where
    type AttrAllowedOps CompletionWordsActivationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CompletionWordsActivationPropertyInfo = (~) [GtkSource.Flags.CompletionActivation]
    type AttrBaseTypeConstraint CompletionWordsActivationPropertyInfo = IsCompletionWords
    type AttrGetType CompletionWordsActivationPropertyInfo = [GtkSource.Flags.CompletionActivation]
    type AttrLabel CompletionWordsActivationPropertyInfo = "activation"
    type AttrOrigin CompletionWordsActivationPropertyInfo = CompletionWords
    attrGet _ = getCompletionWordsActivation
    attrSet _ = setCompletionWordsActivation
    attrConstruct _ = constructCompletionWordsActivation
    attrClear _ = undefined

-- VVV Prop "icon"
   -- Type: TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

getCompletionWordsIcon :: (MonadIO m, IsCompletionWords o) => o -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)
getCompletionWordsIcon obj = liftIO $ getObjectPropertyObject obj "icon" GdkPixbuf.Pixbuf.Pixbuf

setCompletionWordsIcon :: (MonadIO m, IsCompletionWords o, GdkPixbuf.Pixbuf.IsPixbuf a) => o -> a -> m ()
setCompletionWordsIcon obj val = liftIO $ setObjectPropertyObject obj "icon" (Just val)

constructCompletionWordsIcon :: (IsCompletionWords o, GdkPixbuf.Pixbuf.IsPixbuf a) => a -> IO (GValueConstruct o)
constructCompletionWordsIcon val = constructObjectPropertyObject "icon" (Just val)

clearCompletionWordsIcon :: (MonadIO m, IsCompletionWords o) => o -> m ()
clearCompletionWordsIcon obj = liftIO $ setObjectPropertyObject obj "icon" (Nothing :: Maybe GdkPixbuf.Pixbuf.Pixbuf)

data CompletionWordsIconPropertyInfo
instance AttrInfo CompletionWordsIconPropertyInfo where
    type AttrAllowedOps CompletionWordsIconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionWordsIconPropertyInfo = GdkPixbuf.Pixbuf.IsPixbuf
    type AttrBaseTypeConstraint CompletionWordsIconPropertyInfo = IsCompletionWords
    type AttrGetType CompletionWordsIconPropertyInfo = (Maybe GdkPixbuf.Pixbuf.Pixbuf)
    type AttrLabel CompletionWordsIconPropertyInfo = "icon"
    type AttrOrigin CompletionWordsIconPropertyInfo = CompletionWords
    attrGet _ = getCompletionWordsIcon
    attrSet _ = setCompletionWordsIcon
    attrConstruct _ = constructCompletionWordsIcon
    attrClear _ = clearCompletionWordsIcon

-- VVV Prop "interactive-delay"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

getCompletionWordsInteractiveDelay :: (MonadIO m, IsCompletionWords o) => o -> m Int32
getCompletionWordsInteractiveDelay obj = liftIO $ getObjectPropertyInt32 obj "interactive-delay"

setCompletionWordsInteractiveDelay :: (MonadIO m, IsCompletionWords o) => o -> Int32 -> m ()
setCompletionWordsInteractiveDelay obj val = liftIO $ setObjectPropertyInt32 obj "interactive-delay" val

constructCompletionWordsInteractiveDelay :: (IsCompletionWords o) => Int32 -> IO (GValueConstruct o)
constructCompletionWordsInteractiveDelay val = constructObjectPropertyInt32 "interactive-delay" val

data CompletionWordsInteractiveDelayPropertyInfo
instance AttrInfo CompletionWordsInteractiveDelayPropertyInfo where
    type AttrAllowedOps CompletionWordsInteractiveDelayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CompletionWordsInteractiveDelayPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint CompletionWordsInteractiveDelayPropertyInfo = IsCompletionWords
    type AttrGetType CompletionWordsInteractiveDelayPropertyInfo = Int32
    type AttrLabel CompletionWordsInteractiveDelayPropertyInfo = "interactive-delay"
    type AttrOrigin CompletionWordsInteractiveDelayPropertyInfo = CompletionWords
    attrGet _ = getCompletionWordsInteractiveDelay
    attrSet _ = setCompletionWordsInteractiveDelay
    attrConstruct _ = constructCompletionWordsInteractiveDelay
    attrClear _ = undefined

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

getCompletionWordsMinimumWordSize :: (MonadIO m, IsCompletionWords o) => o -> m Word32
getCompletionWordsMinimumWordSize obj = liftIO $ getObjectPropertyUInt32 obj "minimum-word-size"

setCompletionWordsMinimumWordSize :: (MonadIO m, IsCompletionWords o) => o -> Word32 -> m ()
setCompletionWordsMinimumWordSize obj val = liftIO $ setObjectPropertyUInt32 obj "minimum-word-size" val

constructCompletionWordsMinimumWordSize :: (IsCompletionWords o) => Word32 -> IO (GValueConstruct o)
constructCompletionWordsMinimumWordSize val = constructObjectPropertyUInt32 "minimum-word-size" val

data CompletionWordsMinimumWordSizePropertyInfo
instance AttrInfo CompletionWordsMinimumWordSizePropertyInfo where
    type AttrAllowedOps CompletionWordsMinimumWordSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CompletionWordsMinimumWordSizePropertyInfo = (~) Word32
    type AttrBaseTypeConstraint CompletionWordsMinimumWordSizePropertyInfo = IsCompletionWords
    type AttrGetType CompletionWordsMinimumWordSizePropertyInfo = Word32
    type AttrLabel CompletionWordsMinimumWordSizePropertyInfo = "minimum-word-size"
    type AttrOrigin CompletionWordsMinimumWordSizePropertyInfo = CompletionWords
    attrGet _ = getCompletionWordsMinimumWordSize
    attrSet _ = setCompletionWordsMinimumWordSize
    attrConstruct _ = constructCompletionWordsMinimumWordSize
    attrClear _ = undefined

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

getCompletionWordsName :: (MonadIO m, IsCompletionWords o) => o -> m (Maybe T.Text)
getCompletionWordsName obj = liftIO $ getObjectPropertyString obj "name"

setCompletionWordsName :: (MonadIO m, IsCompletionWords o) => o -> T.Text -> m ()
setCompletionWordsName obj val = liftIO $ setObjectPropertyString obj "name" (Just val)

constructCompletionWordsName :: (IsCompletionWords o) => T.Text -> IO (GValueConstruct o)
constructCompletionWordsName val = constructObjectPropertyString "name" (Just val)

clearCompletionWordsName :: (MonadIO m, IsCompletionWords o) => o -> m ()
clearCompletionWordsName obj = liftIO $ setObjectPropertyString obj "name" (Nothing :: Maybe T.Text)

data CompletionWordsNamePropertyInfo
instance AttrInfo CompletionWordsNamePropertyInfo where
    type AttrAllowedOps CompletionWordsNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionWordsNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CompletionWordsNamePropertyInfo = IsCompletionWords
    type AttrGetType CompletionWordsNamePropertyInfo = (Maybe T.Text)
    type AttrLabel CompletionWordsNamePropertyInfo = "name"
    type AttrOrigin CompletionWordsNamePropertyInfo = CompletionWords
    attrGet _ = getCompletionWordsName
    attrSet _ = setCompletionWordsName
    attrConstruct _ = constructCompletionWordsName
    attrClear _ = clearCompletionWordsName

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

getCompletionWordsPriority :: (MonadIO m, IsCompletionWords o) => o -> m Int32
getCompletionWordsPriority obj = liftIO $ getObjectPropertyInt32 obj "priority"

setCompletionWordsPriority :: (MonadIO m, IsCompletionWords o) => o -> Int32 -> m ()
setCompletionWordsPriority obj val = liftIO $ setObjectPropertyInt32 obj "priority" val

constructCompletionWordsPriority :: (IsCompletionWords o) => Int32 -> IO (GValueConstruct o)
constructCompletionWordsPriority val = constructObjectPropertyInt32 "priority" val

data CompletionWordsPriorityPropertyInfo
instance AttrInfo CompletionWordsPriorityPropertyInfo where
    type AttrAllowedOps CompletionWordsPriorityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CompletionWordsPriorityPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint CompletionWordsPriorityPropertyInfo = IsCompletionWords
    type AttrGetType CompletionWordsPriorityPropertyInfo = Int32
    type AttrLabel CompletionWordsPriorityPropertyInfo = "priority"
    type AttrOrigin CompletionWordsPriorityPropertyInfo = CompletionWords
    attrGet _ = getCompletionWordsPriority
    attrSet _ = setCompletionWordsPriority
    attrConstruct _ = constructCompletionWordsPriority
    attrClear _ = undefined

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

getCompletionWordsProposalsBatchSize :: (MonadIO m, IsCompletionWords o) => o -> m Word32
getCompletionWordsProposalsBatchSize obj = liftIO $ getObjectPropertyUInt32 obj "proposals-batch-size"

setCompletionWordsProposalsBatchSize :: (MonadIO m, IsCompletionWords o) => o -> Word32 -> m ()
setCompletionWordsProposalsBatchSize obj val = liftIO $ setObjectPropertyUInt32 obj "proposals-batch-size" val

constructCompletionWordsProposalsBatchSize :: (IsCompletionWords o) => Word32 -> IO (GValueConstruct o)
constructCompletionWordsProposalsBatchSize val = constructObjectPropertyUInt32 "proposals-batch-size" val

data CompletionWordsProposalsBatchSizePropertyInfo
instance AttrInfo CompletionWordsProposalsBatchSizePropertyInfo where
    type AttrAllowedOps CompletionWordsProposalsBatchSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CompletionWordsProposalsBatchSizePropertyInfo = (~) Word32
    type AttrBaseTypeConstraint CompletionWordsProposalsBatchSizePropertyInfo = IsCompletionWords
    type AttrGetType CompletionWordsProposalsBatchSizePropertyInfo = Word32
    type AttrLabel CompletionWordsProposalsBatchSizePropertyInfo = "proposals-batch-size"
    type AttrOrigin CompletionWordsProposalsBatchSizePropertyInfo = CompletionWords
    attrGet _ = getCompletionWordsProposalsBatchSize
    attrSet _ = setCompletionWordsProposalsBatchSize
    attrConstruct _ = constructCompletionWordsProposalsBatchSize
    attrClear _ = undefined

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

getCompletionWordsScanBatchSize :: (MonadIO m, IsCompletionWords o) => o -> m Word32
getCompletionWordsScanBatchSize obj = liftIO $ getObjectPropertyUInt32 obj "scan-batch-size"

setCompletionWordsScanBatchSize :: (MonadIO m, IsCompletionWords o) => o -> Word32 -> m ()
setCompletionWordsScanBatchSize obj val = liftIO $ setObjectPropertyUInt32 obj "scan-batch-size" val

constructCompletionWordsScanBatchSize :: (IsCompletionWords o) => Word32 -> IO (GValueConstruct o)
constructCompletionWordsScanBatchSize val = constructObjectPropertyUInt32 "scan-batch-size" val

data CompletionWordsScanBatchSizePropertyInfo
instance AttrInfo CompletionWordsScanBatchSizePropertyInfo where
    type AttrAllowedOps CompletionWordsScanBatchSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint CompletionWordsScanBatchSizePropertyInfo = (~) Word32
    type AttrBaseTypeConstraint CompletionWordsScanBatchSizePropertyInfo = IsCompletionWords
    type AttrGetType CompletionWordsScanBatchSizePropertyInfo = Word32
    type AttrLabel CompletionWordsScanBatchSizePropertyInfo = "scan-batch-size"
    type AttrOrigin CompletionWordsScanBatchSizePropertyInfo = CompletionWords
    attrGet _ = getCompletionWordsScanBatchSize
    attrSet _ = setCompletionWordsScanBatchSize
    attrConstruct _ = constructCompletionWordsScanBatchSize
    attrClear _ = undefined

instance O.HasAttributeList CompletionWords
type instance O.AttributeList CompletionWords = CompletionWordsAttributeList
type CompletionWordsAttributeList = ('[ '("activation", CompletionWordsActivationPropertyInfo), '("icon", CompletionWordsIconPropertyInfo), '("interactiveDelay", CompletionWordsInteractiveDelayPropertyInfo), '("minimumWordSize", CompletionWordsMinimumWordSizePropertyInfo), '("name", CompletionWordsNamePropertyInfo), '("priority", CompletionWordsPriorityPropertyInfo), '("proposalsBatchSize", CompletionWordsProposalsBatchSizePropertyInfo), '("scanBatchSize", CompletionWordsScanBatchSizePropertyInfo)] :: [(Symbol, *)])

completionWordsActivation :: AttrLabelProxy "activation"
completionWordsActivation = AttrLabelProxy

completionWordsIcon :: AttrLabelProxy "icon"
completionWordsIcon = AttrLabelProxy

completionWordsInteractiveDelay :: AttrLabelProxy "interactiveDelay"
completionWordsInteractiveDelay = AttrLabelProxy

completionWordsMinimumWordSize :: AttrLabelProxy "minimumWordSize"
completionWordsMinimumWordSize = AttrLabelProxy

completionWordsName :: AttrLabelProxy "name"
completionWordsName = AttrLabelProxy

completionWordsPriority :: AttrLabelProxy "priority"
completionWordsPriority = AttrLabelProxy

completionWordsProposalsBatchSize :: AttrLabelProxy "proposalsBatchSize"
completionWordsProposalsBatchSize = AttrLabelProxy

completionWordsScanBatchSize :: AttrLabelProxy "scanBatchSize"
completionWordsScanBatchSize = AttrLabelProxy

type instance O.SignalList CompletionWords = CompletionWordsSignalList
type CompletionWordsSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method CompletionWords::new
-- method type : Constructor
-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The name for the provider, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A specific icon for the provider, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionWords"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_words_new" gtk_source_completion_words_new :: 
    CString ->                              -- name : TBasicType TUTF8
    Ptr GdkPixbuf.Pixbuf.Pixbuf ->          -- icon : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})
    IO (Ptr CompletionWords)

{- |
/No description available in the introspection data./
-}
completionWordsNew ::
    (B.CallStack.HasCallStack, MonadIO m, GdkPixbuf.Pixbuf.IsPixbuf a) =>
    Maybe (T.Text)
    {- ^ /@name@/: The name for the provider, or 'Nothing'. -}
    -> Maybe (a)
    {- ^ /@icon@/: A specific icon for the provider, or 'Nothing'. -}
    -> m CompletionWords
    {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionWords.CompletionWords' provider -}
completionWordsNew name icon = liftIO $ do
    maybeName <- case name of
        Nothing -> return nullPtr
        Just jName -> do
            jName' <- textToCString jName
            return jName'
    maybeIcon <- case icon of
        Nothing -> return nullPtr
        Just jIcon -> do
            jIcon' <- unsafeManagedPtrCastPtr jIcon
            return jIcon'
    result <- gtk_source_completion_words_new maybeName maybeIcon
    checkUnexpectedReturnNULL "completionWordsNew" result
    result' <- (wrapObject CompletionWords) result
    whenJust icon touchManagedPtr
    freeMem maybeName
    return result'

-- method CompletionWords::register
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "words", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionWords"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionWords", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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_words_register" gtk_source_completion_words_register :: 
    Ptr CompletionWords ->                  -- words : TInterface (Name {namespace = "GtkSource", name = "CompletionWords"})
    Ptr Gtk.TextBuffer.TextBuffer ->        -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO ()

{- |
Registers /@buffer@/ in the /@words@/ provider.
-}
completionWordsRegister ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionWords a, Gtk.TextBuffer.IsTextBuffer b) =>
    a
    {- ^ /@words@/: a 'GI.GtkSource.Objects.CompletionWords.CompletionWords' -}
    -> b
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m ()
completionWordsRegister words buffer = liftIO $ do
    words' <- unsafeManagedPtrCastPtr words
    buffer' <- unsafeManagedPtrCastPtr buffer
    gtk_source_completion_words_register words' buffer'
    touchManagedPtr words
    touchManagedPtr buffer
    return ()

data CompletionWordsRegisterMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCompletionWords a, Gtk.TextBuffer.IsTextBuffer b) => O.MethodInfo CompletionWordsRegisterMethodInfo a signature where
    overloadedMethod _ = completionWordsRegister

-- method CompletionWords::unregister
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "words", argType = TInterface (Name {namespace = "GtkSource", name = "CompletionWords"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceCompletionWords", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface (Name {namespace = "Gtk", name = "TextBuffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkTextBuffer", 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_words_unregister" gtk_source_completion_words_unregister :: 
    Ptr CompletionWords ->                  -- words : TInterface (Name {namespace = "GtkSource", name = "CompletionWords"})
    Ptr Gtk.TextBuffer.TextBuffer ->        -- buffer : TInterface (Name {namespace = "Gtk", name = "TextBuffer"})
    IO ()

{- |
Unregisters /@buffer@/ from the /@words@/ provider.
-}
completionWordsUnregister ::
    (B.CallStack.HasCallStack, MonadIO m, IsCompletionWords a, Gtk.TextBuffer.IsTextBuffer b) =>
    a
    {- ^ /@words@/: a 'GI.GtkSource.Objects.CompletionWords.CompletionWords' -}
    -> b
    {- ^ /@buffer@/: a 'GI.Gtk.Objects.TextBuffer.TextBuffer' -}
    -> m ()
completionWordsUnregister words buffer = liftIO $ do
    words' <- unsafeManagedPtrCastPtr words
    buffer' <- unsafeManagedPtrCastPtr buffer
    gtk_source_completion_words_unregister words' buffer'
    touchManagedPtr words
    touchManagedPtr buffer
    return ()

data CompletionWordsUnregisterMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsCompletionWords a, Gtk.TextBuffer.IsTextBuffer b) => O.MethodInfo CompletionWordsUnregisterMethodInfo a signature where
    overloadedMethod _ = completionWordsUnregister