// Package pango was automatically generated by github.com/bnema/puregotk DO NOT EDIT
package pango

import (
	"structs"
	"unsafe"

	"github.com/ebitengine/purego"

	"github.com/bnema/puregotk/pkg/core"
	"github.com/bnema/puregotk/v4/gobject"
	"github.com/bnema/puregotk/v4/gobject/types"
)

// Class structure for `PangoRenderer`.
//
// The following vfuncs take user space coordinates in Pango units
// and have default implementations:
// - draw_glyphs
// - draw_rectangle
// - draw_error_underline
// - draw_shape
// - draw_glyph_item
//
// The default draw_shape implementation draws nothing.
//
// The following vfuncs take device space coordinates as doubles
// and must be implemented:
// - draw_trapezoid
// - draw_glyph
type RendererClass struct {
	_ structs.HostLayout

	ParentClass gobject.ObjectClass

	xDrawGlyphs uintptr

	xDrawRectangle uintptr

	xDrawErrorUnderline uintptr

	xDrawShape uintptr

	xDrawTrapezoid uintptr

	xDrawGlyph uintptr

	xPartChanged uintptr

	xBegin uintptr

	xEnd uintptr

	xPrepareRun uintptr

	xDrawGlyphItem uintptr

	xPangoReserved2 uintptr

	xPangoReserved3 uintptr

	xPangoReserved4 uintptr
}

func (x *RendererClass) GoPointer() uintptr {
	return uintptr(unsafe.Pointer(x))
}

// OverrideDrawGlyphs sets the "draw_glyphs" callback function.
// draws a `PangoGlyphString`
func (x *RendererClass) OverrideDrawGlyphs(cb func(*Renderer, *Font, *GlyphString, int, int)) {
	if cb == nil {
		x.xDrawGlyphs = 0
	} else {
		x.xDrawGlyphs = purego.NewCallback(func(RendererVarp uintptr, FontVarp uintptr, GlyphsVarp *GlyphString, XVarp int, YVarp int) {
			cb(RendererNewFromInternalPtr(RendererVarp), FontNewFromInternalPtr(FontVarp), GlyphsVarp, XVarp, YVarp)
		})
	}
}

// GetDrawGlyphs gets the "draw_glyphs" callback function.
// draws a `PangoGlyphString`
func (x *RendererClass) GetDrawGlyphs() func(*Renderer, *Font, *GlyphString, int, int) {
	if x.xDrawGlyphs == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr, FontVarp uintptr, GlyphsVarp *GlyphString, XVarp int, YVarp int)
	purego.RegisterFunc(&rawCallback, x.xDrawGlyphs)
	return func(RendererVar *Renderer, FontVar *Font, GlyphsVar *GlyphString, XVar int, YVar int) {
		rawCallback(RendererVar.GoPointer(), FontVar.GoPointer(), GlyphsVar, XVar, YVar)
	}
}

// OverrideDrawRectangle sets the "draw_rectangle" callback function.
// draws a rectangle
func (x *RendererClass) OverrideDrawRectangle(cb func(*Renderer, RenderPart, int, int, int, int)) {
	if cb == nil {
		x.xDrawRectangle = 0
	} else {
		x.xDrawRectangle = purego.NewCallback(func(RendererVarp uintptr, PartVarp RenderPart, XVarp int, YVarp int, WidthVarp int, HeightVarp int) {
			cb(RendererNewFromInternalPtr(RendererVarp), PartVarp, XVarp, YVarp, WidthVarp, HeightVarp)
		})
	}
}

// GetDrawRectangle gets the "draw_rectangle" callback function.
// draws a rectangle
func (x *RendererClass) GetDrawRectangle() func(*Renderer, RenderPart, int, int, int, int) {
	if x.xDrawRectangle == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr, PartVarp RenderPart, XVarp int, YVarp int, WidthVarp int, HeightVarp int)
	purego.RegisterFunc(&rawCallback, x.xDrawRectangle)
	return func(RendererVar *Renderer, PartVar RenderPart, XVar int, YVar int, WidthVar int, HeightVar int) {
		rawCallback(RendererVar.GoPointer(), PartVar, XVar, YVar, WidthVar, HeightVar)
	}
}

