// 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/glib"
	"github.com/bnema/puregotk/v4/gobject/types"
)

// Type of a function that can duplicate user data for an attribute.
type AttrDataCopyFunc func(uintptr) uintptr

// Type of a function filtering a list of attributes.
type AttrFilterFunc func(*Attribute, uintptr) bool

// The `PangoAttrClass` structure stores the type and operations for
// a particular type of attribute.
//
// The functions in this structure should not be called directly. Instead,
// one should use the wrapper functions provided for `PangoAttribute`.
type AttrClass struct {
	_ structs.HostLayout

	Type AttrType

	xCopy uintptr

	xDestroy uintptr

	xEqual uintptr
}

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

// OverrideCopy sets the "copy" callback function.
// function to duplicate an attribute of this type
//
//	(see [method@Pango.Attribute.copy])
func (x *AttrClass) OverrideCopy(cb func(*Attribute) *Attribute) {
	if cb == nil {
		x.xCopy = 0
	} else {
		x.xCopy = purego.NewCallback(func(AttrVarp *Attribute) *Attribute {
			return cb(AttrVarp)
		})
	}
}

// GetCopy gets the "copy" callback function.
// function to duplicate an attribute of this type
//
//	(see [method@Pango.Attribute.copy])
func (x *AttrClass) GetCopy() func(*Attribute) *Attribute {
	if x.xCopy == 0 {
		return nil
	}
	var rawCallback func(AttrVarp *Attribute) *Attribute
	purego.RegisterFunc(&rawCallback, x.xCopy)
	return func(AttrVar *Attribute) *Attribute {
		return rawCallback(AttrVar)
	}
}

// OverrideDestroy sets the "destroy" callback function.
// function to free an attribute of this type
//
//	(see [method@Pango.Attribute.destroy])
func (x *AttrClass) OverrideDestroy(cb func(*Attribute)) {
	if cb == nil {
		x.xDestroy = 0
	} else {
		x.xDestroy = purego.NewCallback(func(AttrVarp *Attribute) {
			cb(AttrVarp)
		})
	}
}

// GetDestroy gets the "destroy" callback function.
// function to free an attribute of this type
//
//	(see [method@Pango.Attribute.destroy])
func (x *AttrClass) GetDestroy() func(*Attribute) {
	if x.xDestroy == 0 {
		return nil
	}
	var rawCallback func(AttrVarp *Attribute)
	purego.RegisterFunc(&rawCallback, x.xDestroy)
	return func(AttrVar *Attribute) {
		rawCallback(AttrVar)
	}
}

// OverrideEqual sets the "equal" callback function.
// function to check two attributes of this type for equality
//
//	(see [method@Pango.Attribute.equal])
func (x *AttrClass) OverrideEqual(cb func(*Attribute, *Attribute) bool) {
	if cb == nil {
		x.xEqual = 0
	} else {
		x.xEqual = purego.NewCallback(func(Attr1Varp *Attribute, Attr2Varp *Attribute) bool {
			return cb(Attr1Varp, Attr2Varp)
		})
	}
}

// GetEqual gets the "equal" callback function.
// function to check two attributes of this type for equality
//
//	(see [method@Pango.Attribute.equal])
func (x *AttrClass) GetEqual() func(*Attribute, *Attribute) bool {
	if x.xEqual == 0 {
		return nil
	}
	var rawCallback func(Attr1Varp *Attribute, Attr2Varp *Attribute) bool
	purego.RegisterFunc(&rawCallback, x.xEqual)
	return func(Attr1Var *Attribute, Attr2Var *Attribute) bool {
		return rawCallback(Attr1Var, Attr2Var)
	}
}

// The `PangoAttrColor` structure is used to represent attributes that
// are colors.
type AttrColor struct {
	_ structs.HostLayout

	Attr uintptr

	Color uintptr
}

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

// The `PangoAttrFloat` structure is used to represent attributes with
// a float or double value.
type AttrFloat struct {
	_ structs.HostLayout

	Attr uintptr

	Value float64
}

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

// The `PangoAttrFontDesc` structure is used to store an attribute that
// sets all aspects of the font description at once.
type AttrFontDesc struct {
	_ structs.HostLayout

	Attr uintptr

	Desc *FontDescription
}

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

// The `PangoAttrFontFeatures` structure is used to represent OpenType
// font features as an attribute.
type AttrFontFeatures struct {
	_ structs.HostLayout

	Attr uintptr

	Features uintptr
}

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

// The `PangoAttrInt` structure is used to represent attributes with
// an integer or enumeration value.
type AttrInt struct {
	_ structs.HostLayout

	Attr uintptr

	Value int
}

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

// A `PangoAttrIterator` is used to iterate through a `PangoAttrList`.
//
// A new iterator is created with [method@Pango.AttrList.get_iterator].
// Once the iterator is created, it can be advanced through the style
// changes in the text using [method@Pango.AttrIterator.next]. At each
// style change, the range of the current style segment and the attributes
// currently in effect can be queried.
type AttrIterator struct {
	_ structs.HostLayout
}

var xAttrIteratorGLibType func() types.GType

func AttrIteratorGLibType() types.GType {
	return xAttrIteratorGLibType()
}

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

var xAttrIteratorCopy func(uintptr) *AttrIterator

