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

type EventControllerKeyClass struct {
	_ structs.HostLayout
}

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

// Provides access to key events.
type EventControllerKey struct {
	EventController
}

var xEventControllerKeyGLibType func() types.GType

func EventControllerKeyGLibType() types.GType {
	return xEventControllerKeyGLibType()
}

func EventControllerKeyNewFromInternalPtr(ptr uintptr) *EventControllerKey {
	cls := &EventControllerKey{}
	cls.Ptr = ptr
	return cls
}

var xNewEventControllerKey func() uintptr

// Creates a new event controller that will handle key events.
func NewEventControllerKey() *EventControllerKey {
	var cls *EventControllerKey

	cret := xNewEventControllerKey()

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

var xEventControllerKeyForward func(uintptr, uintptr) bool

// Forwards the current event of this @controller to a @widget.
//
// This function can only be used in handlers for the
// [signal@Gtk.EventControllerKey::key-pressed],
// [signal@Gtk.EventControllerKey::key-released]
// or [signal@Gtk.EventControllerKey::modifiers] signals.
func (x *EventControllerKey) Forward(WidgetVar *Widget) bool {

	cret := xEventControllerKeyForward(x.GoPointer(), WidgetVar.GoPointer())
	return cret
}

var xEventControllerKeyGetGroup func(uintptr) uint

// Gets the key group of the current event of this @controller.
//
// See [method@Gdk.KeyEvent.get_layout].
func (x *EventControllerKey) GetGroup() uint {

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

var xEventControllerKeyGetImContext func(uintptr) uintptr

// Gets the input method context of the key @controller.
func (x *EventControllerKey) GetImContext() *IMContext {
	var cls *IMContext

	cret := xEventControllerKeyGetImContext(x.GoPointer())

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

var xEventControllerKeySetImContext func(uintptr, uintptr)

// Sets the input method context of the key @controller.
func (x *EventControllerKey) SetImContext(ImContextVar *IMContext) {

	xEventControllerKeySetImContext(x.GoPointer(), ImContextVar.GoPointer())

}

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

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

// Emitted whenever the input method context filters away
// a keypress and prevents the @controller receiving it.
//
// See [method@Gtk.EventControllerKey.set_im_context] and
// [method@Gtk.IMContext.filter_keypress].
func (x *EventControllerKey) ConnectImUpdate(cb *func(EventControllerKey)) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "im-update", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

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

		cbFn(fa)

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

// Emitted whenever a key is pressed.
func (x *EventControllerKey) ConnectKeyPressed(cb *func(EventControllerKey, uint, uint, gdk.ModifierType) bool) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "key-pressed", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr, KeyvalVarp uint, KeycodeVarp uint, StateVarp gdk.ModifierType) bool {
		fa := EventControllerKey{}
		fa.Ptr = clsPtr
		cbFn := *cb

		return cbFn(fa, KeyvalVarp, KeycodeVarp, StateVarp)

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

// Emitted whenever a key is released.
func (x *EventControllerKey) ConnectKeyReleased(cb *func(EventControllerKey, uint, uint, gdk.ModifierType)) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "key-released", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr, KeyvalVarp uint, KeycodeVarp uint, StateVarp gdk.ModifierType) {
		fa := EventControllerKey{}
		fa.Ptr = clsPtr
		cbFn := *cb

		cbFn(fa, KeyvalVarp, KeycodeVarp, StateVarp)

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

// Emitted whenever the state of modifier keys and pointer buttons change.
func (x *EventControllerKey) ConnectModifiers(cb *func(EventControllerKey, gdk.ModifierType) bool) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "modifiers", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr, StateVarp gdk.ModifierType) bool {
		fa := EventControllerKey{}
		fa.Ptr = clsPtr
		cbFn := *cb

		return cbFn(fa, StateVarp)

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

	core.PuregoSafeRegister(&xNewEventControllerKey, libs, "gtk_event_controller_key_new")

	core.PuregoSafeRegister(&xEventControllerKeyForward, libs, "gtk_event_controller_key_forward")
	core.PuregoSafeRegister(&xEventControllerKeyGetGroup, libs, "gtk_event_controller_key_get_group")
	core.PuregoSafeRegister(&xEventControllerKeyGetImContext, libs, "gtk_event_controller_key_get_im_context")
	core.PuregoSafeRegister(&xEventControllerKeySetImContext, libs, "gtk_event_controller_key_set_im_context")

}