{- |
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.CompletionItem
    ( 

-- * Exported types
    CompletionItem(..)                      ,
    IsCompletionItem                        ,
    toCompletionItem                        ,
    noCompletionItem                        ,


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


-- ** newFromStock #method:newFromStock#
    completionItemNewFromStock              ,


-- ** newWithMarkup #method:newWithMarkup#
    completionItemNewWithMarkup             ,




 -- * Properties
-- ** gicon #attr:gicon#
    CompletionItemGiconPropertyInfo         ,
    clearCompletionItemGicon                ,
    completionItemGicon                     ,
    constructCompletionItemGicon            ,
    getCompletionItemGicon                  ,
    setCompletionItemGicon                  ,


-- ** icon #attr:icon#
    CompletionItemIconPropertyInfo          ,
    clearCompletionItemIcon                 ,
    completionItemIcon                      ,
    constructCompletionItemIcon             ,
    getCompletionItemIcon                   ,
    setCompletionItemIcon                   ,


-- ** iconName #attr:iconName#
    CompletionItemIconNamePropertyInfo      ,
    clearCompletionItemIconName             ,
    completionItemIconName                  ,
    constructCompletionItemIconName         ,
    getCompletionItemIconName               ,
    setCompletionItemIconName               ,


-- ** info #attr:info#
    CompletionItemInfoPropertyInfo          ,
    clearCompletionItemInfo                 ,
    completionItemInfo                      ,
    constructCompletionItemInfo             ,
    getCompletionItemInfo                   ,
    setCompletionItemInfo                   ,


-- ** label #attr:label#
    CompletionItemLabelPropertyInfo         ,
    clearCompletionItemLabel                ,
    completionItemLabel                     ,
    constructCompletionItemLabel            ,
    getCompletionItemLabel                  ,
    setCompletionItemLabel                  ,


-- ** markup #attr:markup#
    CompletionItemMarkupPropertyInfo        ,
    clearCompletionItemMarkup               ,
    completionItemMarkup                    ,
    constructCompletionItemMarkup           ,
    getCompletionItemMarkup                 ,
    setCompletionItemMarkup                 ,


-- ** text #attr:text#
    CompletionItemTextPropertyInfo          ,
    clearCompletionItemText                 ,
    completionItemText                      ,
    constructCompletionItemText             ,
    getCompletionItemText                   ,
    setCompletionItemText                   ,




    ) 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.Gio.Interfaces.Icon as Gio.Icon
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.CompletionProposal as GtkSource.CompletionProposal

newtype CompletionItem = CompletionItem (ManagedPtr CompletionItem)
foreign import ccall "gtk_source_completion_item_get_type"
    c_gtk_source_completion_item_get_type :: IO GType

instance GObject CompletionItem where
    gobjectType _ = c_gtk_source_completion_item_get_type
    

class GObject o => IsCompletionItem o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError CompletionItem a) =>
    IsCompletionItem a
#endif
instance IsCompletionItem CompletionItem
instance GObject.Object.IsObject CompletionItem
instance GtkSource.CompletionProposal.IsCompletionProposal CompletionItem

toCompletionItem :: IsCompletionItem o => o -> IO CompletionItem
toCompletionItem = unsafeCastTo CompletionItem

noCompletionItem :: Maybe CompletionItem
noCompletionItem = Nothing

type family ResolveCompletionItemMethod (t :: Symbol) (o :: *) :: * where
    ResolveCompletionItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveCompletionItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveCompletionItemMethod "changed" o = GtkSource.CompletionProposal.CompletionProposalChangedMethodInfo
    ResolveCompletionItemMethod "equal" o = GtkSource.CompletionProposal.CompletionProposalEqualMethodInfo
    ResolveCompletionItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveCompletionItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveCompletionItemMethod "hash" o = GtkSource.CompletionProposal.CompletionProposalHashMethodInfo
    ResolveCompletionItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveCompletionItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveCompletionItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveCompletionItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveCompletionItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveCompletionItemMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveCompletionItemMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveCompletionItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveCompletionItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveCompletionItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveCompletionItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveCompletionItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveCompletionItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveCompletionItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveCompletionItemMethod "getGicon" o = GtkSource.CompletionProposal.CompletionProposalGetGiconMethodInfo
    ResolveCompletionItemMethod "getIcon" o = GtkSource.CompletionProposal.CompletionProposalGetIconMethodInfo
    ResolveCompletionItemMethod "getIconName" o = GtkSource.CompletionProposal.CompletionProposalGetIconNameMethodInfo
    ResolveCompletionItemMethod "getInfo" o = GtkSource.CompletionProposal.CompletionProposalGetInfoMethodInfo
    ResolveCompletionItemMethod "getLabel" o = GtkSource.CompletionProposal.CompletionProposalGetLabelMethodInfo
    ResolveCompletionItemMethod "getMarkup" o = GtkSource.CompletionProposal.CompletionProposalGetMarkupMethodInfo
    ResolveCompletionItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveCompletionItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveCompletionItemMethod "getText" o = GtkSource.CompletionProposal.CompletionProposalGetTextMethodInfo
    ResolveCompletionItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveCompletionItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveCompletionItemMethod l o = O.MethodResolutionFailed l o

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

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

