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

// The virtual table for `GtkSorter`.
type SorterClass struct {
	_ structs.HostLayout

	ParentClass gobject.ObjectClass

	xCompare uintptr

	xGetOrder uintptr

	xGtkReserved1 uintptr

	xGtkReserved2 uintptr

	xGtkReserved3 uintptr

	xGtkReserved4 uintptr

	xGtkReserved5 uintptr

	xGtkReserved6 uintptr

	xGtkReserved7 uintptr

	xGtkReserved8 uintptr
}

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

// OverrideCompare sets the "compare" callback function.
// Compare two items. See gtk_sorter_compare() for details.
func (x *SorterClass) OverrideCompare(cb func(*Sorter, *gobject.Object, *gobject.Object) Ordering) {
	if cb == nil {
		x.xCompare = 0
	} else {
		x.xCompare = purego.NewCallback(func(SelfVarp uintptr, Item1Varp uintptr, Item2Varp uintptr) Ordering {
			return cb(SorterNewFromInternalPtr(SelfVarp), gobject.ObjectNewFromInternalPtr(Item1Varp), gobject.ObjectNewFromInternalPtr(Item2Varp))
		})
	}
}

// GetCompare gets the "compare" callback function.
// Compare two items. See gtk_sorter_compare() for details.
func (x *SorterClass) GetCompare() func(*Sorter, *gobject.Object, *gobject.Object) Ordering {
	if x.xCompare == 0 {
		return nil
	}
	var rawCallback func(SelfVarp uintptr, Item1Varp uintptr, Item2Varp uintptr) Ordering
	purego.RegisterFunc(&rawCallback, x.xCompare)
	return func(SelfVar *Sorter, Item1Var *gobject.Object, Item2Var *gobject.Object) Ordering {
		return rawCallback(SelfVar.GoPointer(), Item1Var.GoPointer(), Item2Var.GoPointer())
	}
}

// OverrideGetOrder sets the "get_order" callback function.
// Get the `GtkSorderOrder` that applies to the current sorter.
//
//	If unimplemented, it returns %GTK_SORTER_ORDER_PARTIAL.
func (x *SorterClass) OverrideGetOrder(cb func(*Sorter) SorterOrder) {
	if cb == nil {
		x.xGetOrder = 0
	} else {
		x.xGetOrder = purego.NewCallback(func(SelfVarp uintptr) SorterOrder {
			return cb(SorterNewFromInternalPtr(SelfVarp))
		})
	}
}

// GetGetOrder gets the "get_order" callback function.
// Get the `GtkSorderOrder` that applies to the current sorter.
//
//	If unimplemented, it returns %GTK_SORTER_ORDER_PARTIAL.
func (x *SorterClass) GetGetOrder() func(*Sorter) SorterOrder {
	if x.xGetOrder == 0 {
		return nil
	}
	var rawCallback func(SelfVarp uintptr) SorterOrder
	purego.RegisterFunc(&rawCallback, x.xGetOrder)
	return func(SelfVar *Sorter) SorterOrder {
		return rawCallback(SelfVar.GoPointer())
	}
}

