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

type BuilderClass struct {
	_ structs.HostLayout
}

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

// Error codes that identify various errors that can occur while using
// `GtkBuilder`.
type BuilderError int

var xBuilderErrorGLibType func() types.GType

func BuilderErrorGLibType() types.GType {
	return xBuilderErrorGLibType()
}

const (

	// A type-func attribute didn’t name
	//  a function that returns a `GType`.
	BuilderErrorInvalidTypeFunctionValue BuilderError = 0
	// The input contained a tag that `GtkBuilder`
	//  can’t handle.
	BuilderErrorUnhandledTagValue BuilderError = 1
	// An attribute that is required by
	//  `GtkBuilder` was missing.
	BuilderErrorMissingAttributeValue BuilderError = 2
	// `GtkBuilder` found an attribute that
	//  it doesn’t understand.
	BuilderErrorInvalidAttributeValue BuilderError = 3
	// `GtkBuilder` found a tag that
	//  it doesn’t understand.
	BuilderErrorInvalidTagValue BuilderError = 4
	// A required property value was
	//  missing.
	BuilderErrorMissingPropertyValueValue BuilderError = 5
	// `GtkBuilder` couldn’t parse
	//  some attribute value.
	BuilderErrorInvalidValueValue BuilderError = 6
	// The input file requires a newer version
	//  of GTK.
	BuilderErrorVersionMismatchValue BuilderError = 7
	// An object id occurred twice.
	BuilderErrorDuplicateIdValue BuilderError = 8
	// A specified object type is of the same type or
	//  derived from the type of the composite class being extended with builder XML.
	BuilderErrorObjectTypeRefusedValue BuilderError = 9
	// The wrong type was specified in a composite class’s template XML
	BuilderErrorTemplateMismatchValue BuilderError = 10
	// The specified property is unknown for the object class.
	BuilderErrorInvalidPropertyValue BuilderError = 11
	// The specified signal is unknown for the object class.
	BuilderErrorInvalidSignalValue BuilderError = 12
	// An object id is unknown.
	BuilderErrorInvalidIdValue BuilderError = 13
	// A function could not be found. This often happens
	//   when symbols are set to be kept private. Compiling code with -rdynamic or using the
	//   `gmodule-export-2.0` pkgconfig module can fix this problem.
	BuilderErrorInvalidFunctionValue BuilderError = 14
)

var xBuilderErrorQuark func() glib.Quark

// Registers an error quark for [class@Gtk.Builder] errors.
func BuilderErrorQuark() glib.Quark {

	cret := xBuilderErrorQuark()
	return cret
}

