{- | 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 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 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 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 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: \\ GtkSourceLanguage *lang; lang = gtk_source_language_manager_guess_language (filename, NULL); gtk_source_buffer_set_language (buffer, lang); \<\/programlisting>\<\/informalexample> or \\ 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. \ \ 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