// OverrideDrawErrorUnderline sets the "draw_error_underline" callback function.
// draws a squiggly line that approximately
// covers the given rectangle in the style of an underline used to
// indicate a spelling error.
func (x *RendererClass) OverrideDrawErrorUnderline(cb func(*Renderer, int, int, int, int)) {
	if cb == nil {
		x.xDrawErrorUnderline = 0
	} else {
		x.xDrawErrorUnderline = purego.NewCallback(func(RendererVarp uintptr, XVarp int, YVarp int, WidthVarp int, HeightVarp int) {
			cb(RendererNewFromInternalPtr(RendererVarp), XVarp, YVarp, WidthVarp, HeightVarp)
		})
	}
}

// GetDrawErrorUnderline gets the "draw_error_underline" callback function.
// draws a squiggly line that approximately
// covers the given rectangle in the style of an underline used to
// indicate a spelling error.
func (x *RendererClass) GetDrawErrorUnderline() func(*Renderer, int, int, int, int) {
	if x.xDrawErrorUnderline == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr, XVarp int, YVarp int, WidthVarp int, HeightVarp int)
	purego.RegisterFunc(&rawCallback, x.xDrawErrorUnderline)
	return func(RendererVar *Renderer, XVar int, YVar int, WidthVar int, HeightVar int) {
		rawCallback(RendererVar.GoPointer(), XVar, YVar, WidthVar, HeightVar)
	}
}

// OverrideDrawShape sets the "draw_shape" callback function.
// draw content for a glyph shaped with `PangoAttrShape`
//
//	@x, @y are the coordinates of the left edge of the baseline,
//	in user coordinates.
func (x *RendererClass) OverrideDrawShape(cb func(*Renderer, *AttrShape, int, int)) {
	if cb == nil {
		x.xDrawShape = 0
	} else {
		x.xDrawShape = purego.NewCallback(func(RendererVarp uintptr, AttrVarp *AttrShape, XVarp int, YVarp int) {
			cb(RendererNewFromInternalPtr(RendererVarp), AttrVarp, XVarp, YVarp)
		})
	}
}

// GetDrawShape gets the "draw_shape" callback function.
// draw content for a glyph shaped with `PangoAttrShape`
//
//	@x, @y are the coordinates of the left edge of the baseline,
//	in user coordinates.
func (x *RendererClass) GetDrawShape() func(*Renderer, *AttrShape, int, int) {
	if x.xDrawShape == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr, AttrVarp *AttrShape, XVarp int, YVarp int)
	purego.RegisterFunc(&rawCallback, x.xDrawShape)
	return func(RendererVar *Renderer, AttrVar *AttrShape, XVar int, YVar int) {
		rawCallback(RendererVar.GoPointer(), AttrVar, XVar, YVar)
	}
}

// OverrideDrawTrapezoid sets the "draw_trapezoid" callback function.
// draws a trapezoidal filled area
func (x *RendererClass) OverrideDrawTrapezoid(cb func(*Renderer, RenderPart, float64, float64, float64, float64, float64, float64)) {
	if cb == nil {
		x.xDrawTrapezoid = 0
	} else {
		x.xDrawTrapezoid = purego.NewCallback(func(RendererVarp uintptr, PartVarp RenderPart, Y1Varp float64, X11Varp float64, X21Varp float64, Y2Varp float64, X12Varp float64, X22Varp float64) {
			cb(RendererNewFromInternalPtr(RendererVarp), PartVarp, Y1Varp, X11Varp, X21Varp, Y2Varp, X12Varp, X22Varp)
		})
	}
}

// GetDrawTrapezoid gets the "draw_trapezoid" callback function.
// draws a trapezoidal filled area
func (x *RendererClass) GetDrawTrapezoid() func(*Renderer, RenderPart, float64, float64, float64, float64, float64, float64) {
	if x.xDrawTrapezoid == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr, PartVarp RenderPart, Y1Varp float64, X11Varp float64, X21Varp float64, Y2Varp float64, X12Varp float64, X22Varp float64)
	purego.RegisterFunc(&rawCallback, x.xDrawTrapezoid)
	return func(RendererVar *Renderer, PartVar RenderPart, Y1Var float64, X11Var float64, X21Var float64, Y2Var float64, X12Var float64, X22Var float64) {
		rawCallback(RendererVar.GoPointer(), PartVar, Y1Var, X11Var, X21Var, Y2Var, X12Var, X22Var)
	}
}

