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

type EventControllerClass struct {
	_ structs.HostLayout
}

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

// The base class for event controllers.
//
// These are ancillary objects associated to widgets, which react
// to `GdkEvents`, and possibly trigger actions as a consequence.
//
// Event controllers are added to a widget with
// [method@Gtk.Widget.add_controller]. It is rarely necessary to
// explicitly remove a controller with [method@Gtk.Widget.remove_controller].
//
// See the chapter on [input handling](input-handling.html) for
// an overview of the basic concepts, such as the capture and bubble
// phases of event propagation.
type EventController struct {
	gobject.Object
}

var xEventControllerGLibType func() types.GType

func EventControllerGLibType() types.GType {
	return xEventControllerGLibType()
}

func EventControllerNewFromInternalPtr(ptr uintptr) *EventController {
	cls := &EventController{}
	cls.Ptr = ptr
	return cls
}

var xEventControllerGetCurrentEvent func(uintptr) uintptr

// Returns the event that is currently being handled by the controller.
//
// At other times, %NULL is returned.
func (x *EventController) GetCurrentEvent() *gdk.Event {
	var cls *gdk.Event

	cret := xEventControllerGetCurrentEvent(x.GoPointer())

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

var xEventControllerGetCurrentEventDevice func(uintptr) uintptr

// Returns the device of the event that is currently being
// handled by the controller.
//
// At other times, %NULL is returned.
func (x *EventController) GetCurrentEventDevice() *gdk.Device {
	var cls *gdk.Device

	cret := xEventControllerGetCurrentEventDevice(x.GoPointer())

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

var xEventControllerGetCurrentEventState func(uintptr) gdk.ModifierType

// Returns the modifier state of the event that is currently being
// handled by the controller.
//
// At other times, 0 is returned.
func (x *EventController) GetCurrentEventState() gdk.ModifierType {

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

var xEventControllerGetCurrentEventTime func(uintptr) uint32

// Returns the timestamp of the event that is currently being
// handled by the controller.
//
// At other times, 0 is returned.
func (x *EventController) GetCurrentEventTime() uint32 {

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

var xEventControllerGetName func(uintptr) string

// Gets the name of @controller.
func (x *EventController) GetName() string {

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

var xEventControllerGetPropagationLimit func(uintptr) PropagationLimit

// Gets the propagation limit of the event controller.
func (x *EventController) GetPropagationLimit() PropagationLimit {

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

var xEventControllerGetPropagationPhase func(uintptr) PropagationPhase

// Gets the propagation phase at which @controller handles events.
func (x *EventController) GetPropagationPhase() PropagationPhase {

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

var xEventControllerGetWidget func(uintptr) uintptr

// Returns the `GtkWidget` this controller relates to.
func (x *EventController) GetWidget() *Widget {
	var cls *Widget

	cret := xEventControllerGetWidget(x.GoPointer())

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

var xEventControllerReset func(uintptr)

// Resets the @controller to a clean state.
func (x *EventController) Reset() {

	xEventControllerReset(x.GoPointer())

}

var xEventControllerSetName func(uintptr, uintptr)

// Sets a name on the controller that can be used for debugging.
func (x *EventController) SetName(NameVar *string) {

	NameVarPtr := core.GStrdupNullable(NameVar)
	defer core.GFreeNullable(NameVarPtr)

	xEventControllerSetName(x.GoPointer(), NameVarPtr)

}

var xEventControllerSetPropagationLimit func(uintptr, PropagationLimit)

// Sets the event propagation limit on the event controller.
//
// If the limit is set to %GTK_LIMIT_SAME_NATIVE, the controller
// won't handle events that are targeted at widgets on a different
// surface, such as popovers.
func (x *EventController) SetPropagationLimit(LimitVar PropagationLimit) {

	xEventControllerSetPropagationLimit(x.GoPointer(), LimitVar)

}

var xEventControllerSetPropagationPhase func(uintptr, PropagationPhase)

// Sets the propagation phase at which a controller handles events.
//
// If @phase is %GTK_PHASE_NONE, no automatic event handling will be
// performed, but other additional gesture maintenance will.
func (x *EventController) SetPropagationPhase(PhaseVar PropagationPhase) {

	xEventControllerSetPropagationPhase(x.GoPointer(), PhaseVar)

}

var xEventControllerSetStaticName func(uintptr, uintptr)

// Sets a name on the controller that can be used for debugging.
func (x *EventController) SetStaticName(NameVar *string) {

	NameVarPtr := core.GStrdupNullable(NameVar)
	defer core.GFreeNullable(NameVarPtr)

	xEventControllerSetStaticName(x.GoPointer(), NameVarPtr)

}

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

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

// SetPropertyName sets the "name" property.
// The name for this controller, typically used for debugging purposes.
func (x *EventController) SetPropertyName(value string) {
	var v gobject.Value
	v.Init(gobject.TypeStringVal)
	v.SetString(&value)
	x.SetProperty("name", &v)
}

// GetPropertyName gets the "name" property.
// The name for this controller, typically used for debugging purposes.
func (x *EventController) GetPropertyName() string {
	var v gobject.Value
	x.GetProperty("name", &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(&xEventControllerGLibType, libs, "gtk_event_controller_get_type")

	core.PuregoSafeRegister(&xEventControllerGetCurrentEvent, libs, "gtk_event_controller_get_current_event")
	core.PuregoSafeRegister(&xEventControllerGetCurrentEventDevice, libs, "gtk_event_controller_get_current_event_device")
	core.PuregoSafeRegister(&xEventControllerGetCurrentEventState, libs, "gtk_event_controller_get_current_event_state")
	core.PuregoSafeRegister(&xEventControllerGetCurrentEventTime, libs, "gtk_event_controller_get_current_event_time")
	core.PuregoSafeRegister(&xEventControllerGetName, libs, "gtk_event_controller_get_name")
	core.PuregoSafeRegister(&xEventControllerGetPropagationLimit, libs, "gtk_event_controller_get_propagation_limit")
	core.PuregoSafeRegister(&xEventControllerGetPropagationPhase, libs, "gtk_event_controller_get_propagation_phase")
	core.PuregoSafeRegister(&xEventControllerGetWidget, libs, "gtk_event_controller_get_widget")
	core.PuregoSafeRegister(&xEventControllerReset, libs, "gtk_event_controller_reset")
	core.PuregoSafeRegister(&xEventControllerSetName, libs, "gtk_event_controller_set_name")
	core.PuregoSafeRegister(&xEventControllerSetPropagationLimit, libs, "gtk_event_controller_set_propagation_limit")
	core.PuregoSafeRegister(&xEventControllerSetPropagationPhase, libs, "gtk_event_controller_set_propagation_phase")
	core.PuregoSafeRegister(&xEventControllerSetStaticName, libs, "gtk_event_controller_set_static_name")

}