CompletionWords.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

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

module GI.GtkSource.Objects.CompletionWords
    ( 

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


 -- * Methods
-- ** new #method:new#

    completionWordsNew                      ,


-- ** register #method:register#

#if ENABLE_OVERLOADING
    CompletionWordsRegisterMethodInfo       ,
#endif
    completionWordsRegister                 ,


-- ** unregister #method:unregister#

#if ENABLE_OVERLOADING
    CompletionWordsUnregisterMethodInfo     ,
#endif
    completionWordsUnregister               ,




 -- * Properties
-- ** activation #attr:activation#
{- | The type of activation.

/Since: 3.10/
-}
#if ENABLE_OVERLOADING
    CompletionWordsActivationPropertyInfo   ,
#endif
#if ENABLE_OVERLOADING
    completionWordsActivation               ,
#endif
    constructCompletionWordsActivation      ,
    getCompletionWordsActivation            ,
    setCompletionWordsActivation            ,


-- ** icon #attr:icon#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CompletionWordsIconPropertyInfo         ,
#endif
    clearCompletionWordsIcon                ,
#if ENABLE_OVERLOADING
    completionWordsIcon                     ,
#endif
    constructCompletionWordsIcon            ,
    getCompletionWordsIcon                  ,
    setCompletionWordsIcon                  ,


-- ** interactiveDelay #attr:interactiveDelay#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CompletionWordsInteractiveDelayPropertyInfo,
#endif
#if ENABLE_OVERLOADING
    completionWordsInteractiveDelay         ,
#endif
    constructCompletionWordsInteractiveDelay,
    getCompletionWordsInteractiveDelay      ,
    setCompletionWordsInteractiveDelay      ,


-- ** minimumWordSize #attr:minimumWordSize#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CompletionWordsMinimumWordSizePropertyInfo,
#endif
#if ENABLE_OVERLOADING
    completionWordsMinimumWordSize          ,
#endif
    constructCompletionWordsMinimumWordSize ,
    getCompletionWordsMinimumWordSize       ,
    setCompletionWordsMinimumWordSize       ,


-- ** name #attr:name#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CompletionWordsNamePropertyInfo         ,
#endif
    clearCompletionWordsName                ,
#if ENABLE_OVERLOADING
    completionWordsName                     ,
#endif
    constructCompletionWordsName            ,
    getCompletionWordsName                  ,
    setCompletionWordsName                  ,


-- ** priority #attr:priority#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CompletionWordsPriorityPropertyInfo     ,
#endif
#if ENABLE_OVERLOADING
    completionWordsPriority                 ,
#endif
    constructCompletionWordsPriority        ,
    getCompletionWordsPriority              ,
    setCompletionWordsPriority              ,


-- ** proposalsBatchSize #attr:proposalsBatchSize#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CompletionWordsProposalsBatchSizePropertyInfo,
#endif
#if ENABLE_OVERLOADING
    completionWordsProposalsBatchSize       ,
#endif
    constructCompletionWordsProposalsBatchSize,
    getCompletionWordsProposalsBatchSize    ,
    setCompletionWordsProposalsBatchSize    ,


-- ** scanBatchSize #attr:scanBatchSize#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    CompletionWordsScanBatchSizePropertyInfo,
#endif
#if ENABLE_OVERLOADING
    completionWordsScanBatchSize            ,
#endif
    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.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.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.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

-- | Memory-managed wrapper type.
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
    

-- | Type class for types which can be safely cast to `CompletionWords`, for instance with `toCompletionWords`.
class (GObject o, O.IsDescendantOf CompletionWords o) => IsCompletionWords o
instance (GObject o, O.IsDescendantOf CompletionWords o) => IsCompletionWords o

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

-- | Cast to `CompletionWords`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toCompletionWords :: (MonadIO m, IsCompletionWords o) => o -> m CompletionWords
toCompletionWords = liftIO . unsafeCastTo CompletionWords

-- | A convenience alias for `Nothing` :: `Maybe` `CompletionWords`.
noCompletionWords :: Maybe CompletionWords
noCompletionWords = Nothing

#if ENABLE_OVERLOADING
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "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) => OL.IsLabel t (CompletionWords -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

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

{- |
Get the value of the “@activation@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completionWords #activation
@
-}
getCompletionWordsActivation :: (MonadIO m, IsCompletionWords o) => o -> m [GtkSource.Flags.CompletionActivation]
getCompletionWordsActivation obj = liftIO $ B.Properties.getObjectPropertyFlags obj "activation"

{- |
Set the value of the “@activation@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' completionWords [ #activation 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCompletionWordsActivation :: (MonadIO m, IsCompletionWords o) => o -> [GtkSource.Flags.CompletionActivation] -> m ()
setCompletionWordsActivation obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "activation" val

{- |
Construct a `GValueConstruct` with valid value for the “@activation@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCompletionWordsActivation :: (IsCompletionWords o) => [GtkSource.Flags.CompletionActivation] -> IO (GValueConstruct o)
constructCompletionWordsActivation val = B.Properties.constructObjectPropertyFlags "activation" val

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@icon@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completionWords #icon
@
-}
getCompletionWordsIcon :: (MonadIO m, IsCompletionWords o) => o -> m (Maybe GdkPixbuf.Pixbuf.Pixbuf)
getCompletionWordsIcon obj = liftIO $ B.Properties.getObjectPropertyObject obj "icon" GdkPixbuf.Pixbuf.Pixbuf

{- |
Set the value of the “@icon@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' completionWords [ #icon 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCompletionWordsIcon :: (MonadIO m, IsCompletionWords o, GdkPixbuf.Pixbuf.IsPixbuf a) => o -> a -> m ()
setCompletionWordsIcon obj val = liftIO $ B.Properties.setObjectPropertyObject obj "icon" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@icon@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCompletionWordsIcon :: (IsCompletionWords o, GdkPixbuf.Pixbuf.IsPixbuf a) => a -> IO (GValueConstruct o)
constructCompletionWordsIcon val = B.Properties.constructObjectPropertyObject "icon" (Just val)

{- |
Set the value of the “@icon@” property to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #icon
@
-}
clearCompletionWordsIcon :: (MonadIO m, IsCompletionWords o) => o -> m ()
clearCompletionWordsIcon obj = liftIO $ B.Properties.setObjectPropertyObject obj "icon" (Nothing :: Maybe GdkPixbuf.Pixbuf.Pixbuf)

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@interactive-delay@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completionWords #interactiveDelay
@
-}
getCompletionWordsInteractiveDelay :: (MonadIO m, IsCompletionWords o) => o -> m Int32
getCompletionWordsInteractiveDelay obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "interactive-delay"

{- |
Set the value of the “@interactive-delay@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' completionWords [ #interactiveDelay 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCompletionWordsInteractiveDelay :: (MonadIO m, IsCompletionWords o) => o -> Int32 -> m ()
setCompletionWordsInteractiveDelay obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "interactive-delay" val

{- |
Construct a `GValueConstruct` with valid value for the “@interactive-delay@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCompletionWordsInteractiveDelay :: (IsCompletionWords o) => Int32 -> IO (GValueConstruct o)
constructCompletionWordsInteractiveDelay val = B.Properties.constructObjectPropertyInt32 "interactive-delay" val

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@minimum-word-size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completionWords #minimumWordSize
@
-}
getCompletionWordsMinimumWordSize :: (MonadIO m, IsCompletionWords o) => o -> m Word32
getCompletionWordsMinimumWordSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "minimum-word-size"

{- |
Set the value of the “@minimum-word-size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' completionWords [ #minimumWordSize 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCompletionWordsMinimumWordSize :: (MonadIO m, IsCompletionWords o) => o -> Word32 -> m ()
setCompletionWordsMinimumWordSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "minimum-word-size" val

{- |
Construct a `GValueConstruct` with valid value for the “@minimum-word-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCompletionWordsMinimumWordSize :: (IsCompletionWords o) => Word32 -> IO (GValueConstruct o)
constructCompletionWordsMinimumWordSize val = B.Properties.constructObjectPropertyUInt32 "minimum-word-size" val

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@name@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completionWords #name
@
-}
getCompletionWordsName :: (MonadIO m, IsCompletionWords o) => o -> m (Maybe T.Text)
getCompletionWordsName obj = liftIO $ B.Properties.getObjectPropertyString obj "name"

{- |
Set the value of the “@name@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' completionWords [ #name 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCompletionWordsName :: (MonadIO m, IsCompletionWords o) => o -> T.Text -> m ()
setCompletionWordsName obj val = liftIO $ B.Properties.setObjectPropertyString obj "name" (Just val)

{- |
Construct a `GValueConstruct` with valid value for the “@name@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCompletionWordsName :: (IsCompletionWords o) => T.Text -> IO (GValueConstruct o)
constructCompletionWordsName val = B.Properties.constructObjectPropertyString "name" (Just val)

{- |
Set the value of the “@name@” property to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #name
@
-}
clearCompletionWordsName :: (MonadIO m, IsCompletionWords o) => o -> m ()
clearCompletionWordsName obj = liftIO $ B.Properties.setObjectPropertyString obj "name" (Nothing :: Maybe T.Text)

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@priority@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completionWords #priority
@
-}
getCompletionWordsPriority :: (MonadIO m, IsCompletionWords o) => o -> m Int32
getCompletionWordsPriority obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "priority"

{- |
Set the value of the “@priority@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' completionWords [ #priority 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCompletionWordsPriority :: (MonadIO m, IsCompletionWords o) => o -> Int32 -> m ()
setCompletionWordsPriority obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "priority" val

{- |
Construct a `GValueConstruct` with valid value for the “@priority@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCompletionWordsPriority :: (IsCompletionWords o) => Int32 -> IO (GValueConstruct o)
constructCompletionWordsPriority val = B.Properties.constructObjectPropertyInt32 "priority" val

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@proposals-batch-size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completionWords #proposalsBatchSize
@
-}
getCompletionWordsProposalsBatchSize :: (MonadIO m, IsCompletionWords o) => o -> m Word32
getCompletionWordsProposalsBatchSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "proposals-batch-size"

{- |
Set the value of the “@proposals-batch-size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' completionWords [ #proposalsBatchSize 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCompletionWordsProposalsBatchSize :: (MonadIO m, IsCompletionWords o) => o -> Word32 -> m ()
setCompletionWordsProposalsBatchSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "proposals-batch-size" val

{- |
Construct a `GValueConstruct` with valid value for the “@proposals-batch-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCompletionWordsProposalsBatchSize :: (IsCompletionWords o) => Word32 -> IO (GValueConstruct o)
constructCompletionWordsProposalsBatchSize val = B.Properties.constructObjectPropertyUInt32 "proposals-batch-size" val

#if ENABLE_OVERLOADING
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
#endif

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

{- |
Get the value of the “@scan-batch-size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' completionWords #scanBatchSize
@
-}
getCompletionWordsScanBatchSize :: (MonadIO m, IsCompletionWords o) => o -> m Word32
getCompletionWordsScanBatchSize obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "scan-batch-size"

{- |
Set the value of the “@scan-batch-size@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' completionWords [ #scanBatchSize 'Data.GI.Base.Attributes.:=' value ]
@
-}
setCompletionWordsScanBatchSize :: (MonadIO m, IsCompletionWords o) => o -> Word32 -> m ()
setCompletionWordsScanBatchSize obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "scan-batch-size" val

{- |
Construct a `GValueConstruct` with valid value for the “@scan-batch-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructCompletionWordsScanBatchSize :: (IsCompletionWords o) => Word32 -> IO (GValueConstruct o)
constructCompletionWordsScanBatchSize val = B.Properties.constructObjectPropertyUInt32 "scan-batch-size" val

#if ENABLE_OVERLOADING
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
#endif

#if ENABLE_OVERLOADING
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, *)])
#endif

#if ENABLE_OVERLOADING
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

#endif

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

#endif

-- 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'

#if ENABLE_OVERLOADING
#endif

-- 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 ()

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

#endif

-- 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 ()

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

#endif