-- VVV Prop "gicon"
   -- Type: TInterface (Name {namespace = "Gio", name = "Icon"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getCompletionItemGicon :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe Gio.Icon.Icon)
getCompletionItemGicon obj = liftIO $ getObjectPropertyObject obj "gicon" Gio.Icon.Icon

setCompletionItemGicon :: (MonadIO m, IsCompletionItem o, Gio.Icon.IsIcon a) => o -> a -> m ()
setCompletionItemGicon obj val = liftIO $ setObjectPropertyObject obj "gicon" (Just val)

constructCompletionItemGicon :: (IsCompletionItem o, Gio.Icon.IsIcon a) => a -> IO (GValueConstruct o)
constructCompletionItemGicon val = constructObjectPropertyObject "gicon" (Just val)

clearCompletionItemGicon :: (MonadIO m, IsCompletionItem o) => o -> m ()
clearCompletionItemGicon obj = liftIO $ setObjectPropertyObject obj "gicon" (Nothing :: Maybe Gio.Icon.Icon)

data CompletionItemGiconPropertyInfo
instance AttrInfo CompletionItemGiconPropertyInfo where
    type AttrAllowedOps CompletionItemGiconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionItemGiconPropertyInfo = Gio.Icon.IsIcon
    type AttrBaseTypeConstraint CompletionItemGiconPropertyInfo = IsCompletionItem
    type AttrGetType CompletionItemGiconPropertyInfo = (Maybe Gio.Icon.Icon)
    type AttrLabel CompletionItemGiconPropertyInfo = "gicon"
    type AttrOrigin CompletionItemGiconPropertyInfo = CompletionItem
    attrGet _ = getCompletionItemGicon
    attrSet _ = setCompletionItemGicon
    attrConstruct _ = constructCompletionItemGicon
    attrClear _ = clearCompletionItemGicon

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

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

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

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

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

data CompletionItemIconPropertyInfo
instance AttrInfo CompletionItemIconPropertyInfo where
    type AttrAllowedOps CompletionItemIconPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionItemIconPropertyInfo = GdkPixbuf.Pixbuf.IsPixbuf
    type AttrBaseTypeConstraint CompletionItemIconPropertyInfo = IsCompletionItem
    type AttrGetType CompletionItemIconPropertyInfo = (Maybe GdkPixbuf.Pixbuf.Pixbuf)
    type AttrLabel CompletionItemIconPropertyInfo = "icon"
    type AttrOrigin CompletionItemIconPropertyInfo = CompletionItem
    attrGet _ = getCompletionItemIcon
    attrSet _ = setCompletionItemIcon
    attrConstruct _ = constructCompletionItemIcon
    attrClear _ = clearCompletionItemIcon

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

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

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

constructCompletionItemIconName :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o)
constructCompletionItemIconName val = constructObjectPropertyString "icon-name" (Just val)

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

data CompletionItemIconNamePropertyInfo
instance AttrInfo CompletionItemIconNamePropertyInfo where
    type AttrAllowedOps CompletionItemIconNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionItemIconNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CompletionItemIconNamePropertyInfo = IsCompletionItem
    type AttrGetType CompletionItemIconNamePropertyInfo = (Maybe T.Text)
    type AttrLabel CompletionItemIconNamePropertyInfo = "icon-name"
    type AttrOrigin CompletionItemIconNamePropertyInfo = CompletionItem
    attrGet _ = getCompletionItemIconName
    attrSet _ = setCompletionItemIconName
    attrConstruct _ = constructCompletionItemIconName
    attrClear _ = clearCompletionItemIconName

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