// OverrideDrawGlyph sets the "draw_glyph" callback function.
// draws a single glyph
func (x *RendererClass) OverrideDrawGlyph(cb func(*Renderer, *Font, Glyph, float64, float64)) {
	if cb == nil {
		x.xDrawGlyph = 0
	} else {
		x.xDrawGlyph = purego.NewCallback(func(RendererVarp uintptr, FontVarp uintptr, GlyphVarp Glyph, XVarp float64, YVarp float64) {
			cb(RendererNewFromInternalPtr(RendererVarp), FontNewFromInternalPtr(FontVarp), GlyphVarp, XVarp, YVarp)
		})
	}
}

// GetDrawGlyph gets the "draw_glyph" callback function.
// draws a single glyph
func (x *RendererClass) GetDrawGlyph() func(*Renderer, *Font, Glyph, float64, float64) {
	if x.xDrawGlyph == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr, FontVarp uintptr, GlyphVarp Glyph, XVarp float64, YVarp float64)
	purego.RegisterFunc(&rawCallback, x.xDrawGlyph)
	return func(RendererVar *Renderer, FontVar *Font, GlyphVar Glyph, XVar float64, YVar float64) {
		rawCallback(RendererVar.GoPointer(), FontVar.GoPointer(), GlyphVar, XVar, YVar)
	}
}

// OverridePartChanged sets the "part_changed" callback function.
// do renderer specific processing when rendering
//
//	attributes change
func (x *RendererClass) OverridePartChanged(cb func(*Renderer, RenderPart)) {
	if cb == nil {
		x.xPartChanged = 0
	} else {
		x.xPartChanged = purego.NewCallback(func(RendererVarp uintptr, PartVarp RenderPart) {
			cb(RendererNewFromInternalPtr(RendererVarp), PartVarp)
		})
	}
}

// GetPartChanged gets the "part_changed" callback function.
// do renderer specific processing when rendering
//
//	attributes change
func (x *RendererClass) GetPartChanged() func(*Renderer, RenderPart) {
	if x.xPartChanged == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr, PartVarp RenderPart)
	purego.RegisterFunc(&rawCallback, x.xPartChanged)
	return func(RendererVar *Renderer, PartVar RenderPart) {
		rawCallback(RendererVar.GoPointer(), PartVar)
	}
}

// OverrideBegin sets the "begin" callback function.
// Do renderer-specific initialization before drawing
func (x *RendererClass) OverrideBegin(cb func(*Renderer)) {
	if cb == nil {
		x.xBegin = 0
	} else {
		x.xBegin = purego.NewCallback(func(RendererVarp uintptr) {
			cb(RendererNewFromInternalPtr(RendererVarp))
		})
	}
}

// GetBegin gets the "begin" callback function.
// Do renderer-specific initialization before drawing
func (x *RendererClass) GetBegin() func(*Renderer) {
	if x.xBegin == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr)
	purego.RegisterFunc(&rawCallback, x.xBegin)
	return func(RendererVar *Renderer) {
		rawCallback(RendererVar.GoPointer())
	}
}

// OverrideEnd sets the "end" callback function.
// Do renderer-specific cleanup after drawing
func (x *RendererClass) OverrideEnd(cb func(*Renderer)) {
	if cb == nil {
		x.xEnd = 0
	} else {
		x.xEnd = purego.NewCallback(func(RendererVarp uintptr) {
			cb(RendererNewFromInternalPtr(RendererVarp))
		})
	}
}

// GetEnd gets the "end" callback function.
// Do renderer-specific cleanup after drawing
func (x *RendererClass) GetEnd() func(*Renderer) {
	if x.xEnd == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr)
	purego.RegisterFunc(&rawCallback, x.xEnd)
	return func(RendererVar *Renderer) {
		rawCallback(RendererVar.GoPointer())
	}
}

