{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GtkSource.Objects.LanguageManager
(
LanguageManager(..) ,
IsLanguageManager ,
toLanguageManager ,
#if defined(ENABLE_OVERLOADING)
ResolveLanguageManagerMethod ,
#endif
languageManagerGetDefault ,
#if defined(ENABLE_OVERLOADING)
LanguageManagerGetLanguageMethodInfo ,
#endif
languageManagerGetLanguage ,
#if defined(ENABLE_OVERLOADING)
LanguageManagerGetLanguageIdsMethodInfo ,
#endif
languageManagerGetLanguageIds ,
#if defined(ENABLE_OVERLOADING)
LanguageManagerGetSearchPathMethodInfo ,
#endif
languageManagerGetSearchPath ,
#if defined(ENABLE_OVERLOADING)
LanguageManagerGuessLanguageMethodInfo ,
#endif
languageManagerGuessLanguage ,
languageManagerNew ,
#if defined(ENABLE_OVERLOADING)
LanguageManagerSetSearchPathMethodInfo ,
#endif
languageManagerSetSearchPath ,
#if defined(ENABLE_OVERLOADING)
LanguageManagerLanguageIdsPropertyInfo ,
#endif
getLanguageManagerLanguageIds ,
#if defined(ENABLE_OVERLOADING)
languageManagerLanguageIds ,
#endif
#if defined(ENABLE_OVERLOADING)
LanguageManagerSearchPathPropertyInfo ,
#endif
clearLanguageManagerSearchPath ,
constructLanguageManagerSearchPath ,
getLanguageManagerSearchPath ,
#if defined(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.BasicTypes as B.Types
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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
newtype LanguageManager = LanguageManager (SP.ManagedPtr LanguageManager)
deriving (LanguageManager -> LanguageManager -> Bool
(LanguageManager -> LanguageManager -> Bool)
-> (LanguageManager -> LanguageManager -> Bool)
-> Eq LanguageManager
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LanguageManager -> LanguageManager -> Bool
$c/= :: LanguageManager -> LanguageManager -> Bool
== :: LanguageManager -> LanguageManager -> Bool
$c== :: LanguageManager -> LanguageManager -> Bool
Eq)
instance SP.ManagedPtrNewtype LanguageManager where
toManagedPtr :: LanguageManager -> ManagedPtr LanguageManager
toManagedPtr (LanguageManager ManagedPtr LanguageManager
p) = ManagedPtr LanguageManager
p
foreign import ccall "gtk_source_language_manager_get_type"
c_gtk_source_language_manager_get_type :: IO B.Types.GType
instance B.Types.TypedObject LanguageManager where
glibType :: IO GType
glibType = IO GType
c_gtk_source_language_manager_get_type
instance B.Types.GObject LanguageManager
instance B.GValue.IsGValue LanguageManager where
toGValue :: LanguageManager -> IO GValue
toGValue LanguageManager
o = do
GType
gtype <- IO GType
c_gtk_source_language_manager_get_type
LanguageManager -> (Ptr LanguageManager -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr LanguageManager
o (GType
-> (GValue -> Ptr LanguageManager -> IO ())
-> Ptr LanguageManager
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr LanguageManager -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO LanguageManager
fromGValue GValue
gv = do
Ptr LanguageManager
ptr <- GValue -> IO (Ptr LanguageManager)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr LanguageManager)
(ManagedPtr LanguageManager -> LanguageManager)
-> Ptr LanguageManager -> IO LanguageManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr LanguageManager -> LanguageManager
LanguageManager Ptr LanguageManager
ptr
class (SP.GObject o, O.IsDescendantOf LanguageManager o) => IsLanguageManager o
instance (SP.GObject o, O.IsDescendantOf LanguageManager o) => IsLanguageManager o
instance O.HasParentTypes LanguageManager
type instance O.ParentTypes LanguageManager = '[GObject.Object.Object]
toLanguageManager :: (MonadIO m, IsLanguageManager o) => o -> m LanguageManager
toLanguageManager :: o -> m LanguageManager
toLanguageManager = IO LanguageManager -> m LanguageManager
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LanguageManager -> m LanguageManager)
-> (o -> IO LanguageManager) -> o -> m LanguageManager
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr LanguageManager -> LanguageManager)
-> o -> IO LanguageManager
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr LanguageManager -> LanguageManager
LanguageManager
#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
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 @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
getLanguageManagerLanguageIds :: (MonadIO m, IsLanguageManager o) => o -> m (Maybe [T.Text])
getLanguageManagerLanguageIds :: o -> m (Maybe [Text])
getLanguageManagerLanguageIds o
obj = IO (Maybe [Text]) -> m (Maybe [Text])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [Text]) -> m (Maybe [Text]))
-> IO (Maybe [Text]) -> m (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe [Text])
forall a. GObject a => a -> String -> IO (Maybe [Text])
B.Properties.getObjectPropertyStringArray o
obj String
"language-ids"
#if defined(ENABLE_OVERLOADING)
data LanguageManagerLanguageIdsPropertyInfo
instance AttrInfo LanguageManagerLanguageIdsPropertyInfo where
type AttrAllowedOps LanguageManagerLanguageIdsPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint LanguageManagerLanguageIdsPropertyInfo = IsLanguageManager
type AttrSetTypeConstraint LanguageManagerLanguageIdsPropertyInfo = (~) ()
type AttrTransferTypeConstraint LanguageManagerLanguageIdsPropertyInfo = (~) ()
type AttrTransferType LanguageManagerLanguageIdsPropertyInfo = ()
type AttrGetType LanguageManagerLanguageIdsPropertyInfo = (Maybe [T.Text])
type AttrLabel LanguageManagerLanguageIdsPropertyInfo = "language-ids"
type AttrOrigin LanguageManagerLanguageIdsPropertyInfo = LanguageManager
attrGet = getLanguageManagerLanguageIds
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
#endif
getLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> m [T.Text]
getLanguageManagerSearchPath :: o -> m [Text]
getLanguageManagerSearchPath o
obj = IO [Text] -> m [Text]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe [Text]) -> IO [Text]
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getLanguageManagerSearchPath" (IO (Maybe [Text]) -> IO [Text]) -> IO (Maybe [Text]) -> IO [Text]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe [Text])
forall a. GObject a => a -> String -> IO (Maybe [Text])
B.Properties.getObjectPropertyStringArray o
obj String
"search-path"
setLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> [T.Text] -> m ()
setLanguageManagerSearchPath :: o -> [Text] -> m ()
setLanguageManagerSearchPath o
obj [Text]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe [Text] -> IO ()
forall a. GObject a => a -> String -> Maybe [Text] -> IO ()
B.Properties.setObjectPropertyStringArray o
obj String
"search-path" ([Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
val)
constructLanguageManagerSearchPath :: (IsLanguageManager o, MIO.MonadIO m) => [T.Text] -> m (GValueConstruct o)
constructLanguageManagerSearchPath :: [Text] -> m (GValueConstruct o)
constructLanguageManagerSearchPath [Text]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe [Text] -> IO (GValueConstruct o)
forall o. String -> Maybe [Text] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyStringArray String
"search-path" ([Text] -> Maybe [Text]
forall a. a -> Maybe a
P.Just [Text]
val)
clearLanguageManagerSearchPath :: (MonadIO m, IsLanguageManager o) => o -> m ()
clearLanguageManagerSearchPath :: o -> m ()
clearLanguageManagerSearchPath o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe [Text] -> IO ()
forall a. GObject a => a -> String -> Maybe [Text] -> IO ()
B.Properties.setObjectPropertyStringArray o
obj String
"search-path" (Maybe [Text]
forall a. Maybe a
Nothing :: Maybe [T.Text])
#if defined(ENABLE_OVERLOADING)
data LanguageManagerSearchPathPropertyInfo
instance AttrInfo LanguageManagerSearchPathPropertyInfo where
type AttrAllowedOps LanguageManagerSearchPathPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint LanguageManagerSearchPathPropertyInfo = IsLanguageManager
type AttrSetTypeConstraint LanguageManagerSearchPathPropertyInfo = (~) [T.Text]
type AttrTransferTypeConstraint LanguageManagerSearchPathPropertyInfo = (~) [T.Text]
type AttrTransferType LanguageManagerSearchPathPropertyInfo = [T.Text]
type AttrGetType LanguageManagerSearchPathPropertyInfo = [T.Text]
type AttrLabel LanguageManagerSearchPathPropertyInfo = "search-path"
type AttrOrigin LanguageManagerSearchPathPropertyInfo = LanguageManager
attrGet = getLanguageManagerSearchPath
attrSet = setLanguageManagerSearchPath
attrTransfer _ v = do
return v
attrConstruct = constructLanguageManagerSearchPath
attrClear = clearLanguageManagerSearchPath
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList LanguageManager
type instance O.AttributeList LanguageManager = LanguageManagerAttributeList
type LanguageManagerAttributeList = ('[ '("languageIds", LanguageManagerLanguageIdsPropertyInfo), '("searchPath", LanguageManagerSearchPathPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
languageManagerLanguageIds :: AttrLabelProxy "languageIds"
languageManagerLanguageIds = AttrLabelProxy
languageManagerSearchPath :: AttrLabelProxy "searchPath"
languageManagerSearchPath = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList LanguageManager = LanguageManagerSignalList
type LanguageManagerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gtk_source_language_manager_new" gtk_source_language_manager_new ::
IO (Ptr LanguageManager)
languageManagerNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m LanguageManager
languageManagerNew :: m LanguageManager
languageManagerNew = IO LanguageManager -> m LanguageManager
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LanguageManager -> m LanguageManager)
-> IO LanguageManager -> m LanguageManager
forall a b. (a -> b) -> a -> b
$ do
Ptr LanguageManager
result <- IO (Ptr LanguageManager)
gtk_source_language_manager_new
Text -> Ptr LanguageManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"languageManagerNew" Ptr LanguageManager
result
LanguageManager
result' <- ((ManagedPtr LanguageManager -> LanguageManager)
-> Ptr LanguageManager -> IO LanguageManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr LanguageManager -> LanguageManager
LanguageManager) Ptr LanguageManager
result
LanguageManager -> IO LanguageManager
forall (m :: * -> *) a. Monad m => a -> m a
return LanguageManager
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gtk_source_language_manager_get_language" gtk_source_language_manager_get_language ::
Ptr LanguageManager ->
CString ->
IO (Ptr GtkSource.Language.Language)
languageManagerGetLanguage ::
(B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
a
-> T.Text
-> m (Maybe GtkSource.Language.Language)
languageManagerGetLanguage :: a -> Text -> m (Maybe Language)
languageManagerGetLanguage a
lm Text
id = IO (Maybe Language) -> m (Maybe Language)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Language) -> m (Maybe Language))
-> IO (Maybe Language) -> m (Maybe Language)
forall a b. (a -> b) -> a -> b
$ do
Ptr LanguageManager
lm' <- a -> IO (Ptr LanguageManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
lm
CString
id' <- Text -> IO CString
textToCString Text
id
Ptr Language
result <- Ptr LanguageManager -> CString -> IO (Ptr Language)
gtk_source_language_manager_get_language Ptr LanguageManager
lm' CString
id'
Maybe Language
maybeResult <- Ptr Language
-> (Ptr Language -> IO Language) -> IO (Maybe Language)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Language
result ((Ptr Language -> IO Language) -> IO (Maybe Language))
-> (Ptr Language -> IO Language) -> IO (Maybe Language)
forall a b. (a -> b) -> a -> b
$ \Ptr Language
result' -> do
Language
result'' <- ((ManagedPtr Language -> Language) -> Ptr Language -> IO Language
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Language -> Language
GtkSource.Language.Language) Ptr Language
result'
Language -> IO Language
forall (m :: * -> *) a. Monad m => a -> m a
return Language
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
lm
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
id'
Maybe Language -> IO (Maybe Language)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Language
maybeResult
#if defined(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
foreign import ccall "gtk_source_language_manager_get_language_ids" gtk_source_language_manager_get_language_ids ::
Ptr LanguageManager ->
IO (Ptr CString)
languageManagerGetLanguageIds ::
(B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
a
-> m (Maybe [T.Text])
languageManagerGetLanguageIds :: a -> m (Maybe [Text])
languageManagerGetLanguageIds a
lm = IO (Maybe [Text]) -> m (Maybe [Text])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [Text]) -> m (Maybe [Text]))
-> IO (Maybe [Text]) -> m (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ do
Ptr LanguageManager
lm' <- a -> IO (Ptr LanguageManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
lm
Ptr CString
result <- Ptr LanguageManager -> IO (Ptr CString)
gtk_source_language_manager_get_language_ids Ptr LanguageManager
lm'
Maybe [Text]
maybeResult <- Ptr CString -> (Ptr CString -> IO [Text]) -> IO (Maybe [Text])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CString
result ((Ptr CString -> IO [Text]) -> IO (Maybe [Text]))
-> (Ptr CString -> IO [Text]) -> IO (Maybe [Text])
forall a b. (a -> b) -> a -> b
$ \Ptr CString
result' -> do
[Text]
result'' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result'
[Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
lm
Maybe [Text] -> IO (Maybe [Text])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeResult
#if defined(ENABLE_OVERLOADING)
data LanguageManagerGetLanguageIdsMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGetLanguageIdsMethodInfo a signature where
overloadedMethod = languageManagerGetLanguageIds
#endif
foreign import ccall "gtk_source_language_manager_get_search_path" gtk_source_language_manager_get_search_path ::
Ptr LanguageManager ->
IO (Ptr CString)
languageManagerGetSearchPath ::
(B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
a
-> m [T.Text]
languageManagerGetSearchPath :: a -> m [Text]
languageManagerGetSearchPath a
lm = IO [Text] -> m [Text]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
Ptr LanguageManager
lm' <- a -> IO (Ptr LanguageManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
lm
Ptr CString
result <- Ptr LanguageManager -> IO (Ptr CString)
gtk_source_language_manager_get_search_path Ptr LanguageManager
lm'
Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"languageManagerGetSearchPath" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
lm
[Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
#if defined(ENABLE_OVERLOADING)
data LanguageManagerGetSearchPathMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerGetSearchPathMethodInfo a signature where
overloadedMethod = languageManagerGetSearchPath
#endif
foreign import ccall "gtk_source_language_manager_guess_language" gtk_source_language_manager_guess_language ::
Ptr LanguageManager ->
CString ->
CString ->
IO (Ptr GtkSource.Language.Language)
languageManagerGuessLanguage ::
(B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
a
-> Maybe (T.Text)
-> Maybe (T.Text)
-> m (Maybe GtkSource.Language.Language)
languageManagerGuessLanguage :: a -> Maybe Text -> Maybe Text -> m (Maybe Language)
languageManagerGuessLanguage a
lm Maybe Text
filename Maybe Text
contentType = IO (Maybe Language) -> m (Maybe Language)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Language) -> m (Maybe Language))
-> IO (Maybe Language) -> m (Maybe Language)
forall a b. (a -> b) -> a -> b
$ do
Ptr LanguageManager
lm' <- a -> IO (Ptr LanguageManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
lm
CString
maybeFilename <- case Maybe Text
filename of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jFilename -> do
CString
jFilename' <- Text -> IO CString
textToCString Text
jFilename
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFilename'
CString
maybeContentType <- case Maybe Text
contentType of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jContentType -> do
CString
jContentType' <- Text -> IO CString
textToCString Text
jContentType
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jContentType'
Ptr Language
result <- Ptr LanguageManager -> CString -> CString -> IO (Ptr Language)
gtk_source_language_manager_guess_language Ptr LanguageManager
lm' CString
maybeFilename CString
maybeContentType
Maybe Language
maybeResult <- Ptr Language
-> (Ptr Language -> IO Language) -> IO (Maybe Language)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Language
result ((Ptr Language -> IO Language) -> IO (Maybe Language))
-> (Ptr Language -> IO Language) -> IO (Maybe Language)
forall a b. (a -> b) -> a -> b
$ \Ptr Language
result' -> do
Language
result'' <- ((ManagedPtr Language -> Language) -> Ptr Language -> IO Language
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Language -> Language
GtkSource.Language.Language) Ptr Language
result'
Language -> IO Language
forall (m :: * -> *) a. Monad m => a -> m a
return Language
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
lm
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFilename
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeContentType
Maybe Language -> IO (Maybe Language)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Language
maybeResult
#if defined(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
foreign import ccall "gtk_source_language_manager_set_search_path" gtk_source_language_manager_set_search_path ::
Ptr LanguageManager ->
Ptr CString ->
IO ()
languageManagerSetSearchPath ::
(B.CallStack.HasCallStack, MonadIO m, IsLanguageManager a) =>
a
-> Maybe ([T.Text])
-> m ()
languageManagerSetSearchPath :: a -> Maybe [Text] -> m ()
languageManagerSetSearchPath a
lm Maybe [Text]
dirs = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr LanguageManager
lm' <- a -> IO (Ptr LanguageManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
lm
Ptr CString
maybeDirs <- case Maybe [Text]
dirs of
Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
Just [Text]
jDirs -> do
Ptr CString
jDirs' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jDirs
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jDirs'
Ptr LanguageManager -> Ptr CString -> IO ()
gtk_source_language_manager_set_search_path Ptr LanguageManager
lm' Ptr CString
maybeDirs
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
lm
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeDirs
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeDirs
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data LanguageManagerSetSearchPathMethodInfo
instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsLanguageManager a) => O.MethodInfo LanguageManagerSetSearchPathMethodInfo a signature where
overloadedMethod = languageManagerSetSearchPath
#endif
foreign import ccall "gtk_source_language_manager_get_default" gtk_source_language_manager_get_default ::
IO (Ptr LanguageManager)
languageManagerGetDefault ::
(B.CallStack.HasCallStack, MonadIO m) =>
m LanguageManager
languageManagerGetDefault :: m LanguageManager
languageManagerGetDefault = IO LanguageManager -> m LanguageManager
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LanguageManager -> m LanguageManager)
-> IO LanguageManager -> m LanguageManager
forall a b. (a -> b) -> a -> b
$ do
Ptr LanguageManager
result <- IO (Ptr LanguageManager)
gtk_source_language_manager_get_default
Text -> Ptr LanguageManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"languageManagerGetDefault" Ptr LanguageManager
result
LanguageManager
result' <- ((ManagedPtr LanguageManager -> LanguageManager)
-> Ptr LanguageManager -> IO LanguageManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr LanguageManager -> LanguageManager
LanguageManager) Ptr LanguageManager
result
LanguageManager -> IO LanguageManager
forall (m :: * -> *) a. Monad m => a -> m a
return LanguageManager
result'
#if defined(ENABLE_OVERLOADING)
#endif