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

-- * Exported types
    LanguageManager(..)                     ,
    IsLanguageManager                       ,
    toLanguageManager                       ,
    noLanguageManager                       ,


 -- * Methods
-- ** getDefault #method:getDefault#
    languageManagerGetDefault               ,


-- ** getLanguage #method:getLanguage#
    LanguageManagerGetLanguageMethodInfo    ,
    languageManagerGetLanguage              ,


-- ** getLanguageIds #method:getLanguageIds#
    LanguageManagerGetLanguageIdsMethodInfo ,
    languageManagerGetLanguageIds           ,


-- ** getSearchPath #method:getSearchPath#
    LanguageManagerGetSearchPathMethodInfo  ,
    languageManagerGetSearchPath            ,


-- ** guessLanguage #method:guessLanguage#
    LanguageManagerGuessLanguageMethodInfo  ,
    languageManagerGuessLanguage            ,


-- ** new #method:new#
    languageManagerNew                      ,


-- ** setSearchPath #method:setSearchPath#
    LanguageManagerSetSearchPathMethodInfo  ,
    languageManagerSetSearchPath            ,




 -- * Properties
-- ** languageIds #attr:languageIds#
    LanguageManagerLanguageIdsPropertyInfo  ,
    getLanguageManagerLanguageIds           ,
    languageManagerLanguageIds              ,


-- ** searchPath #attr:searchPath#
    LanguageManagerSearchPathPropertyInfo   ,
    clearLanguageManagerSearchPath          ,
    constructLanguageManagerSearchPath      ,
    getLanguageManagerSearchPath            ,
    languageManagerSearchPath               ,
    setLanguageManagerSearchPath            ,




    ) 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 {-# SOURCE #-} qualified GI.GtkSource.Objects.Language as GtkSource.Language

newtype LanguageManager = LanguageManager (ManagedPtr LanguageManager)
foreign import ccall "gtk_source_language_manager_get_type"
    c_gtk_source_language_manager_get_type :: IO GType

instance GObject LanguageManager where
    gobjectType _ = c_gtk_source_language_manager_get_type
    

class GObject o => IsLanguageManager o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError LanguageManager a) =>
    IsLanguageManager a
#endif
instance IsLanguageManager LanguageManager
instance GObject.Object.IsObject LanguageManager

toLanguageManager :: IsLanguageManager o => o -> IO LanguageManager
toLanguageManager = unsafeCastTo LanguageManager

noLanguageManager :: Maybe LanguageManager
noLanguageManager = Nothing

type family ResolveLanguageManagerMethod (t :: Symbol) (o :: *) :: * where
    ResolveLanguageManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveLanguageManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveLanguageManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveLanguageManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveLanguageManagerMethod "guessLanguage" o = LanguageManagerGuessLanguageMethodInfo
    ResolveLanguageManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveLanguageManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveLanguageManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveLanguageManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveLanguageManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveLanguageManagerMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveLanguageManagerMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveLanguageManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveLanguageManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveLanguageManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveLanguageManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveLanguageManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveLanguageManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveLanguageManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveLanguageManagerMethod "getLanguage" o = LanguageManagerGetLanguageMethodInfo
    ResolveLanguageManagerMethod "getLanguageIds" o = LanguageManagerGetLanguageIdsMethodInfo
    ResolveLanguageManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveLanguageManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveLanguageManagerMethod "getSearchPath" o = LanguageManagerGetSearchPathMethodInfo
    ResolveLanguageManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveLanguageManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveLanguageManagerMethod "setSearchPath" o = LanguageManagerSetSearchPathMethodInfo
    ResolveLanguageManagerMethod l o = O.MethodResolutionFailed l o

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

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

-- VVV Prop "language-ids"
   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

getLanguageManagerLanguageIds :: (MonadIO m, IsLanguageManager o) => o -> m (Maybe [T.Text])
getLanguageManagerLanguageIds obj = liftIO $ getObjectPropertyStringArray obj "language-ids"