// OverridePrepareRun sets the "prepare_run" callback function.
// updates the renderer for a new run
func (x *RendererClass) OverridePrepareRun(cb func(*Renderer, *LayoutRun)) {
	if cb == nil {
		x.xPrepareRun = 0
	} else {
		x.xPrepareRun = purego.NewCallback(func(RendererVarp uintptr, RunVarp *LayoutRun) {
			cb(RendererNewFromInternalPtr(RendererVarp), RunVarp)
		})
	}
}

// GetPrepareRun gets the "prepare_run" callback function.
// updates the renderer for a new run
func (x *RendererClass) GetPrepareRun() func(*Renderer, *LayoutRun) {
	if x.xPrepareRun == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr, RunVarp *LayoutRun)
	purego.RegisterFunc(&rawCallback, x.xPrepareRun)
	return func(RendererVar *Renderer, RunVar *LayoutRun) {
		rawCallback(RendererVar.GoPointer(), RunVar)
	}
}

// OverrideDrawGlyphItem sets the "draw_glyph_item" callback function.
// draws a `PangoGlyphItem`
func (x *RendererClass) OverrideDrawGlyphItem(cb func(*Renderer, string, *GlyphItem, int, int)) {
	if cb == nil {
		x.xDrawGlyphItem = 0
	} else {
		x.xDrawGlyphItem = purego.NewCallback(func(RendererVarp uintptr, TextVarp string, GlyphItemVarp *GlyphItem, XVarp int, YVarp int) {
			cb(RendererNewFromInternalPtr(RendererVarp), TextVarp, GlyphItemVarp, XVarp, YVarp)
		})
	}
}

// GetDrawGlyphItem gets the "draw_glyph_item" callback function.
// draws a `PangoGlyphItem`
func (x *RendererClass) GetDrawGlyphItem() func(*Renderer, string, *GlyphItem, int, int) {
	if x.xDrawGlyphItem == 0 {
		return nil
	}
	var rawCallback func(RendererVarp uintptr, TextVarp string, GlyphItemVarp *GlyphItem, XVarp int, YVarp int)
	purego.RegisterFunc(&rawCallback, x.xDrawGlyphItem)
	return func(RendererVar *Renderer, TextVar string, GlyphItemVar *GlyphItem, XVar int, YVar int) {
		rawCallback(RendererVar.GoPointer(), TextVar, GlyphItemVar, XVar, YVar)
	}
}

