    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    'GI.Pango.Objects.Renderer.Renderer' is a base class for objects that are used to
    render Pango objects such as 'GI.Pango.Structs.GlyphString.GlyphString' and
    'GI.Pango.Objects.Layout.Layout'.

    /Since: 1.8/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Pango.Objects.Renderer
        (

    -- * Exported types
        Renderer(..)                            ,
        IsRenderer                              ,
        toRenderer                              ,
        noRenderer                              ,

     -- * Methods
    -- ** activate #method:activate#

    #if ENABLE_OVERLOADING
        RendererActivateMethodInfo              ,
    #endif
        rendererActivate                        ,

    -- ** deactivate #method:deactivate#

    #if ENABLE_OVERLOADING
        RendererDeactivateMethodInfo            ,
    #endif
        rendererDeactivate                      ,

    -- ** drawErrorUnderline #method:drawErrorUnderline#

    #if ENABLE_OVERLOADING
        RendererDrawErrorUnderlineMethodInfo    ,
    #endif
        rendererDrawErrorUnderline              ,

    -- ** drawGlyph #method:drawGlyph#

    #if ENABLE_OVERLOADING
        RendererDrawGlyphMethodInfo             ,
    #endif
        rendererDrawGlyph                       ,

    -- ** drawGlyphItem #method:drawGlyphItem#

    #if ENABLE_OVERLOADING
        RendererDrawGlyphItemMethodInfo         ,
    #endif
        rendererDrawGlyphItem                   ,

    -- ** drawGlyphs #method:drawGlyphs#

    #if ENABLE_OVERLOADING
        RendererDrawGlyphsMethodInfo            ,
    #endif
        rendererDrawGlyphs                      ,

    -- ** drawLayout #method:drawLayout#

    #if ENABLE_OVERLOADING
        RendererDrawLayoutMethodInfo            ,
    #endif
        rendererDrawLayout                      ,

    -- ** drawLayoutLine #method:drawLayoutLine#

    #if ENABLE_OVERLOADING
        RendererDrawLayoutLineMethodInfo        ,
    #endif
        rendererDrawLayoutLine                  ,

    -- ** drawRectangle #method:drawRectangle#

    #if ENABLE_OVERLOADING
        RendererDrawRectangleMethodInfo         ,
    #endif
        rendererDrawRectangle                   ,

    -- ** drawTrapezoid #method:drawTrapezoid#

    #if ENABLE_OVERLOADING
        RendererDrawTrapezoidMethodInfo         ,
    #endif
        rendererDrawTrapezoid                   ,

    -- ** getAlpha #method:getAlpha#

    #if ENABLE_OVERLOADING
        RendererGetAlphaMethodInfo              ,
    #endif
        rendererGetAlpha                        ,

    -- ** getColor #method:getColor#

    #if ENABLE_OVERLOADING
        RendererGetColorMethodInfo              ,
    #endif
        rendererGetColor                        ,

    -- ** getLayout #method:getLayout#

    #if ENABLE_OVERLOADING
        RendererGetLayoutMethodInfo             ,
    #endif
        rendererGetLayout                       ,

    -- ** getLayoutLine #method:getLayoutLine#

    #if ENABLE_OVERLOADING
        RendererGetLayoutLineMethodInfo         ,
    #endif
        rendererGetLayoutLine                   ,

    -- ** getMatrix #method:getMatrix#

    #if ENABLE_OVERLOADING
        RendererGetMatrixMethodInfo             ,
    #endif
        rendererGetMatrix                       ,

    -- ** partChanged #method:partChanged#

    #if ENABLE_OVERLOADING
        RendererPartChangedMethodInfo           ,
    #endif
        rendererPartChanged                     ,

    -- ** setAlpha #method:setAlpha#

    #if ENABLE_OVERLOADING
        RendererSetAlphaMethodInfo              ,
    #endif
        rendererSetAlpha                        ,

    -- ** setColor #method:setColor#

    #if ENABLE_OVERLOADING
        RendererSetColorMethodInfo              ,
    #endif
        rendererSetColor                        ,

    -- ** setMatrix #method:setMatrix#

    #if ENABLE_OVERLOADING
        RendererSetMatrixMethodInfo             ,
    #endif
        rendererSetMatrix                       ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    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.Layout as Pango.Layout
    import {-# SOURCE #-} qualified GI.Pango.Structs.Color as Pango.Color
    import {-# SOURCE #-} qualified GI.Pango.Structs.GlyphItem as Pango.GlyphItem
    import {-# SOURCE #-} qualified GI.Pango.Structs.GlyphString as Pango.GlyphString
    import {-# SOURCE #-} qualified GI.Pango.Structs.LayoutLine as Pango.LayoutLine
    import {-# SOURCE #-} qualified GI.Pango.Structs.Matrix as Pango.Matrix

    -- | Memory-managed wrapper type.
    newtype Renderer = Renderer (ManagedPtr Renderer)
    foreign import ccall "pango_renderer_get_type"
        c_pango_renderer_get_type :: IO GType

    instance GObject Renderer where
        gobjectType _ = c_pango_renderer_get_type

    -- | Type class for types which can be safely cast to `Renderer`, for instance with `toRenderer`.
    class GObject o => IsRenderer o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Renderer a) =>
        IsRenderer a
    #endif
    instance IsRenderer Renderer
    instance GObject.Object.IsObject Renderer

    -- | Cast to `Renderer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toRenderer :: (MonadIO m, IsRenderer o) => o -> m Renderer
    toRenderer = liftIO . unsafeCastTo Renderer

    -- | A convenience alias for `Nothing` :: `Maybe` `Renderer`.
    noRenderer :: Maybe Renderer
    noRenderer = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveRendererMethod (t :: Symbol) (o :: *) :: * where
        ResolveRendererMethod "activate" o = RendererActivateMethodInfo
        ResolveRendererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveRendererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveRendererMethod "deactivate" o = RendererDeactivateMethodInfo
        ResolveRendererMethod "drawErrorUnderline" o = RendererDrawErrorUnderlineMethodInfo
        ResolveRendererMethod "drawGlyph" o = RendererDrawGlyphMethodInfo
        ResolveRendererMethod "drawGlyphItem" o = RendererDrawGlyphItemMethodInfo
        ResolveRendererMethod "drawGlyphs" o = RendererDrawGlyphsMethodInfo
        ResolveRendererMethod "drawLayout" o = RendererDrawLayoutMethodInfo
        ResolveRendererMethod "drawLayoutLine" o = RendererDrawLayoutLineMethodInfo
        ResolveRendererMethod "drawRectangle" o = RendererDrawRectangleMethodInfo
        ResolveRendererMethod "drawTrapezoid" o = RendererDrawTrapezoidMethodInfo
        ResolveRendererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveRendererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveRendererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveRendererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveRendererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveRendererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveRendererMethod "partChanged" o = RendererPartChangedMethodInfo
        ResolveRendererMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveRendererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveRendererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveRendererMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveRendererMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveRendererMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveRendererMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveRendererMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveRendererMethod "getAlpha" o = RendererGetAlphaMethodInfo
        ResolveRendererMethod "getColor" o = RendererGetColorMethodInfo
        ResolveRendererMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveRendererMethod "getLayout" o = RendererGetLayoutMethodInfo
        ResolveRendererMethod "getLayoutLine" o = RendererGetLayoutLineMethodInfo
        ResolveRendererMethod "getMatrix" o = RendererGetMatrixMethodInfo
        ResolveRendererMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveRendererMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveRendererMethod "setAlpha" o = RendererSetAlphaMethodInfo
        ResolveRendererMethod "setColor" o = RendererSetColorMethodInfo
        ResolveRendererMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveRendererMethod "setMatrix" o = RendererSetMatrixMethodInfo
        ResolveRendererMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveRendererMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveRendererMethod t Renderer, O.MethodInfo info Renderer p) => O.IsLabelProxy t (Renderer -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveRendererMethod t Renderer, O.MethodInfo info Renderer p) => O.IsLabel t (Renderer -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList Renderer
    type instance O.AttributeList Renderer = RendererAttributeList
    type RendererAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    #endif

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

    #endif

    -- method Renderer::activate
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_activate" pango_renderer_activate ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        IO ()

    {- |
    Does initial setup before rendering operations on /@renderer@/.
    'GI.Pango.Objects.Renderer.rendererDeactivate' should be called when done drawing.
    Calls such as 'GI.Pango.Objects.Renderer.rendererDrawLayout' automatically
    activate the layout before drawing on it. Calls to
    'GI.Pango.Objects.Renderer.rendererActivate' and 'GI.Pango.Objects.Renderer.rendererDeactivate' can
    be nested and the renderer will only be initialized and
    deinitialized once.

    /Since: 1.8/
    -}
    rendererActivate ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> m ()
    rendererActivate renderer = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        pango_renderer_activate renderer'
        touchManagedPtr renderer
        return ()

    #if ENABLE_OVERLOADING
    data RendererActivateMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererActivateMethodInfo a signature where
        overloadedMethod _ = rendererActivate

    #endif

    -- method Renderer::deactivate
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_deactivate" pango_renderer_deactivate ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        IO ()

    {- |
    Cleans up after rendering operations on /@renderer@/. See
    docs for 'GI.Pango.Objects.Renderer.rendererActivate'.

    /Since: 1.8/
    -}
    rendererDeactivate ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> m ()
    rendererDeactivate renderer = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        pango_renderer_deactivate renderer'
        touchManagedPtr renderer
        return ()

    #if ENABLE_OVERLOADING
    data RendererDeactivateMethodInfo
    instance (signature ~ (m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererDeactivateMethodInfo a signature where
        overloadedMethod _ = rendererDeactivate

    #endif

    -- method Renderer::draw_error_underline
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate of underline, in Pango units in user coordinate system", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate of underline, in Pango units in user coordinate system", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width of underline, in Pango units in user coordinate system", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height of underline, in Pango units in user coordinate system", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_draw_error_underline" pango_renderer_draw_error_underline ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        Int32 ->                                -- width : TBasicType TInt
        Int32 ->                                -- height : TBasicType TInt
        IO ()

    {- |
    Draw a squiggly line that approximately covers the given rectangle
    in the style of an underline used to indicate a spelling error.
    (The width of the underline is rounded to an integer number
    of up\/down segments and the resulting rectangle is centered
    in the original rectangle)

    This should be called while /@renderer@/ is already active.  Use
    'GI.Pango.Objects.Renderer.rendererActivate' to activate a renderer.

    /Since: 1.8/
    -}
    rendererDrawErrorUnderline ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Int32
        {- ^ /@x@/: X coordinate of underline, in Pango units in user coordinate system -}
        -> Int32
        {- ^ /@y@/: Y coordinate of underline, in Pango units in user coordinate system -}
        -> Int32
        {- ^ /@width@/: width of underline, in Pango units in user coordinate system -}
        -> Int32
        {- ^ /@height@/: height of underline, in Pango units in user coordinate system -}
        -> m ()
    rendererDrawErrorUnderline renderer x y width height = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        pango_renderer_draw_error_underline renderer' x y width height
        touchManagedPtr renderer
        return ()

    #if ENABLE_OVERLOADING
    data RendererDrawErrorUnderlineMethodInfo
    instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererDrawErrorUnderlineMethodInfo a signature where
        overloadedMethod _ = rendererDrawErrorUnderline

    #endif

    -- method Renderer::draw_glyph
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font", argType = TInterface (Name {namespace = "Pango", name = "Font"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoFont", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "glyph", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the glyph index of a single glyph", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate of left edge of baseline of glyph", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate of left edge of baseline of glyph", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_draw_glyph" pango_renderer_draw_glyph ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        Ptr Pango.Font.Font ->                  -- font : TInterface (Name {namespace = "Pango", name = "Font"})
        Word32 ->                               -- glyph : TBasicType TUInt32
        CDouble ->                              -- x : TBasicType TDouble
        CDouble ->                              -- y : TBasicType TDouble
        IO ()

    {- |
    Draws a single glyph with coordinates in device space.

    /Since: 1.8/
    -}
    rendererDrawGlyph ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a, Pango.Font.IsFont b) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> b
        {- ^ /@font@/: a 'GI.Pango.Objects.Font.Font' -}
        -> Word32
        {- ^ /@glyph@/: the glyph index of a single glyph -}
        -> Double
        {- ^ /@x@/: X coordinate of left edge of baseline of glyph -}
        -> Double
        {- ^ /@y@/: Y coordinate of left edge of baseline of glyph -}
        -> m ()
    rendererDrawGlyph renderer font glyph x y = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        font' <- unsafeManagedPtrCastPtr font
        let x' = realToFrac x
        let y' = realToFrac y
        pango_renderer_draw_glyph renderer' font' glyph x' y'
        touchManagedPtr renderer
        touchManagedPtr font
        return ()

    #if ENABLE_OVERLOADING
    data RendererDrawGlyphMethodInfo
    instance (signature ~ (b -> Word32 -> Double -> Double -> m ()), MonadIO m, IsRenderer a, Pango.Font.IsFont b) => O.MethodInfo RendererDrawGlyphMethodInfo a signature where
        overloadedMethod _ = rendererDrawGlyph

    #endif

    -- method Renderer::draw_glyph_item
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the UTF-8 text that @glyph_item refers to, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "glyph_item", argType = TInterface (Name {namespace = "Pango", name = "GlyphItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphItem", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position of left edge of baseline, in user space coordinates\n  in Pango units.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position of left edge of baseline, in user space coordinates\n   in Pango units.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_draw_glyph_item" pango_renderer_draw_glyph_item ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        CString ->                              -- text : TBasicType TUTF8
        Ptr Pango.GlyphItem.GlyphItem ->        -- glyph_item : TInterface (Name {namespace = "Pango", name = "GlyphItem"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        IO ()

    {- |
    Draws the glyphs in /@glyphItem@/ with the specified 'GI.Pango.Objects.Renderer.Renderer',
    embedding the text associated with the glyphs in the output if the
    output format supports it (PDF for example).

    Note that /@text@/ is the start of the text for layout, which is then
    indexed by \<literal>/@glyphItem@/->item->offset\<\/literal>.

    If /@text@/ is 'Nothing', this simply calls 'GI.Pango.Objects.Renderer.rendererDrawGlyphs'.

    The default implementation of this method simply falls back to
    'GI.Pango.Objects.Renderer.rendererDrawGlyphs'.

    /Since: 1.22/
    -}
    rendererDrawGlyphItem ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Maybe (T.Text)
        {- ^ /@text@/: the UTF-8 text that /@glyphItem@/ refers to, or 'Nothing' -}
        -> Pango.GlyphItem.GlyphItem
        {- ^ /@glyphItem@/: a 'GI.Pango.Structs.GlyphItem.GlyphItem' -}
        -> Int32
        {- ^ /@x@/: X position of left edge of baseline, in user space coordinates
      in Pango units. -}
        -> Int32
        {- ^ /@y@/: Y position of left edge of baseline, in user space coordinates
       in Pango units. -}
        -> m ()
    rendererDrawGlyphItem renderer text glyphItem x y = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        maybeText <- case text of
            Nothing -> return nullPtr
            Just jText -> do
                jText' <- textToCString jText
                return jText'
        glyphItem' <- unsafeManagedPtrGetPtr glyphItem
        pango_renderer_draw_glyph_item renderer' maybeText glyphItem' x y
        touchManagedPtr renderer
        touchManagedPtr glyphItem
        freeMem maybeText
        return ()

    #if ENABLE_OVERLOADING
    data RendererDrawGlyphItemMethodInfo
    instance (signature ~ (Maybe (T.Text) -> Pango.GlyphItem.GlyphItem -> Int32 -> Int32 -> m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererDrawGlyphItemMethodInfo a signature where
        overloadedMethod _ = rendererDrawGlyphItem

    #endif

    -- method Renderer::draw_glyphs
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "font", argType = TInterface (Name {namespace = "Pango", name = "Font"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoFont", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "glyphs", argType = TInterface (Name {namespace = "Pango", name = "GlyphString"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphString", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position of left edge of baseline, in user space coordinates\n  in Pango units.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position of left edge of baseline, in user space coordinates\n   in Pango units.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_draw_glyphs" pango_renderer_draw_glyphs ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        Ptr Pango.Font.Font ->                  -- font : TInterface (Name {namespace = "Pango", name = "Font"})
        Ptr Pango.GlyphString.GlyphString ->    -- glyphs : TInterface (Name {namespace = "Pango", name = "GlyphString"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        IO ()

    {- |
    Draws the glyphs in /@glyphs@/ with the specified 'GI.Pango.Objects.Renderer.Renderer'.

    /Since: 1.8/
    -}
    rendererDrawGlyphs ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a, Pango.Font.IsFont b) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> b
        {- ^ /@font@/: a 'GI.Pango.Objects.Font.Font' -}
        -> Pango.GlyphString.GlyphString
        {- ^ /@glyphs@/: a 'GI.Pango.Structs.GlyphString.GlyphString' -}
        -> Int32
        {- ^ /@x@/: X position of left edge of baseline, in user space coordinates
      in Pango units. -}
        -> Int32
        {- ^ /@y@/: Y position of left edge of baseline, in user space coordinates
       in Pango units. -}
        -> m ()
    rendererDrawGlyphs renderer font glyphs x y = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        font' <- unsafeManagedPtrCastPtr font
        glyphs' <- unsafeManagedPtrGetPtr glyphs
        pango_renderer_draw_glyphs renderer' font' glyphs' x y
        touchManagedPtr renderer
        touchManagedPtr font
        touchManagedPtr glyphs
        return ()

    #if ENABLE_OVERLOADING
    data RendererDrawGlyphsMethodInfo
    instance (signature ~ (b -> Pango.GlyphString.GlyphString -> Int32 -> Int32 -> m ()), MonadIO m, IsRenderer a, Pango.Font.IsFont b) => O.MethodInfo RendererDrawGlyphsMethodInfo a signature where
        overloadedMethod _ = rendererDrawGlyphs

    #endif

    -- method Renderer::draw_layout
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "layout", argType = TInterface (Name {namespace = "Pango", name = "Layout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position of left edge of baseline, in user space coordinates\n  in Pango units.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position of left edge of baseline, in user space coordinates\n   in Pango units.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_draw_layout" pango_renderer_draw_layout ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        Ptr Pango.Layout.Layout ->              -- layout : TInterface (Name {namespace = "Pango", name = "Layout"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        IO ()

    {- |
    Draws /@layout@/ with the specified 'GI.Pango.Objects.Renderer.Renderer'.

    /Since: 1.8/
    -}
    rendererDrawLayout ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a, Pango.Layout.IsLayout b) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> b
        {- ^ /@layout@/: a 'GI.Pango.Objects.Layout.Layout' -}
        -> Int32
        {- ^ /@x@/: X position of left edge of baseline, in user space coordinates
      in Pango units. -}
        -> Int32
        {- ^ /@y@/: Y position of left edge of baseline, in user space coordinates
       in Pango units. -}
        -> m ()
    rendererDrawLayout renderer layout x y = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        layout' <- unsafeManagedPtrCastPtr layout
        pango_renderer_draw_layout renderer' layout' x y
        touchManagedPtr renderer
        touchManagedPtr layout
        return ()

    #if ENABLE_OVERLOADING
    data RendererDrawLayoutMethodInfo
    instance (signature ~ (b -> Int32 -> Int32 -> m ()), MonadIO m, IsRenderer a, Pango.Layout.IsLayout b) => O.MethodInfo RendererDrawLayoutMethodInfo a signature where
        overloadedMethod _ = rendererDrawLayout

    #endif

    -- method Renderer::draw_layout_line
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TInterface (Name {namespace = "Pango", name = "LayoutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayoutLine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position of left edge of baseline, in user space coordinates\n  in Pango units.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position of left edge of baseline, in user space coordinates\n   in Pango units.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_draw_layout_line" pango_renderer_draw_layout_line ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        Ptr Pango.LayoutLine.LayoutLine ->      -- line : TInterface (Name {namespace = "Pango", name = "LayoutLine"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        IO ()

    {- |
    Draws /@line@/ with the specified 'GI.Pango.Objects.Renderer.Renderer'.

    /Since: 1.8/
    -}
    rendererDrawLayoutLine ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Pango.LayoutLine.LayoutLine
        {- ^ /@line@/: a 'GI.Pango.Structs.LayoutLine.LayoutLine' -}
        -> Int32
        {- ^ /@x@/: X position of left edge of baseline, in user space coordinates
      in Pango units. -}
        -> Int32
        {- ^ /@y@/: Y position of left edge of baseline, in user space coordinates
       in Pango units. -}
        -> m ()
    rendererDrawLayoutLine renderer line x y = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        line' <- unsafeManagedPtrGetPtr line
        pango_renderer_draw_layout_line renderer' line' x y
        touchManagedPtr renderer
        touchManagedPtr line
        return ()

    #if ENABLE_OVERLOADING
    data RendererDrawLayoutLineMethodInfo
    instance (signature ~ (Pango.LayoutLine.LayoutLine -> Int32 -> Int32 -> m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererDrawLayoutLineMethodInfo a signature where
        overloadedMethod _ = rendererDrawLayoutLine

    #endif

    -- method Renderer::draw_rectangle
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "part", argType = TInterface (Name {namespace = "Pango", name = "RenderPart"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "type of object this rectangle is part of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X position at which to draw rectangle, in user space coordinates in Pango units", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y position at which to draw rectangle, in user space coordinates in Pango units", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width of rectangle in Pango units in user space coordinates", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height of rectangle in Pango units in user space coordinates", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_draw_rectangle" pango_renderer_draw_rectangle ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        CUInt ->                                -- part : TInterface (Name {namespace = "Pango", name = "RenderPart"})
        Int32 ->                                -- x : TBasicType TInt
        Int32 ->                                -- y : TBasicType TInt
        Int32 ->                                -- width : TBasicType TInt
        Int32 ->                                -- height : TBasicType TInt
        IO ()

    {- |
    Draws an axis-aligned rectangle in user space coordinates with the
    specified 'GI.Pango.Objects.Renderer.Renderer'.

    This should be called while /@renderer@/ is already active.  Use
    'GI.Pango.Objects.Renderer.rendererActivate' to activate a renderer.

    /Since: 1.8/
    -}
    rendererDrawRectangle ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Pango.Enums.RenderPart
        {- ^ /@part@/: type of object this rectangle is part of -}
        -> Int32
        {- ^ /@x@/: X position at which to draw rectangle, in user space coordinates in Pango units -}
        -> Int32
        {- ^ /@y@/: Y position at which to draw rectangle, in user space coordinates in Pango units -}
        -> Int32
        {- ^ /@width@/: width of rectangle in Pango units in user space coordinates -}
        -> Int32
        {- ^ /@height@/: height of rectangle in Pango units in user space coordinates -}
        -> m ()
    rendererDrawRectangle renderer part x y width height = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        let part' = (fromIntegral . fromEnum) part
        pango_renderer_draw_rectangle renderer' part' x y width height
        touchManagedPtr renderer
        return ()

    #if ENABLE_OVERLOADING
    data RendererDrawRectangleMethodInfo
    instance (signature ~ (Pango.Enums.RenderPart -> Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererDrawRectangleMethodInfo a signature where
        overloadedMethod _ = rendererDrawRectangle

    #endif

    -- method Renderer::draw_trapezoid
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "part", argType = TInterface (Name {namespace = "Pango", name = "RenderPart"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "type of object this trapezoid is part of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y1_", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate of top of trapezoid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x11", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate of left end of top of trapezoid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x21", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate of right end of top of trapezoid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y2", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate of bottom of trapezoid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x12", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate of left end of bottom of trapezoid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x22", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate of right end of bottom of trapezoid", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_draw_trapezoid" pango_renderer_draw_trapezoid ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        CUInt ->                                -- part : TInterface (Name {namespace = "Pango", name = "RenderPart"})
        CDouble ->                              -- y1_ : TBasicType TDouble
        CDouble ->                              -- x11 : TBasicType TDouble
        CDouble ->                              -- x21 : TBasicType TDouble
        CDouble ->                              -- y2 : TBasicType TDouble
        CDouble ->                              -- x12 : TBasicType TDouble
        CDouble ->                              -- x22 : TBasicType TDouble
        IO ()

    {- |
    Draws a trapezoid with the parallel sides aligned with the X axis
    using the given 'GI.Pango.Objects.Renderer.Renderer'; coordinates are in device space.

    /Since: 1.8/
    -}
    rendererDrawTrapezoid ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Pango.Enums.RenderPart
        {- ^ /@part@/: type of object this trapezoid is part of -}
        -> Double
        {- ^ /@y1_@/: Y coordinate of top of trapezoid -}
        -> Double
        {- ^ /@x11@/: X coordinate of left end of top of trapezoid -}
        -> Double
        {- ^ /@x21@/: X coordinate of right end of top of trapezoid -}
        -> Double
        {- ^ /@y2@/: Y coordinate of bottom of trapezoid -}
        -> Double
        {- ^ /@x12@/: X coordinate of left end of bottom of trapezoid -}
        -> Double
        {- ^ /@x22@/: X coordinate of right end of bottom of trapezoid -}
        -> m ()
    rendererDrawTrapezoid renderer part y1_ x11 x21 y2 x12 x22 = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        let part' = (fromIntegral . fromEnum) part
        let y1_' = realToFrac y1_
        let x11' = realToFrac x11
        let x21' = realToFrac x21
        let y2' = realToFrac y2
        let x12' = realToFrac x12
        let x22' = realToFrac x22
        pango_renderer_draw_trapezoid renderer' part' y1_' x11' x21' y2' x12' x22'
        touchManagedPtr renderer
        return ()

    #if ENABLE_OVERLOADING
    data RendererDrawTrapezoidMethodInfo
    instance (signature ~ (Pango.Enums.RenderPart -> Double -> Double -> Double -> Double -> Double -> Double -> m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererDrawTrapezoidMethodInfo a signature where
        overloadedMethod _ = rendererDrawTrapezoid

    #endif

    -- method Renderer::get_alpha
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "part", argType = TInterface (Name {namespace = "Pango", name = "RenderPart"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the part to get the alpha for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt16)
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_get_alpha" pango_renderer_get_alpha ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        CUInt ->                                -- part : TInterface (Name {namespace = "Pango", name = "RenderPart"})
        IO Word16

    {- |
    Gets the current alpha for the specified part.

    /Since: 1.38/
    -}
    rendererGetAlpha ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Pango.Enums.RenderPart
        {- ^ /@part@/: the part to get the alpha for -}
        -> m Word16
        {- ^ __Returns:__ the alpha for the specified part,
      or 0 if it hasn\'t been set and should be
      inherited from the environment. -}
    rendererGetAlpha renderer part = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        let part' = (fromIntegral . fromEnum) part
        result <- pango_renderer_get_alpha renderer' part'
        touchManagedPtr renderer
        return result

    #if ENABLE_OVERLOADING
    data RendererGetAlphaMethodInfo
    instance (signature ~ (Pango.Enums.RenderPart -> m Word16), MonadIO m, IsRenderer a) => O.MethodInfo RendererGetAlphaMethodInfo a signature where
        overloadedMethod _ = rendererGetAlpha

    #endif

    -- method Renderer::get_color
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "part", argType = TInterface (Name {namespace = "Pango", name = "RenderPart"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the part to get the color for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Pango", name = "Color"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_get_color" pango_renderer_get_color ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        CUInt ->                                -- part : TInterface (Name {namespace = "Pango", name = "RenderPart"})
        IO (Ptr Pango.Color.Color)

    {- |
    Gets the current rendering color for the specified part.

    /Since: 1.8/
    -}
    rendererGetColor ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Pango.Enums.RenderPart
        {- ^ /@part@/: the part to get the color for -}
        -> m (Maybe Pango.Color.Color)
        {- ^ __Returns:__ the color for the
      specified part, or 'Nothing' if it hasn\'t been set and should be
      inherited from the environment. -}
    rendererGetColor renderer part = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        let part' = (fromIntegral . fromEnum) part
        result <- pango_renderer_get_color renderer' part'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newBoxed Pango.Color.Color) result'
            return result''
        touchManagedPtr renderer
        return maybeResult

    #if ENABLE_OVERLOADING
    data RendererGetColorMethodInfo
    instance (signature ~ (Pango.Enums.RenderPart -> m (Maybe Pango.Color.Color)), MonadIO m, IsRenderer a) => O.MethodInfo RendererGetColorMethodInfo a signature where
        overloadedMethod _ = rendererGetColor

    #endif

    -- method Renderer::get_layout
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Pango", name = "Layout"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_get_layout" pango_renderer_get_layout ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        IO (Ptr Pango.Layout.Layout)

    {- |
    Gets the layout currently being rendered using /@renderer@/.
    Calling this function only makes sense from inside a subclass\'s
    methods, like in its draw_shape\<!---->() for example.

    The returned layout should not be modified while still being
    rendered.

    /Since: 1.20/
    -}
    rendererGetLayout ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> m (Maybe Pango.Layout.Layout)
        {- ^ __Returns:__ the layout, or 'Nothing' if
     no layout is being rendered using /@renderer@/ at this time. -}
    rendererGetLayout renderer = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        result <- pango_renderer_get_layout renderer'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newObject Pango.Layout.Layout) result'
            return result''
        touchManagedPtr renderer
        return maybeResult

    #if ENABLE_OVERLOADING
    data RendererGetLayoutMethodInfo
    instance (signature ~ (m (Maybe Pango.Layout.Layout)), MonadIO m, IsRenderer a) => O.MethodInfo RendererGetLayoutMethodInfo a signature where
        overloadedMethod _ = rendererGetLayout

    #endif

    -- method Renderer::get_layout_line
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Pango", name = "LayoutLine"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_get_layout_line" pango_renderer_get_layout_line ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        IO (Ptr Pango.LayoutLine.LayoutLine)

    {- |
    Gets the layout line currently being rendered using /@renderer@/.
    Calling this function only makes sense from inside a subclass\'s
    methods, like in its draw_shape\<!---->() for example.

    The returned layout line should not be modified while still being
    rendered.

    /Since: 1.20/
    -}
    rendererGetLayoutLine ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> m (Maybe Pango.LayoutLine.LayoutLine)
        {- ^ __Returns:__ the layout line, or 'Nothing'
      if no layout line is being rendered using /@renderer@/ at this time. -}
    rendererGetLayoutLine renderer = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        result <- pango_renderer_get_layout_line renderer'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newBoxed Pango.LayoutLine.LayoutLine) result'
            return result''
        touchManagedPtr renderer
        return maybeResult

    #if ENABLE_OVERLOADING
    data RendererGetLayoutLineMethodInfo
    instance (signature ~ (m (Maybe Pango.LayoutLine.LayoutLine)), MonadIO m, IsRenderer a) => O.MethodInfo RendererGetLayoutLineMethodInfo a signature where
        overloadedMethod _ = rendererGetLayoutLine

    #endif

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

    foreign import ccall "pango_renderer_get_matrix" pango_renderer_get_matrix ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        IO (Ptr Pango.Matrix.Matrix)

    {- |
    Gets the transformation matrix that will be applied when
    rendering. See 'GI.Pango.Objects.Renderer.rendererSetMatrix'.

    /Since: 1.8/
    -}
    rendererGetMatrix ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> m (Maybe Pango.Matrix.Matrix)
        {- ^ __Returns:__ the matrix, or '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. -}
    rendererGetMatrix renderer = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        result <- pango_renderer_get_matrix renderer'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (newBoxed Pango.Matrix.Matrix) result'
            return result''
        touchManagedPtr renderer
        return maybeResult

    #if ENABLE_OVERLOADING
    data RendererGetMatrixMethodInfo
    instance (signature ~ (m (Maybe Pango.Matrix.Matrix)), MonadIO m, IsRenderer a) => O.MethodInfo RendererGetMatrixMethodInfo a signature where
        overloadedMethod _ = rendererGetMatrix

    #endif

    -- method Renderer::part_changed
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "part", argType = TInterface (Name {namespace = "Pango", name = "RenderPart"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the part for which rendering has changed.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_part_changed" pango_renderer_part_changed ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        CUInt ->                                -- part : TInterface (Name {namespace = "Pango", name = "RenderPart"})
        IO ()

    {- |
    Informs Pango that the way that the rendering is done
    for /@part@/ has changed in a way that would prevent multiple
    pieces being joined together into one drawing call. For
    instance, if a subclass of 'GI.Pango.Objects.Renderer.Renderer' was to add a stipple
    option for drawing underlines, it needs to call

    \<informalexample>\<programlisting>
    pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
    \<\/programlisting>\<\/informalexample>

    When the stipple changes or underlines with different stipples
    might be joined together. Pango automatically calls this for
    changes to colors. (See 'GI.Pango.Objects.Renderer.rendererSetColor')

    /Since: 1.8/
    -}
    rendererPartChanged ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Pango.Enums.RenderPart
        {- ^ /@part@/: the part for which rendering has changed. -}
        -> m ()
    rendererPartChanged renderer part = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        let part' = (fromIntegral . fromEnum) part
        pango_renderer_part_changed renderer' part'
        touchManagedPtr renderer
        return ()

    #if ENABLE_OVERLOADING
    data RendererPartChangedMethodInfo
    instance (signature ~ (Pango.Enums.RenderPart -> m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererPartChangedMethodInfo a signature where
        overloadedMethod _ = rendererPartChanged

    #endif

    -- method Renderer::set_alpha
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "part", argType = TInterface (Name {namespace = "Pango", name = "RenderPart"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the part to set the alpha for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "alpha", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an alpha value between 1 and 65536, or 0 to unset the alpha", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_set_alpha" pango_renderer_set_alpha ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        CUInt ->                                -- part : TInterface (Name {namespace = "Pango", name = "RenderPart"})
        Word16 ->                               -- alpha : TBasicType TUInt16
        IO ()

    {- |
    Sets the alpha for part of the rendering.
    Note that the alpha may only be used if a color is
    specified for /@part@/ as well.

    /Since: 1.38/
    -}
    rendererSetAlpha ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Pango.Enums.RenderPart
        {- ^ /@part@/: the part to set the alpha for -}
        -> Word16
        {- ^ /@alpha@/: an alpha value between 1 and 65536, or 0 to unset the alpha -}
        -> m ()
    rendererSetAlpha renderer part alpha = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        let part' = (fromIntegral . fromEnum) part
        pango_renderer_set_alpha renderer' part' alpha
        touchManagedPtr renderer
        return ()

    #if ENABLE_OVERLOADING
    data RendererSetAlphaMethodInfo
    instance (signature ~ (Pango.Enums.RenderPart -> Word16 -> m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererSetAlphaMethodInfo a signature where
        overloadedMethod _ = rendererSetAlpha

    #endif

    -- method Renderer::set_color
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "part", argType = TInterface (Name {namespace = "Pango", name = "RenderPart"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the part to change the color of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Pango", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the new color or %NULL to unset the current color", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_set_color" pango_renderer_set_color ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        CUInt ->                                -- part : TInterface (Name {namespace = "Pango", name = "RenderPart"})
        Ptr Pango.Color.Color ->                -- color : TInterface (Name {namespace = "Pango", name = "Color"})
        IO ()

    {- |
    Sets the color for part of the rendering.
    Also see 'GI.Pango.Objects.Renderer.rendererSetAlpha'.

    /Since: 1.8/
    -}
    rendererSetColor ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Pango.Enums.RenderPart
        {- ^ /@part@/: the part to change the color of -}
        -> Maybe (Pango.Color.Color)
        {- ^ /@color@/: the new color or 'Nothing' to unset the current color -}
        -> m ()
    rendererSetColor renderer part color = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        let part' = (fromIntegral . fromEnum) part
        maybeColor <- case color of
            Nothing -> return nullPtr
            Just jColor -> do
                jColor' <- unsafeManagedPtrGetPtr jColor
                return jColor'
        pango_renderer_set_color renderer' part' maybeColor
        touchManagedPtr renderer
        whenJust color touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data RendererSetColorMethodInfo
    instance (signature ~ (Pango.Enums.RenderPart -> Maybe (Pango.Color.Color) -> m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererSetColorMethodInfo a signature where
        overloadedMethod _ = rendererSetColor

    #endif

    -- method Renderer::set_matrix
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "renderer", argType = TInterface (Name {namespace = "Pango", name = "Renderer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoRenderer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = 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 matrix.\n (No matrix set is the same as setting the identity matrix.)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "pango_renderer_set_matrix" pango_renderer_set_matrix ::
        Ptr Renderer ->                         -- renderer : TInterface (Name {namespace = "Pango", name = "Renderer"})
        Ptr Pango.Matrix.Matrix ->              -- matrix : TInterface (Name {namespace = "Pango", name = "Matrix"})
        IO ()

    {- |
    Sets the transformation matrix that will be applied when rendering.

    /Since: 1.8/
    -}
    rendererSetMatrix ::
        (B.CallStack.HasCallStack, MonadIO m, IsRenderer a) =>
        a
        {- ^ /@renderer@/: a 'GI.Pango.Objects.Renderer.Renderer' -}
        -> Maybe (Pango.Matrix.Matrix)
        {- ^ /@matrix@/: a 'GI.Pango.Structs.Matrix.Matrix', or 'Nothing' to unset any existing matrix.
     (No matrix set is the same as setting the identity matrix.) -}
        -> m ()
    rendererSetMatrix renderer matrix = liftIO $ do
        renderer' <- unsafeManagedPtrCastPtr renderer
        maybeMatrix <- case matrix of
            Nothing -> return nullPtr
            Just jMatrix -> do
                jMatrix' <- unsafeManagedPtrGetPtr jMatrix
                return jMatrix'
        pango_renderer_set_matrix renderer' maybeMatrix
        touchManagedPtr renderer
        whenJust matrix touchManagedPtr
        return ()

    #if ENABLE_OVERLOADING
    data RendererSetMatrixMethodInfo
    instance (signature ~ (Maybe (Pango.Matrix.Matrix) -> m ()), MonadIO m, IsRenderer a) => O.MethodInfo RendererSetMatrixMethodInfo a signature where
        overloadedMethod _ = rendererSetMatrix

    #endif