// Copy a `PangoAttrIterator`.
func (x *AttrIterator) Copy() *AttrIterator {

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

var xAttrIteratorDestroy func(uintptr)

// Destroy a `PangoAttrIterator` and free all associated memory.
func (x *AttrIterator) Destroy() {

	xAttrIteratorDestroy(x.GoPointer())

}

var xAttrIteratorGet func(uintptr, AttrType) *Attribute

// Find the current attribute of a particular type
// at the iterator location.
//
// When multiple attributes of the same type overlap,
// the attribute whose range starts closest to the
// current location is used.
func (x *AttrIterator) Get(TypeVar AttrType) *Attribute {

	cret := xAttrIteratorGet(x.GoPointer(), TypeVar)
	return cret
}

var xAttrIteratorGetAttrs func(uintptr) *glib.SList

// Gets a list of all attributes at the current position of the
// iterator.
func (x *AttrIterator) GetAttrs() *glib.SList {

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

var xAttrIteratorGetFont func(uintptr, *FontDescription, **Language, **glib.SList)

// Get the font and other attributes at the current
// iterator position.
func (x *AttrIterator) GetFont(DescVar *FontDescription, LanguageVar **Language, ExtraAttrsVar **glib.SList) {

	xAttrIteratorGetFont(x.GoPointer(), DescVar, LanguageVar, ExtraAttrsVar)

}

var xAttrIteratorNext func(uintptr) bool

// Advance the iterator until the next change of style.
func (x *AttrIterator) Next() bool {

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

var xAttrIteratorRange func(uintptr, *int, *int)

// Get the range of the current segment.
//
// Note that the stored return values are signed, not unsigned
// like the values in `PangoAttribute`. To deal with this API
// oversight, stored return values that wouldn't fit into
// a signed integer are clamped to %G_MAXINT.
func (x *AttrIterator) Range(StartVar *int, EndVar *int) {

	xAttrIteratorRange(x.GoPointer(), StartVar, EndVar)

}

// The `PangoAttrLanguage` structure is used to represent attributes that
// are languages.
type AttrLanguage struct {
	_ structs.HostLayout

	Attr uintptr

	Value *Language
}

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

// A `PangoAttrList` represents a list of attributes that apply to a section
// of text.
//
// The attributes in a `PangoAttrList` are, in general, allowed to overlap in
// an arbitrary fashion. However, if the attributes are manipulated only through
// [method@Pango.AttrList.change], the overlap between properties will meet
// stricter criteria.
//
// Since the `PangoAttrList` structure is stored as a linear list, it is not
// suitable for storing attributes for large amounts of text. In general, you
// should not use a single `PangoAttrList` for more than one paragraph of text.
type AttrList struct {
	_ structs.HostLayout
}

var xAttrListGLibType func() types.GType

func AttrListGLibType() types.GType {
	return xAttrListGLibType()
}

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

var xNewAttrList func() *AttrList

// Create a new empty attribute list with a reference
// count of one.
func NewAttrList() *AttrList {

	cret := xNewAttrList()
	return cret
}

var xAttrListChange func(uintptr, *Attribute)

// Insert the given attribute into the `PangoAttrList`.
//
// It will replace any attributes of the same type
// on that segment and be merged with any adjoining
// attributes that are identical.
//
// This function is slower than [method@Pango.AttrList.insert]
// for creating an attribute list in order (potentially
// much slower for large lists). However,
// [method@Pango.AttrList.insert] is not suitable for
// continually changing a set of attributes since it
// never removes or combines existing attributes.
func (x *AttrList) Change(AttrVar *Attribute) {

	xAttrListChange(x.GoPointer(), AttrVar)

}

var xAttrListCopy func(uintptr) *AttrList

// Copy @list and return an identical new list.
func (x *AttrList) Copy() *AttrList {

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

var xAttrListEqual func(uintptr, *AttrList) bool

// Checks whether @list and @other_list contain the same
// attributes and whether those attributes apply to the
// same ranges.
//
// Beware that this will return wrong values if any list
// contains duplicates.
func (x *AttrList) Equal(OtherListVar *AttrList) bool {

	cret := xAttrListEqual(x.GoPointer(), OtherListVar)
	return cret
}

var xAttrListFilter func(uintptr, uintptr, uintptr) *AttrList

// Given a `PangoAttrList` and callback function, removes
// any elements of @list for which @func returns %TRUE and
// inserts them into a new list.
func (x *AttrList) Filter(FuncVar *AttrFilterFunc, DataVar uintptr) *AttrList {

	var FuncVarRef uintptr
	if FuncVar != nil {
		FuncVarPtr := uintptr(unsafe.Pointer(FuncVar))
		if cbRefPtr, ok := glib.GetCallback(FuncVarPtr); ok {
			FuncVarRef = cbRefPtr
		} else {
			fcb := func(arg0 *Attribute, arg1 uintptr) bool {
				cbFn := *FuncVar
				return cbFn(arg0, arg1)
			}
			FuncVarRef = purego.NewCallback(fcb)
			glib.SaveCallbackWithClosure(FuncVarPtr, FuncVarRef, FuncVar)
		}
	}

	cret := xAttrListFilter(x.GoPointer(), FuncVarRef, DataVar)
	return cret
}

var xAttrListGetAttributes func(uintptr) *glib.SList

// Gets a list of all attributes in @list.
func (x *AttrList) GetAttributes() *glib.SList {

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

var xAttrListGetIterator func(uintptr) *AttrIterator

// Create a iterator initialized to the beginning of the list.
//
// @list must not be modified until this iterator is freed.
func (x *AttrList) GetIterator() *AttrIterator {

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

var xAttrListInsert func(uintptr, *Attribute)

// Insert the given attribute into the `PangoAttrList`.
//
// It will be inserted after all other attributes with a
// matching @start_index.
func (x *AttrList) Insert(AttrVar *Attribute) {

	xAttrListInsert(x.GoPointer(), AttrVar)

}

var xAttrListInsertBefore func(uintptr, *Attribute)

// Insert the given attribute into the `PangoAttrList`.
//
// It will be inserted before all other attributes with a
// matching @start_index.
func (x *AttrList) InsertBefore(AttrVar *Attribute) {

	xAttrListInsertBefore(x.GoPointer(), AttrVar)

}

var xAttrListRef func(uintptr) *AttrList

// Increase the reference count of the given attribute
// list by one.
func (x *AttrList) Ref() *AttrList {

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

var xAttrListSplice func(uintptr, *AttrList, int, int)

// This function opens up a hole in @list, fills it
// in with attributes from the left, and then merges
// @other on top of the hole.
//
// This operation is equivalent to stretching every attribute
// that applies at position @pos in @list by an amount @len,
// and then calling [method@Pango.AttrList.change] with a copy
// of each attribute in @other in sequence (offset in position
// by @pos, and limited in length to @len).
//
// This operation proves useful for, for instance, inserting
// a pre-edit string in the middle of an edit buffer.
//
// For backwards compatibility, the function behaves differently
// when @len is 0. In this case, the attributes from @other are
// not imited to @len, and are just overlayed on top of @list.
//
// This mode is useful for merging two lists of attributes together.
func (x *AttrList) Splice(OtherVar *AttrList, PosVar int, LenVar int) {

	xAttrListSplice(x.GoPointer(), OtherVar, PosVar, LenVar)

}

var xAttrListToString func(uintptr) string

// Serializes a `PangoAttrList` to a string.
//
// In the resulting string, serialized attributes are separated by newlines or commas.
// Individual attributes are serialized to a string of the form
//
//	[START END] TYPE VALUE
//
// Where START and END are the indices (with -1 being accepted in place
// of MAXUINT), TYPE is the nickname of the attribute value type, e.g.
// _weight_ or _stretch_, and the value is serialized according to its type:
//
// Optionally, START and END can be omitted to indicate unlimited extent.
//
// - enum values as nick or numeric value
// - boolean values as _true_ or _false_
// - integers and floats as numbers
// - strings as string, optionally quoted
// - font features as quoted string
// - PangoLanguage as string
// - PangoFontDescription as serialized by [method@Pango.FontDescription.to_string], quoted
// - PangoColor as serialized by [method@Pango.Color.to_string]
//
// Examples:
//
//	0 10 foreground red, 5 15 weight bold, 0 200 font-desc "Sans 10"
//
//	0 -1 weight 700
//	0 100 family Times
//
//	weight bold
//
// To parse the returned value, use [func@Pango.AttrList.from_string].
//
// Note that shape attributes can not be serialized.
func (x *AttrList) ToString() string {

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

var xAttrListUnref func(uintptr)

// Decrease the reference count of the given attribute
// list by one.
//
// If the result is zero, free the attribute list
// and the attributes it contains.
func (x *AttrList) Unref() {

	xAttrListUnref(x.GoPointer())

}

var xAttrListUpdate func(uintptr, int, int, int)

// Update indices of attributes in @list for a change in the
// text they refer to.
//
// The change that this function applies is removing @remove
// bytes at position @pos and inserting @add bytes instead.
//
// Attributes that fall entirely in the (@pos, @pos + @remove)
// range are removed.
//
// Attributes that start or end inside the (@pos, @pos + @remove)
// range are shortened to reflect the removal.
//
// Attributes start and end positions are updated if they are
// behind @pos + @remove.
func (x *AttrList) Update(PosVar int, RemoveVar int, AddVar int) {

	xAttrListUpdate(x.GoPointer(), PosVar, RemoveVar, AddVar)

}

// The `PangoAttrShape` structure is used to represent attributes which
// impose shape restrictions.
type AttrShape struct {
	_ structs.HostLayout

	Attr uintptr

	InkRect uintptr

	LogicalRect uintptr

	Data uintptr

	CopyFunc AttrDataCopyFunc

	DestroyFunc glib.DestroyNotify
}

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

// The `PangoAttrSize` structure is used to represent attributes which
// set font size.
type AttrSize struct {
	_ structs.HostLayout

	Attr uintptr

	Size int

	Absolute uint
}

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

// The `PangoAttrString` structure is used to represent attributes with
// a string value.
type AttrString struct {
	_ structs.HostLayout

	Attr uintptr

	Value uintptr
}

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

// The `PangoAttribute` structure represents the common portions of all
// attributes.
//
// Particular types of attributes include this structure as their initial
// portion. The common portion of the attribute holds the range to which
// the value in the type-specific part of the attribute applies and should
// be initialized using [method@Pango.Attribute.init]. By default, an attribute
// will have an all-inclusive range of [0,%G_MAXUINT].
type Attribute struct {
	_ structs.HostLayout

	Klass *AttrClass

	StartIndex uint

	EndIndex uint
}

var xAttributeGLibType func() types.GType

func AttributeGLibType() types.GType {
	return xAttributeGLibType()
}

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

var xAttributeAsColor func(uintptr) *AttrColor

// Returns the attribute cast to `PangoAttrColor`.
//
// This is mainly useful for language bindings.
func (x *Attribute) AsColor() *AttrColor {

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

var xAttributeAsFloat func(uintptr) *AttrFloat

// Returns the attribute cast to `PangoAttrFloat`.
//
// This is mainly useful for language bindings.
func (x *Attribute) AsFloat() *AttrFloat {

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

var xAttributeAsFontDesc func(uintptr) *AttrFontDesc

// Returns the attribute cast to `PangoAttrFontDesc`.
//
// This is mainly useful for language bindings.
func (x *Attribute) AsFontDesc() *AttrFontDesc {

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

var xAttributeAsFontFeatures func(uintptr) *AttrFontFeatures

// Returns the attribute cast to `PangoAttrFontFeatures`.
//
// This is mainly useful for language bindings.
func (x *Attribute) AsFontFeatures() *AttrFontFeatures {

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

var xAttributeAsInt func(uintptr) *AttrInt

// Returns the attribute cast to `PangoAttrInt`.
//
// This is mainly useful for language bindings.
func (x *Attribute) AsInt() *AttrInt {

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

var xAttributeAsLanguage func(uintptr) *AttrLanguage

// Returns the attribute cast to `PangoAttrLanguage`.
//
// This is mainly useful for language bindings.
func (x *Attribute) AsLanguage() *AttrLanguage {

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

var xAttributeAsShape func(uintptr) *AttrShape

// Returns the attribute cast to `PangoAttrShape`.
//
// This is mainly useful for language bindings.
func (x *Attribute) AsShape() *AttrShape {

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

var xAttributeAsSize func(uintptr) *AttrSize

// Returns the attribute cast to `PangoAttrSize`.
//
// This is mainly useful for language bindings.
func (x *Attribute) AsSize() *AttrSize {

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

var xAttributeAsString func(uintptr) *AttrString

// Returns the attribute cast to `PangoAttrString`.
//
// This is mainly useful for language bindings.
func (x *Attribute) AsString() *AttrString {

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

var xAttributeCopy func(uintptr) *Attribute

// Make a copy of an attribute.
func (x *Attribute) Copy() *Attribute {

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

var xAttributeDestroy func(uintptr)

// Destroy a `PangoAttribute` and free all associated memory.
func (x *Attribute) Destroy() {

	xAttributeDestroy(x.GoPointer())

}

var xAttributeEqual func(uintptr, *Attribute) bool

// Compare two attributes for equality.
//
// This compares only the actual value of the two
// attributes and not the ranges that the attributes
// apply to.
func (x *Attribute) Equal(Attr2Var *Attribute) bool {

	cret := xAttributeEqual(x.GoPointer(), Attr2Var)
	return cret
}

var xAttributeInit func(uintptr, *AttrClass)

// Initializes @attr's klass to @klass, it's start_index to
// %PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING and end_index to
// %PANGO_ATTR_INDEX_TO_TEXT_END such that the attribute applies
// to the entire text by default.
func (x *Attribute) Init(KlassVar *AttrClass) {

	xAttributeInit(x.GoPointer(), KlassVar)

}

const (
	// Value for @start_index in `PangoAttribute` that indicates
	// the beginning of the text.
	ATTR_INDEX_FROM_TEXT_BEGINNING uint = 0
	// Value for @end_index in `PangoAttribute` that indicates
	// the end of the text.
	ATTR_INDEX_TO_TEXT_END uint = 4294967295
)

// These flags affect how Pango treats characters that are normally
// not visible in the output.
type ShowFlags int

var xShowFlagsGLibType func() types.GType

func ShowFlagsGLibType() types.GType {
	return xShowFlagsGLibType()
}

const (

	// No special treatment for invisible characters
	ShowNoneValue ShowFlags = 0
	// Render spaces, tabs and newlines visibly
	ShowSpacesValue ShowFlags = 1
	// Render line breaks visibly
	ShowLineBreaksValue ShowFlags = 2
	// Render default-ignorable Unicode
	//   characters visibly
	ShowIgnorablesValue ShowFlags = 4
)

// The `PangoAttrType` distinguishes between different types of attributes.
//
// Along with the predefined values, it is possible to allocate additional
// values for custom attributes using [func@AttrType.register]. The predefined
// values are given below. The type of structure used to store the attribute is
// listed in parentheses after the description.
type AttrType int

var xAttrTypeGLibType func() types.GType

func AttrTypeGLibType() types.GType {
	return xAttrTypeGLibType()
}

const (

	// does not happen
	AttrInvalidValue AttrType = 0
	// language ([struct@Pango.AttrLanguage])
	AttrLanguageValue AttrType = 1
	// font family name list ([struct@Pango.AttrString])
	AttrFamilyValue AttrType = 2
	// font slant style ([struct@Pango.AttrInt])
	AttrStyleValue AttrType = 3
	// font weight ([struct@Pango.AttrInt])
	AttrWeightValue AttrType = 4
	// font variant (normal or small caps) ([struct@Pango.AttrInt])
	AttrVariantValue AttrType = 5
	// font stretch ([struct@Pango.AttrInt])
	AttrStretchValue AttrType = 6
	// font size in points scaled by %PANGO_SCALE ([struct@Pango.AttrInt])
	AttrSizeValue AttrType = 7
	// font description ([struct@Pango.AttrFontDesc])
	AttrFontDescValue AttrType = 8
	// foreground color ([struct@Pango.AttrColor])
	AttrForegroundValue AttrType = 9
	// background color ([struct@Pango.AttrColor])
	AttrBackgroundValue AttrType = 10
	// whether the text has an underline ([struct@Pango.AttrInt])
	AttrUnderlineValue AttrType = 11
	// whether the text is struck-through ([struct@Pango.AttrInt])
	AttrStrikethroughValue AttrType = 12
	// baseline displacement ([struct@Pango.AttrInt])
	AttrRiseValue AttrType = 13
	// shape ([struct@Pango.AttrShape])
	AttrShapeValue AttrType = 14
	// font size scale factor ([struct@Pango.AttrFloat])
	AttrScaleValue AttrType = 15
	// whether fallback is enabled ([struct@Pango.AttrInt])
	AttrFallbackValue AttrType = 16
	// letter spacing ([struct@PangoAttrInt])
	AttrLetterSpacingValue AttrType = 17
	// underline color ([struct@Pango.AttrColor])
	AttrUnderlineColorValue AttrType = 18
	// strikethrough color ([struct@Pango.AttrColor])
	AttrStrikethroughColorValue AttrType = 19
	// font size in pixels scaled by %PANGO_SCALE ([struct@Pango.AttrInt])
	AttrAbsoluteSizeValue AttrType = 20
	// base text gravity ([struct@Pango.AttrInt])
	AttrGravityValue AttrType = 21
	// gravity hint ([struct@Pango.AttrInt])
	AttrGravityHintValue AttrType = 22
	// OpenType font features ([struct@Pango.AttrFontFeatures]). Since 1.38
	AttrFontFeaturesValue AttrType = 23
	// foreground alpha ([struct@Pango.AttrInt]). Since 1.38
	AttrForegroundAlphaValue AttrType = 24
	// background alpha ([struct@Pango.AttrInt]). Since 1.38
	AttrBackgroundAlphaValue AttrType = 25
	// whether breaks are allowed ([struct@Pango.AttrInt]). Since 1.44
	AttrAllowBreaksValue AttrType = 26
	// how to render invisible characters ([struct@Pango.AttrInt]). Since 1.44
	AttrShowValue AttrType = 27
	// whether to insert hyphens at intra-word line breaks ([struct@Pango.AttrInt]). Since 1.44
	AttrInsertHyphensValue AttrType = 28
	// whether the text has an overline ([struct@Pango.AttrInt]). Since 1.46
	AttrOverlineValue AttrType = 29
	// overline color ([struct@Pango.AttrColor]). Since 1.46
	AttrOverlineColorValue AttrType = 30
	// line height factor ([struct@Pango.AttrFloat]). Since: 1.50
	AttrLineHeightValue AttrType = 31
	// line height ([struct@Pango.AttrInt]). Since: 1.50
	AttrAbsoluteLineHeightValue AttrType = 32

	AttrTextTransformValue AttrType = 33
	// override segmentation to classify the range of the attribute as a single word ([struct@Pango.AttrInt]). Since 1.50
	AttrWordValue AttrType = 34
	// override segmentation to classify the range of the attribute as a single sentence ([struct@Pango.AttrInt]). Since 1.50
	AttrSentenceValue AttrType = 35
	// baseline displacement ([struct@Pango.AttrInt]). Since 1.50
	AttrBaselineShiftValue AttrType = 36
	// font-relative size change ([struct@Pango.AttrInt]). Since 1.50
	AttrFontScaleValue AttrType = 37
)

// An enumeration that affects baseline shifts between runs.
type BaselineShift int

var xBaselineShiftGLibType func() types.GType

func BaselineShiftGLibType() types.GType {
	return xBaselineShiftGLibType()
}

const (

	// Leave the baseline unchanged
	BaselineShiftNoneValue BaselineShift = 0
	// Shift the baseline to the superscript position,
	//   relative to the previous run
	BaselineShiftSuperscriptValue BaselineShift = 1
	// Shift the baseline to the subscript position,
	//   relative to the previous run
	BaselineShiftSubscriptValue BaselineShift = 2
)

// An enumeration that affects font sizes for superscript
// and subscript positioning and for (emulated) Small Caps.
type FontScale int

var xFontScaleGLibType func() types.GType

func FontScaleGLibType() types.GType {
	return xFontScaleGLibType()
}

const (

	// Leave the font size unchanged
	FontScaleNoneValue FontScale = 0
	// Change the font to a size suitable for superscripts
	FontScaleSuperscriptValue FontScale = 1
	// Change the font to a size suitable for subscripts
	FontScaleSubscriptValue FontScale = 2
	// Change the font to a size suitable for Small Caps
	FontScaleSmallCapsValue FontScale = 3
)

// The `PangoOverline` enumeration is used to specify whether text
// should be overlined, and if so, the type of line.
type Overline int

var xOverlineGLibType func() types.GType

func OverlineGLibType() types.GType {
	return xOverlineGLibType()
}

const (

	// no overline should be drawn
	OverlineNoneValue Overline = 0
	// Draw a single line above the ink
	//   extents of the text being underlined.
	OverlineSingleValue Overline = 1
)

// An enumeration that affects how Pango treats characters during shaping.
type TextTransform int

var xTextTransformGLibType func() types.GType

func TextTransformGLibType() types.GType {
	return xTextTransformGLibType()
}

const (

	// Leave text unchanged
	TextTransformNoneValue TextTransform = 0
	// Display letters and numbers as lowercase
	TextTransformLowercaseValue TextTransform = 1
	// Display letters and numbers as uppercase
	TextTransformUppercaseValue TextTransform = 2
	// Display the first character of a word
	//   in titlecase
	TextTransformCapitalizeValue TextTransform = 3
)

// The `PangoUnderline` enumeration is used to specify whether text
// should be underlined, and if so, the type of underlining.
type Underline int

var xUnderlineGLibType func() types.GType

func UnderlineGLibType() types.GType {
	return xUnderlineGLibType()
}

const (

	// no underline should be drawn
	UnderlineNoneValue Underline = 0
	// a single underline should be drawn
	UnderlineSingleValue Underline = 1
	// a double underline should be drawn
	UnderlineDoubleValue Underline = 2
	// a single underline should be drawn at a
	//   position beneath the ink extents of the text being
	//   underlined. This should be used only for underlining
	//   single characters, such as for keyboard accelerators.
	//   %PANGO_UNDERLINE_SINGLE should be used for extended
	//   portions of text.
	UnderlineLowValue Underline = 3
	// an underline indicating an error should
	//   be drawn below. The exact style of rendering is up to the
	//   `PangoRenderer` in use, but typical styles include wavy
	//   or dotted lines.
	//   This underline is typically used to indicate an error such
	//   as a possible mispelling; in some cases a contrasting color
	//   may automatically be used. This type of underlining is
	//   available since Pango 1.4.
	UnderlineErrorValue Underline = 4
	// Like @PANGO_UNDERLINE_SINGLE, but
	//   drawn continuously across multiple runs. This type
	//   of underlining is available since Pango 1.46.
	UnderlineSingleLineValue Underline = 5
	// Like @PANGO_UNDERLINE_DOUBLE, but
	//   drawn continuously across multiple runs. This type
	//   of underlining is available since Pango 1.46.
	UnderlineDoubleLineValue Underline = 6
	// Like @PANGO_UNDERLINE_ERROR, but
	//   drawn continuously across multiple runs. This type
	//   of underlining is available since Pango 1.46.
	UnderlineErrorLineValue Underline = 7
)

var xAttrAllowBreaksNew func(bool) *Attribute

// Create a new allow-breaks attribute.
//
// If breaks are disabled, the range will be kept in a
// single run, as far as possible.
func AttrAllowBreaksNew(AllowBreaksVar bool) *Attribute {

	cret := xAttrAllowBreaksNew(AllowBreaksVar)
	return cret
}

var xAttrBackgroundAlphaNew func(uint16) *Attribute

// Create a new background alpha attribute.
func AttrBackgroundAlphaNew(AlphaVar uint16) *Attribute {

	cret := xAttrBackgroundAlphaNew(AlphaVar)
	return cret
}

var xAttrBackgroundNew func(uint16, uint16, uint16) *Attribute

// Create a new background color attribute.
func AttrBackgroundNew(RedVar uint16, GreenVar uint16, BlueVar uint16) *Attribute {

	cret := xAttrBackgroundNew(RedVar, GreenVar, BlueVar)
	return cret
}

var xAttrBaselineShiftNew func(int) *Attribute

// Create a new baseline displacement attribute.
//
// The effect of this attribute is to shift the baseline of a run,
// relative to the run of preceding run.
//
// <picture>
//
//	<source srcset="baseline-shift-dark.png" media="(prefers-color-scheme: dark)">
//	<img alt="Baseline Shift" src="baseline-shift-light.png">
//
// </picture>
func AttrBaselineShiftNew(ShiftVar int) *Attribute {

	cret := xAttrBaselineShiftNew(ShiftVar)
	return cret
}

var xAttrFallbackNew func(bool) *Attribute

// Create a new font fallback attribute.
//
// If fallback is disabled, characters will only be
// used from the closest matching font on the system.
// No fallback will be done to other fonts on the system
// that might contain the characters in the text.
func AttrFallbackNew(EnableFallbackVar bool) *Attribute {

	cret := xAttrFallbackNew(EnableFallbackVar)
	return cret
}

var xAttrFamilyNew func(string) *Attribute

// Create a new font family attribute.
func AttrFamilyNew(FamilyVar string) *Attribute {

	cret := xAttrFamilyNew(FamilyVar)
	return cret
}

var xAttrFontDescNew func(*FontDescription) *Attribute

// Create a new font description attribute.
//
// This attribute allows setting family, style, weight, variant,
// stretch, and size simultaneously.
func AttrFontDescNew(DescVar *FontDescription) *Attribute {

	cret := xAttrFontDescNew(DescVar)
	return cret
}

var xAttrFontFeaturesNew func(string) *Attribute

// Create a new font features tag attribute.
//
// You can use this attribute to select OpenType font features like small-caps,
// alternative glyphs, ligatures, etc. for fonts that support them.
func AttrFontFeaturesNew(FeaturesVar string) *Attribute {

	cret := xAttrFontFeaturesNew(FeaturesVar)
	return cret
}

var xAttrFontScaleNew func(FontScale) *Attribute

// Create a new font scale attribute.
//
// The effect of this attribute is to change the font size of a run,
// relative to the size of preceding run.
func AttrFontScaleNew(ScaleVar FontScale) *Attribute {

	cret := xAttrFontScaleNew(ScaleVar)
	return cret
}

var xAttrForegroundAlphaNew func(uint16) *Attribute

// Create a new foreground alpha attribute.
func AttrForegroundAlphaNew(AlphaVar uint16) *Attribute {

	cret := xAttrForegroundAlphaNew(AlphaVar)
	return cret
}

var xAttrForegroundNew func(uint16, uint16, uint16) *Attribute

// Create a new foreground color attribute.
func AttrForegroundNew(RedVar uint16, GreenVar uint16, BlueVar uint16) *Attribute {

	cret := xAttrForegroundNew(RedVar, GreenVar, BlueVar)
	return cret
}

var xAttrGravityHintNew func(GravityHint) *Attribute

// Create a new gravity hint attribute.
func AttrGravityHintNew(HintVar GravityHint) *Attribute {

	cret := xAttrGravityHintNew(HintVar)
	return cret
}

var xAttrGravityNew func(Gravity) *Attribute

// Create a new gravity attribute.
func AttrGravityNew(GravityVar Gravity) *Attribute {

	cret := xAttrGravityNew(GravityVar)
	return cret
}

var xAttrInsertHyphensNew func(bool) *Attribute

// Create a new insert-hyphens attribute.
//
// Pango will insert hyphens when breaking lines in
// the middle of a word. This attribute can be used
// to suppress the hyphen.
func AttrInsertHyphensNew(InsertHyphensVar bool) *Attribute {

	cret := xAttrInsertHyphensNew(InsertHyphensVar)
	return cret
}

var xAttrLanguageNew func(*Language) *Attribute

// Create a new language tag attribute.
func AttrLanguageNew(LanguageVar *Language) *Attribute {

	cret := xAttrLanguageNew(LanguageVar)
	return cret
}

var xAttrLetterSpacingNew func(int) *Attribute

// Create a new letter-spacing attribute.
func AttrLetterSpacingNew(LetterSpacingVar int) *Attribute {

	cret := xAttrLetterSpacingNew(LetterSpacingVar)
	return cret
}

var xAttrLineHeightNew func(float64) *Attribute

// Modify the height of logical line extents by a factor.
//
// This affects the values returned by
// [method@Pango.LayoutLine.get_extents],
// [method@Pango.LayoutLine.get_pixel_extents] and
// [method@Pango.LayoutIter.get_line_extents].
func AttrLineHeightNew(FactorVar float64) *Attribute {

	cret := xAttrLineHeightNew(FactorVar)
	return cret
}

var xAttrLineHeightNewAbsolute func(int) *Attribute

// Override the height of logical line extents to be @height.
//
// This affects the values returned by
// [method@Pango.LayoutLine.get_extents],
// [method@Pango.LayoutLine.get_pixel_extents] and
// [method@Pango.LayoutIter.get_line_extents].
func AttrLineHeightNewAbsolute(HeightVar int) *Attribute {

	cret := xAttrLineHeightNewAbsolute(HeightVar)
	return cret
}

var xAttrListFromString func(string) *AttrList

// Deserializes a `PangoAttrList` from a string.
//
// This is the counterpart to [method@Pango.AttrList.to_string].
// See that functions for details about the format.
func AttrListFromString(TextVar string) *AttrList {

	cret := xAttrListFromString(TextVar)
	return cret
}

var xAttrOverlineColorNew func(uint16, uint16, uint16) *Attribute

// Create a new overline color attribute.
//
// This attribute modifies the color of overlines.
// If not set, overlines will use the foreground color.
func AttrOverlineColorNew(RedVar uint16, GreenVar uint16, BlueVar uint16) *Attribute {

	cret := xAttrOverlineColorNew(RedVar, GreenVar, BlueVar)
	return cret
}

var xAttrOverlineNew func(Overline) *Attribute

// Create a new overline-style attribute.
func AttrOverlineNew(OverlineVar Overline) *Attribute {

	cret := xAttrOverlineNew(OverlineVar)
	return cret
}

var xAttrRiseNew func(int) *Attribute

// Create a new baseline displacement attribute.
func AttrRiseNew(RiseVar int) *Attribute {

	cret := xAttrRiseNew(RiseVar)
	return cret
}

var xAttrScaleNew func(float64) *Attribute

// Create a new font size scale attribute.
//
// The base font for the affected text will have
// its size multiplied by @scale_factor.
func AttrScaleNew(ScaleFactorVar float64) *Attribute {

	cret := xAttrScaleNew(ScaleFactorVar)
	return cret
}

var xAttrSentenceNew func() *Attribute

// Marks the range of the attribute as a single sentence.
//
// Note that this may require adjustments to word and
// sentence classification around the range.
func AttrSentenceNew() *Attribute {

	cret := xAttrSentenceNew()
	return cret
}

var xAttrShapeNew func(*Rectangle, *Rectangle) *Attribute

// Create a new shape attribute.
//
// A shape is used to impose a particular ink and logical
// rectangle on the result of shaping a particular glyph.
// This might be used, for instance, for embedding a picture
// or a widget inside a `PangoLayout`.
func AttrShapeNew(InkRectVar *Rectangle, LogicalRectVar *Rectangle) *Attribute {

	cret := xAttrShapeNew(InkRectVar, LogicalRectVar)
	return cret
}

var xAttrShapeNewWithData func(*Rectangle, *Rectangle, uintptr, uintptr, uintptr) *Attribute

// Creates a new shape attribute.
//
// Like [func@Pango.AttrShape.new], but a user data pointer
// is also provided; this pointer can be accessed when later
// rendering the glyph.
func AttrShapeNewWithData(InkRectVar *Rectangle, LogicalRectVar *Rectangle, DataVar uintptr, CopyFuncVar *AttrDataCopyFunc, DestroyFuncVar *glib.DestroyNotify) *Attribute {

	var CopyFuncVarRef uintptr
	if CopyFuncVar != nil {
		CopyFuncVarPtr := uintptr(unsafe.Pointer(CopyFuncVar))
		if cbRefPtr, ok := glib.GetCallback(CopyFuncVarPtr); ok {
			CopyFuncVarRef = cbRefPtr
		} else {
			fcb := func(arg0 uintptr) uintptr {
				cbFn := *CopyFuncVar
				return cbFn(arg0)
			}
			CopyFuncVarRef = purego.NewCallback(fcb)
			glib.SaveCallbackWithClosure(CopyFuncVarPtr, CopyFuncVarRef, CopyFuncVar)
		}
	}

	var DestroyFuncVarRef uintptr
	if DestroyFuncVar != nil {
		DestroyFuncVarPtr := uintptr(unsafe.Pointer(DestroyFuncVar))
		if cbRefPtr, ok := glib.GetCallback(DestroyFuncVarPtr); ok {
			DestroyFuncVarRef = cbRefPtr
		} else {
			fcb := func(arg0 uintptr) {
				cbFn := *DestroyFuncVar
				cbFn(arg0)
			}
			DestroyFuncVarRef = purego.NewCallback(fcb)
			glib.SaveCallbackWithClosure(DestroyFuncVarPtr, DestroyFuncVarRef, DestroyFuncVar)
		}
	}

	cret := xAttrShapeNewWithData(InkRectVar, LogicalRectVar, DataVar, CopyFuncVarRef, DestroyFuncVarRef)
	return cret
}

var xAttrShowNew func(ShowFlags) *Attribute

// Create a new attribute that influences how invisible
// characters are rendered.
func AttrShowNew(FlagsVar ShowFlags) *Attribute {

	cret := xAttrShowNew(FlagsVar)
	return cret
}

var xAttrSizeNew func(int) *Attribute

// Create a new font-size attribute in fractional points.
func AttrSizeNew(SizeVar int) *Attribute {

	cret := xAttrSizeNew(SizeVar)
	return cret
}

var xAttrSizeNewAbsolute func(int) *Attribute

// Create a new font-size attribute in device units.
func AttrSizeNewAbsolute(SizeVar int) *Attribute {

	cret := xAttrSizeNewAbsolute(SizeVar)
	return cret
}

var xAttrStretchNew func(Stretch) *Attribute

// Create a new font stretch attribute.
func AttrStretchNew(StretchVar Stretch) *Attribute {

	cret := xAttrStretchNew(StretchVar)
	return cret
}

var xAttrStrikethroughColorNew func(uint16, uint16, uint16) *Attribute

// Create a new strikethrough color attribute.
//
// This attribute modifies the color of strikethrough lines.
// If not set, strikethrough lines will use the foreground color.
func AttrStrikethroughColorNew(RedVar uint16, GreenVar uint16, BlueVar uint16) *Attribute {

	cret := xAttrStrikethroughColorNew(RedVar, GreenVar, BlueVar)
	return cret
}

var xAttrStrikethroughNew func(bool) *Attribute

// Create a new strike-through attribute.
func AttrStrikethroughNew(StrikethroughVar bool) *Attribute {

	cret := xAttrStrikethroughNew(StrikethroughVar)
	return cret
}

var xAttrStyleNew func(Style) *Attribute

// Create a new font slant style attribute.
func AttrStyleNew(StyleVar Style) *Attribute {

	cret := xAttrStyleNew(StyleVar)
	return cret
}

var xAttrTextTransformNew func(TextTransform) *Attribute

// Create a new attribute that influences how characters
// are transformed during shaping.
func AttrTextTransformNew(TransformVar TextTransform) *Attribute {

	cret := xAttrTextTransformNew(TransformVar)
	return cret
}

var xAttrTypeGetName func(AttrType) string

// Fetches the attribute type name.
//
// The attribute type name is the string passed in
// when registering the type using
// [func@Pango.AttrType.register].
//
// The returned value is an interned string (see
// g_intern_string() for what that means) that should
// not be modified or freed.
func AttrTypeGetName(TypeVar AttrType) string {

	cret := xAttrTypeGetName(TypeVar)
	return cret
}

var xAttrTypeRegister func(string) AttrType

// Allocate a new attribute type ID.
//
// The attribute type name can be accessed later
// by using [func@Pango.AttrType.get_name].
func AttrTypeRegister(NameVar string) AttrType {

	cret := xAttrTypeRegister(NameVar)
	return cret
}

var xAttrUnderlineColorNew func(uint16, uint16, uint16) *Attribute

// Create a new underline color attribute.
//
// This attribute modifies the color of underlines.
// If not set, underlines will use the foreground color.
func AttrUnderlineColorNew(RedVar uint16, GreenVar uint16, BlueVar uint16) *Attribute {

	cret := xAttrUnderlineColorNew(RedVar, GreenVar, BlueVar)
	return cret
}

var xAttrUnderlineNew func(Underline) *Attribute

// Create a new underline-style attribute.
func AttrUnderlineNew(UnderlineVar Underline) *Attribute {

	cret := xAttrUnderlineNew(UnderlineVar)
	return cret
}

var xAttrVariantNew func(Variant) *Attribute

// Create a new font variant attribute (normal or small caps).
func AttrVariantNew(VariantVar Variant) *Attribute {

	cret := xAttrVariantNew(VariantVar)
	return cret
}

var xAttrWeightNew func(Weight) *Attribute

// Create a new font weight attribute.
func AttrWeightNew(WeightVar Weight) *Attribute {

	cret := xAttrWeightNew(WeightVar)
	return cret
}

var xAttrWordNew func() *Attribute

// Marks the range of the attribute as a single word.
//
// Note that this may require adjustments to word and
// sentence classification around the range.
func AttrWordNew() *Attribute {

	cret := xAttrWordNew()
	return cret
}

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(&xShowFlagsGLibType, libs, "pango_show_flags_get_type")

	core.PuregoSafeRegister(&xAttrTypeGLibType, libs, "pango_attr_type_get_type")

	core.PuregoSafeRegister(&xBaselineShiftGLibType, libs, "pango_baseline_shift_get_type")

	core.PuregoSafeRegister(&xFontScaleGLibType, libs, "pango_font_scale_get_type")

	core.PuregoSafeRegister(&xOverlineGLibType, libs, "pango_overline_get_type")

	core.PuregoSafeRegister(&xTextTransformGLibType, libs, "pango_text_transform_get_type")

	core.PuregoSafeRegister(&xUnderlineGLibType, libs, "pango_underline_get_type")

	core.PuregoSafeRegister(&xAttrAllowBreaksNew, libs, "pango_attr_allow_breaks_new")
	core.PuregoSafeRegister(&xAttrBackgroundAlphaNew, libs, "pango_attr_background_alpha_new")
	core.PuregoSafeRegister(&xAttrBackgroundNew, libs, "pango_attr_background_new")
	core.PuregoSafeRegister(&xAttrBaselineShiftNew, libs, "pango_attr_baseline_shift_new")
	core.PuregoSafeRegister(&xAttrFallbackNew, libs, "pango_attr_fallback_new")
	core.PuregoSafeRegister(&xAttrFamilyNew, libs, "pango_attr_family_new")
	core.PuregoSafeRegister(&xAttrFontDescNew, libs, "pango_attr_font_desc_new")
	core.PuregoSafeRegister(&xAttrFontFeaturesNew, libs, "pango_attr_font_features_new")
	core.PuregoSafeRegister(&xAttrFontScaleNew, libs, "pango_attr_font_scale_new")
	core.PuregoSafeRegister(&xAttrForegroundAlphaNew, libs, "pango_attr_foreground_alpha_new")
	core.PuregoSafeRegister(&xAttrForegroundNew, libs, "pango_attr_foreground_new")
	core.PuregoSafeRegister(&xAttrGravityHintNew, libs, "pango_attr_gravity_hint_new")
	core.PuregoSafeRegister(&xAttrGravityNew, libs, "pango_attr_gravity_new")
	core.PuregoSafeRegister(&xAttrInsertHyphensNew, libs, "pango_attr_insert_hyphens_new")
	core.PuregoSafeRegister(&xAttrLanguageNew, libs, "pango_attr_language_new")
	core.PuregoSafeRegister(&xAttrLetterSpacingNew, libs, "pango_attr_letter_spacing_new")
	core.PuregoSafeRegister(&xAttrLineHeightNew, libs, "pango_attr_line_height_new")
	core.PuregoSafeRegister(&xAttrLineHeightNewAbsolute, libs, "pango_attr_line_height_new_absolute")
	core.PuregoSafeRegister(&xAttrListFromString, libs, "pango_attr_list_from_string")
	core.PuregoSafeRegister(&xAttrOverlineColorNew, libs, "pango_attr_overline_color_new")
	core.PuregoSafeRegister(&xAttrOverlineNew, libs, "pango_attr_overline_new")
	core.PuregoSafeRegister(&xAttrRiseNew, libs, "pango_attr_rise_new")
	core.PuregoSafeRegister(&xAttrScaleNew, libs, "pango_attr_scale_new")
	core.PuregoSafeRegister(&xAttrSentenceNew, libs, "pango_attr_sentence_new")
	core.PuregoSafeRegister(&xAttrShapeNew, libs, "pango_attr_shape_new")
	core.PuregoSafeRegister(&xAttrShapeNewWithData, libs, "pango_attr_shape_new_with_data")
	core.PuregoSafeRegister(&xAttrShowNew, libs, "pango_attr_show_new")
	core.PuregoSafeRegister(&xAttrSizeNew, libs, "pango_attr_size_new")
	core.PuregoSafeRegister(&xAttrSizeNewAbsolute, libs, "pango_attr_size_new_absolute")
	core.PuregoSafeRegister(&xAttrStretchNew, libs, "pango_attr_stretch_new")
	core.PuregoSafeRegister(&xAttrStrikethroughColorNew, libs, "pango_attr_strikethrough_color_new")
	core.PuregoSafeRegister(&xAttrStrikethroughNew, libs, "pango_attr_strikethrough_new")
	core.PuregoSafeRegister(&xAttrStyleNew, libs, "pango_attr_style_new")
	core.PuregoSafeRegister(&xAttrTextTransformNew, libs, "pango_attr_text_transform_new")
	core.PuregoSafeRegister(&xAttrTypeGetName, libs, "pango_attr_type_get_name")
	core.PuregoSafeRegister(&xAttrTypeRegister, libs, "pango_attr_type_register")
	core.PuregoSafeRegister(&xAttrUnderlineColorNew, libs, "pango_attr_underline_color_new")
	core.PuregoSafeRegister(&xAttrUnderlineNew, libs, "pango_attr_underline_new")
	core.PuregoSafeRegister(&xAttrVariantNew, libs, "pango_attr_variant_new")
	core.PuregoSafeRegister(&xAttrWeightNew, libs, "pango_attr_weight_new")
	core.PuregoSafeRegister(&xAttrWordNew, libs, "pango_attr_word_new")

	core.PuregoSafeRegister(&xAttrIteratorGLibType, libs, "pango_attr_iterator_get_type")

	core.PuregoSafeRegister(&xAttrIteratorCopy, libs, "pango_attr_iterator_copy")
	core.PuregoSafeRegister(&xAttrIteratorDestroy, libs, "pango_attr_iterator_destroy")
	core.PuregoSafeRegister(&xAttrIteratorGet, libs, "pango_attr_iterator_get")
	core.PuregoSafeRegister(&xAttrIteratorGetAttrs, libs, "pango_attr_iterator_get_attrs")
	core.PuregoSafeRegister(&xAttrIteratorGetFont, libs, "pango_attr_iterator_get_font")
	core.PuregoSafeRegister(&xAttrIteratorNext, libs, "pango_attr_iterator_next")
	core.PuregoSafeRegister(&xAttrIteratorRange, libs, "pango_attr_iterator_range")

	core.PuregoSafeRegister(&xAttrListGLibType, libs, "pango_attr_list_get_type")

	core.PuregoSafeRegister(&xNewAttrList, libs, "pango_attr_list_new")

	core.PuregoSafeRegister(&xAttrListChange, libs, "pango_attr_list_change")
	core.PuregoSafeRegister(&xAttrListCopy, libs, "pango_attr_list_copy")
	core.PuregoSafeRegister(&xAttrListEqual, libs, "pango_attr_list_equal")
	core.PuregoSafeRegister(&xAttrListFilter, libs, "pango_attr_list_filter")
	core.PuregoSafeRegister(&xAttrListGetAttributes, libs, "pango_attr_list_get_attributes")
	core.PuregoSafeRegister(&xAttrListGetIterator, libs, "pango_attr_list_get_iterator")
	core.PuregoSafeRegister(&xAttrListInsert, libs, "pango_attr_list_insert")
	core.PuregoSafeRegister(&xAttrListInsertBefore, libs, "pango_attr_list_insert_before")
	core.PuregoSafeRegister(&xAttrListRef, libs, "pango_attr_list_ref")
	core.PuregoSafeRegister(&xAttrListSplice, libs, "pango_attr_list_splice")
	core.PuregoSafeRegister(&xAttrListToString, libs, "pango_attr_list_to_string")
	core.PuregoSafeRegister(&xAttrListUnref, libs, "pango_attr_list_unref")
	core.PuregoSafeRegister(&xAttrListUpdate, libs, "pango_attr_list_update")

	core.PuregoSafeRegister(&xAttributeGLibType, libs, "pango_attribute_get_type")

	core.PuregoSafeRegister(&xAttributeAsColor, libs, "pango_attribute_as_color")
	core.PuregoSafeRegister(&xAttributeAsFloat, libs, "pango_attribute_as_float")
	core.PuregoSafeRegister(&xAttributeAsFontDesc, libs, "pango_attribute_as_font_desc")
	core.PuregoSafeRegister(&xAttributeAsFontFeatures, libs, "pango_attribute_as_font_features")
	core.PuregoSafeRegister(&xAttributeAsInt, libs, "pango_attribute_as_int")
	core.PuregoSafeRegister(&xAttributeAsLanguage, libs, "pango_attribute_as_language")
	core.PuregoSafeRegister(&xAttributeAsShape, libs, "pango_attribute_as_shape")
	core.PuregoSafeRegister(&xAttributeAsSize, libs, "pango_attribute_as_size")
	core.PuregoSafeRegister(&xAttributeAsString, libs, "pango_attribute_as_string")
	core.PuregoSafeRegister(&xAttributeCopy, libs, "pango_attribute_copy")
	core.PuregoSafeRegister(&xAttributeDestroy, libs, "pango_attribute_destroy")
	core.PuregoSafeRegister(&xAttributeEqual, libs, "pango_attribute_equal")
	core.PuregoSafeRegister(&xAttributeInit, libs, "pango_attribute_init")

}