// OverridePangoReserved2 sets the "_pango_reserved2" callback function.
func (x *RendererClass) OverridePangoReserved2(cb func()) {
	if cb == nil {
		x.xPangoReserved2 = 0
	} else {
		x.xPangoReserved2 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetPangoReserved2 gets the "_pango_reserved2" callback function.
func (x *RendererClass) GetPangoReserved2() func() {
	if x.xPangoReserved2 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xPangoReserved2)
	return func() {
		rawCallback()
	}
}

// OverridePangoReserved3 sets the "_pango_reserved3" callback function.
func (x *RendererClass) OverridePangoReserved3(cb func()) {
	if cb == nil {
		x.xPangoReserved3 = 0
	} else {
		x.xPangoReserved3 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetPangoReserved3 gets the "_pango_reserved3" callback function.
func (x *RendererClass) GetPangoReserved3() func() {
	if x.xPangoReserved3 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xPangoReserved3)
	return func() {
		rawCallback()
	}
}

// OverridePangoReserved4 sets the "_pango_reserved4" callback function.
func (x *RendererClass) OverridePangoReserved4(cb func()) {
	if cb == nil {
		x.xPangoReserved4 = 0
	} else {
		x.xPangoReserved4 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetPangoReserved4 gets the "_pango_reserved4" callback function.
func (x *RendererClass) GetPangoReserved4() func() {
	if x.xPangoReserved4 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xPangoReserved4)
	return func() {
		rawCallback()
	}
}

type RendererPrivate struct {
	_ structs.HostLayout
}

func (x *RendererPrivate) GoPointer() uintptr {
	return uintptr(unsafe.Pointer(x))
}

// `PangoRenderPart` defines different items to render for such
// purposes as setting colors.
type RenderPart int

var xRenderPartGLibType func() types.GType

func RenderPartGLibType() types.GType {
	return xRenderPartGLibType()
}

const (

	// the text itself
	RenderPartForegroundValue RenderPart = 0
	// the area behind the text
	RenderPartBackgroundValue RenderPart = 1
	// underlines
	RenderPartUnderlineValue RenderPart = 2
	// strikethrough lines
	RenderPartStrikethroughValue RenderPart = 3
	// overlines
	RenderPartOverlineValue RenderPart = 4
)

// `PangoRenderer` is a base class for objects that can render text
// provided as `PangoGlyphString` or `PangoLayout`.
//
// By subclassing `PangoRenderer` and overriding operations such as
// @draw_glyphs and @draw_rectangle, renderers for particular font
// backends and destinations can be created.
type Renderer struct {
	gobject.Object
}

var xRendererGLibType func() types.GType

func RendererGLibType() types.GType {
	return xRendererGLibType()
}

func RendererNewFromInternalPtr(ptr uintptr) *Renderer {
	cls := &Renderer{}
	cls.Ptr = ptr
	return cls
}

var xRendererActivate func(uintptr)

// Does initial setup before rendering operations on @renderer.
//
// [method@Pango.Renderer.deactivate] should be called when done drawing.
// Calls such as [method@Pango.Renderer.draw_layout] automatically
// activate the layout before drawing on it.
//
// Calls to [method@Pango.Renderer.activate] and
// [method@Pango.Renderer.deactivate] can be nested and the
// renderer will only be initialized and deinitialized once.
func (x *Renderer) Activate() {

	xRendererActivate(x.GoPointer())

}

var xRendererDeactivate func(uintptr)

// Cleans up after rendering operations on @renderer.
//
// See docs for [method@Pango.Renderer.activate].
func (x *Renderer) Deactivate() {

	xRendererDeactivate(x.GoPointer())

}

var xRendererDrawErrorUnderline func(uintptr, int, int, int, int)

// 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 [method@Pango.Renderer.activate] to activate a renderer.
func (x *Renderer) DrawErrorUnderline(XVar int, YVar int, WidthVar int, HeightVar int) {

	xRendererDrawErrorUnderline(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)

}

var xRendererDrawGlyph func(uintptr, uintptr, Glyph, float64, float64)

// Draws a single glyph with coordinates in device space.
func (x *Renderer) DrawGlyph(FontVar *Font, GlyphVar Glyph, XVar float64, YVar float64) {

	xRendererDrawGlyph(x.GoPointer(), FontVar.GoPointer(), GlyphVar, XVar, YVar)

}

var xRendererDrawGlyphItem func(uintptr, uintptr, *GlyphItem, int, int)

// Draws the glyphs in @glyph_item with the specified `PangoRenderer`,
// embedding the text associated with the glyphs in the output if the
// output format supports it.
//
// This is useful for rendering text in PDF.
//
// Note that this method does not handle attributes in @glyph_item.
// If you want colors, shapes and lines handled automatically according
// to those attributes, you need to use pango_renderer_draw_layout_line()
// or pango_renderer_draw_layout().
//
// Note that @text is the start of the text for layout, which is then
// indexed by `glyph_item->item->offset`.
//
// If @text is %NULL, this simply calls [method@Pango.Renderer.draw_glyphs].
//
// The default implementation of this method simply falls back to
// [method@Pango.Renderer.draw_glyphs].
func (x *Renderer) DrawGlyphItem(TextVar *string, GlyphItemVar *GlyphItem, XVar int, YVar int) {

	TextVarPtr := core.GStrdupNullable(TextVar)
	defer core.GFreeNullable(TextVarPtr)

	xRendererDrawGlyphItem(x.GoPointer(), TextVarPtr, GlyphItemVar, XVar, YVar)

}

var xRendererDrawGlyphs func(uintptr, uintptr, *GlyphString, int, int)

// Draws the glyphs in @glyphs with the specified `PangoRenderer`.
func (x *Renderer) DrawGlyphs(FontVar *Font, GlyphsVar *GlyphString, XVar int, YVar int) {

	xRendererDrawGlyphs(x.GoPointer(), FontVar.GoPointer(), GlyphsVar, XVar, YVar)

}

var xRendererDrawLayout func(uintptr, uintptr, int, int)

// Draws @layout with the specified `PangoRenderer`.
//
// This is equivalent to drawing the lines of the layout, at their
// respective positions relative to @x, @y.
func (x *Renderer) DrawLayout(LayoutVar *Layout, XVar int, YVar int) {

	xRendererDrawLayout(x.GoPointer(), LayoutVar.GoPointer(), XVar, YVar)

}

var xRendererDrawLayoutLine func(uintptr, *LayoutLine, int, int)

// Draws @line with the specified `PangoRenderer`.
//
// This draws the glyph items that make up the line, as well as
// shapes, backgrounds and lines that are specified by the attributes
// of those items.
func (x *Renderer) DrawLayoutLine(LineVar *LayoutLine, XVar int, YVar int) {

	xRendererDrawLayoutLine(x.GoPointer(), LineVar, XVar, YVar)

}

var xRendererDrawRectangle func(uintptr, RenderPart, int, int, int, int)

// Draws an axis-aligned rectangle in user space coordinates with the
// specified `PangoRenderer`.
//
// This should be called while @renderer is already active.
// Use [method@Pango.Renderer.activate] to activate a renderer.
func (x *Renderer) DrawRectangle(PartVar RenderPart, XVar int, YVar int, WidthVar int, HeightVar int) {

	xRendererDrawRectangle(x.GoPointer(), PartVar, XVar, YVar, WidthVar, HeightVar)

}

var xRendererDrawTrapezoid func(uintptr, RenderPart, float64, float64, float64, float64, float64, float64)

// Draws a trapezoid with the parallel sides aligned with the X axis
// using the given `PangoRenderer`; coordinates are in device space.
func (x *Renderer) DrawTrapezoid(PartVar RenderPart, Y1Var float64, X11Var float64, X21Var float64, Y2Var float64, X12Var float64, X22Var float64) {

	xRendererDrawTrapezoid(x.GoPointer(), PartVar, Y1Var, X11Var, X21Var, Y2Var, X12Var, X22Var)

}

var xRendererGetAlpha func(uintptr, RenderPart) uint16

// Gets the current alpha for the specified part.
func (x *Renderer) GetAlpha(PartVar RenderPart) uint16 {

	cret := xRendererGetAlpha(x.GoPointer(), PartVar)
	return cret
}

var xRendererGetColor func(uintptr, RenderPart) *Color

// Gets the current rendering color for the specified part.
func (x *Renderer) GetColor(PartVar RenderPart) *Color {

	cret := xRendererGetColor(x.GoPointer(), PartVar)
	return cret
}

var xRendererGetLayout func(uintptr) uintptr

// 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 vfunc, for example.
//
// The returned layout should not be modified while still being
// rendered.
func (x *Renderer) GetLayout() *Layout {
	var cls *Layout

	cret := xRendererGetLayout(x.GoPointer())

	if cret == 0 {
		return nil
	}
	gobject.IncreaseRef(cret)
	cls = &Layout{}
	cls.Ptr = cret
	return cls
}

var xRendererGetLayoutLine func(uintptr) *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 vfunc, for example.
//
// The returned layout line should not be modified while still being
// rendered.
func (x *Renderer) GetLayoutLine() *LayoutLine {

	cret := xRendererGetLayoutLine(x.GoPointer())
	return cret
}

var xRendererGetMatrix func(uintptr) *Matrix

// Gets the transformation matrix that will be applied when
// rendering.
//
// See [method@Pango.Renderer.set_matrix].
func (x *Renderer) GetMatrix() *Matrix {

	cret := xRendererGetMatrix(x.GoPointer())
	return cret
}

var xRendererPartChanged func(uintptr, RenderPart)

// Informs Pango that the way that the rendering is done
// for @part has changed.
//
// This should be called if the rendering changes in a way that would
// prevent multiple pieces being joined together into one drawing call.
// For instance, if a subclass of `PangoRenderer` was to add a stipple
// option for drawing underlines, it needs to call
//
// ```
// pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
// ```
//
// When the stipple changes or underlines with different stipples
// might be joined together. Pango automatically calls this for
// changes to colors. (See [method@Pango.Renderer.set_color])
func (x *Renderer) PartChanged(PartVar RenderPart) {

	xRendererPartChanged(x.GoPointer(), PartVar)

}

var xRendererSetAlpha func(uintptr, RenderPart, uint16)

// 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.
func (x *Renderer) SetAlpha(PartVar RenderPart, AlphaVar uint16) {

	xRendererSetAlpha(x.GoPointer(), PartVar, AlphaVar)

}

var xRendererSetColor func(uintptr, RenderPart, *Color)

// Sets the color for part of the rendering.
//
// Also see [method@Pango.Renderer.set_alpha].
func (x *Renderer) SetColor(PartVar RenderPart, ColorVar *Color) {

	xRendererSetColor(x.GoPointer(), PartVar, ColorVar)

}

var xRendererSetMatrix func(uintptr, *Matrix)

// Sets the transformation matrix that will be applied when rendering.
func (x *Renderer) SetMatrix(MatrixVar *Matrix) {

	xRendererSetMatrix(x.GoPointer(), MatrixVar)

}

func (c *Renderer) GoPointer() uintptr {
	if c == nil {
		return 0
	}
	return c.Ptr
}

func (c *Renderer) SetGoPointer(ptr uintptr) {
	c.Ptr = ptr
}

func init() {
	core.SetPackageName("PANGO", "pango")
	core.SetSharedLibraries("PANGO", []string{"libpango-1.0.so.0"})
	var libs []uintptr
	for _, libPath := range core.GetPaths("PANGO") {
		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			panic(err)
		}
		libs = append(libs, lib)
	}

	core.PuregoSafeRegister(&xRenderPartGLibType, libs, "pango_render_part_get_type")

	core.PuregoSafeRegister(&xRendererGLibType, libs, "pango_renderer_get_type")

	core.PuregoSafeRegister(&xRendererActivate, libs, "pango_renderer_activate")
	core.PuregoSafeRegister(&xRendererDeactivate, libs, "pango_renderer_deactivate")
	core.PuregoSafeRegister(&xRendererDrawErrorUnderline, libs, "pango_renderer_draw_error_underline")
	core.PuregoSafeRegister(&xRendererDrawGlyph, libs, "pango_renderer_draw_glyph")
	core.PuregoSafeRegister(&xRendererDrawGlyphItem, libs, "pango_renderer_draw_glyph_item")
	core.PuregoSafeRegister(&xRendererDrawGlyphs, libs, "pango_renderer_draw_glyphs")
	core.PuregoSafeRegister(&xRendererDrawLayout, libs, "pango_renderer_draw_layout")
	core.PuregoSafeRegister(&xRendererDrawLayoutLine, libs, "pango_renderer_draw_layout_line")
	core.PuregoSafeRegister(&xRendererDrawRectangle, libs, "pango_renderer_draw_rectangle")
	core.PuregoSafeRegister(&xRendererDrawTrapezoid, libs, "pango_renderer_draw_trapezoid")
	core.PuregoSafeRegister(&xRendererGetAlpha, libs, "pango_renderer_get_alpha")
	core.PuregoSafeRegister(&xRendererGetColor, libs, "pango_renderer_get_color")
	core.PuregoSafeRegister(&xRendererGetLayout, libs, "pango_renderer_get_layout")
	core.PuregoSafeRegister(&xRendererGetLayoutLine, libs, "pango_renderer_get_layout_line")
	core.PuregoSafeRegister(&xRendererGetMatrix, libs, "pango_renderer_get_matrix")
	core.PuregoSafeRegister(&xRendererPartChanged, libs, "pango_renderer_part_changed")
	core.PuregoSafeRegister(&xRendererSetAlpha, libs, "pango_renderer_set_alpha")
	core.PuregoSafeRegister(&xRendererSetColor, libs, "pango_renderer_set_color")
	core.PuregoSafeRegister(&xRendererSetMatrix, libs, "pango_renderer_set_matrix")

}