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

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


 -- * Methods
-- ** getDefault #method:getDefault#

    languageManagerGetDefault               ,


-- ** getLanguage #method:getLanguage#

#if ENABLE_OVERLOADING
    LanguageManagerGetLanguageMethodInfo    ,
#endif
    languageManagerGetLanguage              ,


-- ** getLanguageIds #method:getLanguageIds#

#if ENABLE_OVERLOADING
    LanguageManagerGetLanguageIdsMethodInfo ,
#endif
    languageManagerGetLanguageIds           ,


-- ** getSearchPath #method:getSearchPath#

#if ENABLE_OVERLOADING
    LanguageManagerGetSearchPathMethodInfo  ,
#endif
    languageManagerGetSearchPath            ,


-- ** guessLanguage #method:guessLanguage#

#if ENABLE_OVERLOADING
    LanguageManagerGuessLanguageMethodInfo  ,
#endif
    languageManagerGuessLanguage            ,


-- ** new #method:new#

    languageManagerNew                      ,


-- ** setSearchPath #method:setSearchPath#

#if ENABLE_OVERLOADING
    LanguageManagerSetSearchPathMethodInfo  ,
#endif
    languageManagerSetSearchPath            ,




 -- * Properties
-- ** languageIds #attr:languageIds#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    LanguageManagerLanguageIdsPropertyInfo  ,
#endif
    getLanguageManagerLanguageIds           ,
#if ENABLE_OVERLOADING
    languageManagerLanguageIds              ,
#endif


-- ** searchPath #attr:searchPath#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
    LanguageManagerSearchPathPropertyInfo   ,
#endif
    clearLanguageManagerSearchPath          ,
    constructLanguageManagerSearchPath      ,
    getLanguageManagerSearchPath            ,
#if ENABLE_OVERLOADING
    languageManagerSearchPath               ,
#endif
    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.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 {-# SOURCE #-} qualified GI.GtkSource.Objects.Language as GtkSource.Language

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

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

instance O.HasParentTypes LanguageManager
type instance O.ParentTypes LanguageManager = '[GObject.Object.Object]

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

-- | A convenience alias for `Nothing` :: `Maybe` `LanguageManager`.
noLanguageManager :: Maybe LanguageManager
noLanguageManager = Nothing

#if ENABLE_OVERLOADING
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 "getv" o = GObject.Object.ObjectGetvMethodInfo
    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 "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) => OL.IsLabel t (LanguageManager -> 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 "language-ids"
   -- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

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

@
'Data.GI.Base.Attributes.get' languageManager #languageIds
@
-}
getLanguageManagerLanguageIds :: (MonadIO m, IsLanguageManager o) => o -> m (Maybe [T.Text])
getLanguageManagerLanguageIds obj = liftIO $ B.Properties.getObjectPropertyStringArray obj "language-ids"

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

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

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

@
'Data.GI.Base.Attributes.get' languageManager #searchPath
@
-}
getLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> m [T.Text]
getLanguageManagerSearchPath obj = liftIO $ checkUnexpectedNothing "getLanguageManagerSearchPath" $ B.Properties.getObjectPropertyStringArray obj "search-path"

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

@
'Data.GI.Base.Attributes.set' languageManager [ #searchPath 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> [T.Text] -> m ()
setLanguageManagerSearchPath obj val = liftIO $ B.Properties.setObjectPropertyStringArray obj "search-path" (Just val)

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

{- |
Set the value of the “@search-path@” 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' #searchPath
@
-}
clearLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> m ()
clearLanguageManagerSearchPath obj = liftIO $ B.Properties.setObjectPropertyStringArray obj "search-path" (Nothing :: Maybe [T.Text])

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

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

#if ENABLE_OVERLOADING
languageManagerLanguageIds :: AttrLabelProxy "languageIds"
languageManagerLanguageIds = AttrLabelProxy

languageManagerSearchPath :: AttrLabelProxy "searchPath"
languageManagerSearchPath = AttrLabelProxy

#endif

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

#endif

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

#if ENABLE_OVERLOADING
#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

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

#endif

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

#if ENABLE_OVERLOADING
#endif