{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GtkSource.Objects.Language
    ( 

-- * Exported types
    Language(..)                            ,
    IsLanguage                              ,
    toLanguage                              ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveLanguageMethod                   ,
#endif


-- ** getGlobs #method:getGlobs#

#if defined(ENABLE_OVERLOADING)
    LanguageGetGlobsMethodInfo              ,
#endif
    languageGetGlobs                        ,


-- ** getHidden #method:getHidden#

#if defined(ENABLE_OVERLOADING)
    LanguageGetHiddenMethodInfo             ,
#endif
    languageGetHidden                       ,


-- ** getId #method:getId#

#if defined(ENABLE_OVERLOADING)
    LanguageGetIdMethodInfo                 ,
#endif
    languageGetId                           ,


-- ** getMetadata #method:getMetadata#

#if defined(ENABLE_OVERLOADING)
    LanguageGetMetadataMethodInfo           ,
#endif
    languageGetMetadata                     ,


-- ** getMimeTypes #method:getMimeTypes#

#if defined(ENABLE_OVERLOADING)
    LanguageGetMimeTypesMethodInfo          ,
#endif
    languageGetMimeTypes                    ,


-- ** getName #method:getName#

#if defined(ENABLE_OVERLOADING)
    LanguageGetNameMethodInfo               ,
#endif
    languageGetName                         ,


-- ** getSection #method:getSection#

#if defined(ENABLE_OVERLOADING)
    LanguageGetSectionMethodInfo            ,
#endif
    languageGetSection                      ,


-- ** getStyleFallback #method:getStyleFallback#

#if defined(ENABLE_OVERLOADING)
    LanguageGetStyleFallbackMethodInfo      ,
#endif
    languageGetStyleFallback                ,


-- ** getStyleIds #method:getStyleIds#

#if defined(ENABLE_OVERLOADING)
    LanguageGetStyleIdsMethodInfo           ,
#endif
    languageGetStyleIds                     ,


-- ** getStyleName #method:getStyleName#

#if defined(ENABLE_OVERLOADING)
    LanguageGetStyleNameMethodInfo          ,
#endif
    languageGetStyleName                    ,




 -- * Properties
-- ** hidden #attr:hidden#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LanguageHiddenPropertyInfo              ,
#endif
    getLanguageHidden                       ,
#if defined(ENABLE_OVERLOADING)
    languageHidden                          ,
#endif


-- ** id #attr:id#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LanguageIdPropertyInfo                  ,
#endif
    getLanguageId                           ,
#if defined(ENABLE_OVERLOADING)
    languageId                              ,
#endif


-- ** name #attr:name#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LanguageNamePropertyInfo                ,
#endif
    getLanguageName                         ,
#if defined(ENABLE_OVERLOADING)
    languageName                            ,
#endif


-- ** section #attr:section#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    LanguageSectionPropertyInfo             ,
#endif
    getLanguageSection                      ,
#if defined(ENABLE_OVERLOADING)
    languageSection                         ,
#endif




    ) 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

-- | Memory-managed wrapper type.
newtype Language = Language (SP.ManagedPtr Language)
    deriving (Language -> Language -> Bool
(Language -> Language -> Bool)
-> (Language -> Language -> Bool) -> Eq Language
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Language -> Language -> Bool
$c/= :: Language -> Language -> Bool
== :: Language -> Language -> Bool
$c== :: Language -> Language -> Bool
Eq)

instance SP.ManagedPtrNewtype Language where
    toManagedPtr :: Language -> ManagedPtr Language
toManagedPtr (Language ManagedPtr Language
p) = ManagedPtr Language
p

foreign import ccall "gtk_source_language_get_type"
    c_gtk_source_language_get_type :: IO B.Types.GType

instance B.Types.TypedObject Language where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_language_get_type

instance B.Types.GObject Language

-- | Convert 'Language' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue Language where
    toGValue :: Language -> IO GValue
toGValue Language
o = do
        GType
gtype <- IO GType
c_gtk_source_language_get_type
        Language -> (Ptr Language -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Language
o (GType
-> (GValue -> Ptr Language -> IO ()) -> Ptr Language -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Language -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO Language
fromGValue GValue
gv = do
        Ptr Language
ptr <- GValue -> IO (Ptr Language)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Language)
        (ManagedPtr Language -> Language) -> Ptr Language -> IO Language
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Language -> Language
Language Ptr Language
ptr
        
    

-- | Type class for types which can be safely cast to `Language`, for instance with `toLanguage`.
class (SP.GObject o, O.IsDescendantOf Language o) => IsLanguage o
instance (SP.GObject o, O.IsDescendantOf Language o) => IsLanguage o

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

-- | Cast to `Language`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toLanguage :: (MonadIO m, IsLanguage o) => o -> m Language
toLanguage :: o -> m Language
toLanguage = IO Language -> m Language
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Language -> m Language)
-> (o -> IO Language) -> o -> m Language
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Language -> Language) -> o -> IO Language
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Language -> Language
Language