// Reads XML descriptions of a user interface and instantiates the described objects.
//
// To create a `GtkBuilder` from a user interface description, call
// [ctor@Gtk.Builder.new_from_file], [ctor@Gtk.Builder.new_from_resource]
// or [ctor@Gtk.Builder.new_from_string].
//
// In the (unusual) case that you want to add user interface
// descriptions from multiple sources to the same `GtkBuilder` you can
// call [ctor@Gtk.Builder.new] to get an empty builder and populate it by
// (multiple) calls to [method@Gtk.Builder.add_from_file],
// [method@Gtk.Builder.add_from_resource] or
// [method@Gtk.Builder.add_from_string].
//
// A `GtkBuilder` holds a reference to all objects that it has constructed
// and drops these references when it is finalized. This finalization can
// cause the destruction of non-widget objects or widgets which are not
// contained in a toplevel window. For toplevel windows constructed by a
// builder, it is the responsibility of the user to call
// [method@Gtk.Window.destroy] to get rid of them and all the widgets
// they contain.
//
// The functions [method@Gtk.Builder.get_object] and
// [method@Gtk.Builder.get_objects] can be used to access the widgets in
// the interface by the names assigned to them inside the UI description.
// Toplevel windows returned by these functions will stay around until the
// user explicitly destroys them with [method@Gtk.Window.destroy]. Other
// widgets will either be part of a larger hierarchy constructed by the
// builder (in which case you should not have to worry about their lifecycle),
// or without a parent, in which case they have to be added to some container
// to make use of them. Non-widget objects need to be reffed with
// g_object_ref() to keep them beyond the lifespan of the builder.
//
// ## GtkBuilder UI Definitions
//
// `GtkBuilder` parses textual descriptions of user interfaces which are
// specified in XML format. We refer to these descriptions as “GtkBuilder
// UI definitions” or just “UI definitions” if the context is clear.
//
// ### Structure of UI definitions
//
// UI definition files are always encoded in UTF-8.
//
// The toplevel element is `<interface>`. It optionally takes a “domain”
// attribute, which will make the builder look for translated strings
// using `dgettext()` in the domain specified. This can also be done by
// calling [method@Gtk.Builder.set_translation_domain] on the builder.
// For example:
//
// ```xml
// <?xml version="1.0" encoding="UTF-8"?>
// <interface domain="your-app">
//
//	...
//
// </interface>
// ```
//
// ### Requirements
//
// The target toolkit version(s) are described by `<requires>` elements,
// the “lib” attribute specifies the widget library in question (currently
// the only supported value is “gtk”) and the “version” attribute specifies
// the target version in the form “`<major>`.`<minor>`”. `GtkBuilder` will
// error out if the version requirements are not met. For example:
//
// ```xml
// <?xml version="1.0" encoding="UTF-8"?>
// <interface domain="your-app">
//
//	<requires lib="gtk" version="4.0" />
//
// </interface>
// ```
//
// ### Objects
//
// Objects are defined as children of the `<interface>` element.
//
// Objects are described by `<object>` elements, which can contain
// `<property>` elements to set properties, `<signal>` elements which
// connect signals to handlers, and `<child>` elements, which describe
// child objects.
//
// Typically, the specific kind of object represented by an `<object>`
// element is specified by the “class” attribute. If the type has not
// been loaded yet, GTK tries to find the `get_type()` function from the
// class name by applying heuristics. This works in most cases, but if
// necessary, it is possible to specify the name of the `get_type()`
// function explicitly with the "type-func" attribute. If your UI definition
// is referencing internal types, you should make sure to call
// `g_type_ensure()` for each object type before parsing the UI definition.
//
// Objects may be given a name with the “id” attribute, which allows the
// application to retrieve them from the builder with
// [method@Gtk.Builder.get_object]. An id is also necessary to use the
// object as property value in other parts of the UI definition. GTK
// reserves ids starting and ending with `___` (three consecutive
// underscores) for its own purposes.
//
// ### Properties
//
// Setting properties of objects is pretty straightforward with the
// `<property>` element: the “name” attribute specifies the name of the
// property, and the content of the element specifies the value:
//
// ```xml
// <object class="GtkButton">
//
//	<property name="label">Hello, world</property>
//
// </object>
// ```
//
// If the “translatable” attribute is set to a true value, GTK uses
// `gettext()` (or `dgettext()` if the builder has a translation domain set)
// to find a translation for the value. This happens before the value
// is parsed, so it can be used for properties of any type, but it is
// probably most useful for string properties. It is also possible to
// specify a context to disambiguate short strings, and comments which
// may help the translators:
//
// ```xml
// <object class="GtkButton">
//
//	<property name="label"
//	          translatable="yes"
//	          context="button"
//	          comments="A classic">Hello, world</property>
//
// </object>
// ```
//
// The xgettext tool that is part of gettext can extract these strings,
// but note that it only looks for translatable="yes".
//
// `GtkBuilder` can parse textual representations for the most common
// property types:
//
//   - characters
//   - strings
//   - integers
//   - floating-point numbers
//   - booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are interpreted
//     as true values, strings like “FALSE”, “f”, “no”, “n”, “0” are interpreted
//     as false values)
//   - string lists (separated by newlines)
//   - enumeration types (can be specified by their full C identifier their short
//     name used when registering the enumeration type, or their integer value)
//   - flag types (can be specified by their C identifier or short name,
//     optionally combined with “|” for bitwise OR, or a single integer value
//     e.g., “GTK_INPUT_HINT_EMOJI|GTK_INPUT_HINT_LOWERCASE”, or “emoji|lowercase” or 520).
//   - colors (in the format understood by [method@Gdk.RGBA.parse])
//   - transforms (in the format understood by [func@Gsk.Transform.parse])
//   - Pango attribute lists (in the format understood by [method@Pango.AttrList.to_string])
//   - Pango tab arrays (in the format understood by [method@Pango.TabArray.to_string])
//   - Pango font descriptions (in the format understood by [func@Pango.FontDescription.from_string])
//   - `GVariant` (in the format understood by [func@GLib.Variant.parse])
//   - textures (can be specified as an object id, a resource path or a filename of an image file to load relative to the Builder file or the CWD if [method@Gtk.Builder.add_from_string] was used)
//   - GFile (like textures, can be specified as an object id, a URI or a filename of a file to load relative to the Builder file or the CWD if [method@Gtk.Builder.add_from_string] was used)
//
// Objects can be referred to by their name and by default refer to
// objects declared in the local XML fragment and objects exposed via
// [method@Gtk.Builder.expose_object]. In general, `GtkBuilder` allows
// forward references to objects declared in the local XML; an object
// doesn’t have to be constructed before it can be referred to. The
// exception to this rule is that an object has to be constructed before
// it can be used as the value of a construct-only property.
//
// ### Child objects
//
// Many widgets have properties for child widgets, such as
// [property@Gtk.Expander:child]. In this case, the preferred way to
// specify the child widget in a ui file is to simply set the property:
//
// ```xml
// <object class="GtkExpander">
//
//	<property name="child">
//	  <object class="GtkLabel">
//	  ...
//	  </object>
//	</property>
//
// </object>
// ```
//
// Generic containers that can contain an arbitrary number of children,
// such as [class@Gtk.Box] instead use the `<child>` element. A `<child>`
// element contains an `<object>` element which describes the child object.
// Most often, child objects are widgets inside a container, but they can
// also be, e.g., actions in an action group, or columns in a tree model.
//
// Any object type that implements the [iface@Gtk.Buildable] interface can
// specify how children may be added to it. Since many objects and widgets that
// are included with GTK already implement the `GtkBuildable` interface,
// typically child objects can be added using the `<child>` element without
// having to be concerned about the underlying implementation.
//
// See the [`GtkWidget` documentation](class.Widget.html#gtkwidget-as-gtkbuildable)
// for many examples of using `GtkBuilder` with widgets, including setting
// child objects using the `<child>` element.
//
// A noteworthy special case to the general rule that only objects implementing
// `GtkBuildable` may specify how to handle the `<child>` element is that
// `GtkBuilder` provides special support for adding objects to a
// [class@Gio.ListStore] by using the `<child>` element. For instance:
//
// ```xml
// <object class="GListStore">
//
//	<property name="item-type">MyObject</property>
//	<child>
//	  <object class="MyObject" />
//	</child>
//	...
//
// </object>
// ```
//
// ### Property bindings
//
// It is also possible to bind a property value to another object's
// property value using the attributes "bind-source" to specify the
// source object of the binding, and optionally, "bind-property" and
// "bind-flags" to specify the source property and source binding flags
// respectively. Internally, `GtkBuilder` implements this using
// [class@GObject.Binding] objects.
//
// For instance, in the example below the “label” property of the
// `bottom_label` widget is bound to the “label” property of the
// `top_button` widget:
//
// ```xml
// <object class="GtkBox">
//
//	<property name="orientation">vertical</property>
//	<child>
//	  <object class="GtkButton" id="top_button">
//	    <property name="label">Hello, world</property>
//	  </object>
//	</child>
//	<child>
//	  <object class="GtkLabel" id="bottom_label">
//	    <property name="label"
//	              bind-source="top_button"
//	              bind-property="label"
//	              bind-flags="sync-create" />
//	  </object>
//	</child>
//
// </object>
// ```
//
// For more information, see the documentation of the
// [method@GObject.Object.bind_property] method.
//
// Please note that another way to set up bindings between objects in .ui files
// is to use the `GtkExpression` methodology. See the
// [`GtkExpression` documentation](class.Expression.html#gtkexpression-in-ui-files)
// for more information.
//
// ### Internal children
//
// Sometimes it is necessary to refer to widgets which have implicitly
// been constructed by GTK as part of a composite widget, to set
// properties on them or to add further children (e.g. the content area
// of a `GtkDialog`). This can be achieved by setting the “internal-child”
// property of the `<child>` element to a true value. Note that `GtkBuilder`
// still requires an `<object>` element for the internal child, even if it
// has already been constructed.
//
// ### Specialized children
//
// A number of widgets have different places where a child can be added
// (e.g. tabs vs. page content in notebooks). This can be reflected in
// a UI definition by specifying the “type” attribute on a `<child>`
// The possible values for the “type” attribute are described in the
// sections describing the widget-specific portions of UI definitions.
//
// ### Signal handlers and function pointers
//
// Signal handlers are set up with the `<signal>` element. The “name”
// attribute specifies the name of the signal, and the “handler” attribute
// specifies the function to connect to the signal.
//
// ```xml
// <object class="GtkButton" id="hello_button">
//
//	<signal name="clicked" handler="hello_button__clicked" />
//
// </object>
// ```
//
// The remaining attributes, “after”, “swapped” and “object”, have the
// same meaning as the corresponding parameters of the
// [func@GObject.signal_connect_object] or [func@GObject.signal_connect_data]
// functions:
//
//   - “after” matches the `G_CONNECT_AFTER` flag, and will ensure that the
//     handler is called after the default class closure for the signal
//   - “swapped” matches the `G_CONNECT_SWAPPED` flag, and will swap the
//     instance and closure arguments when invoking the signal handler
//   - “object” will bind the signal handler to the lifetime of the object
//     referenced by the attribute
//
// By default "swapped" will be set to "yes" if not specified otherwise, in
// the case where "object" is set, for convenience. A “last_modification_time”
// attribute is also allowed, but it does not have a meaning to the builder.
//
// When compiling applications for Windows, you must declare signal callbacks
// with the `G_MODULE_EXPORT` decorator, or they will not be put in the symbol
// table:
//
// ```c
// G_MODULE_EXPORT void
// hello_button__clicked (GtkButton *button,
//
//	gpointer data)
//
//	{
//	  // ...
//	}
//
// ```
//
// On Linux and Unix, this is not necessary; applications should instead
// be compiled with the `-Wl,--export-dynamic` argument inside their compiler
// flags, and linked against `gmodule-export-2.0`.
//
// ## Example UI Definition
//
// ```xml
// <interface>
//
//	<object class="GtkDialog" id="dialog1">
//	  <child internal-child="content_area">
//	    <object class="GtkBox">
//	      <child internal-child="action_area">
//	        <object class="GtkBox">
//	          <child>
//	            <object class="GtkButton" id="ok_button">
//	              <property name="label" translatable="yes">_Ok</property>
//	              <property name="use-underline">True</property>
//	              <signal name="clicked" handler="ok_button_clicked"/>
//	            </object>
//	          </child>
//	        </object>
//	      </child>
//	    </object>
//	  </child>
//	</object>
//
// </interface>
// ```
//
// ## Using GtkBuildable for extending UI definitions
//
// Objects can implement the [iface@Gtk.Buildable] interface to add custom
// elements and attributes to the XML. Typically, any extension will be
// documented in each type that implements the interface.
//
// ## Menus
//
// In addition to objects with properties that are created with `<object>` and
// `<property>` elements, `GtkBuilder` also allows to parse XML menu definitions
// as used by [class@Gio.Menu] when exporting menu models over D-Bus, and as
// described in the [class@Gtk.PopoverMenu] documentation. Menus can be defined
// as toplevel elements, or as property values for properties of type `GMenuModel`.
//
// ## Templates
//
// When describing a [class@Gtk.Widget], you can use the `<template>` tag to
// describe a UI bound to a specific widget type. GTK will automatically load
// the UI definition when instantiating the type, and bind children and
// signal handlers to instance fields and function symbols.
//
// For more information, see the [`GtkWidget` documentation](class.Widget.html#building-composite-widgets-from-template-xml)
// for details.
type Builder struct {
	gobject.Object
}