data LanguageManagerLanguageIdsPropertyInfo
instance AttrInfo LanguageManagerLanguageIdsPropertyInfo where
    type AttrAllowedOps LanguageManagerLanguageIdsPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint LanguageManagerLanguageIdsPropertyInfo = (~) ()
    type AttrBaseTypeConstraint LanguageManagerLanguageIdsPropertyInfo = IsLanguageManager
    type AttrGetType LanguageManagerLanguageIdsPropertyInfo = (Maybe [T.Text])
    type AttrLabel LanguageManagerLanguageIdsPropertyInfo = "language-ids"
    type AttrOrigin LanguageManagerLanguageIdsPropertyInfo = LanguageManager
    attrGet _ = getLanguageManagerLanguageIds
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "search-path"
   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just True)

getLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> m [T.Text]
getLanguageManagerSearchPath obj = liftIO $ checkUnexpectedNothing "getLanguageManagerSearchPath" $ getObjectPropertyStringArray obj "search-path"

setLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> [T.Text] -> m ()
setLanguageManagerSearchPath obj val = liftIO $ setObjectPropertyStringArray obj "search-path" (Just val)

constructLanguageManagerSearchPath :: (IsLanguageManager o) => [T.Text] -> IO (GValueConstruct o)
constructLanguageManagerSearchPath val = constructObjectPropertyStringArray "search-path" (Just val)

clearLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> m ()
clearLanguageManagerSearchPath obj = liftIO $ setObjectPropertyStringArray obj "search-path" (Nothing :: Maybe [T.Text])

data LanguageManagerSearchPathPropertyInfo
instance AttrInfo LanguageManagerSearchPathPropertyInfo where
    type AttrAllowedOps LanguageManagerSearchPathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint LanguageManagerSearchPathPropertyInfo = (~) [T.Text]
    type AttrBaseTypeConstraint LanguageManagerSearchPathPropertyInfo = IsLanguageManager
    type AttrGetType LanguageManagerSearchPathPropertyInfo = [T.Text]
    type AttrLabel LanguageManagerSearchPathPropertyInfo = "search-path"
    type AttrOrigin LanguageManagerSearchPathPropertyInfo = LanguageManager
    attrGet _ = getLanguageManagerSearchPath
    attrSet _ = setLanguageManagerSearchPath
    attrConstruct _ = constructLanguageManagerSearchPath
    attrClear _ = clearLanguageManagerSearchPath

instance O.HasAttributeList LanguageManager
type instance O.AttributeList LanguageManager = LanguageManagerAttributeList
type LanguageManagerAttributeList = ('[ '("languageIds", LanguageManagerLanguageIdsPropertyInfo), '("searchPath", LanguageManagerSearchPathPropertyInfo)] :: [(Symbol, *)])

languageManagerLanguageIds :: AttrLabelProxy "languageIds"
languageManagerLanguageIds = AttrLabelProxy

languageManagerSearchPath :: AttrLabelProxy "searchPath"
languageManagerSearchPath = AttrLabelProxy

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

-- method LanguageManager::new
-- method type : Constructor
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_language_manager_new" gtk_source_language_manager_new :: 
    IO (Ptr LanguageManager)

{- |
Creates a new language manager. If you do not need more than one language
manager or a private language manager instance then use
'GI.GtkSource.Objects.LanguageManager.languageManagerGetDefault' instead.
-}
languageManagerNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m LanguageManager
    {- ^ __Returns:__ a new 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -}
languageManagerNew  = liftIO $ do
    result <- gtk_source_language_manager_new
    checkUnexpectedReturnNULL "languageManagerNew" result
    result' <- (wrapObject LanguageManager) result
    return result'

-- method LanguageManager::get_language
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a language id.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Language"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_language_manager_get_language" gtk_source_language_manager_get_language :: 
    Ptr LanguageManager ->                  -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"})
    CString ->                              -- id : TBasicType TUTF8
    IO (Ptr GtkSource.Language.Language)

{- |
Gets the 'GI.GtkSource.Objects.Language.Language' identified by the given /@id@/ in the language
manager.
-}
languageManagerGetLanguage ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
    a
    {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -}
    -> T.Text
    {- ^ /@id@/: a language id. -}
    -> m (Maybe GtkSource.Language.Language)
    {- ^ __Returns:__ a 'GI.GtkSource.Objects.Language.Language', or 'Nothing'
if there is no language identified by the given /@id@/. Return value is
owned by /@lm@/ and should not be freed. -}
languageManagerGetLanguage lm id = liftIO $ do
    lm' <- unsafeManagedPtrCastPtr lm
    id' <- textToCString id
    result <- gtk_source_language_manager_get_language lm' id'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject GtkSource.Language.Language) result'
        return result''
    touchManagedPtr lm
    freeMem id'
    return maybeResult

