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

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"
)

type GridClass struct {
	_ structs.HostLayout

	ParentClass WidgetClass

	Padding [8]uintptr
}

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

// Arranges its child widgets in rows and columns.
//
// <picture>
//
//	<source srcset="grid-dark.png" media="(prefers-color-scheme: dark)">
//	<img alt="An example GtkGrid" src="grid.png">
//
// </picture>
//
// It supports arbitrary positions and horizontal/vertical spans.
//
// Children are added using [method@Gtk.Grid.attach]. They can span multiple
// rows or columns. It is also possible to add a child next to an existing
// child, using [method@Gtk.Grid.attach_next_to]. To remove a child from the
// grid, use [method@Gtk.Grid.remove].
//
// The behaviour of `GtkGrid` when several children occupy the same grid
// cell is undefined.
//
// # GtkGrid as GtkBuildable
//
// Every child in a `GtkGrid` has access to a custom [iface@Gtk.Buildable]
// element, called `<layout>`. It can by used to specify a position in the
// grid and optionally spans. All properties that can be used in the `<layout>`
// element are implemented by [class@Gtk.GridLayoutChild].
//
// It is implemented by `GtkWidget` using [class@Gtk.LayoutManager].
//
// To showcase it, here is a simple example:
//
// ```xml
// <object class="GtkGrid" id="my_grid">
//
//	<child>
//	  <object class="GtkButton" id="button1">
//	    <property name="label">Button 1</property>
//	    <layout>
//	      <property name="column">0</property>
//	      <property name="row">0</property>
//	    </layout>
//	  </object>
//	</child>
//	<child>
//	  <object class="GtkButton" id="button2">
//	    <property name="label">Button 2</property>
//	    <layout>
//	      <property name="column">1</property>
//	      <property name="row">0</property>
//	    </layout>
//	  </object>
//	</child>
//	<child>
//	  <object class="GtkButton" id="button3">
//	    <property name="label">Button 3</property>
//	    <layout>
//	      <property name="column">2</property>
//	      <property name="row">0</property>
//	      <property name="row-span">2</property>
//	    </layout>
//	  </object>
//	</child>
//	<child>
//	  <object class="GtkButton" id="button4">
//	    <property name="label">Button 4</property>
//	    <layout>
//	      <property name="column">0</property>
//	      <property name="row">1</property>
//	      <property name="column-span">2</property>
//	    </layout>
//	  </object>
//	</child>
//
// </object>
// ```
//
// It organizes the first two buttons side-by-side in one cell each.
// The third button is in the last column but spans across two rows.
// This is defined by the `row-span` property. The last button is
// located in the second row and spans across two columns, which is
// defined by the `column-span` property.
//
// # CSS nodes
//
// `GtkGrid` uses a single CSS node with name `grid`.
//
// # Accessibility
//
// Until GTK 4.10, `GtkGrid` used the [enum@Gtk.AccessibleRole.group] role.
//
// Starting from GTK 4.12, `GtkGrid` uses the [enum@Gtk.AccessibleRole.generic] role.
type Grid struct {
	Widget
}

var xGridGLibType func() types.GType

func GridGLibType() types.GType {
	return xGridGLibType()
}

func GridNewFromInternalPtr(ptr uintptr) *Grid {
	cls := &Grid{}
	cls.Ptr = ptr
	return cls
}

var xNewGrid func() uintptr