// OverrideGtkReserved1 sets the "_gtk_reserved1" callback function.
func (x *SorterClass) OverrideGtkReserved1(cb func()) {
	if cb == nil {
		x.xGtkReserved1 = 0
	} else {
		x.xGtkReserved1 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGtkReserved1 gets the "_gtk_reserved1" callback function.
func (x *SorterClass) GetGtkReserved1() func() {
	if x.xGtkReserved1 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGtkReserved1)
	return func() {
		rawCallback()
	}
}

// OverrideGtkReserved2 sets the "_gtk_reserved2" callback function.
func (x *SorterClass) OverrideGtkReserved2(cb func()) {
	if cb == nil {
		x.xGtkReserved2 = 0
	} else {
		x.xGtkReserved2 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGtkReserved2 gets the "_gtk_reserved2" callback function.
func (x *SorterClass) GetGtkReserved2() func() {
	if x.xGtkReserved2 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGtkReserved2)
	return func() {
		rawCallback()
	}
}

// OverrideGtkReserved3 sets the "_gtk_reserved3" callback function.
func (x *SorterClass) OverrideGtkReserved3(cb func()) {
	if cb == nil {
		x.xGtkReserved3 = 0
	} else {
		x.xGtkReserved3 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGtkReserved3 gets the "_gtk_reserved3" callback function.
func (x *SorterClass) GetGtkReserved3() func() {
	if x.xGtkReserved3 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGtkReserved3)
	return func() {
		rawCallback()
	}
}

// OverrideGtkReserved4 sets the "_gtk_reserved4" callback function.
func (x *SorterClass) OverrideGtkReserved4(cb func()) {
	if cb == nil {
		x.xGtkReserved4 = 0
	} else {
		x.xGtkReserved4 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGtkReserved4 gets the "_gtk_reserved4" callback function.
func (x *SorterClass) GetGtkReserved4() func() {
	if x.xGtkReserved4 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGtkReserved4)
	return func() {
		rawCallback()
	}
}

// OverrideGtkReserved5 sets the "_gtk_reserved5" callback function.
func (x *SorterClass) OverrideGtkReserved5(cb func()) {
	if cb == nil {
		x.xGtkReserved5 = 0
	} else {
		x.xGtkReserved5 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGtkReserved5 gets the "_gtk_reserved5" callback function.
func (x *SorterClass) GetGtkReserved5() func() {
	if x.xGtkReserved5 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGtkReserved5)
	return func() {
		rawCallback()
	}
}

// OverrideGtkReserved6 sets the "_gtk_reserved6" callback function.
func (x *SorterClass) OverrideGtkReserved6(cb func()) {
	if cb == nil {
		x.xGtkReserved6 = 0
	} else {
		x.xGtkReserved6 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGtkReserved6 gets the "_gtk_reserved6" callback function.
func (x *SorterClass) GetGtkReserved6() func() {
	if x.xGtkReserved6 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGtkReserved6)
	return func() {
		rawCallback()
	}
}

// OverrideGtkReserved7 sets the "_gtk_reserved7" callback function.
func (x *SorterClass) OverrideGtkReserved7(cb func()) {
	if cb == nil {
		x.xGtkReserved7 = 0
	} else {
		x.xGtkReserved7 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGtkReserved7 gets the "_gtk_reserved7" callback function.
func (x *SorterClass) GetGtkReserved7() func() {
	if x.xGtkReserved7 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGtkReserved7)
	return func() {
		rawCallback()
	}
}

// OverrideGtkReserved8 sets the "_gtk_reserved8" callback function.
func (x *SorterClass) OverrideGtkReserved8(cb func()) {
	if cb == nil {
		x.xGtkReserved8 = 0
	} else {
		x.xGtkReserved8 = purego.NewCallback(func() {
			cb()
		})
	}
}

// GetGtkReserved8 gets the "_gtk_reserved8" callback function.
func (x *SorterClass) GetGtkReserved8() func() {
	if x.xGtkReserved8 == 0 {
		return nil
	}
	var rawCallback func()
	purego.RegisterFunc(&rawCallback, x.xGtkReserved8)
	return func() {
		rawCallback()
	}
}

// Describes changes in a sorter in more detail and allows users
// to optimize resorting.
type SorterChange int

var xSorterChangeGLibType func() types.GType

func SorterChangeGLibType() types.GType {
	return xSorterChangeGLibType()
}

const (

	// The sorter change cannot be described
	//   by any of the other enumeration values
	SorterChangeDifferentValue SorterChange = 0
	// The sort order was inverted. Comparisons
	//   that returned %GTK_ORDERING_SMALLER now return %GTK_ORDERING_LARGER
	//   and vice versa. Other comparisons return the same values as before.
	SorterChangeInvertedValue SorterChange = 1
	// The sorter is less strict: Comparisons
	//   may now return %GTK_ORDERING_EQUAL that did not do so before.
	SorterChangeLessStrictValue SorterChange = 2
	// The sorter is more strict: Comparisons
	//   that did return %GTK_ORDERING_EQUAL may not do so anymore.
	SorterChangeMoreStrictValue SorterChange = 3
)

// Describes the type of order that a `GtkSorter` may produce.
type SorterOrder int

var xSorterOrderGLibType func() types.GType

func SorterOrderGLibType() types.GType {
	return xSorterOrderGLibType()
}

const (

	// A partial order. Any `GtkOrdering` is possible.
	SorterOrderPartialValue SorterOrder = 0
	// No order, all elements are considered equal.
	//   gtk_sorter_compare() will only return %GTK_ORDERING_EQUAL.
	SorterOrderNoneValue SorterOrder = 1
	// A total order. gtk_sorter_compare() will only
	//   return %GTK_ORDERING_EQUAL if an item is compared with itself. Two
	//   different items will never cause this value to be returned.
	SorterOrderTotalValue SorterOrder = 2
)

// Describes sorting criteria for a [class@Gtk.SortListModel].
//
// Its primary user is [class@Gtk.SortListModel]
//
// The model will use a sorter to determine the order in which
// its items should appear by calling [method@Gtk.Sorter.compare]
// for pairs of items.
//
// Sorters may change their sorting behavior through their lifetime.
// In that case, they will emit the [signal@Gtk.Sorter::changed] signal
// to notify that the sort order is no longer valid and should be updated
// by calling gtk_sorter_compare() again.
//
// GTK provides various pre-made sorter implementations for common sorting
// operations. [class@Gtk.ColumnView] has built-in support for sorting lists
// via the [property@Gtk.ColumnViewColumn:sorter] property, where the user can
// change the sorting by clicking on list headers.
//
// Of course, in particular for large lists, it is also possible to subclass
// `GtkSorter` and provide one's own sorter.
type Sorter struct {
	gobject.Object
}

var xSorterGLibType func() types.GType

func SorterGLibType() types.GType {
	return xSorterGLibType()
}

func SorterNewFromInternalPtr(ptr uintptr) *Sorter {
	cls := &Sorter{}
	cls.Ptr = ptr
	return cls
}

var xSorterChanged func(uintptr, SorterChange)

// Notifies all users of the sorter that it has changed.
//
// This emits the [signal@Gtk.Sorter::changed] signal. Users
// of the sorter should then update the sort order via
// [method@Gtk.Sorter.compare].
//
// Depending on the @change parameter, it may be possible to
// update the sort order without a full resorting. Refer to
// the [enum@Gtk.SorterChange] documentation for details.
//
// This function is intended for implementers of `GtkSorter`
// subclasses and should not be called from other functions.
func (x *Sorter) Changed(ChangeVar SorterChange) {

	xSorterChanged(x.GoPointer(), ChangeVar)

}

var xSorterCompare func(uintptr, uintptr, uintptr) Ordering

// Compares two given items according to the sort order implemented
// by the sorter.
//
// Sorters implement a partial order:
//
//   - It is reflexive, ie a = a
//   - It is antisymmetric, ie if a < b and b < a, then a = b
//   - It is transitive, ie given any 3 items with a ≤ b and b ≤ c,
//     then a ≤ c
//
// The sorter may signal it conforms to additional constraints
// via the return value of [method@Gtk.Sorter.get_order].
func (x *Sorter) Compare(Item1Var *gobject.Object, Item2Var *gobject.Object) Ordering {

	cret := xSorterCompare(x.GoPointer(), Item1Var.GoPointer(), Item2Var.GoPointer())
	return cret
}

var xSorterGetOrder func(uintptr) SorterOrder

// Gets the order that @self conforms to.
//
// See [enum@Gtk.SorterOrder] for details
// of the possible return values.
//
// This function is intended to allow optimizations.
func (x *Sorter) GetOrder() SorterOrder {

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

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

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

// Emitted whenever the sorter changed.
//
// Users of the sorter should then update the sort order
// again via gtk_sorter_compare().
//
// [class@Gtk.SortListModel] handles this signal automatically.
//
// Depending on the @change parameter, it may be possible to update
// the sort order without a full resorting. Refer to the
// [enum@Gtk.SorterChange] documentation for details.
func (x *Sorter) ConnectChanged(cb *func(Sorter, SorterChange)) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr, ChangeVarp SorterChange) {
		fa := Sorter{}
		fa.Ptr = clsPtr
		cbFn := *cb

		cbFn(fa, ChangeVarp)

	}
	cbRefPtr := purego.NewCallback(fcb)
	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
	handlerID := gobject.SignalConnect(x.GoPointer(), "changed", cbRefPtr)
	glib.SaveHandlerMapping(handlerID, cbPtr)
	return handlerID
}

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(&xSorterChangeGLibType, libs, "gtk_sorter_change_get_type")

	core.PuregoSafeRegister(&xSorterOrderGLibType, libs, "gtk_sorter_order_get_type")

	core.PuregoSafeRegister(&xSorterGLibType, libs, "gtk_sorter_get_type")

	core.PuregoSafeRegister(&xSorterChanged, libs, "gtk_sorter_changed")
	core.PuregoSafeRegister(&xSorterCompare, libs, "gtk_sorter_compare")
	core.PuregoSafeRegister(&xSorterGetOrder, libs, "gtk_sorter_get_order")

}