var xBuilderGLibType func() types.GType

func BuilderGLibType() types.GType {
	return xBuilderGLibType()
}

func BuilderNewFromInternalPtr(ptr uintptr) *Builder {
	cls := &Builder{}
	cls.Ptr = ptr
	return cls
}

var xNewBuilder func() uintptr

// Creates a new empty builder object.
//
// This function is only useful if you intend to make multiple calls
// to [method@Gtk.Builder.add_from_file], [method@Gtk.Builder.add_from_resource]
// or [method@Gtk.Builder.add_from_string] in order to merge multiple UI
// descriptions into a single builder.
func NewBuilder() *Builder {
	var cls *Builder

	cret := xNewBuilder()

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

var xNewBuilderFromFile func(string) uintptr

// Parses the UI definition in the file @filename.
//
// If there is an error opening the file or parsing the description then
// the program will be aborted. You should only ever attempt to parse
// user interface descriptions that are shipped as part of your program.
func NewBuilderFromFile(FilenameVar string) *Builder {
	var cls *Builder

	cret := xNewBuilderFromFile(FilenameVar)

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

var xNewBuilderFromResource func(string) uintptr

// Parses the UI definition at @resource_path.
//
// If there is an error locating the resource or parsing the
// description, then the program will be aborted.
func NewBuilderFromResource(ResourcePathVar string) *Builder {
	var cls *Builder

	cret := xNewBuilderFromResource(ResourcePathVar)

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

var xNewBuilderFromString func(string, int) uintptr

// Parses the UI definition in @string.
//
// If @string is %NULL-terminated, then @length should be -1.
// If @length is not -1, then it is the length of @string.
//
// If there is an error parsing @string then the program will be
// aborted. You should not attempt to parse user interface description
// from untrusted sources.
func NewBuilderFromString(StringVar string, LengthVar int) *Builder {
	var cls *Builder

	cret := xNewBuilderFromString(StringVar, LengthVar)

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

var xBuilderAddFromFile func(uintptr, string, **glib.Error) bool

// Parses a file containing a UI definition and merges it with
// the current contents of @builder.
//
// This function is useful if you need to call
// [method@Gtk.Builder.set_current_object]) to add user data to
// callbacks before loading GtkBuilder UI. Otherwise, you probably
// want [ctor@Gtk.Builder.new_from_file] instead.
//
// If an error occurs, 0 will be returned and @error will be assigned a
// `GError` from the `GTK_BUILDER_ERROR`, `G_MARKUP_ERROR` or `G_FILE_ERROR`
// domains.
//
// It’s not really reasonable to attempt to handle failures of this
// call. You should not use this function with untrusted files (ie:
// files that are not part of your application). Broken `GtkBuilder`
// files can easily crash your program, and it’s possible that memory
// was leaked leading up to the reported failure. The only reasonable
// thing to do when an error is detected is to call `g_error()`.
func (x *Builder) AddFromFile(FilenameVar string) (bool, error) {
	var cerr *glib.Error

	cret := xBuilderAddFromFile(x.GoPointer(), FilenameVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xBuilderAddFromResource func(uintptr, string, **glib.Error) bool

// Parses a resource file containing a UI definition
// and merges it with the current contents of @builder.
//
// This function is useful if you need to call
// [method@Gtk.Builder.set_current_object] to add user data to
// callbacks before loading GtkBuilder UI. Otherwise, you probably
// want [ctor@Gtk.Builder.new_from_resource] instead.
//
// If an error occurs, 0 will be returned and @error will be assigned a
// `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_RESOURCE_ERROR
// domain.
//
// It’s not really reasonable to attempt to handle failures of this
// call.  The only reasonable thing to do when an error is detected is
// to call g_error().
func (x *Builder) AddFromResource(ResourcePathVar string) (bool, error) {
	var cerr *glib.Error

	cret := xBuilderAddFromResource(x.GoPointer(), ResourcePathVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xBuilderAddFromString func(uintptr, string, int, **glib.Error) bool

// Parses a string containing a UI definition and merges it
// with the current contents of @builder.
//
// This function is useful if you need to call
// [method@Gtk.Builder.set_current_object] to add user data to
// callbacks before loading `GtkBuilder` UI. Otherwise, you probably
// want [ctor@Gtk.Builder.new_from_string] instead.
//
// Upon errors %FALSE will be returned and @error will be assigned a
// `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or
// %G_VARIANT_PARSE_ERROR domain.
//
// It’s not really reasonable to attempt to handle failures of this
// call.  The only reasonable thing to do when an error is detected is
// to call g_error().
func (x *Builder) AddFromString(BufferVar string, LengthVar int) (bool, error) {
	var cerr *glib.Error

	cret := xBuilderAddFromString(x.GoPointer(), BufferVar, LengthVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xBuilderAddObjectsFromFile func(uintptr, string, []string, **glib.Error) bool

// Parses a file containing a UI definition building only the
// requested objects and merges them with the current contents
// of @builder.
//
// Upon errors, 0 will be returned and @error will be assigned a
// `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_FILE_ERROR
// domain.
//
// If you are adding an object that depends on an object that is not
// its child (for instance a `GtkTreeView` that depends on its
// `GtkTreeModel`), you have to explicitly list all of them in @object_ids.
func (x *Builder) AddObjectsFromFile(FilenameVar string, ObjectIdsVar []string) (bool, error) {
	var cerr *glib.Error

	cret := xBuilderAddObjectsFromFile(x.GoPointer(), FilenameVar, ObjectIdsVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xBuilderAddObjectsFromResource func(uintptr, string, []string, **glib.Error) bool

// Parses a resource file containing a UI definition, building
// only the requested objects and merges them with the current
// contents of @builder.
//
// Upon errors, 0 will be returned and @error will be assigned a
// `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_RESOURCE_ERROR
// domain.
//
// If you are adding an object that depends on an object that is not
// its child (for instance a `GtkTreeView` that depends on its
// `GtkTreeModel`), you have to explicitly list all of them in @object_ids.
func (x *Builder) AddObjectsFromResource(ResourcePathVar string, ObjectIdsVar []string) (bool, error) {
	var cerr *glib.Error

	cret := xBuilderAddObjectsFromResource(x.GoPointer(), ResourcePathVar, ObjectIdsVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xBuilderAddObjectsFromString func(uintptr, string, int, []string, **glib.Error) bool

// Parses a string containing a UI definition, building only the
// requested objects and merges them with the current contents of
// @builder.
//
// Upon errors %FALSE will be returned and @error will be assigned a
// `GError` from the %GTK_BUILDER_ERROR or %G_MARKUP_ERROR domain.
//
// If you are adding an object that depends on an object that is not
// its child (for instance a `GtkTreeView` that depends on its
// `GtkTreeModel`), you have to explicitly list all of them in @object_ids.
func (x *Builder) AddObjectsFromString(BufferVar string, LengthVar int, ObjectIdsVar []string) (bool, error) {
	var cerr *glib.Error

	cret := xBuilderAddObjectsFromString(x.GoPointer(), BufferVar, LengthVar, ObjectIdsVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xBuilderCreateClosure func(uintptr, string, BuilderClosureFlags, uintptr, **glib.Error) *gobject.Closure

// Creates a closure to invoke the function called @function_name.
//
// This is using the create_closure() implementation of @builder's
// [iface@Gtk.BuilderScope].
//
// If no closure could be created, %NULL will be returned and @error
// will be set.
func (x *Builder) CreateClosure(FunctionNameVar string, FlagsVar BuilderClosureFlags, ObjectVar *gobject.Object) (*gobject.Closure, error) {
	var cerr *glib.Error

	cret := xBuilderCreateClosure(x.GoPointer(), FunctionNameVar, FlagsVar, ObjectVar.GoPointer(), &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xBuilderExposeObject func(uintptr, string, uintptr)

// Add @object to the @builder object pool so it can be
// referenced just like any other object built by builder.
//
// Only a single object may be added using @name. However,
// it is not an error to expose the same object under multiple
// names. `gtk_builder_get_object()` may be used to determine
// if an object has already been added with @name.
func (x *Builder) ExposeObject(NameVar string, ObjectVar *gobject.Object) {

	xBuilderExposeObject(x.GoPointer(), NameVar, ObjectVar.GoPointer())

}

var xBuilderExtendWithTemplate func(uintptr, uintptr, types.GType, string, int, **glib.Error) bool

// Main private entry point for building composite components
// from template XML.
//
// Most likely you do not need to call this function in applications as
// templates are handled by `GtkWidget`.
func (x *Builder) ExtendWithTemplate(ObjectVar *gobject.Object, TemplateTypeVar types.GType, BufferVar string, LengthVar int) (bool, error) {
	var cerr *glib.Error

	cret := xBuilderExtendWithTemplate(x.GoPointer(), ObjectVar.GoPointer(), TemplateTypeVar, BufferVar, LengthVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xBuilderGetCurrentObject func(uintptr) uintptr

// Gets the current object set via gtk_builder_set_current_object().
func (x *Builder) GetCurrentObject() *gobject.Object {
	var cls *gobject.Object

	cret := xBuilderGetCurrentObject(x.GoPointer())

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

var xBuilderGetObject func(uintptr, string) uintptr

// Gets the object named @name.
//
// Note that this function does not increment the reference count
// of the returned object.
func (x *Builder) GetObject(NameVar string) *gobject.Object {
	var cls *gobject.Object

	cret := xBuilderGetObject(x.GoPointer(), NameVar)

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

var xBuilderGetObjects func(uintptr) *glib.SList

// Gets all objects that have been constructed by @builder.
//
// Note that this function does not increment the reference
// counts of the returned objects.
func (x *Builder) GetObjects() *glib.SList {

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

var xBuilderGetScope func(uintptr) uintptr

// Gets the scope in use that was set via gtk_builder_set_scope().
func (x *Builder) GetScope() *BuilderScopeBase {
	var cls *BuilderScopeBase

	cret := xBuilderGetScope(x.GoPointer())

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

var xBuilderGetTranslationDomain func(uintptr) string

// Gets the translation domain of @builder.
func (x *Builder) GetTranslationDomain() string {

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

var xBuilderGetTypeFromName func(uintptr, string) types.GType

// Looks up a type by name.
//
// This is using the virtual function that `GtkBuilder` has
// for that purpose. This is mainly used when implementing
// the `GtkBuildable` interface on a type.
func (x *Builder) GetTypeFromName(TypeNameVar string) types.GType {

	cret := xBuilderGetTypeFromName(x.GoPointer(), TypeNameVar)
	return cret
}

var xBuilderSetCurrentObject func(uintptr, uintptr)

// Sets the current object for the @builder.
//
// The current object can be thought of as the `this` object that the
// builder is working for and will often be used as the default object
// when an object is optional.
//
// [method@Gtk.Widget.init_template] for example will set the current
// object to the widget the template is inited for. For functions like
// [ctor@Gtk.Builder.new_from_resource], the current object will be %NULL.
func (x *Builder) SetCurrentObject(CurrentObjectVar *gobject.Object) {

	xBuilderSetCurrentObject(x.GoPointer(), CurrentObjectVar.GoPointer())

}

var xBuilderSetScope func(uintptr, uintptr)

// Sets the scope the builder should operate in.
//
// If @scope is %NULL, a new [class@Gtk.BuilderCScope] will be created.
func (x *Builder) SetScope(ScopeVar BuilderScope) {

	xBuilderSetScope(x.GoPointer(), ScopeVar.GoPointer())

}

var xBuilderSetTranslationDomain func(uintptr, uintptr)

// Sets the translation domain of @builder.
func (x *Builder) SetTranslationDomain(DomainVar *string) {

	DomainVarPtr := core.GStrdupNullable(DomainVar)
	defer core.GFreeNullable(DomainVarPtr)

	xBuilderSetTranslationDomain(x.GoPointer(), DomainVarPtr)

}

var xBuilderValueFromString func(uintptr, uintptr, string, *gobject.Value, **glib.Error) bool

// Demarshals a value from a string.
//
// This function calls g_value_init() on the @value argument,
// so it need not be initialised beforehand.
//
// Can handle char, uchar, boolean, int, uint, long,
// ulong, enum, flags, float, double, string, `GdkRGBA` and
// `GtkAdjustment` type values.
//
// Upon errors %FALSE will be returned and @error will be
// assigned a `GError` from the %GTK_BUILDER_ERROR domain.
func (x *Builder) ValueFromString(PspecVar *gobject.ParamSpec, StringVar string, ValueVar *gobject.Value) (bool, error) {
	var cerr *glib.Error

	cret := xBuilderValueFromString(x.GoPointer(), PspecVar.GoPointer(), StringVar, ValueVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

var xBuilderValueFromStringType func(uintptr, types.GType, string, *gobject.Value, **glib.Error) bool

// Demarshals a value from a string.
//
// Unlike [method@Gtk.Builder.value_from_string], this function
// takes a `GType` instead of `GParamSpec`.
//
// Calls g_value_init() on the @value argument, so it
// need not be initialised beforehand.
//
// Upon errors %FALSE will be returned and @error will be
// assigned a `GError` from the %GTK_BUILDER_ERROR domain.
func (x *Builder) ValueFromStringType(TypeVar types.GType, StringVar string, ValueVar *gobject.Value) (bool, error) {
	var cerr *glib.Error

	cret := xBuilderValueFromStringType(x.GoPointer(), TypeVar, StringVar, ValueVar, &cerr)
	if cerr == nil {
		return cret, nil
	}
	return cret, cerr

}

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

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

// SetPropertyTranslationDomain sets the "translation-domain" property.
// The translation domain used when translating property values that
// have been marked as translatable.
//
// If the translation domain is %NULL, `GtkBuilder` uses gettext(),
// otherwise g_dgettext().
func (x *Builder) SetPropertyTranslationDomain(value string) {
	var v gobject.Value
	v.Init(gobject.TypeStringVal)
	v.SetString(&value)
	x.SetProperty("translation-domain", &v)
}

// GetPropertyTranslationDomain gets the "translation-domain" property.
// The translation domain used when translating property values that
// have been marked as translatable.
//
// If the translation domain is %NULL, `GtkBuilder` uses gettext(),
// otherwise g_dgettext().
func (x *Builder) GetPropertyTranslationDomain() string {
	var v gobject.Value
	x.GetProperty("translation-domain", &v)
	return v.GetString()
}

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(&xBuilderErrorGLibType, libs, "gtk_builder_error_get_type")

	core.PuregoSafeRegister(&xBuilderErrorQuark, libs, "gtk_builder_error_quark")

	core.PuregoSafeRegister(&xBuilderGLibType, libs, "gtk_builder_get_type")

	core.PuregoSafeRegister(&xNewBuilder, libs, "gtk_builder_new")
	core.PuregoSafeRegister(&xNewBuilderFromFile, libs, "gtk_builder_new_from_file")
	core.PuregoSafeRegister(&xNewBuilderFromResource, libs, "gtk_builder_new_from_resource")
	core.PuregoSafeRegister(&xNewBuilderFromString, libs, "gtk_builder_new_from_string")

	core.PuregoSafeRegister(&xBuilderAddFromFile, libs, "gtk_builder_add_from_file")
	core.PuregoSafeRegister(&xBuilderAddFromResource, libs, "gtk_builder_add_from_resource")
	core.PuregoSafeRegister(&xBuilderAddFromString, libs, "gtk_builder_add_from_string")
	core.PuregoSafeRegister(&xBuilderAddObjectsFromFile, libs, "gtk_builder_add_objects_from_file")
	core.PuregoSafeRegister(&xBuilderAddObjectsFromResource, libs, "gtk_builder_add_objects_from_resource")
	core.PuregoSafeRegister(&xBuilderAddObjectsFromString, libs, "gtk_builder_add_objects_from_string")
	core.PuregoSafeRegister(&xBuilderCreateClosure, libs, "gtk_builder_create_closure")
	core.PuregoSafeRegister(&xBuilderExposeObject, libs, "gtk_builder_expose_object")
	core.PuregoSafeRegister(&xBuilderExtendWithTemplate, libs, "gtk_builder_extend_with_template")
	core.PuregoSafeRegister(&xBuilderGetCurrentObject, libs, "gtk_builder_get_current_object")
	core.PuregoSafeRegister(&xBuilderGetObject, libs, "gtk_builder_get_object")
	core.PuregoSafeRegister(&xBuilderGetObjects, libs, "gtk_builder_get_objects")
	core.PuregoSafeRegister(&xBuilderGetScope, libs, "gtk_builder_get_scope")
	core.PuregoSafeRegister(&xBuilderGetTranslationDomain, libs, "gtk_builder_get_translation_domain")
	core.PuregoSafeRegister(&xBuilderGetTypeFromName, libs, "gtk_builder_get_type_from_name")
	core.PuregoSafeRegister(&xBuilderSetCurrentObject, libs, "gtk_builder_set_current_object")
	core.PuregoSafeRegister(&xBuilderSetScope, libs, "gtk_builder_set_scope")
	core.PuregoSafeRegister(&xBuilderSetTranslationDomain, libs, "gtk_builder_set_translation_domain")
	core.PuregoSafeRegister(&xBuilderValueFromString, libs, "gtk_builder_value_from_string")
	core.PuregoSafeRegister(&xBuilderValueFromStringType, libs, "gtk_builder_value_from_string_type")

}