    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A @PangoContext@ stores global information used to control the
    -- itemization process.
    --
    -- The information stored by @PangoContext@ includes the fontmap used
    -- to look up fonts, and default values such as the default language,
    -- default gravity, or default font.
    --
    -- To obtain a @PangoContext@, use 'GI.Pango.Objects.FontMap.fontMapCreateContext'.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Pango.Objects.Context
        (

    -- * Exported types
        Context(..)                             ,
        IsContext                               ,
        toContext                               ,

     -- * 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"), [changed]("GI.Pango.Objects.Context#g:method:changed"), [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"), [listFamilies]("GI.Pango.Objects.Context#g:method:listFamilies"), [loadFont]("GI.Pango.Objects.Context#g:method:loadFont"), [loadFontset]("GI.Pango.Objects.Context#g:method:loadFontset"), [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
    -- [getBaseDir]("GI.Pango.Objects.Context#g:method:getBaseDir"), [getBaseGravity]("GI.Pango.Objects.Context#g:method:getBaseGravity"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getFontDescription]("GI.Pango.Objects.Context#g:method:getFontDescription"), [getFontMap]("GI.Pango.Objects.Context#g:method:getFontMap"), [getGravity]("GI.Pango.Objects.Context#g:method:getGravity"), [getGravityHint]("GI.Pango.Objects.Context#g:method:getGravityHint"), [getLanguage]("GI.Pango.Objects.Context#g:method:getLanguage"), [getMatrix]("GI.Pango.Objects.Context#g:method:getMatrix"), [getMetrics]("GI.Pango.Objects.Context#g:method:getMetrics"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRoundGlyphPositions]("GI.Pango.Objects.Context#g:method:getRoundGlyphPositions"), [getSerial]("GI.Pango.Objects.Context#g:method:getSerial").
    --
    -- ==== Setters
    -- [setBaseDir]("GI.Pango.Objects.Context#g:method:setBaseDir"), [setBaseGravity]("GI.Pango.Objects.Context#g:method:setBaseGravity"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFontDescription]("GI.Pango.Objects.Context#g:method:setFontDescription"), [setFontMap]("GI.Pango.Objects.Context#g:method:setFontMap"), [setGravityHint]("GI.Pango.Objects.Context#g:method:setGravityHint"), [setLanguage]("GI.Pango.Objects.Context#g:method:setLanguage"), [setMatrix]("GI.Pango.Objects.Context#g:method:setMatrix"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRoundGlyphPositions]("GI.Pango.Objects.Context#g:method:setRoundGlyphPositions").

    #if defined(ENABLE_OVERLOADING)
        ResolveContextMethod                    ,
    #endif

    -- ** changed #method:changed#

    #if defined(ENABLE_OVERLOADING)
        ContextChangedMethodInfo                ,
    #endif
        contextChanged                          ,

    -- ** getBaseDir #method:getBaseDir#

    #if defined(ENABLE_OVERLOADING)
        ContextGetBaseDirMethodInfo             ,
    #endif
        contextGetBaseDir                       ,

    -- ** getBaseGravity #method:getBaseGravity#

    #if defined(ENABLE_OVERLOADING)
        ContextGetBaseGravityMethodInfo         ,
    #endif
        contextGetBaseGravity                   ,

    -- ** getFontDescription #method:getFontDescription#

    #if defined(ENABLE_OVERLOADING)
        ContextGetFontDescriptionMethodInfo     ,
    #endif
        contextGetFontDescription               ,

    -- ** getFontMap #method:getFontMap#

    #if defined(ENABLE_OVERLOADING)
        ContextGetFontMapMethodInfo             ,
    #endif
        contextGetFontMap                       ,

    -- ** getGravity #method:getGravity#

    #if defined(ENABLE_OVERLOADING)
        ContextGetGravityMethodInfo             ,
    #endif
        contextGetGravity                       ,

    -- ** getGravityHint #method:getGravityHint#

    #if defined(ENABLE_OVERLOADING)
        ContextGetGravityHintMethodInfo         ,
    #endif
        contextGetGravityHint                   ,

    -- ** getLanguage #method:getLanguage#

    #if defined(ENABLE_OVERLOADING)
        ContextGetLanguageMethodInfo            ,
    #endif
        contextGetLanguage                      ,

    -- ** getMatrix #method:getMatrix#

    #if defined(ENABLE_OVERLOADING)
        ContextGetMatrixMethodInfo              ,
    #endif
        contextGetMatrix                        ,

    -- ** getMetrics #method:getMetrics#

    #if defined(ENABLE_OVERLOADING)
        ContextGetMetricsMethodInfo             ,
    #endif
        contextGetMetrics                       ,

    -- ** getRoundGlyphPositions #method:getRoundGlyphPositions#

    #if defined(ENABLE_OVERLOADING)
        ContextGetRoundGlyphPositionsMethodInfo ,
    #endif
        contextGetRoundGlyphPositions           ,

    -- ** getSerial #method:getSerial#

    #if defined(ENABLE_OVERLOADING)
        ContextGetSerialMethodInfo              ,
    #endif
        contextGetSerial                        ,

    -- ** listFamilies #method:listFamilies#

    #if defined(ENABLE_OVERLOADING)
        ContextListFamiliesMethodInfo           ,
    #endif
        contextListFamilies                     ,

    -- ** loadFont #method:loadFont#

    #if defined(ENABLE_OVERLOADING)
        ContextLoadFontMethodInfo               ,
    #endif
        contextLoadFont                         ,

    -- ** loadFontset #method:loadFontset#

    #if defined(ENABLE_OVERLOADING)
        ContextLoadFontsetMethodInfo            ,
    #endif
        contextLoadFontset                      ,

    -- ** new #method:new#

        contextNew                              ,

    -- ** setBaseDir #method:setBaseDir#

    #if defined(ENABLE_OVERLOADING)
        ContextSetBaseDirMethodInfo             ,
    #endif
        contextSetBaseDir                       ,

    -- ** setBaseGravity #method:setBaseGravity#

    #if defined(ENABLE_OVERLOADING)
        ContextSetBaseGravityMethodInfo         ,
    #endif
        contextSetBaseGravity                   ,

    -- ** setFontDescription #method:setFontDescription#

    #if defined(ENABLE_OVERLOADING)
        ContextSetFontDescriptionMethodInfo     ,
    #endif
        contextSetFontDescription               ,

    -- ** setFontMap #method:setFontMap#

    #if defined(ENABLE_OVERLOADING)
        ContextSetFontMapMethodInfo             ,
    #endif
        contextSetFontMap                       ,

    -- ** setGravityHint #method:setGravityHint#

    #if defined(ENABLE_OVERLOADING)
        ContextSetGravityHintMethodInfo         ,
    #endif
        contextSetGravityHint                   ,

    -- ** setLanguage #method:setLanguage#

    #if defined(ENABLE_OVERLOADING)
        ContextSetLanguageMethodInfo            ,
    #endif
        contextSetLanguage                      ,

    -- ** setMatrix #method:setMatrix#

    #if defined(ENABLE_OVERLOADING)
        ContextSetMatrixMethodInfo              ,
    #endif
        contextSetMatrix                        ,

    -- ** setRoundGlyphPositions #method:setRoundGlyphPositions#

    #if defined(ENABLE_OVERLOADING)
        ContextSetRoundGlyphPositionsMethodInfo ,
    #endif
        contextSetRoundGlyphPositions           ,

        ) 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.GHashTable as B.GHT
    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.Kind as DK
    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 Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)
    import qualified GI.GLib.Structs.Bytes as GLib.Bytes
    import qualified GI.GObject.Objects.Object as GObject.Object
    import qualified GI.Gio.Interfaces.ListModel as Gio.ListModel
    import qualified GI.HarfBuzz.Structs.FeatureT as HarfBuzz.FeatureT
    import qualified GI.Pango.Callbacks as Pango.Callbacks
    import {-# SOURCE #-} qualified GI.Pango.Enums as Pango.Enums
    import {-# SOURCE #-} qualified GI.Pango.Flags as Pango.Flags
    import {-# SOURCE #-} qualified GI.Pango.Objects.Coverage as Pango.Coverage
    import {-# SOURCE #-} qualified GI.Pango.Objects.Font as Pango.Font
    import {-# SOURCE #-} qualified GI.Pango.Objects.FontFace as Pango.FontFace
    import {-# SOURCE #-} qualified GI.Pango.Objects.FontFamily as Pango.FontFamily
    import {-# SOURCE #-} qualified GI.Pango.Objects.FontMap as Pango.FontMap
    import {-# SOURCE #-} qualified GI.Pango.Objects.Fontset as Pango.Fontset
    import {-# SOURCE #-} qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
    import {-# SOURCE #-} qualified GI.Pango.Structs.FontMetrics as Pango.FontMetrics
    import {-# SOURCE #-} qualified GI.Pango.Structs.Language as Pango.Language
    import {-# SOURCE #-} qualified GI.Pango.Structs.Matrix as Pango.Matrix
    import {-# SOURCE #-} qualified GI.Pango.Structs.Rectangle as Pango.Rectangle

    #else
    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Pango.Enums as Pango.Enums
    import {-# SOURCE #-} qualified GI.Pango.Objects.Font as Pango.Font
    import {-# SOURCE #-} qualified GI.Pango.Objects.FontFamily as Pango.FontFamily
    import {-# SOURCE #-} qualified GI.Pango.Objects.FontMap as Pango.FontMap
    import {-# SOURCE #-} qualified GI.Pango.Objects.Fontset as Pango.Fontset
    import {-# SOURCE #-} qualified GI.Pango.Structs.FontDescription as Pango.FontDescription
    import {-# SOURCE #-} qualified GI.Pango.Structs.FontMetrics as Pango.FontMetrics
    import {-# SOURCE #-} qualified GI.Pango.Structs.Language as Pango.Language
    import {-# SOURCE #-} qualified GI.Pango.Structs.Matrix as Pango.Matrix

    #endif

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

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

    foreign import ccall "pango_context_get_type"
        c_pango_context_get_type :: IO B.Types.GType

    instance B.Types.TypedObject Context where
        glibType :: IO GType
    glibType = IO GType
    c_pango_context_get_type

    instance B.Types.GObject Context

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

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

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

    -- | Convert 'Context' 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 Context) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_pango_context_get_type
        gvalueSet_ :: Ptr GValue -> Maybe Context -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe Context
    P.Nothing = Ptr GValue -> Ptr Context -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv (Ptr Context
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr Context)
        gvalueSet_ Ptr GValue
    gv (P.Just Context
    obj) = Context -> (Ptr Context -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr Context
    obj (Ptr GValue -> Ptr Context -> IO ()
    forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_object Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe Context)
    gvalueGet_ Ptr GValue
    gv = do
            Ptr Context
    ptr <- Ptr GValue -> IO (Ptr Context)
    forall a. GObject a => Ptr GValue -> IO (Ptr a)
    B.GValue.get_object Ptr GValue
    gv :: IO (FP.Ptr Context)
            if Ptr Context
    ptr Ptr Context -> Ptr Context -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Ptr Context
    forall a. Ptr a
    FP.nullPtr
            then Context -> Maybe Context
    forall a. a -> Maybe a
    P.Just (Context -> Maybe Context) -> IO Context -> IO (Maybe Context)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ManagedPtr Context -> Context) -> Ptr Context -> IO Context
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    B.ManagedPtr.newObject ManagedPtr Context -> Context
    Context Ptr Context
    ptr
            else Maybe Context -> IO (Maybe Context)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Context
    forall a. Maybe a
    P.Nothing

    #if defined(ENABLE_OVERLOADING)
    type family ResolveContextMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
        ResolveContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveContextMethod "changed" o = ContextChangedMethodInfo
        ResolveContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveContextMethod "listFamilies" o = ContextListFamiliesMethodInfo
        ResolveContextMethod "loadFont" o = ContextLoadFontMethodInfo
        ResolveContextMethod "loadFontset" o = ContextLoadFontsetMethodInfo
        ResolveContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveContextMethod "getBaseDir" o = ContextGetBaseDirMethodInfo
        ResolveContextMethod "getBaseGravity" o = ContextGetBaseGravityMethodInfo
        ResolveContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveContextMethod "getFontDescription" o = ContextGetFontDescriptionMethodInfo
        ResolveContextMethod "getFontMap" o = ContextGetFontMapMethodInfo
        ResolveContextMethod "getGravity" o = ContextGetGravityMethodInfo
        ResolveContextMethod "getGravityHint" o = ContextGetGravityHintMethodInfo
        ResolveContextMethod "getLanguage" o = ContextGetLanguageMethodInfo
        ResolveContextMethod "getMatrix" o = ContextGetMatrixMethodInfo
        ResolveContextMethod "getMetrics" o = ContextGetMetricsMethodInfo
        ResolveContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveContextMethod "getRoundGlyphPositions" o = ContextGetRoundGlyphPositionsMethodInfo
        ResolveContextMethod "getSerial" o = ContextGetSerialMethodInfo
        ResolveContextMethod "setBaseDir" o = ContextSetBaseDirMethodInfo
        ResolveContextMethod "setBaseGravity" o = ContextSetBaseGravityMethodInfo
        ResolveContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveContextMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
        ResolveContextMethod "setFontDescription" o = ContextSetFontDescriptionMethodInfo
        ResolveContextMethod "setFontMap" o = ContextSetFontMapMethodInfo
        ResolveContextMethod "setGravityHint" o = ContextSetGravityHintMethodInfo
        ResolveContextMethod "setLanguage" o = ContextSetLanguageMethodInfo
        ResolveContextMethod "setMatrix" o = ContextSetMatrixMethodInfo
        ResolveContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveContextMethod "setRoundGlyphPositions" o = ContextSetRoundGlyphPositionsMethodInfo
        ResolveContextMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveContextMethod t Context, O.OverloadedMethod info Context p) => OL.IsLabel t (Context -> 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 ~ ResolveContextMethod t Context, O.OverloadedMethod info Context p, R.HasField t Context p) => R.HasField t Context p where
        getField = O.overloadedMethod @info

    #endif

    instance (info ~ ResolveContextMethod t Context, O.OverloadedMethodInfo info Context) => OL.IsLabel t (O.MethodProxy info Context) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.MethodProxy
    #else
        fromLabel _ = O.MethodProxy
    #endif

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList Context
    type instance O.AttributeList Context = ContextAttributeList
    type ContextAttributeList = ('[ ] :: [(Symbol, DK.Type)])
    #endif

    #if defined(ENABLE_OVERLOADING)
    #endif

    #if defined(ENABLE_OVERLOADING)
    type instance O.SignalList Context = ContextSignalList
    type ContextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

    #endif

    -- method Context::new
    -- method type : Constructor
    -- Args: []
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Context" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_new" pango_context_new ::
        IO (Ptr Context)

    -- | Creates a new @PangoContext@ initialized to default values.
    --
    -- This function is not particularly useful as it should always
    -- be followed by a 'GI.Pango.Objects.Context.contextSetFontMap' call, and the
    -- function 'GI.Pango.Objects.FontMap.fontMapCreateContext' does these two steps
    -- together and hence users are recommended to use that.
    --
    -- If you are using Pango as part of a higher-level system,
    -- that system may have it\'s own way of create a @PangoContext@.
    -- For instance, the GTK toolkit has, among others,
    -- @gtk_widget_get_pango_context()@. Use those instead.
    contextNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Context
        -- ^ __Returns:__ the newly allocated @PangoContext@, which should
        --   be freed with 'GI.GObject.Objects.Object.objectUnref'.
    contextNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Context
    contextNew  = IO Context -> m Context
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Context -> m Context) -> IO Context -> m Context
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    result <- IO (Ptr Context)
    pango_context_new
        Text -> Ptr Context -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "contextNew" Ptr Context
    result
        Context
    result' <- ((ManagedPtr Context -> Context) -> Ptr Context -> IO Context
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Context -> Context
    Context) Ptr Context
    result
        Context -> IO Context
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Context
    result'

    #if defined(ENABLE_OVERLOADING)
    #endif

    -- method Context::changed
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_changed" pango_context_changed ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO ()

    -- | Forces a change in the context, which will cause any @PangoLayout@
    -- using this context to re-layout.
    --
    -- This function is only useful when implementing a new backend
    -- for Pango, something applications won\'t do. Backends should
    -- call this function if they have attached extra data to the context
    -- and such data is changed.
    --
    -- /Since: 1.32.4/
    contextChanged ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m ()
    contextChanged :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m ()
    contextChanged a
    context = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr Context -> IO ()
    pango_context_changed Ptr Context
    context'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ContextChangedMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsContext a) => O.OverloadedMethod ContextChangedMethodInfo a signature where
        overloadedMethod = contextChanged

    instance O.OverloadedMethodInfo ContextChangedMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextChanged",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextChanged"
            })

    #endif

    -- method Context::get_base_dir
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Direction" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_base_dir" pango_context_get_base_dir ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO CUInt

    -- | Retrieves the base direction for the context.
    --
    -- See 'GI.Pango.Objects.Context.contextSetBaseDir'.
    contextGetBaseDir ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m Pango.Enums.Direction
        -- ^ __Returns:__ the base direction for the context.
    contextGetBaseDir :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m Direction
    contextGetBaseDir a
    context = IO Direction -> m Direction
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Direction -> m Direction) -> IO Direction -> m Direction
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CUInt
    result <- Ptr Context -> IO CUInt
    pango_context_get_base_dir Ptr Context
    context'
        let result' :: Direction
    result' = (Int -> Direction
    forall a. Enum a => Int -> a
    toEnum (Int -> Direction) -> (CUInt -> Int) -> CUInt -> Direction
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Direction -> IO Direction
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Direction
    result'

    #if defined(ENABLE_OVERLOADING)
    data ContextGetBaseDirMethodInfo
    instance (signature ~ (m Pango.Enums.Direction), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetBaseDirMethodInfo a signature where
        overloadedMethod = contextGetBaseDir

    instance O.OverloadedMethodInfo ContextGetBaseDirMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetBaseDir",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetBaseDir"
            })

    #endif

    -- method Context::get_base_gravity
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Gravity" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_base_gravity" pango_context_get_base_gravity ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO CUInt

    -- | Retrieves the base gravity for the context.
    --
    -- See 'GI.Pango.Objects.Context.contextSetBaseGravity'.
    --
    -- /Since: 1.16/
    contextGetBaseGravity ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m Pango.Enums.Gravity
        -- ^ __Returns:__ the base gravity for the context.
    contextGetBaseGravity :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m Gravity
    contextGetBaseGravity a
    context = IO Gravity -> m Gravity
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Gravity -> m Gravity) -> IO Gravity -> m Gravity
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CUInt
    result <- Ptr Context -> IO CUInt
    pango_context_get_base_gravity Ptr Context
    context'
        let result' :: Gravity
    result' = (Int -> Gravity
    forall a. Enum a => Int -> a
    toEnum (Int -> Gravity) -> (CUInt -> Int) -> CUInt -> Gravity
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Gravity -> IO Gravity
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Gravity
    result'

    #if defined(ENABLE_OVERLOADING)
    data ContextGetBaseGravityMethodInfo
    instance (signature ~ (m Pango.Enums.Gravity), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetBaseGravityMethodInfo a signature where
        overloadedMethod = contextGetBaseGravity

    instance O.OverloadedMethodInfo ContextGetBaseGravityMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetBaseGravity",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetBaseGravity"
            })

    #endif

    -- method Context::get_font_description
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface
    --                  Name { namespace = "Pango" , name = "FontDescription" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_font_description" pango_context_get_font_description ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO (Ptr Pango.FontDescription.FontDescription)

    -- | Retrieve the default font description for the context.
    contextGetFontDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m (Maybe Pango.FontDescription.FontDescription)
        -- ^ __Returns:__ a pointer to the context\'s default font
        --   description. This value must not be modified or freed.
    contextGetFontDescription :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m (Maybe FontDescription)
    contextGetFontDescription a
    context = IO (Maybe FontDescription) -> m (Maybe FontDescription)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe FontDescription) -> m (Maybe FontDescription))
    -> IO (Maybe FontDescription) -> m (Maybe FontDescription)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr FontDescription
    result <- Ptr Context -> IO (Ptr FontDescription)
    pango_context_get_font_description Ptr Context
    context'
        Maybe FontDescription
    maybeResult <- Ptr FontDescription
    -> (Ptr FontDescription -> IO FontDescription)
    -> IO (Maybe FontDescription)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr FontDescription
    result ((Ptr FontDescription -> IO FontDescription)
     -> IO (Maybe FontDescription))
    -> (Ptr FontDescription -> IO FontDescription)
    -> IO (Maybe FontDescription)
    forall a b. (a -> b) -> a -> b
    $ \Ptr FontDescription
    result' -> do
            FontDescription
    result'' <- ((ManagedPtr FontDescription -> FontDescription)
    -> Ptr FontDescription -> IO FontDescription
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr FontDescription -> FontDescription
    Pango.FontDescription.FontDescription) Ptr FontDescription
    result'
            FontDescription -> IO FontDescription
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FontDescription
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe FontDescription -> IO (Maybe FontDescription)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe FontDescription
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ContextGetFontDescriptionMethodInfo
    instance (signature ~ (m (Maybe Pango.FontDescription.FontDescription)), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetFontDescriptionMethodInfo a signature where
        overloadedMethod = contextGetFontDescription

    instance O.OverloadedMethodInfo ContextGetFontDescriptionMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetFontDescription",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetFontDescription"
            })

    #endif

    -- method Context::get_font_map
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "FontMap" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_font_map" pango_context_get_font_map ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO (Ptr Pango.FontMap.FontMap)

    -- | Gets the @PangoFontMap@ used to look up fonts for this context.
    --
    -- /Since: 1.6/
    contextGetFontMap ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m (Maybe Pango.FontMap.FontMap)
        -- ^ __Returns:__ the font map for the.
        --   @PangoContext@ This value is owned by Pango and should not be
        --   unreferenced.
    contextGetFontMap :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m (Maybe FontMap)
    contextGetFontMap a
    context = IO (Maybe FontMap) -> m (Maybe FontMap)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe FontMap) -> m (Maybe FontMap))
    -> IO (Maybe FontMap) -> m (Maybe FontMap)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr FontMap
    result <- Ptr Context -> IO (Ptr FontMap)
    pango_context_get_font_map Ptr Context
    context'
        Maybe FontMap
    maybeResult <- Ptr FontMap -> (Ptr FontMap -> IO FontMap) -> IO (Maybe FontMap)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr FontMap
    result ((Ptr FontMap -> IO FontMap) -> IO (Maybe FontMap))
    -> (Ptr FontMap -> IO FontMap) -> IO (Maybe FontMap)
    forall a b. (a -> b) -> a -> b
    $ \Ptr FontMap
    result' -> do
            FontMap
    result'' <- ((ManagedPtr FontMap -> FontMap) -> Ptr FontMap -> IO FontMap
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr FontMap -> FontMap
    Pango.FontMap.FontMap) Ptr FontMap
    result'
            FontMap -> IO FontMap
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FontMap
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe FontMap -> IO (Maybe FontMap)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe FontMap
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ContextGetFontMapMethodInfo
    instance (signature ~ (m (Maybe Pango.FontMap.FontMap)), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetFontMapMethodInfo a signature where
        overloadedMethod = contextGetFontMap

    instance O.OverloadedMethodInfo ContextGetFontMapMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetFontMap",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetFontMap"
            })

    #endif

    -- method Context::get_gravity
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Gravity" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_gravity" pango_context_get_gravity ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO CUInt

    -- | Retrieves the gravity for the context.
    --
    -- This is similar to 'GI.Pango.Objects.Context.contextGetBaseGravity',
    -- except for when the base gravity is 'GI.Pango.Enums.GravityAuto' for
    -- which [func/@pango@/.Gravity.get_for_matrix] is used to return the
    -- gravity from the current context matrix.
    --
    -- /Since: 1.16/
    contextGetGravity ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m Pango.Enums.Gravity
        -- ^ __Returns:__ the resolved gravity for the context.
    contextGetGravity :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m Gravity
    contextGetGravity a
    context = IO Gravity -> m Gravity
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Gravity -> m Gravity) -> IO Gravity -> m Gravity
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CUInt
    result <- Ptr Context -> IO CUInt
    pango_context_get_gravity Ptr Context
    context'
        let result' :: Gravity
    result' = (Int -> Gravity
    forall a. Enum a => Int -> a
    toEnum (Int -> Gravity) -> (CUInt -> Int) -> CUInt -> Gravity
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Gravity -> IO Gravity
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Gravity
    result'

    #if defined(ENABLE_OVERLOADING)
    data ContextGetGravityMethodInfo
    instance (signature ~ (m Pango.Enums.Gravity), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetGravityMethodInfo a signature where
        overloadedMethod = contextGetGravity

    instance O.OverloadedMethodInfo ContextGetGravityMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetGravity",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetGravity"
            })

    #endif

    -- method Context::get_gravity_hint
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Pango" , name = "GravityHint" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_gravity_hint" pango_context_get_gravity_hint ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO CUInt

    -- | Retrieves the gravity hint for the context.
    --
    -- See 'GI.Pango.Objects.Context.contextSetGravityHint' for details.
    --
    -- /Since: 1.16/
    contextGetGravityHint ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m Pango.Enums.GravityHint
        -- ^ __Returns:__ the gravity hint for the context.
    contextGetGravityHint :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m GravityHint
    contextGetGravityHint a
    context = IO GravityHint -> m GravityHint
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GravityHint -> m GravityHint)
    -> IO GravityHint -> m GravityHint
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CUInt
    result <- Ptr Context -> IO CUInt
    pango_context_get_gravity_hint Ptr Context
    context'
        let result' :: GravityHint
    result' = (Int -> GravityHint
    forall a. Enum a => Int -> a
    toEnum (Int -> GravityHint) -> (CUInt -> Int) -> CUInt -> GravityHint
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CUInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral) CUInt
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        GravityHint -> IO GravityHint
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return GravityHint
    result'

    #if defined(ENABLE_OVERLOADING)
    data ContextGetGravityHintMethodInfo
    instance (signature ~ (m Pango.Enums.GravityHint), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetGravityHintMethodInfo a signature where
        overloadedMethod = contextGetGravityHint

    instance O.OverloadedMethodInfo ContextGetGravityHintMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetGravityHint",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetGravityHint"
            })

    #endif

    -- method Context::get_language
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Language" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_language" pango_context_get_language ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO (Ptr Pango.Language.Language)

    -- | Retrieves the global language tag for the context.
    contextGetLanguage ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m Pango.Language.Language
        -- ^ __Returns:__ the global language tag.
    contextGetLanguage :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m Language
    contextGetLanguage a
    context = IO Language -> m Language
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Language -> m Language) -> IO Language -> m Language
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr Language
    result <- Ptr Context -> IO (Ptr Language)
    pango_context_get_language Ptr Context
    context'
        Text -> Ptr Language -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "contextGetLanguage" Ptr Language
    result
        Language
    result' <- ((ManagedPtr Language -> Language) -> Ptr Language -> IO Language
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr Language -> Language
    Pango.Language.Language) Ptr Language
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Language -> IO Language
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Language
    result'

    #if defined(ENABLE_OVERLOADING)
    data ContextGetLanguageMethodInfo
    instance (signature ~ (m Pango.Language.Language), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetLanguageMethodInfo a signature where
        overloadedMethod = contextGetLanguage

    instance O.OverloadedMethodInfo ContextGetLanguageMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetLanguage",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetLanguage"
            })

    #endif

    -- method Context::get_matrix
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Matrix" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_matrix" pango_context_get_matrix ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO (Ptr Pango.Matrix.Matrix)

    -- | Gets the transformation matrix that will be applied when
    -- rendering with this context.
    --
    -- See 'GI.Pango.Objects.Context.contextSetMatrix'.
    --
    -- /Since: 1.6/
    contextGetMatrix ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m (Maybe Pango.Matrix.Matrix)
        -- ^ __Returns:__ the matrix, or 'P.Nothing' if no
        --   matrix has been set (which is the same as the identity matrix).
        --   The returned matrix is owned by Pango and must not be modified
        --   or freed.
    contextGetMatrix :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m (Maybe Matrix)
    contextGetMatrix a
    context = IO (Maybe Matrix) -> m (Maybe Matrix)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Matrix) -> m (Maybe Matrix))
    -> IO (Maybe Matrix) -> m (Maybe Matrix)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr Matrix
    result <- Ptr Context -> IO (Ptr Matrix)
    pango_context_get_matrix Ptr Context
    context'
        Maybe Matrix
    maybeResult <- Ptr Matrix -> (Ptr Matrix -> IO Matrix) -> IO (Maybe Matrix)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Matrix
    result ((Ptr Matrix -> IO Matrix) -> IO (Maybe Matrix))
    -> (Ptr Matrix -> IO Matrix) -> IO (Maybe Matrix)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Matrix
    result' -> do
            Matrix
    result'' <- ((ManagedPtr Matrix -> Matrix) -> Ptr Matrix -> IO Matrix
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr Matrix -> Matrix
    Pango.Matrix.Matrix) Ptr Matrix
    result'
            Matrix -> IO Matrix
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Matrix
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe Matrix -> IO (Maybe Matrix)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Matrix
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ContextGetMatrixMethodInfo
    instance (signature ~ (m (Maybe Pango.Matrix.Matrix)), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetMatrixMethodInfo a signature where
        overloadedMethod = contextGetMatrix

    instance O.OverloadedMethodInfo ContextGetMatrixMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetMatrix",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetMatrix"
            })

    #endif

    -- method Context::get_metrics
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "desc"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "FontDescription" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a `PangoFontDescription` structure. %NULL means that the\n  font description from the context will be used."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "language"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Language" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "language tag used to determine which script to get\n  the metrics for. %NULL means that the language tag from the context\n  will be used. If no language tag is set on the context, metrics\n  for the default language (as determined by [func@Pango.Language.get_default]\n  will be returned."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just
    --               (TInterface Name { namespace = "Pango" , name = "FontMetrics" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_metrics" pango_context_get_metrics ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        Ptr Pango.FontDescription.FontDescription -> -- desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
        Ptr Pango.Language.Language ->          -- language : TInterface (Name {namespace = "Pango", name = "Language"})
        IO (Ptr Pango.FontMetrics.FontMetrics)

    -- | Get overall metric information for a particular font description.
    --
    -- Since the metrics may be substantially different for different scripts,
    -- a language tag can be provided to indicate that the metrics should be
    -- retrieved that correspond to the script(s) used by that language.
    --
    -- The @PangoFontDescription@ is interpreted in the same way as by [func/@itemize@/],
    -- and the family name may be a comma separated list of names. If characters
    -- from multiple of these families would be used to render the string, then
    -- the returned fonts would be a composite of the metrics for the fonts loaded
    -- for the individual families.
    contextGetMetrics ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Maybe (Pango.FontDescription.FontDescription)
        -- ^ /@desc@/: a @PangoFontDescription@ structure. 'P.Nothing' means that the
        --   font description from the context will be used.
        -> Maybe (Pango.Language.Language)
        -- ^ /@language@/: language tag used to determine which script to get
        --   the metrics for. 'P.Nothing' means that the language tag from the context
        --   will be used. If no language tag is set on the context, metrics
        --   for the default language (as determined by [func/@pango@/.Language.get_default]
        --   will be returned.
        -> m Pango.FontMetrics.FontMetrics
        -- ^ __Returns:__ a @PangoFontMetrics@ object. The caller must call
        --   'GI.Pango.Structs.FontMetrics.fontMetricsUnref' when finished using the object.
    contextGetMetrics :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> Maybe FontDescription -> Maybe Language -> m FontMetrics
    contextGetMetrics a
    context Maybe FontDescription
    desc Maybe Language
    language = IO FontMetrics -> m FontMetrics
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO FontMetrics -> m FontMetrics)
    -> IO FontMetrics -> m FontMetrics
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr FontDescription
    maybeDesc <- case Maybe FontDescription
    desc of
            Maybe FontDescription
    Nothing -> Ptr FontDescription -> IO (Ptr FontDescription)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr FontDescription
    forall a. Ptr a
    FP.nullPtr
            Just FontDescription
    jDesc -> do
                Ptr FontDescription
    jDesc' <- FontDescription -> IO (Ptr FontDescription)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr FontDescription
    jDesc
                Ptr FontDescription -> IO (Ptr FontDescription)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr FontDescription
    jDesc'
        Ptr Language
    maybeLanguage <- case Maybe Language
    language of
            Maybe Language
    Nothing -> Ptr Language -> IO (Ptr Language)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Language
    forall a. Ptr a
    FP.nullPtr
            Just Language
    jLanguage -> do
                Ptr Language
    jLanguage' <- Language -> IO (Ptr Language)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Language
    jLanguage
                Ptr Language -> IO (Ptr Language)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Language
    jLanguage'
        Ptr FontMetrics
    result <- Ptr Context
    -> Ptr FontDescription -> Ptr Language -> IO (Ptr FontMetrics)
    pango_context_get_metrics Ptr Context
    context' Ptr FontDescription
    maybeDesc Ptr Language
    maybeLanguage
        Text -> Ptr FontMetrics -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL Text
    "contextGetMetrics" Ptr FontMetrics
    result
        FontMetrics
    result' <- ((ManagedPtr FontMetrics -> FontMetrics)
    -> Ptr FontMetrics -> IO FontMetrics
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr FontMetrics -> FontMetrics
    Pango.FontMetrics.FontMetrics) Ptr FontMetrics
    result
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe FontDescription -> (FontDescription -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe FontDescription
    desc FontDescription -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        Maybe Language -> (Language -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe Language
    language Language -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        FontMetrics -> IO FontMetrics
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return FontMetrics
    result'

    #if defined(ENABLE_OVERLOADING)
    data ContextGetMetricsMethodInfo
    instance (signature ~ (Maybe (Pango.FontDescription.FontDescription) -> Maybe (Pango.Language.Language) -> m Pango.FontMetrics.FontMetrics), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetMetricsMethodInfo a signature where
        overloadedMethod = contextGetMetrics

    instance O.OverloadedMethodInfo ContextGetMetricsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetMetrics",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetMetrics"
            })

    #endif

    -- method Context::get_round_glyph_positions
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_round_glyph_positions" pango_context_get_round_glyph_positions ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO CInt

    -- | Returns whether font rendering with this context should
    -- round glyph positions and widths.
    --
    -- /Since: 1.44/
    contextGetRoundGlyphPositions ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m Bool
    contextGetRoundGlyphPositions :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m Bool
    contextGetRoundGlyphPositions a
    context = IO Bool -> m Bool
    forall a. IO a -> m a
    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 Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        CInt
    result <- Ptr Context -> IO CInt
    pango_context_get_round_glyph_positions Ptr Context
    context'
        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
    context
        Bool -> IO Bool
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data ContextGetRoundGlyphPositionsMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetRoundGlyphPositionsMethodInfo a signature where
        overloadedMethod = contextGetRoundGlyphPositions

    instance O.OverloadedMethodInfo ContextGetRoundGlyphPositionsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetRoundGlyphPositions",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetRoundGlyphPositions"
            })

    #endif

    -- method Context::get_serial
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TBasicType TUInt)
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_get_serial" pango_context_get_serial ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        IO Word32

    -- | Returns the current serial number of /@context@/.
    --
    -- The serial number is initialized to an small number larger than zero
    -- when a new context is created and is increased whenever the context
    -- is changed using any of the setter functions, or the @PangoFontMap@ it
    -- uses to find fonts has changed. The serial may wrap, but will never
    -- have the value 0. Since it can wrap, never compare it with \"less than\",
    -- always use \"not equals\".
    --
    -- This can be used to automatically detect changes to a @PangoContext@,
    -- and is only useful when implementing objects that need update when their
    -- @PangoContext@ changes, like @PangoLayout@.
    --
    -- /Since: 1.32.4/
    contextGetSerial ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m Word32
        -- ^ __Returns:__ The current serial number of /@context@/.
    contextGetSerial :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m Word32
    contextGetSerial a
    context = IO Word32 -> m Word32
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Word32
    result <- Ptr Context -> IO Word32
    pango_context_get_serial Ptr Context
    context'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Word32 -> IO Word32
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    result

    #if defined(ENABLE_OVERLOADING)
    data ContextGetSerialMethodInfo
    instance (signature ~ (m Word32), MonadIO m, IsContext a) => O.OverloadedMethod ContextGetSerialMethodInfo a signature where
        overloadedMethod = contextGetSerial

    instance O.OverloadedMethodInfo ContextGetSerialMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextGetSerial",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextGetSerial"
            })

    #endif

    -- method Context::list_families
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "families"
    --           , argType =
    --               TCArray
    --                 False
    --                 (-1)
    --                 2
    --                 (TInterface Name { namespace = "Pango" , name = "FontFamily" })
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "location\n  to store a pointer to an array of `PangoFontFamily`. This array should\n  be freed with g_free()."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferContainer
    --           }
    --       , Arg
    --           { argCName = "n_families"
    --           , argType = TBasicType TInt
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "location to store the number of elements in @descs"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferEverything
    --           }
    --       ]
    -- Lengths: [ Arg
    --              { argCName = "n_families"
    --              , argType = TBasicType TInt
    --              , direction = DirectionOut
    --              , mayBeNull = False
    --              , argDoc =
    --                  Documentation
    --                    { rawDocText =
    --                        Just "location to store the number of elements in @descs"
    --                    , sinceVersion = Nothing
    --                    }
    --              , argScope = ScopeTypeInvalid
    --              , argClosure = -1
    --              , argDestroy = -1
    --              , argCallerAllocates = False
    --              , argCallbackUserData = False
    --              , transfer = TransferEverything
    --              }
    --          ]
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_list_families" pango_context_list_families ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        Ptr (Ptr (Ptr Pango.FontFamily.FontFamily)) -> -- families : TCArray False (-1) 2 (TInterface (Name {namespace = "Pango", name = "FontFamily"}))
        Ptr Int32 ->                            -- n_families : TBasicType TInt
        IO ()

    -- | List all families for a context.
    contextListFamilies ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> m ([Pango.FontFamily.FontFamily])
    contextListFamilies :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> m [FontFamily]
    contextListFamilies a
    context = IO [FontFamily] -> m [FontFamily]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO [FontFamily] -> m [FontFamily])
    -> IO [FontFamily] -> m [FontFamily]
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr (Ptr (Ptr FontFamily))
    families <- IO (Ptr (Ptr (Ptr FontFamily)))
    forall a. Storable a => IO (Ptr a)
    callocMem :: IO (Ptr (Ptr (Ptr Pango.FontFamily.FontFamily)))
        Ptr Int32
    nFamilies <- IO (Ptr Int32)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr Int32)
        Ptr Context -> Ptr (Ptr (Ptr FontFamily)) -> Ptr Int32 -> IO ()
    pango_context_list_families Ptr Context
    context' Ptr (Ptr (Ptr FontFamily))
    families Ptr Int32
    nFamilies
        Int32
    nFamilies' <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Int32
    nFamilies
        Ptr (Ptr FontFamily)
    families' <- Ptr (Ptr (Ptr FontFamily)) -> IO (Ptr (Ptr FontFamily))
    forall a. Storable a => Ptr a -> IO a
    peek Ptr (Ptr (Ptr FontFamily))
    families
        [Ptr FontFamily]
    families'' <- (Int32 -> Ptr (Ptr FontFamily) -> IO [Ptr FontFamily]
    forall a b. Integral a => a -> Ptr (Ptr b) -> IO [Ptr b]
    unpackPtrArrayWithLength Int32
    nFamilies') Ptr (Ptr FontFamily)
    families'
        [FontFamily]
    families''' <- (Ptr FontFamily -> IO FontFamily)
    -> [Ptr FontFamily] -> IO [FontFamily]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM ((ManagedPtr FontFamily -> FontFamily)
    -> Ptr FontFamily -> IO FontFamily
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr FontFamily -> FontFamily
    Pango.FontFamily.FontFamily) [Ptr FontFamily]
    families''
        Ptr (Ptr FontFamily) -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr (Ptr FontFamily)
    families'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Ptr (Ptr (Ptr FontFamily)) -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr (Ptr (Ptr FontFamily))
    families
        Ptr Int32 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Int32
    nFamilies
        [FontFamily] -> IO [FontFamily]
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [FontFamily]
    families'''

    #if defined(ENABLE_OVERLOADING)
    data ContextListFamiliesMethodInfo
    instance (signature ~ (m ([Pango.FontFamily.FontFamily])), MonadIO m, IsContext a) => O.OverloadedMethod ContextListFamiliesMethodInfo a signature where
        overloadedMethod = contextListFamilies

    instance O.OverloadedMethodInfo ContextListFamiliesMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextListFamilies",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextListFamilies"
            })

    #endif

    -- method Context::load_font
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "desc"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "FontDescription" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a `PangoFontDescription` describing the font to load"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Font" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_load_font" pango_context_load_font ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        Ptr Pango.FontDescription.FontDescription -> -- desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
        IO (Ptr Pango.Font.Font)

    -- | Loads the font in one of the fontmaps in the context
    -- that is the closest match for /@desc@/.
    contextLoadFont ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Pango.FontDescription.FontDescription
        -- ^ /@desc@/: a @PangoFontDescription@ describing the font to load
        -> m (Maybe Pango.Font.Font)
        -- ^ __Returns:__ the newly allocated @PangoFont@
        --   that was loaded, or 'P.Nothing' if no font matched.
    contextLoadFont :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> FontDescription -> m (Maybe Font)
    contextLoadFont a
    context FontDescription
    desc = IO (Maybe Font) -> m (Maybe Font)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Font) -> m (Maybe Font))
    -> IO (Maybe Font) -> m (Maybe Font)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr FontDescription
    desc' <- FontDescription -> IO (Ptr FontDescription)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr FontDescription
    desc
        Ptr Font
    result <- Ptr Context -> Ptr FontDescription -> IO (Ptr Font)
    pango_context_load_font Ptr Context
    context' Ptr FontDescription
    desc'
        Maybe Font
    maybeResult <- Ptr Font -> (Ptr Font -> IO Font) -> IO (Maybe Font)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Font
    result ((Ptr Font -> IO Font) -> IO (Maybe Font))
    -> (Ptr Font -> IO Font) -> IO (Maybe Font)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Font
    result' -> do
            Font
    result'' <- ((ManagedPtr Font -> Font) -> Ptr Font -> IO Font
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Font -> Font
    Pango.Font.Font) Ptr Font
    result'
            Font -> IO Font
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Font
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        FontDescription -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr FontDescription
    desc
        Maybe Font -> IO (Maybe Font)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Font
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ContextLoadFontMethodInfo
    instance (signature ~ (Pango.FontDescription.FontDescription -> m (Maybe Pango.Font.Font)), MonadIO m, IsContext a) => O.OverloadedMethod ContextLoadFontMethodInfo a signature where
        overloadedMethod = contextLoadFont

    instance O.OverloadedMethodInfo ContextLoadFontMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextLoadFont",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextLoadFont"
            })

    #endif

    -- method Context::load_fontset
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "desc"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "FontDescription" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just "a `PangoFontDescription` describing the fonts to load"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "language"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Language" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoLanguage` the fonts will be used for"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Just (TInterface Name { namespace = "Pango" , name = "Fontset" })
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_load_fontset" pango_context_load_fontset ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        Ptr Pango.FontDescription.FontDescription -> -- desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
        Ptr Pango.Language.Language ->          -- language : TInterface (Name {namespace = "Pango", name = "Language"})
        IO (Ptr Pango.Fontset.Fontset)

    -- | Load a set of fonts in the context that can be used to render
    -- a font matching /@desc@/.
    contextLoadFontset ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Pango.FontDescription.FontDescription
        -- ^ /@desc@/: a @PangoFontDescription@ describing the fonts to load
        -> Pango.Language.Language
        -- ^ /@language@/: a @PangoLanguage@ the fonts will be used for
        -> m (Maybe Pango.Fontset.Fontset)
        -- ^ __Returns:__ the newly allocated
        --   @PangoFontset@ loaded, or 'P.Nothing' if no font matched.
    contextLoadFontset :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> FontDescription -> Language -> m (Maybe Fontset)
    contextLoadFontset a
    context FontDescription
    desc Language
    language = IO (Maybe Fontset) -> m (Maybe Fontset)
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe Fontset) -> m (Maybe Fontset))
    -> IO (Maybe Fontset) -> m (Maybe Fontset)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr FontDescription
    desc' <- FontDescription -> IO (Ptr FontDescription)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr FontDescription
    desc
        Ptr Language
    language' <- Language -> IO (Ptr Language)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Language
    language
        Ptr Fontset
    result <- Ptr Context
    -> Ptr FontDescription -> Ptr Language -> IO (Ptr Fontset)
    pango_context_load_fontset Ptr Context
    context' Ptr FontDescription
    desc' Ptr Language
    language'
        Maybe Fontset
    maybeResult <- Ptr Fontset -> (Ptr Fontset -> IO Fontset) -> IO (Maybe Fontset)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr Fontset
    result ((Ptr Fontset -> IO Fontset) -> IO (Maybe Fontset))
    -> (Ptr Fontset -> IO Fontset) -> IO (Maybe Fontset)
    forall a b. (a -> b) -> a -> b
    $ \Ptr Fontset
    result' -> do
            Fontset
    result'' <- ((ManagedPtr Fontset -> Fontset) -> Ptr Fontset -> IO Fontset
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    wrapObject ManagedPtr Fontset -> Fontset
    Pango.Fontset.Fontset) Ptr Fontset
    result'
            Fontset -> IO Fontset
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Fontset
    result''
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        FontDescription -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr FontDescription
    desc
        Language -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr Language
    language
        Maybe Fontset -> IO (Maybe Fontset)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe Fontset
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data ContextLoadFontsetMethodInfo
    instance (signature ~ (Pango.FontDescription.FontDescription -> Pango.Language.Language -> m (Maybe Pango.Fontset.Fontset)), MonadIO m, IsContext a) => O.OverloadedMethod ContextLoadFontsetMethodInfo a signature where
        overloadedMethod = contextLoadFontset

    instance O.OverloadedMethodInfo ContextLoadFontsetMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextLoadFontset",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextLoadFontset"
            })

    #endif

    -- method Context::set_base_dir
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "direction"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Direction" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new base direction"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_set_base_dir" pango_context_set_base_dir ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        CUInt ->                                -- direction : TInterface (Name {namespace = "Pango", name = "Direction"})
        IO ()

    -- | Sets the base direction for the context.
    --
    -- The base direction is used in applying the Unicode bidirectional
    -- algorithm; if the /@direction@/ is 'GI.Pango.Enums.DirectionLtr' or
    -- 'GI.Pango.Enums.DirectionRtl', then the value will be used as the paragraph
    -- direction in the Unicode bidirectional algorithm. A value of
    -- 'GI.Pango.Enums.DirectionWeakLtr' or 'GI.Pango.Enums.DirectionWeakRtl' is used only
    -- for paragraphs that do not contain any strong characters themselves.
    contextSetBaseDir ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Pango.Enums.Direction
        -- ^ /@direction@/: the new base direction
        -> m ()
    contextSetBaseDir :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> Direction -> m ()
    contextSetBaseDir a
    context Direction
    direction = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        let direction' :: CUInt
    direction' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (Direction -> Int) -> Direction -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Direction -> Int
    forall a. Enum a => a -> Int
    fromEnum) Direction
    direction
        Ptr Context -> CUInt -> IO ()
    pango_context_set_base_dir Ptr Context
    context' CUInt
    direction'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ContextSetBaseDirMethodInfo
    instance (signature ~ (Pango.Enums.Direction -> m ()), MonadIO m, IsContext a) => O.OverloadedMethod ContextSetBaseDirMethodInfo a signature where
        overloadedMethod = contextSetBaseDir

    instance O.OverloadedMethodInfo ContextSetBaseDirMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextSetBaseDir",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextSetBaseDir"
            })

    #endif

    -- method Context::set_base_gravity
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "gravity"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Gravity" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new base gravity"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_set_base_gravity" pango_context_set_base_gravity ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        CUInt ->                                -- gravity : TInterface (Name {namespace = "Pango", name = "Gravity"})
        IO ()

    -- | Sets the base gravity for the context.
    --
    -- The base gravity is used in laying vertical text out.
    --
    -- /Since: 1.16/
    contextSetBaseGravity ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Pango.Enums.Gravity
        -- ^ /@gravity@/: the new base gravity
        -> m ()
    contextSetBaseGravity :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> Gravity -> m ()
    contextSetBaseGravity a
    context Gravity
    gravity = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        let gravity' :: CUInt
    gravity' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (Gravity -> Int) -> Gravity -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Gravity -> Int
    forall a. Enum a => a -> Int
    fromEnum) Gravity
    gravity
        Ptr Context -> CUInt -> IO ()
    pango_context_set_base_gravity Ptr Context
    context' CUInt
    gravity'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ContextSetBaseGravityMethodInfo
    instance (signature ~ (Pango.Enums.Gravity -> m ()), MonadIO m, IsContext a) => O.OverloadedMethod ContextSetBaseGravityMethodInfo a signature where
        overloadedMethod = contextSetBaseGravity

    instance O.OverloadedMethodInfo ContextSetBaseGravityMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextSetBaseGravity",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextSetBaseGravity"
            })

    #endif

    -- method Context::set_font_description
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "desc"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "FontDescription" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new pango font description"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_set_font_description" pango_context_set_font_description ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        Ptr Pango.FontDescription.FontDescription -> -- desc : TInterface (Name {namespace = "Pango", name = "FontDescription"})
        IO ()

    -- | Set the default font description for the context
    contextSetFontDescription ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Maybe (Pango.FontDescription.FontDescription)
        -- ^ /@desc@/: the new pango font description
        -> m ()
    contextSetFontDescription :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> Maybe FontDescription -> m ()
    contextSetFontDescription a
    context Maybe FontDescription
    desc = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr FontDescription
    maybeDesc <- case Maybe FontDescription
    desc of
            Maybe FontDescription
    Nothing -> Ptr FontDescription -> IO (Ptr FontDescription)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr FontDescription
    forall a. Ptr a
    FP.nullPtr
            Just FontDescription
    jDesc -> do
                Ptr FontDescription
    jDesc' <- FontDescription -> IO (Ptr FontDescription)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr FontDescription
    jDesc
                Ptr FontDescription -> IO (Ptr FontDescription)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr FontDescription
    jDesc'
        Ptr Context -> Ptr FontDescription -> IO ()
    pango_context_set_font_description Ptr Context
    context' Ptr FontDescription
    maybeDesc
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe FontDescription -> (FontDescription -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe FontDescription
    desc FontDescription -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ContextSetFontDescriptionMethodInfo
    instance (signature ~ (Maybe (Pango.FontDescription.FontDescription) -> m ()), MonadIO m, IsContext a) => O.OverloadedMethod ContextSetFontDescriptionMethodInfo a signature where
        overloadedMethod = contextSetFontDescription

    instance O.OverloadedMethodInfo ContextSetFontDescriptionMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextSetFontDescription",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextSetFontDescription"
            })

    #endif

    -- method Context::set_font_map
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "font_map"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "FontMap" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the `PangoFontMap` to set."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_set_font_map" pango_context_set_font_map ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        Ptr Pango.FontMap.FontMap ->            -- font_map : TInterface (Name {namespace = "Pango", name = "FontMap"})
        IO ()

    -- | Sets the font map to be searched when fonts are looked-up
    -- in this context.
    --
    -- This is only for internal use by Pango backends, a @PangoContext@
    -- obtained via one of the recommended methods should already have a
    -- suitable font map.
    contextSetFontMap ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a, Pango.FontMap.IsFontMap b) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Maybe (b)
        -- ^ /@fontMap@/: the @PangoFontMap@ to set.
        -> m ()
    contextSetFontMap :: forall (m :: * -> *) a b.
    (HasCallStack, MonadIO m, IsContext a, IsFontMap b) =>
    a -> Maybe b -> m ()
    contextSetFontMap a
    context Maybe b
    fontMap = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr FontMap
    maybeFontMap <- case Maybe b
    fontMap of
            Maybe b
    Nothing -> Ptr FontMap -> IO (Ptr FontMap)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr FontMap
    forall a. Ptr a
    FP.nullPtr
            Just b
    jFontMap -> do
                Ptr FontMap
    jFontMap' <- b -> IO (Ptr FontMap)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr b
    jFontMap
                Ptr FontMap -> IO (Ptr FontMap)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr FontMap
    jFontMap'
        Ptr Context -> Ptr FontMap -> IO ()
    pango_context_set_font_map Ptr Context
    context' Ptr FontMap
    maybeFontMap
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe b -> (b -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe b
    fontMap b -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ContextSetFontMapMethodInfo
    instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsContext a, Pango.FontMap.IsFontMap b) => O.OverloadedMethod ContextSetFontMapMethodInfo a signature where
        overloadedMethod = contextSetFontMap

    instance O.OverloadedMethodInfo ContextSetFontMapMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextSetFontMap",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextSetFontMap"
            })

    #endif

    -- method Context::set_gravity_hint
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "hint"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "GravityHint" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new gravity hint"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_set_gravity_hint" pango_context_set_gravity_hint ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        CUInt ->                                -- hint : TInterface (Name {namespace = "Pango", name = "GravityHint"})
        IO ()

    -- | Sets the gravity hint for the context.
    --
    -- The gravity hint is used in laying vertical text out, and
    -- is only relevant if gravity of the context as returned by
    -- 'GI.Pango.Objects.Context.contextGetGravity' is set to 'GI.Pango.Enums.GravityEast'
    -- or 'GI.Pango.Enums.GravityWest'.
    --
    -- /Since: 1.16/
    contextSetGravityHint ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Pango.Enums.GravityHint
        -- ^ /@hint@/: the new gravity hint
        -> m ()
    contextSetGravityHint :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> GravityHint -> m ()
    contextSetGravityHint a
    context GravityHint
    hint = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        let hint' :: CUInt
    hint' = (Int -> CUInt
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> CUInt) -> (GravityHint -> Int) -> GravityHint -> CUInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . GravityHint -> Int
    forall a. Enum a => a -> Int
    fromEnum) GravityHint
    hint
        Ptr Context -> CUInt -> IO ()
    pango_context_set_gravity_hint Ptr Context
    context' CUInt
    hint'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ContextSetGravityHintMethodInfo
    instance (signature ~ (Pango.Enums.GravityHint -> m ()), MonadIO m, IsContext a) => O.OverloadedMethod ContextSetGravityHintMethodInfo a signature where
        overloadedMethod = contextSetGravityHint

    instance O.OverloadedMethodInfo ContextSetGravityHintMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextSetGravityHint",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextSetGravityHint"
            })

    #endif

    -- method Context::set_language
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "language"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Language" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "the new language tag."
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_set_language" pango_context_set_language ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        Ptr Pango.Language.Language ->          -- language : TInterface (Name {namespace = "Pango", name = "Language"})
        IO ()

    -- | Sets the global language tag for the context.
    --
    -- The default language for the locale of the running process
    -- can be found using [func/@pango@/.Language.get_default].
    contextSetLanguage ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Maybe (Pango.Language.Language)
        -- ^ /@language@/: the new language tag.
        -> m ()
    contextSetLanguage :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> Maybe Language -> m ()
    contextSetLanguage a
    context Maybe Language
    language = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr Language
    maybeLanguage <- case Maybe Language
    language of
            Maybe Language
    Nothing -> Ptr Language -> IO (Ptr Language)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Language
    forall a. Ptr a
    FP.nullPtr
            Just Language
    jLanguage -> do
                Ptr Language
    jLanguage' <- Language -> IO (Ptr Language)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Language
    jLanguage
                Ptr Language -> IO (Ptr Language)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Language
    jLanguage'
        Ptr Context -> Ptr Language -> IO ()
    pango_context_set_language Ptr Context
    context' Ptr Language
    maybeLanguage
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe Language -> (Language -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe Language
    language Language -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ContextSetLanguageMethodInfo
    instance (signature ~ (Maybe (Pango.Language.Language) -> m ()), MonadIO m, IsContext a) => O.OverloadedMethod ContextSetLanguageMethodInfo a signature where
        overloadedMethod = contextSetLanguage

    instance O.OverloadedMethodInfo ContextSetLanguageMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextSetLanguage",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextSetLanguage"
            })

    #endif

    -- method Context::set_matrix
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "matrix"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Matrix" }
    --           , direction = DirectionIn
    --           , mayBeNull = True
    --           , argDoc =
    --               Documentation
    --                 { rawDocText =
    --                     Just
    --                       "a `PangoMatrix`, or %NULL to unset any existing\nmatrix. (No matrix set is the same as setting the identity matrix.)"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_set_matrix" pango_context_set_matrix ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        Ptr Pango.Matrix.Matrix ->              -- matrix : TInterface (Name {namespace = "Pango", name = "Matrix"})
        IO ()

    -- | Sets the transformation matrix that will be applied when rendering
    -- with this context.
    --
    -- Note that reported metrics are in the user space coordinates before
    -- the application of the matrix, not device-space coordinates after the
    -- application of the matrix. So, they don\'t scale with the matrix, though
    -- they may change slightly for different matrices, depending on how the
    -- text is fit to the pixel grid.
    --
    -- /Since: 1.6/
    contextSetMatrix ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Maybe (Pango.Matrix.Matrix)
        -- ^ /@matrix@/: a @PangoMatrix@, or 'P.Nothing' to unset any existing
        -- matrix. (No matrix set is the same as setting the identity matrix.)
        -> m ()
    contextSetMatrix :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> Maybe Matrix -> m ()
    contextSetMatrix a
    context Maybe Matrix
    matrix = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        Ptr Matrix
    maybeMatrix <- case Maybe Matrix
    matrix of
            Maybe Matrix
    Nothing -> Ptr Matrix -> IO (Ptr Matrix)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Matrix
    forall a. Ptr a
    FP.nullPtr
            Just Matrix
    jMatrix -> do
                Ptr Matrix
    jMatrix' <- Matrix -> IO (Ptr Matrix)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr Matrix
    jMatrix
                Ptr Matrix -> IO (Ptr Matrix)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Ptr Matrix
    jMatrix'
        Ptr Context -> Ptr Matrix -> IO ()
    pango_context_set_matrix Ptr Context
    context' Ptr Matrix
    maybeMatrix
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        Maybe Matrix -> (Matrix -> IO ()) -> IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe Matrix
    matrix Matrix -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ContextSetMatrixMethodInfo
    instance (signature ~ (Maybe (Pango.Matrix.Matrix) -> m ()), MonadIO m, IsContext a) => O.OverloadedMethod ContextSetMatrixMethodInfo a signature where
        overloadedMethod = contextSetMatrix

    instance O.OverloadedMethodInfo ContextSetMatrixMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextSetMatrix",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextSetMatrix"
            })

    #endif

    -- method Context::set_round_glyph_positions
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "context"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Context" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a `PangoContext`" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "round_positions"
    --           , argType = TBasicType TBoolean
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "whether to round glyph positions"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , argCallbackUserData = False
    --           , transfer = TransferNothing
    --           }
    --       ]
    -- Lengths: []
    -- returnType: Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_context_set_round_glyph_positions" pango_context_set_round_glyph_positions ::
        Ptr Context ->                          -- context : TInterface (Name {namespace = "Pango", name = "Context"})
        CInt ->                                 -- round_positions : TBasicType TBoolean
        IO ()

    -- | Sets whether font rendering with this context should
    -- round glyph positions and widths to integral positions,
    -- in device units.
    --
    -- This is useful when the renderer can\'t handle subpixel
    -- positioning of glyphs.
    --
    -- The default value is to round glyph positions, to remain
    -- compatible with previous Pango behavior.
    --
    -- /Since: 1.44/
    contextSetRoundGlyphPositions ::
        (B.CallStack.HasCallStack, MonadIO m, IsContext a) =>
        a
        -- ^ /@context@/: a @PangoContext@
        -> Bool
        -- ^ /@roundPositions@/: whether to round glyph positions
        -> m ()
    contextSetRoundGlyphPositions :: forall (m :: * -> *) a.
    (HasCallStack, MonadIO m, IsContext a) =>
    a -> Bool -> m ()
    contextSetRoundGlyphPositions a
    context Bool
    roundPositions = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr Context
    context' <- a -> IO (Ptr Context)
    forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
    unsafeManagedPtrCastPtr a
    context
        let roundPositions' :: CInt
    roundPositions' = (Int -> CInt
    forall a b. (Integral a, Num b) => a -> b
    P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> Int
    forall a. Enum a => a -> Int
    P.fromEnum) Bool
    roundPositions
        Ptr Context -> CInt -> IO ()
    pango_context_set_round_glyph_positions Ptr Context
    context' CInt
    roundPositions'
        a -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr a
    context
        () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data ContextSetRoundGlyphPositionsMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsContext a) => O.OverloadedMethod ContextSetRoundGlyphPositionsMethodInfo a signature where
        overloadedMethod = contextSetRoundGlyphPositions

    instance O.OverloadedMethodInfo ContextSetRoundGlyphPositionsMethodInfo a where
        overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.Pango.Objects.Context.contextSetRoundGlyphPositions",
            O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.30/docs/GI-Pango-Objects-Context.html#v:contextSetRoundGlyphPositions"
            })

    #endif