getCompletionItemInfo :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe T.Text)
getCompletionItemInfo obj = liftIO $ getObjectPropertyString obj "info"

setCompletionItemInfo :: (MonadIO m, IsCompletionItem o) => o -> T.Text -> m ()
setCompletionItemInfo obj val = liftIO $ setObjectPropertyString obj "info" (Just val)

constructCompletionItemInfo :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o)
constructCompletionItemInfo val = constructObjectPropertyString "info" (Just val)

clearCompletionItemInfo :: (MonadIO m, IsCompletionItem o) => o -> m ()
clearCompletionItemInfo obj = liftIO $ setObjectPropertyString obj "info" (Nothing :: Maybe T.Text)

data CompletionItemInfoPropertyInfo
instance AttrInfo CompletionItemInfoPropertyInfo where
    type AttrAllowedOps CompletionItemInfoPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionItemInfoPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CompletionItemInfoPropertyInfo = IsCompletionItem
    type AttrGetType CompletionItemInfoPropertyInfo = (Maybe T.Text)
    type AttrLabel CompletionItemInfoPropertyInfo = "info"
    type AttrOrigin CompletionItemInfoPropertyInfo = CompletionItem
    attrGet _ = getCompletionItemInfo
    attrSet _ = setCompletionItemInfo
    attrConstruct _ = constructCompletionItemInfo
    attrClear _ = clearCompletionItemInfo

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

getCompletionItemLabel :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe T.Text)
getCompletionItemLabel obj = liftIO $ getObjectPropertyString obj "label"

setCompletionItemLabel :: (MonadIO m, IsCompletionItem o) => o -> T.Text -> m ()
setCompletionItemLabel obj val = liftIO $ setObjectPropertyString obj "label" (Just val)

constructCompletionItemLabel :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o)
constructCompletionItemLabel val = constructObjectPropertyString "label" (Just val)

clearCompletionItemLabel :: (MonadIO m, IsCompletionItem o) => o -> m ()
clearCompletionItemLabel obj = liftIO $ setObjectPropertyString obj "label" (Nothing :: Maybe T.Text)

data CompletionItemLabelPropertyInfo
instance AttrInfo CompletionItemLabelPropertyInfo where
    type AttrAllowedOps CompletionItemLabelPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionItemLabelPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CompletionItemLabelPropertyInfo = IsCompletionItem
    type AttrGetType CompletionItemLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel CompletionItemLabelPropertyInfo = "label"
    type AttrOrigin CompletionItemLabelPropertyInfo = CompletionItem
    attrGet _ = getCompletionItemLabel
    attrSet _ = setCompletionItemLabel
    attrConstruct _ = constructCompletionItemLabel
    attrClear _ = clearCompletionItemLabel

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

getCompletionItemMarkup :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe T.Text)
getCompletionItemMarkup obj = liftIO $ getObjectPropertyString obj "markup"

setCompletionItemMarkup :: (MonadIO m, IsCompletionItem o) => o -> T.Text -> m ()
setCompletionItemMarkup obj val = liftIO $ setObjectPropertyString obj "markup" (Just val)

constructCompletionItemMarkup :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o)
constructCompletionItemMarkup val = constructObjectPropertyString "markup" (Just val)

clearCompletionItemMarkup :: (MonadIO m, IsCompletionItem o) => o -> m ()
clearCompletionItemMarkup obj = liftIO $ setObjectPropertyString obj "markup" (Nothing :: Maybe T.Text)

data CompletionItemMarkupPropertyInfo
instance AttrInfo CompletionItemMarkupPropertyInfo where
    type AttrAllowedOps CompletionItemMarkupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionItemMarkupPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CompletionItemMarkupPropertyInfo = IsCompletionItem
    type AttrGetType CompletionItemMarkupPropertyInfo = (Maybe T.Text)
    type AttrLabel CompletionItemMarkupPropertyInfo = "markup"
    type AttrOrigin CompletionItemMarkupPropertyInfo = CompletionItem
    attrGet _ = getCompletionItemMarkup
    attrSet _ = setCompletionItemMarkup
    attrConstruct _ = constructCompletionItemMarkup
    attrClear _ = clearCompletionItemMarkup

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

getCompletionItemText :: (MonadIO m, IsCompletionItem o) => o -> m (Maybe T.Text)
getCompletionItemText obj = liftIO $ getObjectPropertyString obj "text"

