{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getGlobs]("GI.GtkSource.Objects.Language#g:method:getGlobs"), [getHidden]("GI.GtkSource.Objects.Language#g:method:getHidden"), [getId]("GI.GtkSource.Objects.Language#g:method:getId"), [getMetadata]("GI.GtkSource.Objects.Language#g:method:getMetadata"), [getMimeTypes]("GI.GtkSource.Objects.Language#g:method:getMimeTypes"), [getName]("GI.GtkSource.Objects.Language#g:method:getName"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getSection]("GI.GtkSource.Objects.Language#g:method:getSection"), [getStyleFallback]("GI.GtkSource.Objects.Language#g:method:getStyleFallback"), [getStyleIds]("GI.GtkSource.Objects.Language#g:method:getStyleIds"), [getStyleName]("GI.GtkSource.Objects.Language#g:method:getStyleName").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#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.GArray as B.GArray
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.Coerce as Coerce
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 GHC.Records as R

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

-- | 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 :: (MIO.MonadIO m, IsLanguage o) => o -> m Language
toLanguage :: forall (m :: * -> *) o.
(MonadIO m, IsLanguage o) =>
o -> m Language
toLanguage = IO Language -> m Language
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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'
B.ManagedPtr.unsafeCastTo ManagedPtr Language -> Language
Language

-- | Convert 'Language' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Language) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_source_language_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Language -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Language
P.Nothing = Ptr GValue -> Ptr Language -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Language
forall a. Ptr a
FP.nullPtr :: FP.Ptr Language)
    gvalueSet_ Ptr GValue
gv (P.Just Language
obj) = Language -> (Ptr Language -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Language
obj (Ptr GValue -> Ptr Language -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Language)
gvalueGet_ Ptr GValue
gv = do
        Ptr Language
ptr <- Ptr GValue -> IO (Ptr Language)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Language)
        if Ptr Language
ptr Ptr Language -> Ptr Language -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Language
forall a. Ptr a
FP.nullPtr
        then Language -> Maybe Language
forall a. a -> Maybe a
P.Just (Language -> Maybe Language) -> IO Language -> IO (Maybe Language)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (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
        else Maybe Language -> IO (Maybe Language)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Language
forall a. Maybe a
P.Nothing
        
    

#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.OverloadedMethod 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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveLanguageMethod t Language, O.OverloadedMethod info Language p, R.HasField t Language p) => R.HasField t Language p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveLanguageMethod t Language, O.OverloadedMethodInfo info Language) => OL.IsLabel t (O.MethodProxy info Language) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#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 :: forall (m :: * -> *) o. (MonadIO m, IsLanguage o) => o -> m Bool
getLanguageHidden o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.hidden"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#g:attr:hidden"
        })
#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 :: forall (m :: * -> *) o. (MonadIO m, IsLanguage o) => o -> m Text
getLanguageId o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.id"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#g:attr:id"
        })
#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 :: forall (m :: * -> *) o. (MonadIO m, IsLanguage o) => o -> m Text
getLanguageName o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.name"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#g:attr:name"
        })
#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 :: forall (m :: * -> *) o. (MonadIO m, IsLanguage o) => o -> m Text
getLanguageSection o
obj = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.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
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.section"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#g:attr:section"
        })
#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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetGlobsMethodInfo a signature where
    overloadedMethod = languageGetGlobs

instance O.OverloadedMethodInfo LanguageGetGlobsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetGlobs",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetHiddenMethodInfo a signature where
    overloadedMethod = languageGetHidden

instance O.OverloadedMethodInfo LanguageGetHiddenMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetHidden",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetIdMethodInfo a signature where
    overloadedMethod = languageGetId

instance O.OverloadedMethodInfo LanguageGetIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetMetadataMethodInfo a signature where
    overloadedMethod = languageGetMetadata

instance O.OverloadedMethodInfo LanguageGetMetadataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetMetadata",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetMimeTypesMethodInfo a signature where
    overloadedMethod = languageGetMimeTypes

instance O.OverloadedMethodInfo LanguageGetMimeTypesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetMimeTypes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetNameMethodInfo a signature where
    overloadedMethod = languageGetName

instance O.OverloadedMethodInfo LanguageGetNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetSectionMethodInfo a signature where
    overloadedMethod = languageGetSection

instance O.OverloadedMethodInfo LanguageGetSectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetSection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetStyleFallbackMethodInfo a signature where
    overloadedMethod = languageGetStyleFallback

instance O.OverloadedMethodInfo LanguageGetStyleFallbackMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetStyleFallback",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetStyleIdsMethodInfo a signature where
    overloadedMethod = languageGetStyleIds

instance O.OverloadedMethodInfo LanguageGetStyleIdsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetStyleIds",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v: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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLanguage a) =>
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.OverloadedMethod LanguageGetStyleNameMethodInfo a signature where
    overloadedMethod = languageGetStyleName

instance O.OverloadedMethodInfo LanguageGetStyleNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.Language.languageGetStyleName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-3.0.25/docs/GI-GtkSource-Objects-Language.html#v:languageGetStyleName"
        })


#endif