data LanguageManagerGetLanguageMethodInfo
instance (signature ~ (T.Text -> m (Maybe GtkSource.Language.Language)), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGetLanguageMethodInfo a signature where
    overloadedMethod _ = languageManagerGetLanguage

-- method LanguageManager::get_language_ids
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_language_manager_get_language_ids" gtk_source_language_manager_get_language_ids :: 
    Ptr LanguageManager ->                  -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"})
    IO (Ptr CString)

{- |
Returns the ids of the available languages.
-}
languageManagerGetLanguageIds ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
    a
    {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -}
    -> m (Maybe [T.Text])
    {- ^ __Returns:__ 
a 'Nothing'-terminated array of strings containing the ids of the available
languages or 'Nothing' if no language is available.
The array is sorted alphabetically according to the language name.
The array is owned by /@lm@/ and must not be modified. -}
languageManagerGetLanguageIds lm = liftIO $ do
    lm' <- unsafeManagedPtrCastPtr lm
    result <- gtk_source_language_manager_get_language_ids lm'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- unpackZeroTerminatedUTF8CArray result'
        return result''
    touchManagedPtr lm
    return maybeResult

data LanguageManagerGetLanguageIdsMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGetLanguageIdsMethodInfo a signature where
    overloadedMethod _ = languageManagerGetLanguageIds

-- method LanguageManager::get_search_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_language_manager_get_search_path" gtk_source_language_manager_get_search_path :: 
    Ptr LanguageManager ->                  -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"})
    IO (Ptr CString)

{- |
Gets the list directories where /@lm@/ looks for language files.
-}
languageManagerGetSearchPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
    a
    {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -}
    -> m [T.Text]
    {- ^ __Returns:__ 'Nothing'-terminated array
containg a list of language files directories.
The array is owned by /@lm@/ and must not be modified. -}
languageManagerGetSearchPath lm = liftIO $ do
    lm' <- unsafeManagedPtrCastPtr lm
    result <- gtk_source_language_manager_get_search_path lm'
    checkUnexpectedReturnNULL "languageManagerGetSearchPath" result
    result' <- unpackZeroTerminatedUTF8CArray result
    touchManagedPtr lm
    return result'

data LanguageManagerGetSearchPathMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGetSearchPathMethodInfo a signature where
    overloadedMethod _ = languageManagerGetSearchPath

-- method LanguageManager::guess_language
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a filename in Glib filename encoding, or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "content_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a content type (as in GIO API), or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "Language"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_language_manager_guess_language" gtk_source_language_manager_guess_language :: 
    Ptr LanguageManager ->                  -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"})
    CString ->                              -- filename : TBasicType TUTF8
    CString ->                              -- content_type : TBasicType TUTF8
    IO (Ptr GtkSource.Language.Language)

{- |
Picks a 'GI.GtkSource.Objects.Language.Language' for given file name and content type,
according to the information in lang files. Either /@filename@/ or
/@contentType@/ may be 'Nothing'. This function can be used as follows:

\<informalexample>\<programlisting>
  GtkSourceLanguage *lang;
  lang = gtk_source_language_manager_guess_language (filename, NULL);
  gtk_source_buffer_set_language (buffer, lang);
\<\/programlisting>\<\/informalexample>

or

\<informalexample>\<programlisting>
  GtkSourceLanguage *lang = NULL;
  gboolean result_uncertain;
  gchar *content_type;

  content_type = g_content_type_guess (filename, NULL, 0, &result_uncertain);
  if (result_uncertain)
    {
      g_free (content_type);
      content_type = NULL;
    }

  lang = gtk_source_language_manager_guess_language (manager, filename, content_type);
  gtk_source_buffer_set_language (buffer, lang);

  g_free (content_type);
\<\/programlisting>\<\/informalexample>

etc. Use 'GI.GtkSource.Objects.Language.languageGetMimeTypes' and 'GI.GtkSource.Objects.Language.languageGetGlobs'
if you need full control over file -> language mapping.

@since 2.4
-}
languageManagerGuessLanguage ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
    a
    {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -}
    -> Maybe (T.Text)
    {- ^ /@filename@/: a filename in Glib filename encoding, or 'Nothing'. -}
    -> Maybe (T.Text)
    {- ^ /@contentType@/: a content type (as in GIO API), or 'Nothing'. -}
    -> m (Maybe GtkSource.Language.Language)
    {- ^ __Returns:__ a 'GI.GtkSource.Objects.Language.Language', or 'Nothing' if there
is no suitable language for given /@filename@/ and\/or /@contentType@/. Return
value is owned by /@lm@/ and should not be freed. -}
languageManagerGuessLanguage lm filename contentType = liftIO $ do
    lm' <- unsafeManagedPtrCastPtr lm
    maybeFilename <- case filename of
        Nothing -> return nullPtr
        Just jFilename -> do
            jFilename' <- textToCString jFilename
            return jFilename'
    maybeContentType <- case contentType of
        Nothing -> return nullPtr
        Just jContentType -> do
            jContentType' <- textToCString jContentType
            return jContentType'
    result <- gtk_source_language_manager_guess_language lm' maybeFilename maybeContentType
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (newObject GtkSource.Language.Language) result'
        return result''
    touchManagedPtr lm
    freeMem maybeFilename
    freeMem maybeContentType
    return maybeResult

data LanguageManagerGuessLanguageMethodInfo
instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> m (Maybe GtkSource.Language.Language)), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGuessLanguageMethodInfo a signature where
    overloadedMethod _ = languageManagerGuessLanguage