setCompletionItemText :: (MonadIO m, IsCompletionItem o) => o -> T.Text -> m ()
setCompletionItemText obj val = liftIO $ setObjectPropertyString obj "text" (Just val)

constructCompletionItemText :: (IsCompletionItem o) => T.Text -> IO (GValueConstruct o)
constructCompletionItemText val = constructObjectPropertyString "text" (Just val)

clearCompletionItemText :: (MonadIO m, IsCompletionItem o) => o -> m ()
clearCompletionItemText obj = liftIO $ setObjectPropertyString obj "text" (Nothing :: Maybe T.Text)

data CompletionItemTextPropertyInfo
instance AttrInfo CompletionItemTextPropertyInfo where
    type AttrAllowedOps CompletionItemTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint CompletionItemTextPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint CompletionItemTextPropertyInfo = IsCompletionItem
    type AttrGetType CompletionItemTextPropertyInfo = (Maybe T.Text)
    type AttrLabel CompletionItemTextPropertyInfo = "text"
    type AttrOrigin CompletionItemTextPropertyInfo = CompletionItem
    attrGet _ = getCompletionItemText
    attrSet _ = setCompletionItemText
    attrConstruct _ = constructCompletionItemText
    attrClear _ = clearCompletionItemText

instance O.HasAttributeList CompletionItem
type instance O.AttributeList CompletionItem = CompletionItemAttributeList
type CompletionItemAttributeList = ('[ '("gicon", CompletionItemGiconPropertyInfo), '("icon", CompletionItemIconPropertyInfo), '("iconName", CompletionItemIconNamePropertyInfo), '("info", CompletionItemInfoPropertyInfo), '("label", CompletionItemLabelPropertyInfo), '("markup", CompletionItemMarkupPropertyInfo), '("text", CompletionItemTextPropertyInfo)] :: [(Symbol, *)])

completionItemGicon :: AttrLabelProxy "gicon"
completionItemGicon = AttrLabelProxy

completionItemIcon :: AttrLabelProxy "icon"
completionItemIcon = AttrLabelProxy

completionItemIconName :: AttrLabelProxy "iconName"
completionItemIconName = AttrLabelProxy

completionItemInfo :: AttrLabelProxy "info"
completionItemInfo = AttrLabelProxy

completionItemLabel :: AttrLabelProxy "label"
completionItemLabel = AttrLabelProxy

completionItemMarkup :: AttrLabelProxy "markup"
completionItemMarkup = AttrLabelProxy

completionItemText :: AttrLabelProxy "text"
completionItemText = AttrLabelProxy