// Creates a new grid widget.
func NewGrid() *Grid {
	var cls *Grid

	cret := xNewGrid()

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

var xGridAttach func(uintptr, uintptr, int, int, int, int)

// Adds a widget to the grid.
//
// The position of @child is determined by @column and @row.
// The number of “cells” that @child will occupy is determined
// by @width and @height.
func (x *Grid) Attach(ChildVar *Widget, ColumnVar int, RowVar int, WidthVar int, HeightVar int) {

	xGridAttach(x.GoPointer(), ChildVar.GoPointer(), ColumnVar, RowVar, WidthVar, HeightVar)

}

var xGridAttachNextTo func(uintptr, uintptr, uintptr, PositionType, int, int)

// Adds a widget to the grid.
//
// The widget is placed next to @sibling, on the side determined by
// @side. When @sibling is %NULL, the widget is placed in row (for
// left or right placement) or column 0 (for top or bottom placement),
// at the end indicated by @side.
//
// Attaching widgets labeled `[1]`, `[2]`, `[3]` with `@sibling == %NULL` and
// `@side == %GTK_POS_LEFT` yields a layout of `[3][2][1]`.
func (x *Grid) AttachNextTo(ChildVar *Widget, SiblingVar *Widget, SideVar PositionType, WidthVar int, HeightVar int) {

	xGridAttachNextTo(x.GoPointer(), ChildVar.GoPointer(), SiblingVar.GoPointer(), SideVar, WidthVar, HeightVar)

}

var xGridGetBaselineRow func(uintptr) int

// Returns which row defines the global baseline of @grid.
func (x *Grid) GetBaselineRow() int {

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

var xGridGetChildAt func(uintptr, int, int) uintptr

// Gets the child of @grid whose area covers the grid
// cell at @column, @row.
func (x *Grid) GetChildAt(ColumnVar int, RowVar int) *Widget {
	var cls *Widget

	cret := xGridGetChildAt(x.GoPointer(), ColumnVar, RowVar)

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

var xGridGetColumnHomogeneous func(uintptr) bool

// Returns whether all columns of @grid have the same width.
func (x *Grid) GetColumnHomogeneous() bool {

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

var xGridGetColumnSpacing func(uintptr) uint

// Returns the amount of space between the columns of @grid.
func (x *Grid) GetColumnSpacing() uint {

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

var xGridGetRowBaselinePosition func(uintptr, int) BaselinePosition

// Returns the baseline position of @row.
//
// See [method@Gtk.Grid.set_row_baseline_position].
func (x *Grid) GetRowBaselinePosition(RowVar int) BaselinePosition {

	cret := xGridGetRowBaselinePosition(x.GoPointer(), RowVar)
	return cret
}

var xGridGetRowHomogeneous func(uintptr) bool

// Returns whether all rows of @grid have the same height.
func (x *Grid) GetRowHomogeneous() bool {

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

var xGridGetRowSpacing func(uintptr) uint

// Returns the amount of space between the rows of @grid.
func (x *Grid) GetRowSpacing() uint {

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

var xGridInsertColumn func(uintptr, int)

// Inserts a column at the specified position.
//
// Children which are attached at or to the right of this position
// are moved one column to the right. Children which span across this
// position are grown to span the new column.
func (x *Grid) InsertColumn(PositionVar int) {

	xGridInsertColumn(x.GoPointer(), PositionVar)

}

var xGridInsertNextTo func(uintptr, uintptr, PositionType)

// Inserts a row or column at the specified position.
//
// The new row or column is placed next to @sibling, on the side
// determined by @side. If @side is %GTK_POS_TOP or %GTK_POS_BOTTOM,
// a row is inserted. If @side is %GTK_POS_LEFT of %GTK_POS_RIGHT,
// a column is inserted.
func (x *Grid) InsertNextTo(SiblingVar *Widget, SideVar PositionType) {

	xGridInsertNextTo(x.GoPointer(), SiblingVar.GoPointer(), SideVar)

}

var xGridInsertRow func(uintptr, int)

// Inserts a row at the specified position.
//
// Children which are attached at or below this position
// are moved one row down. Children which span across this
// position are grown to span the new row.
func (x *Grid) InsertRow(PositionVar int) {

	xGridInsertRow(x.GoPointer(), PositionVar)

}

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

// Queries the attach points and spans of @child inside the given `GtkGrid`.
func (x *Grid) QueryChild(ChildVar *Widget, ColumnVar *int, RowVar *int, WidthVar *int, HeightVar *int) {

	xGridQueryChild(x.GoPointer(), ChildVar.GoPointer(), ColumnVar, RowVar, WidthVar, HeightVar)

}

var xGridRemove func(uintptr, uintptr)

// Removes a child from @grid.
//
// The child must have been added with
// [method@Gtk.Grid.attach] or [method@Gtk.Grid.attach_next_to].
func (x *Grid) Remove(ChildVar *Widget) {

	xGridRemove(x.GoPointer(), ChildVar.GoPointer())

}

var xGridRemoveColumn func(uintptr, int)

// Removes a column from the grid.
//
// Children that are placed in this column are removed,
// spanning children that overlap this column have their
// width reduced by one, and children after the column
// are moved to the left.
func (x *Grid) RemoveColumn(PositionVar int) {

	xGridRemoveColumn(x.GoPointer(), PositionVar)

}

var xGridRemoveRow func(uintptr, int)

// Removes a row from the grid.
//
// Children that are placed in this row are removed,
// spanning children that overlap this row have their
// height reduced by one, and children below the row
// are moved up.
func (x *Grid) RemoveRow(PositionVar int) {

	xGridRemoveRow(x.GoPointer(), PositionVar)

}

var xGridSetBaselineRow func(uintptr, int)

// Sets which row defines the global baseline for the entire grid.
//
// Each row in the grid can have its own local baseline, but only
// one of those is global, meaning it will be the baseline in the
// parent of the @grid.
func (x *Grid) SetBaselineRow(RowVar int) {

	xGridSetBaselineRow(x.GoPointer(), RowVar)

}

var xGridSetColumnHomogeneous func(uintptr, bool)

// Sets whether all columns of @grid will have the same width.
func (x *Grid) SetColumnHomogeneous(HomogeneousVar bool) {

	xGridSetColumnHomogeneous(x.GoPointer(), HomogeneousVar)

}

var xGridSetColumnSpacing func(uintptr, uint)

// Sets the amount of space between columns of @grid.
func (x *Grid) SetColumnSpacing(SpacingVar uint) {

	xGridSetColumnSpacing(x.GoPointer(), SpacingVar)

}

var xGridSetRowBaselinePosition func(uintptr, int, BaselinePosition)

// Sets how the baseline should be positioned on @row of the
// grid, in case that row is assigned more space than is requested.
//
// The default baseline position is %GTK_BASELINE_POSITION_CENTER.
func (x *Grid) SetRowBaselinePosition(RowVar int, PosVar BaselinePosition) {

	xGridSetRowBaselinePosition(x.GoPointer(), RowVar, PosVar)

}

var xGridSetRowHomogeneous func(uintptr, bool)

// Sets whether all rows of @grid will have the same height.
func (x *Grid) SetRowHomogeneous(HomogeneousVar bool) {

	xGridSetRowHomogeneous(x.GoPointer(), HomogeneousVar)

}

var xGridSetRowSpacing func(uintptr, uint)

// Sets the amount of space between rows of @grid.
func (x *Grid) SetRowSpacing(SpacingVar uint) {

	xGridSetRowSpacing(x.GoPointer(), SpacingVar)

}

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

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

// SetPropertyBaselineRow sets the "baseline-row" property.
// The row to align to the baseline when valign is using baseline alignment.
func (x *Grid) SetPropertyBaselineRow(value int) {
	var v gobject.Value
	v.Init(gobject.TypeIntVal)
	v.SetInt(value)
	x.SetProperty("baseline-row", &v)
}

// GetPropertyBaselineRow gets the "baseline-row" property.
// The row to align to the baseline when valign is using baseline alignment.
func (x *Grid) GetPropertyBaselineRow() int {
	var v gobject.Value
	x.GetProperty("baseline-row", &v)
	return v.GetInt()
}

// SetPropertyColumnHomogeneous sets the "column-homogeneous" property.
// If %TRUE, the columns are all the same width.
func (x *Grid) SetPropertyColumnHomogeneous(value bool) {
	var v gobject.Value
	v.Init(gobject.TypeBooleanVal)
	v.SetBoolean(value)
	x.SetProperty("column-homogeneous", &v)
}

// GetPropertyColumnHomogeneous gets the "column-homogeneous" property.
// If %TRUE, the columns are all the same width.
func (x *Grid) GetPropertyColumnHomogeneous() bool {
	var v gobject.Value
	x.GetProperty("column-homogeneous", &v)
	return v.GetBoolean()
}

// SetPropertyColumnSpacing sets the "column-spacing" property.
// The amount of space between two consecutive columns.
func (x *Grid) SetPropertyColumnSpacing(value int) {
	var v gobject.Value
	v.Init(gobject.TypeIntVal)
	v.SetInt(value)
	x.SetProperty("column-spacing", &v)
}

// GetPropertyColumnSpacing gets the "column-spacing" property.
// The amount of space between two consecutive columns.
func (x *Grid) GetPropertyColumnSpacing() int {
	var v gobject.Value
	x.GetProperty("column-spacing", &v)
	return v.GetInt()
}

// SetPropertyRowHomogeneous sets the "row-homogeneous" property.
// If %TRUE, the rows are all the same height.
func (x *Grid) SetPropertyRowHomogeneous(value bool) {
	var v gobject.Value
	v.Init(gobject.TypeBooleanVal)
	v.SetBoolean(value)
	x.SetProperty("row-homogeneous", &v)
}

// GetPropertyRowHomogeneous gets the "row-homogeneous" property.
// If %TRUE, the rows are all the same height.
func (x *Grid) GetPropertyRowHomogeneous() bool {
	var v gobject.Value
	x.GetProperty("row-homogeneous", &v)
	return v.GetBoolean()
}

// SetPropertyRowSpacing sets the "row-spacing" property.
// The amount of space between two consecutive rows.
func (x *Grid) SetPropertyRowSpacing(value int) {
	var v gobject.Value
	v.Init(gobject.TypeIntVal)
	v.SetInt(value)
	x.SetProperty("row-spacing", &v)
}

// GetPropertyRowSpacing gets the "row-spacing" property.
// The amount of space between two consecutive rows.
func (x *Grid) GetPropertyRowSpacing() int {
	var v gobject.Value
	x.GetProperty("row-spacing", &v)
	return v.GetInt()
}

// Requests the user's screen reader to announce the given message.
//
// This kind of notification is useful for messages that
// either have only a visual representation or that are not
// exposed visually at all, e.g. a notification about a
// successful operation.
//
// Also, by using this API, you can ensure that the message
// does not interrupts the user's current screen reader output.
func (x *Grid) Announce(MessageVar string, PriorityVar AccessibleAnnouncementPriority) {

	XGtkAccessibleAnnounce(x.GoPointer(), MessageVar, PriorityVar)

}

// Retrieves the accessible parent for an accessible object.
//
// This function returns `NULL` for top level widgets.
func (x *Grid) GetAccessibleParent() *AccessibleBase {
	var cls *AccessibleBase

	cret := XGtkAccessibleGetAccessibleParent(x.GoPointer())

	if cret == 0 {
		return nil
	}
	cls = &AccessibleBase{}
	cls.Ptr = cret
	return cls
}

// Retrieves the accessible role of an accessible object.
func (x *Grid) GetAccessibleRole() AccessibleRole {

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

// Retrieves the implementation for the given accessible object.
func (x *Grid) GetAtContext() *ATContext {
	var cls *ATContext

	cret := XGtkAccessibleGetAtContext(x.GoPointer())

	if cret == 0 {
		return nil
	}
	cls = &ATContext{}
	cls.Ptr = cret
	return cls
}

// Queries the coordinates and dimensions of this accessible
//
// This functionality can be overridden by `GtkAccessible`
// implementations, e.g. to get the bounds from an ignored
// child widget.
func (x *Grid) GetBounds(XVar *int, YVar *int, WidthVar *int, HeightVar *int) bool {

	cret := XGtkAccessibleGetBounds(x.GoPointer(), XVar, YVar, WidthVar, HeightVar)
	return cret
}

// Retrieves the first accessible child of an accessible object.
func (x *Grid) GetFirstAccessibleChild() *AccessibleBase {
	var cls *AccessibleBase

	cret := XGtkAccessibleGetFirstAccessibleChild(x.GoPointer())

	if cret == 0 {
		return nil
	}
	cls = &AccessibleBase{}
	cls.Ptr = cret
	return cls
}

// Retrieves the next accessible sibling of an accessible object
func (x *Grid) GetNextAccessibleSibling() *AccessibleBase {
	var cls *AccessibleBase

	cret := XGtkAccessibleGetNextAccessibleSibling(x.GoPointer())

	if cret == 0 {
		return nil
	}
	cls = &AccessibleBase{}
	cls.Ptr = cret
	return cls
}

// Queries a platform state, such as focus.
//
// This functionality can be overridden by `GtkAccessible`
// implementations, e.g. to get platform state from an ignored
// child widget, as is the case for `GtkText` wrappers.
func (x *Grid) GetPlatformState(StateVar AccessiblePlatformState) bool {

	cret := XGtkAccessibleGetPlatformState(x.GoPointer(), StateVar)
	return cret
}

// Resets the accessible property to its default value.
func (x *Grid) ResetProperty(PropertyVar AccessibleProperty) {

	XGtkAccessibleResetProperty(x.GoPointer(), PropertyVar)

}

// Resets the accessible relation to its default value.
func (x *Grid) ResetRelation(RelationVar AccessibleRelation) {

	XGtkAccessibleResetRelation(x.GoPointer(), RelationVar)

}

// Resets the accessible state to its default value.
func (x *Grid) ResetState(StateVar AccessibleState) {

	XGtkAccessibleResetState(x.GoPointer(), StateVar)

}

// Sets the parent and sibling of an accessible object.
//
// This function is meant to be used by accessible implementations that are
// not part of the widget hierarchy, and but act as a logical bridge between
// widgets. For instance, if a widget creates an object that holds metadata
// for each child, and you want that object to implement the `GtkAccessible`
// interface, you will use this function to ensure that the parent of each
// child widget is the metadata object, and the parent of each metadata
// object is the container widget.
func (x *Grid) SetAccessibleParent(ParentVar Accessible, NextSiblingVar Accessible) {

	XGtkAccessibleSetAccessibleParent(x.GoPointer(), ParentVar.GoPointer(), NextSiblingVar.GoPointer())

}

// Updates the next accessible sibling.
//
// That might be useful when a new child of a custom accessible
// is created, and it needs to be linked to a previous child.
func (x *Grid) UpdateNextAccessibleSibling(NewSiblingVar Accessible) {

	XGtkAccessibleUpdateNextAccessibleSibling(x.GoPointer(), NewSiblingVar.GoPointer())

}

// Informs ATs that the platform state has changed.
//
// This function should be used by `GtkAccessible` implementations that
// have a platform state but are not widgets. Widgets handle platform
// states automatically.
func (x *Grid) UpdatePlatformState(StateVar AccessiblePlatformState) {

	XGtkAccessibleUpdatePlatformState(x.GoPointer(), StateVar)

}

// Updates a list of accessible properties.
//
// See the [enum@Gtk.AccessibleProperty] documentation for the
// value types of accessible properties.
//
// This function should be called by `GtkWidget` types whenever
// an accessible property change must be communicated to assistive
// technologies.
//
// Example:
// ```c
// value = gtk_adjustment_get_value (adjustment);
// gtk_accessible_update_property (GTK_ACCESSIBLE (spin_button),
//
//	GTK_ACCESSIBLE_PROPERTY_VALUE_NOW, value,
//	-1);
//
// ```
func (x *Grid) UpdateProperty(FirstPropertyVar AccessibleProperty, varArgs ...interface{}) {

	XGtkAccessibleUpdateProperty(x.GoPointer(), FirstPropertyVar, varArgs...)

}

// Updates an array of accessible properties.
//
// This function should be called by `GtkWidget` types whenever an accessible
// property change must be communicated to assistive technologies.
//
// This function is meant to be used by language bindings.
func (x *Grid) UpdatePropertyValue(NPropertiesVar int, PropertiesVar []AccessibleProperty, ValuesVar []gobject.Value) {

	XGtkAccessibleUpdatePropertyValue(x.GoPointer(), NPropertiesVar, PropertiesVar, ValuesVar)

}

// Updates a list of accessible relations.
//
// This function should be called by `GtkWidget` types whenever an accessible
// relation change must be communicated to assistive technologies.
//
// If the [enum@Gtk.AccessibleRelation] requires a list of references,
// you should pass each reference individually, followed by `NULL`, e.g.
//
// ```c
// gtk_accessible_update_relation (accessible,
//
//	GTK_ACCESSIBLE_RELATION_CONTROLS,
//	  ref1, NULL,
//	GTK_ACCESSIBLE_RELATION_LABELLED_BY,
//	  ref1, ref2, ref3, NULL,
//	-1);
//
// ```
func (x *Grid) UpdateRelation(FirstRelationVar AccessibleRelation, varArgs ...interface{}) {

	XGtkAccessibleUpdateRelation(x.GoPointer(), FirstRelationVar, varArgs...)

}

// Updates an array of accessible relations.
//
// This function should be called by `GtkWidget` types whenever an accessible
// relation change must be communicated to assistive technologies.
//
// This function is meant to be used by language bindings.
func (x *Grid) UpdateRelationValue(NRelationsVar int, RelationsVar []AccessibleRelation, ValuesVar []gobject.Value) {

	XGtkAccessibleUpdateRelationValue(x.GoPointer(), NRelationsVar, RelationsVar, ValuesVar)

}

// Updates a list of accessible states.
//
// See the [enum@Gtk.AccessibleState] documentation for the
// value types of accessible states.
//
// This function should be called by `GtkWidget` types whenever
// an accessible state change must be communicated to assistive
// technologies.
//
// Example:
//
// ```c
// value = GTK_ACCESSIBLE_TRISTATE_MIXED;
// gtk_accessible_update_state (GTK_ACCESSIBLE (check_button),
//
//	GTK_ACCESSIBLE_STATE_CHECKED, value,
//	-1);
//
// ```
func (x *Grid) UpdateState(FirstStateVar AccessibleState, varArgs ...interface{}) {

	XGtkAccessibleUpdateState(x.GoPointer(), FirstStateVar, varArgs...)

}

// Updates an array of accessible states.
//
// This function should be called by `GtkWidget` types whenever an accessible
// state change must be communicated to assistive technologies.
//
// This function is meant to be used by language bindings.
func (x *Grid) UpdateStateValue(NStatesVar int, StatesVar []AccessibleState, ValuesVar []gobject.Value) {

	XGtkAccessibleUpdateStateValue(x.GoPointer(), NStatesVar, StatesVar, ValuesVar)

}

// Gets the ID of the @buildable object.
//
// `GtkBuilder` sets the name based on the ID attribute
// of the `<object>` tag used to construct the @buildable.
func (x *Grid) GetBuildableId() string {

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

// Retrieves the orientation of the @orientable.
func (x *Grid) GetOrientation() Orientation {

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

// Sets the orientation of the @orientable.
func (x *Grid) SetOrientation(OrientationVar Orientation) {

	XGtkOrientableSetOrientation(x.GoPointer(), OrientationVar)

}

func init() {
	core.SetPackageName("GTK", "gtk4")
	core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})
	var libs []uintptr
	for _, libPath := range core.GetPaths("GTK") {
		lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
		if err != nil {
			panic(err)
		}
		libs = append(libs, lib)
	}

	core.PuregoSafeRegister(&xGridGLibType, libs, "gtk_grid_get_type")

	core.PuregoSafeRegister(&xNewGrid, libs, "gtk_grid_new")

	core.PuregoSafeRegister(&xGridAttach, libs, "gtk_grid_attach")
	core.PuregoSafeRegister(&xGridAttachNextTo, libs, "gtk_grid_attach_next_to")
	core.PuregoSafeRegister(&xGridGetBaselineRow, libs, "gtk_grid_get_baseline_row")
	core.PuregoSafeRegister(&xGridGetChildAt, libs, "gtk_grid_get_child_at")
	core.PuregoSafeRegister(&xGridGetColumnHomogeneous, libs, "gtk_grid_get_column_homogeneous")
	core.PuregoSafeRegister(&xGridGetColumnSpacing, libs, "gtk_grid_get_column_spacing")
	core.PuregoSafeRegister(&xGridGetRowBaselinePosition, libs, "gtk_grid_get_row_baseline_position")
	core.PuregoSafeRegister(&xGridGetRowHomogeneous, libs, "gtk_grid_get_row_homogeneous")
	core.PuregoSafeRegister(&xGridGetRowSpacing, libs, "gtk_grid_get_row_spacing")
	core.PuregoSafeRegister(&xGridInsertColumn, libs, "gtk_grid_insert_column")
	core.PuregoSafeRegister(&xGridInsertNextTo, libs, "gtk_grid_insert_next_to")
	core.PuregoSafeRegister(&xGridInsertRow, libs, "gtk_grid_insert_row")
	core.PuregoSafeRegister(&xGridQueryChild, libs, "gtk_grid_query_child")
	core.PuregoSafeRegister(&xGridRemove, libs, "gtk_grid_remove")
	core.PuregoSafeRegister(&xGridRemoveColumn, libs, "gtk_grid_remove_column")
	core.PuregoSafeRegister(&xGridRemoveRow, libs, "gtk_grid_remove_row")
	core.PuregoSafeRegister(&xGridSetBaselineRow, libs, "gtk_grid_set_baseline_row")
	core.PuregoSafeRegister(&xGridSetColumnHomogeneous, libs, "gtk_grid_set_column_homogeneous")
	core.PuregoSafeRegister(&xGridSetColumnSpacing, libs, "gtk_grid_set_column_spacing")
	core.PuregoSafeRegister(&xGridSetRowBaselinePosition, libs, "gtk_grid_set_row_baseline_position")
	core.PuregoSafeRegister(&xGridSetRowHomogeneous, libs, "gtk_grid_set_row_homogeneous")
	core.PuregoSafeRegister(&xGridSetRowSpacing, libs, "gtk_grid_set_row_spacing")

}