-- method LanguageManager::set_search_path
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "lm", argType = TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkSourceLanguageManager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dirs", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\na %NULL-terminated array of strings or %NULL.", 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_language_manager_set_search_path" gtk_source_language_manager_set_search_path :: 
    Ptr LanguageManager ->                  -- lm : TInterface (Name {namespace = "GtkSource", name = "LanguageManager"})
    Ptr CString ->                          -- dirs : TCArray True (-1) (-1) (TBasicType TUTF8)
    IO ()

{- |
Sets the list of directories where the /@lm@/ looks for
language files.
If /@dirs@/ is 'Nothing', the search path is reset to default.

\<note>
  \<para>
    At the moment this function can be called only before the
    language files are loaded for the first time. In practice
    to set a custom search path for a 'GI.GtkSource.Objects.LanguageManager.LanguageManager',
    you have to call this function right after creating it.
  \<\/para>
\<\/note>
-}
languageManagerSetSearchPath ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
    a
    {- ^ /@lm@/: a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'. -}
    -> Maybe ([T.Text])
    {- ^ /@dirs@/: 
a 'Nothing'-terminated array of strings or 'Nothing'. -}
    -> m ()
languageManagerSetSearchPath lm dirs = liftIO $ do
    lm' <- unsafeManagedPtrCastPtr lm
    maybeDirs <- case dirs of
        Nothing -> return nullPtr
        Just jDirs -> do
            jDirs' <- packZeroTerminatedUTF8CArray jDirs
            return jDirs'
    gtk_source_language_manager_set_search_path lm' maybeDirs
    touchManagedPtr lm
    mapZeroTerminatedCArray freeMem maybeDirs
    freeMem maybeDirs
    return ()

data LanguageManagerSetSearchPathMethodInfo
instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerSetSearchPathMethodInfo a signature where
    overloadedMethod _ = languageManagerSetSearchPath

-- method LanguageManager::get_default
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GtkSource", name = "LanguageManager"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_language_manager_get_default" gtk_source_language_manager_get_default :: 
    IO (Ptr LanguageManager)

{- |
Returns the default 'GI.GtkSource.Objects.LanguageManager.LanguageManager' instance.
-}
languageManagerGetDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m LanguageManager
    {- ^ __Returns:__ a 'GI.GtkSource.Objects.LanguageManager.LanguageManager'.
Return value is owned by GtkSourceView library and must not be unref\'ed. -}
languageManagerGetDefault  = liftIO $ do
    result <- gtk_source_language_manager_get_default
    checkUnexpectedReturnNULL "languageManagerGetDefault" result
    result' <- (newObject LanguageManager) result
    return result'