type instance O.SignalList CompletionItem = CompletionItemSignalList
type CompletionItemSignalList = ('[ '("changed", GtkSource.CompletionProposal.CompletionProposalChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method CompletionItem::new
-- method type : Constructor
-- Args : [Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item label.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item text.", 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 "The item icon.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item extra information.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_item_new" gtk_source_completion_item_new :: 
    CString ->                              -- label : TBasicType TUTF8
    CString ->                              -- text : TBasicType TUTF8
    Ptr GdkPixbuf.Pixbuf.Pixbuf ->          -- icon : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})
    CString ->                              -- info : TBasicType TUTF8
    IO (Ptr CompletionItem)

{- |
Create a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem' with label /@label@/, icon /@icon@/ and
extra information /@info@/. Both /@icon@/ and /@info@/ can be 'Nothing' in which case
there will be no icon shown and no extra information available.
-}
completionItemNew ::
    (B.CallStack.HasCallStack, MonadIO m, GdkPixbuf.Pixbuf.IsPixbuf a) =>
    T.Text
    {- ^ /@label@/: The item label. -}
    -> T.Text
    {- ^ /@text@/: The item text. -}
    -> Maybe (a)
    {- ^ /@icon@/: The item icon. -}
    -> Maybe (T.Text)
    {- ^ /@info@/: The item extra information. -}
    -> m CompletionItem
    {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -}
completionItemNew label text icon info = liftIO $ do
    label' <- textToCString label
    text' <- textToCString text
    maybeIcon <- case icon of
        Nothing -> return nullPtr
        Just jIcon -> do
            jIcon' <- unsafeManagedPtrCastPtr jIcon
            return jIcon'
    maybeInfo <- case info of
        Nothing -> return nullPtr
        Just jInfo -> do
            jInfo' <- textToCString jInfo
            return jInfo'
    result <- gtk_source_completion_item_new label' text' maybeIcon maybeInfo
    checkUnexpectedReturnNULL "completionItemNew" result
    result' <- (wrapObject CompletionItem) result
    whenJust icon touchManagedPtr
    freeMem label'
    freeMem text'
    freeMem maybeInfo
    return result'

-- method CompletionItem::new_from_stock
-- method type : Constructor
-- Args : [Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item label.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item text.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stock", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The stock icon.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item extra information.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_item_new_from_stock" gtk_source_completion_item_new_from_stock :: 
    CString ->                              -- label : TBasicType TUTF8
    CString ->                              -- text : TBasicType TUTF8
    CString ->                              -- stock : TBasicType TUTF8
    CString ->                              -- info : TBasicType TUTF8
    IO (Ptr CompletionItem)

{-# DEPRECATED completionItemNewFromStock ["(Since version 3.10)","Use 'GI.GtkSource.Objects.CompletionItem.completionItemNew' instead."] #-}
{- |
Creates a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem' from a stock item. If /@label@/ is 'Nothing',
the stock label will be used.
-}
completionItemNewFromStock ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Maybe (T.Text)
    {- ^ /@label@/: The item label. -}
    -> T.Text
    {- ^ /@text@/: The item text. -}
    -> T.Text
    {- ^ /@stock@/: The stock icon. -}
    -> Maybe (T.Text)
    {- ^ /@info@/: The item extra information. -}
    -> m CompletionItem
    {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -}
completionItemNewFromStock label text stock info = liftIO $ do
    maybeLabel <- case label of
        Nothing -> return nullPtr
        Just jLabel -> do
            jLabel' <- textToCString jLabel
            return jLabel'
    text' <- textToCString text
    stock' <- textToCString stock
    maybeInfo <- case info of
        Nothing -> return nullPtr
        Just jInfo -> do
            jInfo' <- textToCString jInfo
            return jInfo'
    result <- gtk_source_completion_item_new_from_stock maybeLabel text' stock' maybeInfo
    checkUnexpectedReturnNULL "completionItemNewFromStock" result
    result' <- (wrapObject CompletionItem) result
    freeMem maybeLabel
    freeMem text'
    freeMem stock'
    freeMem maybeInfo
    return result'

-- method CompletionItem::new_with_markup
-- method type : Constructor
-- Args : [Arg {argCName = "markup", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item markup label.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The item text.", 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 "The item icon.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The item extra information.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "CompletionItem"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_completion_item_new_with_markup" gtk_source_completion_item_new_with_markup :: 
    CString ->                              -- markup : TBasicType TUTF8
    CString ->                              -- text : TBasicType TUTF8
    Ptr GdkPixbuf.Pixbuf.Pixbuf ->          -- icon : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})
    CString ->                              -- info : TBasicType TUTF8
    IO (Ptr CompletionItem)

{- |
Create a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem' with markup label /@markup@/, icon
/@icon@/ and extra information /@info@/. Both /@icon@/ and /@info@/ can be 'Nothing' in
which case there will be no icon shown and no extra information available.
-}
completionItemNewWithMarkup ::
    (B.CallStack.HasCallStack, MonadIO m, GdkPixbuf.Pixbuf.IsPixbuf a) =>
    T.Text
    {- ^ /@markup@/: The item markup label. -}
    -> T.Text
    {- ^ /@text@/: The item text. -}
    -> Maybe (a)
    {- ^ /@icon@/: The item icon. -}
    -> Maybe (T.Text)
    {- ^ /@info@/: The item extra information. -}
    -> m CompletionItem
    {- ^ __Returns:__ a new 'GI.GtkSource.Objects.CompletionItem.CompletionItem'. -}
completionItemNewWithMarkup markup text icon info = liftIO $ do
    markup' <- textToCString markup
    text' <- textToCString text
    maybeIcon <- case icon of
        Nothing -> return nullPtr
        Just jIcon -> do
            jIcon' <- unsafeManagedPtrCastPtr jIcon
            return jIcon'
    maybeInfo <- case info of
        Nothing -> return nullPtr
        Just jInfo -> do
            jInfo' <- textToCString jInfo
            return jInfo'
    result <- gtk_source_completion_item_new_with_markup markup' text' maybeIcon maybeInfo
    checkUnexpectedReturnNULL "completionItemNewWithMarkup" result
    result' <- (wrapObject CompletionItem) result
    whenJust icon touchManagedPtr
    freeMem markup'
    freeMem text'
    freeMem maybeInfo
    return result'