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

import (
	"unsafe"

	"github.com/ebitengine/purego"

	"github.com/bnema/puregotk/pkg/core"
	"github.com/bnema/puregotk/v4/gdk"
	"github.com/bnema/puregotk/v4/glib"
	"github.com/bnema/puregotk/v4/gobject"
	"github.com/bnema/puregotk/v4/gobject/types"
)

// The available modes for [property@Gtk.CellRendererAccel:accel-mode].
type CellRendererAccelMode int

var xCellRendererAccelModeGLibType func() types.GType

func CellRendererAccelModeGLibType() types.GType {
	return xCellRendererAccelModeGLibType()
}

const (

	// GTK accelerators mode
	CellRendererAccelModeGtkValue CellRendererAccelMode = 0
	// Other accelerator mode
	CellRendererAccelModeOtherValue CellRendererAccelMode = 1
)

// Renders a keyboard accelerator in a cell
//
// `GtkCellRendererAccel` displays a keyboard accelerator (i.e. a key
// combination like `Control + a`). If the cell renderer is editable,
// the accelerator can be changed by simply typing the new combination.
type CellRendererAccel struct {
	CellRendererText
}

var xCellRendererAccelGLibType func() types.GType

func CellRendererAccelGLibType() types.GType {
	return xCellRendererAccelGLibType()
}

func CellRendererAccelNewFromInternalPtr(ptr uintptr) *CellRendererAccel {
	cls := &CellRendererAccel{}
	cls.Ptr = ptr
	return cls
}

var xNewCellRendererAccel func() uintptr

// Creates a new `GtkCellRendererAccel`.
func NewCellRendererAccel() *CellRendererAccel {
	var cls *CellRendererAccel

	cret := xNewCellRendererAccel()

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

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

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

// SetPropertyAccelKey sets the "accel-key" property.
// The keyval of the accelerator.
func (x *CellRendererAccel) SetPropertyAccelKey(value uint) {
	var v gobject.Value
	v.Init(gobject.TypeUintVal)
	v.SetUint(value)
	x.SetProperty("accel-key", &v)
}

// GetPropertyAccelKey gets the "accel-key" property.
// The keyval of the accelerator.
func (x *CellRendererAccel) GetPropertyAccelKey() uint {
	var v gobject.Value
	x.GetProperty("accel-key", &v)
	return v.GetUint()
}

// SetPropertyKeycode sets the "keycode" property.
// The hardware keycode of the accelerator. Note that the hardware keycode is
// only relevant if the key does not have a keyval. Normally, the keyboard
// configuration should assign keyvals to all keys.
func (x *CellRendererAccel) SetPropertyKeycode(value uint) {
	var v gobject.Value
	v.Init(gobject.TypeUintVal)
	v.SetUint(value)
	x.SetProperty("keycode", &v)
}

// GetPropertyKeycode gets the "keycode" property.
// The hardware keycode of the accelerator. Note that the hardware keycode is
// only relevant if the key does not have a keyval. Normally, the keyboard
// configuration should assign keyvals to all keys.
func (x *CellRendererAccel) GetPropertyKeycode() uint {
	var v gobject.Value
	x.GetProperty("keycode", &v)
	return v.GetUint()
}

// Gets emitted when the user has removed the accelerator.
func (x *CellRendererAccel) ConnectAccelCleared(cb *func(CellRendererAccel, string)) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "accel-cleared", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr, PathStringVarp uintptr) {
		fa := CellRendererAccel{}
		fa.Ptr = clsPtr
		cbFn := *cb

		cbFn(fa, core.GoString(PathStringVarp))

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

// Gets emitted when the user has selected a new accelerator.
func (x *CellRendererAccel) ConnectAccelEdited(cb *func(CellRendererAccel, string, uint, gdk.ModifierType, uint)) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "accel-edited", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr, PathStringVarp uintptr, AccelKeyVarp uint, AccelModsVarp gdk.ModifierType, HardwareKeycodeVarp uint) {
		fa := CellRendererAccel{}
		fa.Ptr = clsPtr
		cbFn := *cb

		cbFn(fa, core.GoString(PathStringVarp), AccelKeyVarp, AccelModsVarp, HardwareKeycodeVarp)

	}
	cbRefPtr := purego.NewCallback(fcb)
	glib.SaveCallbackWithClosure(cbPtr, cbRefPtr, cb)
	handlerID := gobject.SignalConnect(x.GoPointer(), "accel-edited", 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(&xCellRendererAccelModeGLibType, libs, "gtk_cell_renderer_accel_mode_get_type")

	core.PuregoSafeRegister(&xCellRendererAccelGLibType, libs, "gtk_cell_renderer_accel_get_type")

	core.PuregoSafeRegister(&xNewCellRendererAccel, libs, "gtk_cell_renderer_accel_new")

}