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

type FixedLayoutChildClass struct {
	_ structs.HostLayout

	ParentClass LayoutChildClass
}

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

type FixedLayoutClass struct {
	_ structs.HostLayout

	ParentClass LayoutManagerClass
}

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

// Places child widgets at fixed positions.
//
// Most applications should never use this layout manager; fixed positioning
// and sizing requires constant recalculations on where children need to be
// positioned and sized. Other layout managers perform this kind of work
// internally so that application developers don't need to do it. Specifically,
// widgets positioned in a fixed layout manager will need to take into account:
//
// - Themes, which may change widget sizes.
//
//   - Fonts other than the one you used to write the app will of course
//     change the size of widgets containing text; keep in mind that
//     users may use a larger font because of difficulty reading the
//     default, or they may be using a different OS that provides different
//     fonts.
//
//   - Translation of text into other languages changes its size. Also,
//     display of non-English text will use a different font in many
//     cases.
//
// In addition, `GtkFixedLayout` does not pay attention to text direction and
// thus may produce unwanted results if your app is run under right-to-left
// languages such as Hebrew or Arabic. That is: normally GTK will order
// containers appropriately depending on the text direction, e.g. to put labels
// to the right of the thing they label when using an RTL language;
// `GtkFixedLayout` won't be able to do that for you.
//
// Finally, fixed positioning makes it kind of annoying to add/remove UI
// elements, since you have to reposition all the other  elements. This is a
// long-term maintenance problem for your application.
type FixedLayout struct {
	LayoutManager
}

var xFixedLayoutGLibType func() types.GType

func FixedLayoutGLibType() types.GType {
	return xFixedLayoutGLibType()
}

func FixedLayoutNewFromInternalPtr(ptr uintptr) *FixedLayout {
	cls := &FixedLayout{}
	cls.Ptr = ptr
	return cls
}

var xNewFixedLayout func() uintptr

// Creates a new `GtkFixedLayout`.
func NewFixedLayout() *FixedLayout {
	var cls *FixedLayout

	cret := xNewFixedLayout()

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

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

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

// `GtkLayoutChild` subclass for children in a `GtkFixedLayout`.
type FixedLayoutChild struct {
	LayoutChild
}

var xFixedLayoutChildGLibType func() types.GType

func FixedLayoutChildGLibType() types.GType {
	return xFixedLayoutChildGLibType()
}

func FixedLayoutChildNewFromInternalPtr(ptr uintptr) *FixedLayoutChild {
	cls := &FixedLayoutChild{}
	cls.Ptr = ptr
	return cls
}

var xFixedLayoutChildGetTransform func(uintptr) *gsk.Transform

// Retrieves the transformation of the child.
func (x *FixedLayoutChild) GetTransform() *gsk.Transform {

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

var xFixedLayoutChildSetTransform func(uintptr, *gsk.Transform)

// Sets the transformation of the child of a `GtkFixedLayout`.
func (x *FixedLayoutChild) SetTransform(TransformVar *gsk.Transform) {

	xFixedLayoutChildSetTransform(x.GoPointer(), TransformVar)

}

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

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

// SetPropertyTransform sets the "transform" property.
// The transform of the child.
func (x *FixedLayoutChild) SetPropertyTransform(value uintptr) {
	var v gobject.Value
	v.Init(gobject.TypePointerVal)
	v.SetPointer(value)
	x.SetProperty("transform", &v)
}

// GetPropertyTransform gets the "transform" property.
// The transform of the child.
func (x *FixedLayoutChild) GetPropertyTransform() uintptr {
	var v gobject.Value
	x.GetProperty("transform", &v)
	return v.GetPointer()
}

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(&xFixedLayoutGLibType, libs, "gtk_fixed_layout_get_type")

	core.PuregoSafeRegister(&xNewFixedLayout, libs, "gtk_fixed_layout_new")

	core.PuregoSafeRegister(&xFixedLayoutChildGLibType, libs, "gtk_fixed_layout_child_get_type")

	core.PuregoSafeRegister(&xFixedLayoutChildGetTransform, libs, "gtk_fixed_layout_child_get_transform")
	core.PuregoSafeRegister(&xFixedLayoutChildSetTransform, libs, "gtk_fixed_layout_child_set_transform")

}