#if defined(ENABLE_OVERLOADING)
type family ResolveLanguageMethod (t :: Symbol) (o :: *) :: * where
    ResolveLanguageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveLanguageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveLanguageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveLanguageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveLanguageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveLanguageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveLanguageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveLanguageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveLanguageMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveLanguageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveLanguageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveLanguageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveLanguageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveLanguageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveLanguageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveLanguageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveLanguageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveLanguageMethod "getGlobs" o = LanguageGetGlobsMethodInfo
    ResolveLanguageMethod "getHidden" o = LanguageGetHiddenMethodInfo
    ResolveLanguageMethod "getId" o = LanguageGetIdMethodInfo
    ResolveLanguageMethod "getMetadata" o = LanguageGetMetadataMethodInfo
    ResolveLanguageMethod "getMimeTypes" o = LanguageGetMimeTypesMethodInfo
    ResolveLanguageMethod "getName" o = LanguageGetNameMethodInfo
    ResolveLanguageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveLanguageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveLanguageMethod "getSection" o = LanguageGetSectionMethodInfo
    ResolveLanguageMethod "getStyleFallback" o = LanguageGetStyleFallbackMethodInfo
    ResolveLanguageMethod "getStyleIds" o = LanguageGetStyleIdsMethodInfo
    ResolveLanguageMethod "getStyleName" o = LanguageGetStyleNameMethodInfo
    ResolveLanguageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveLanguageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveLanguageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveLanguageMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveLanguageMethod t Language, O.MethodInfo info Language p) => OL.IsLabel t (Language -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

-- VVV Prop "hidden"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@hidden@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' language #hidden
-- @
getLanguageHidden :: (MonadIO m, IsLanguage o) => o -> m Bool
getLanguageHidden :: o -> m Bool
getLanguageHidden o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"hidden"

#if defined(ENABLE_OVERLOADING)
data LanguageHiddenPropertyInfo
instance AttrInfo LanguageHiddenPropertyInfo where
    type AttrAllowedOps LanguageHiddenPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint LanguageHiddenPropertyInfo = IsLanguage
    type AttrSetTypeConstraint LanguageHiddenPropertyInfo = (~) ()
    type AttrTransferTypeConstraint LanguageHiddenPropertyInfo = (~) ()
    type AttrTransferType LanguageHiddenPropertyInfo = ()
    type AttrGetType LanguageHiddenPropertyInfo = Bool
    type AttrLabel LanguageHiddenPropertyInfo = "hidden"
    type AttrOrigin LanguageHiddenPropertyInfo = Language
    attrGet = getLanguageHidden
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "id"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@id@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' language #id
-- @
getLanguageId :: (MonadIO m, IsLanguage o) => o -> m T.Text
getLanguageId :: o -> m Text
getLanguageId 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
"getLanguageId" (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.getObjectPropertyString o
obj String
"id"

#if defined(ENABLE_OVERLOADING)
data LanguageIdPropertyInfo
instance AttrInfo LanguageIdPropertyInfo where
    type AttrAllowedOps LanguageIdPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint LanguageIdPropertyInfo = IsLanguage
    type AttrSetTypeConstraint LanguageIdPropertyInfo = (~) ()
    type AttrTransferTypeConstraint LanguageIdPropertyInfo = (~) ()
    type AttrTransferType LanguageIdPropertyInfo = ()
    type AttrGetType LanguageIdPropertyInfo = T.Text
    type AttrLabel LanguageIdPropertyInfo = "id"
    type AttrOrigin LanguageIdPropertyInfo = Language
    attrGet = getLanguageId
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

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

-- | Get the value of the “@name@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' language #name
-- @
getLanguageName :: (MonadIO m, IsLanguage o) => o -> m T.Text
getLanguageName :: o -> m Text
getLanguageName 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
"getLanguageName" (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.getObjectPropertyString o
obj String
"name"

#if defined(ENABLE_OVERLOADING)
data LanguageNamePropertyInfo
instance AttrInfo LanguageNamePropertyInfo where
    type AttrAllowedOps LanguageNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint LanguageNamePropertyInfo = IsLanguage
    type AttrSetTypeConstraint LanguageNamePropertyInfo = (~) ()
    type AttrTransferTypeConstraint LanguageNamePropertyInfo = (~) ()
    type AttrTransferType LanguageNamePropertyInfo = ()
    type AttrGetType LanguageNamePropertyInfo = T.Text
    type AttrLabel LanguageNamePropertyInfo = "name"
    type AttrOrigin LanguageNamePropertyInfo = Language
    attrGet = getLanguageName
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

-- VVV Prop "section"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@section@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' language #section
-- @
getLanguageSection :: (MonadIO m, IsLanguage o) => o -> m T.Text
getLanguageSection :: o -> m Text
getLanguageSection 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
"getLanguageSection" (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.getObjectPropertyString o
obj String
"section"

#if defined(ENABLE_OVERLOADING)
data LanguageSectionPropertyInfo
instance AttrInfo LanguageSectionPropertyInfo where
    type AttrAllowedOps LanguageSectionPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint LanguageSectionPropertyInfo = IsLanguage
    type AttrSetTypeConstraint LanguageSectionPropertyInfo = (~) ()
    type AttrTransferTypeConstraint LanguageSectionPropertyInfo = (~) ()
    type AttrTransferType LanguageSectionPropertyInfo = ()
    type AttrGetType LanguageSectionPropertyInfo = T.Text
    type AttrLabel LanguageSectionPropertyInfo = "section"
    type AttrOrigin LanguageSectionPropertyInfo = Language
    attrGet = getLanguageSection
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Language
type instance O.AttributeList Language = LanguageAttributeList
type LanguageAttributeList = ('[ '("hidden", LanguageHiddenPropertyInfo), '("id", LanguageIdPropertyInfo), '("name", LanguageNamePropertyInfo), '("section", LanguageSectionPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
languageHidden :: AttrLabelProxy "hidden"
languageHidden = AttrLabelProxy

languageId :: AttrLabelProxy "id"
languageId = AttrLabelProxy

languageName :: AttrLabelProxy "name"
languageName = AttrLabelProxy

languageSection :: AttrLabelProxy "section"
languageSection = AttrLabelProxy

#endif

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

#endif

-- method Language::get_globs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "language"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Language" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceLanguage."
--                 , 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_get_globs" gtk_source_language_get_globs :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    IO (Ptr CString)

-- | Returns the globs associated to this language. This is just
-- an utility wrapper around 'GI.GtkSource.Objects.Language.languageGetMetadata' to
-- retrieve the \"globs\" metadata property and split it into an array.
languageGetGlobs ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> m (Maybe [T.Text])
    -- ^ __Returns:__ 
    -- a newly-allocated 'P.Nothing' terminated array containing the globs or 'P.Nothing'
    -- if no globs are found.
    -- The returned array must be freed with 'GI.GLib.Functions.strfreev'.
languageGetGlobs :: a -> m (Maybe [Text])
languageGetGlobs a
language = 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 Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    Ptr CString
result <- Ptr Language -> IO (Ptr CString)
gtk_source_language_get_globs Ptr Language
language'
    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'
        (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
result'
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem 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
language
    Maybe [Text] -> IO (Maybe [Text])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeResult

#if defined(ENABLE_OVERLOADING)
data LanguageGetGlobsMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetGlobsMethodInfo a signature where
    overloadedMethod = languageGetGlobs

#endif

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

foreign import ccall "gtk_source_language_get_hidden" gtk_source_language_get_hidden :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    IO CInt

-- | Returns whether the language should be hidden from the user.
languageGetHidden ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the language should be hidden, 'P.False' otherwise.
languageGetHidden :: a -> m Bool
languageGetHidden a
language = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    CInt
result <- Ptr Language -> IO CInt
gtk_source_language_get_hidden Ptr Language
language'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
language
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LanguageGetHiddenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetHiddenMethodInfo a signature where
    overloadedMethod = languageGetHidden

#endif

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

foreign import ccall "gtk_source_language_get_id" gtk_source_language_get_id :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    IO CString

-- | Returns the ID of the language. The ID is not locale-dependent.
-- The returned string is owned by /@language@/ and should not be freed
-- or modified.
languageGetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> m T.Text
    -- ^ __Returns:__ the ID of /@language@/.
languageGetId :: a -> m Text
languageGetId a
language = 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 Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    CString
result <- Ptr Language -> IO CString
gtk_source_language_get_id Ptr Language
language'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"languageGetId" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
language
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data LanguageGetIdMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetIdMethodInfo a signature where
    overloadedMethod = languageGetId

#endif

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

foreign import ccall "gtk_source_language_get_metadata" gtk_source_language_get_metadata :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    CString ->                              -- name : TBasicType TUTF8
    IO CString

-- | /No description available in the introspection data./
languageGetMetadata ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> T.Text
    -- ^ /@name@/: metadata property name.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ value of property /@name@/ stored in
    -- the metadata of /@language@/ or 'P.Nothing' if language does not contain the
    -- specified metadata property.
    -- The returned string is owned by /@language@/ and should not be freed
    -- or modified.
languageGetMetadata :: a -> Text -> m (Maybe Text)
languageGetMetadata a
language Text
name = 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 Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    CString
name' <- Text -> IO CString
textToCString Text
name
    CString
result <- Ptr Language -> CString -> IO CString
gtk_source_language_get_metadata Ptr Language
language' CString
name'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText 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
language
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data LanguageGetMetadataMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetMetadataMethodInfo a signature where
    overloadedMethod = languageGetMetadata

#endif

-- method Language::get_mime_types
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "language"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Language" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceLanguage."
--                 , 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_get_mime_types" gtk_source_language_get_mime_types :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    IO (Ptr CString)

-- | Returns the mime types associated to this language. This is just
-- an utility wrapper around 'GI.GtkSource.Objects.Language.languageGetMetadata' to
-- retrieve the \"mimetypes\" metadata property and split it into an
-- array.
languageGetMimeTypes ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> m (Maybe [T.Text])
    -- ^ __Returns:__ 
    -- a newly-allocated 'P.Nothing' terminated array containing the mime types
    -- or 'P.Nothing' if no mime types are found.
    -- The returned array must be freed with 'GI.GLib.Functions.strfreev'.
languageGetMimeTypes :: a -> m (Maybe [Text])
languageGetMimeTypes a
language = 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 Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    Ptr CString
result <- Ptr Language -> IO (Ptr CString)
gtk_source_language_get_mime_types Ptr Language
language'
    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'
        (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
result'
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem 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
language
    Maybe [Text] -> IO (Maybe [Text])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeResult

#if defined(ENABLE_OVERLOADING)
data LanguageGetMimeTypesMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetMimeTypesMethodInfo a signature where
    overloadedMethod = languageGetMimeTypes

#endif

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

foreign import ccall "gtk_source_language_get_name" gtk_source_language_get_name :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    IO CString

-- | Returns the localized name of the language.
-- The returned string is owned by /@language@/ and should not be freed
-- or modified.
languageGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> m T.Text
    -- ^ __Returns:__ the name of /@language@/.
languageGetName :: a -> m Text
languageGetName a
language = 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 Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    CString
result <- Ptr Language -> IO CString
gtk_source_language_get_name Ptr Language
language'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"languageGetName" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
language
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data LanguageGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetNameMethodInfo a signature where
    overloadedMethod = languageGetName

#endif

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

foreign import ccall "gtk_source_language_get_section" gtk_source_language_get_section :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    IO CString

-- | Returns the localized section of the language.
-- Each language belong to a section (ex. HTML belogs to the
-- Markup section).
-- The returned string is owned by /@language@/ and should not be freed
-- or modified.
languageGetSection ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> m T.Text
    -- ^ __Returns:__ the section of /@language@/.
languageGetSection :: a -> m Text
languageGetSection a
language = 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 Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    CString
result <- Ptr Language -> IO CString
gtk_source_language_get_section Ptr Language
language'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"languageGetSection" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
language
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data LanguageGetSectionMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetSectionMethodInfo a signature where
    overloadedMethod = languageGetSection

#endif

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

foreign import ccall "gtk_source_language_get_style_fallback" gtk_source_language_get_style_fallback :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    CString ->                              -- style_id : TBasicType TUTF8
    IO CString

-- | Returns the ID of the style to use if the specified /@styleId@/
-- is not present in the current style scheme.
-- 
-- /Since: 3.4/
languageGetStyleFallback ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> T.Text
    -- ^ /@styleId@/: a style ID.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the ID of the style to use if the
    -- specified /@styleId@/ is not present in the current style scheme or 'P.Nothing'
    -- if the style has no fallback defined.
    -- The returned string is owned by the /@language@/ and must not be modified.
languageGetStyleFallback :: a -> Text -> m (Maybe Text)
languageGetStyleFallback a
language Text
styleId = 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 Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    CString
styleId' <- Text -> IO CString
textToCString Text
styleId
    CString
result <- Ptr Language -> CString -> IO CString
gtk_source_language_get_style_fallback Ptr Language
language' CString
styleId'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText 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
language
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
styleId'
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data LanguageGetStyleFallbackMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetStyleFallbackMethodInfo a signature where
    overloadedMethod = languageGetStyleFallback

#endif

-- method Language::get_style_ids
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "language"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Language" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceLanguage."
--                 , 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_get_style_ids" gtk_source_language_get_style_ids :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    IO (Ptr CString)

-- | Returns the ids of the styles defined by this /@language@/.
languageGetStyleIds ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> m (Maybe [T.Text])
    -- ^ __Returns:__ 
    -- a newly-allocated 'P.Nothing' terminated array containing ids of the
    -- styles defined by this /@language@/ or 'P.Nothing' if no style is defined.
    -- The returned array must be freed with 'GI.GLib.Functions.strfreev'.
languageGetStyleIds :: a -> m (Maybe [Text])
languageGetStyleIds a
language = 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 Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    Ptr CString
result <- Ptr Language -> IO (Ptr CString)
gtk_source_language_get_style_ids Ptr Language
language'
    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'
        (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
result'
        Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem 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
language
    Maybe [Text] -> IO (Maybe [Text])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [Text]
maybeResult

#if defined(ENABLE_OVERLOADING)
data LanguageGetStyleIdsMethodInfo
instance (signature ~ (m (Maybe [T.Text])), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetStyleIdsMethodInfo a signature where
    overloadedMethod = languageGetStyleIds

#endif

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

foreign import ccall "gtk_source_language_get_style_name" gtk_source_language_get_style_name :: 
    Ptr Language ->                         -- language : TInterface (Name {namespace = "GtkSource", name = "Language"})
    CString ->                              -- style_id : TBasicType TUTF8
    IO CString

-- | Returns the name of the style with ID /@styleId@/ defined by this /@language@/.
languageGetStyleName ::
    (B.CallStack.HasCallStack, MonadIO m, IsLanguage a) =>
    a
    -- ^ /@language@/: a t'GI.GtkSource.Objects.Language.Language'.
    -> T.Text
    -- ^ /@styleId@/: a style ID.
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the name of the style with ID /@styleId@/
    -- defined by this /@language@/ or 'P.Nothing' if the style has no name or there is no
    -- style with ID /@styleId@/ defined by this /@language@/.
    -- The returned string is owned by the /@language@/ and must not be modified.
languageGetStyleName :: a -> Text -> m (Maybe Text)
languageGetStyleName a
language Text
styleId = 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 Language
language' <- a -> IO (Ptr Language)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
language
    CString
styleId' <- Text -> IO CString
textToCString Text
styleId
    CString
result <- Ptr Language -> CString -> IO CString
gtk_source_language_get_style_name Ptr Language
language' CString
styleId'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText 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
language
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
styleId'
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data LanguageGetStyleNameMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m, IsLanguage a) => O.MethodInfo LanguageGetStyleNameMethodInfo a signature where
    overloadedMethod = languageGetStyleName

#endif