// 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 EventControllerScrollClass struct {
	_ structs.HostLayout
}

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

// Describes the behavior of a `GtkEventControllerScroll`.
type EventControllerScrollFlags int

var xEventControllerScrollFlagsGLibType func() types.GType

func EventControllerScrollFlagsGLibType() types.GType {
	return xEventControllerScrollFlagsGLibType()
}

const (

	// Don't emit scroll.
	EventControllerScrollNoneValue EventControllerScrollFlags = 0
	// Emit scroll with vertical deltas.
	EventControllerScrollVerticalValue EventControllerScrollFlags = 1
	// Emit scroll with horizontal deltas.
	EventControllerScrollHorizontalValue EventControllerScrollFlags = 2
	// Only emit deltas that are multiples of 1.
	EventControllerScrollDiscreteValue EventControllerScrollFlags = 4
	// Emit ::decelerate after continuous scroll finishes.
	EventControllerScrollKineticValue EventControllerScrollFlags = 8
	// A #GtkEventControllerScrollFlags value to prefer physical direction over
	// logical direction (i.e. oblivious to natural scroll).
	EventControllerScrollPhysicalDirectionValue EventControllerScrollFlags = 16
	// Emit scroll on both axes.
	EventControllerScrollBothAxesValue EventControllerScrollFlags = 3
)

// Handles scroll events.
//
// It is capable of handling both discrete and continuous scroll
// events from mice or touchpads, abstracting them both with the
// [signal@Gtk.EventControllerScroll::scroll] signal. Deltas in
// the discrete case are multiples of 1.
//
// In the case of continuous scroll events, `GtkEventControllerScroll`
// encloses all [signal@Gtk.EventControllerScroll::scroll] emissions
// between two [signal@Gtk.EventControllerScroll::scroll-begin] and
// [signal@Gtk.EventControllerScroll::scroll-end] signals.
//
// The behavior of the event controller can be modified by the flags
// given at creation time, or modified at a later point through
// [method@Gtk.EventControllerScroll.set_flags] (e.g. because the scrolling
// conditions of the widget changed).
//
// The controller can be set up to emit motion for either/both vertical
// and horizontal scroll events through %GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
// %GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and %GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES.
// If any axis is disabled, the respective [signal@Gtk.EventControllerScroll::scroll]
// delta will be 0. Vertical scroll events will be translated to horizontal
// motion for the devices incapable of horizontal scrolling.
//
// The event controller can also be forced to emit discrete events on all
// devices through %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE. This can be used
// to implement discrete actions triggered through scroll events (e.g.
// switching across combobox options).
//
// The %GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag toggles the emission of the
// [signal@Gtk.EventControllerScroll::decelerate] signal, emitted at the end
// of scrolling with two X/Y velocity arguments that are consistent with the
// motion that was received.
type EventControllerScroll struct {
	EventController
}

var xEventControllerScrollGLibType func() types.GType

func EventControllerScrollGLibType() types.GType {
	return xEventControllerScrollGLibType()
}

func EventControllerScrollNewFromInternalPtr(ptr uintptr) *EventControllerScroll {
	cls := &EventControllerScroll{}
	cls.Ptr = ptr
	return cls
}

var xNewEventControllerScroll func(EventControllerScrollFlags) uintptr

// Creates a new event controller that will handle scroll events.
func NewEventControllerScroll(FlagsVar EventControllerScrollFlags) *EventControllerScroll {
	var cls *EventControllerScroll

	cret := xNewEventControllerScroll(FlagsVar)

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

var xEventControllerScrollGetFlags func(uintptr) EventControllerScrollFlags

// Gets the flags conditioning the scroll controller behavior.
func (x *EventControllerScroll) GetFlags() EventControllerScrollFlags {

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

var xEventControllerScrollGetUnit func(uintptr) gdk.ScrollUnit

// Gets the scroll unit of the last
// [signal@Gtk.EventControllerScroll::scroll] signal received.
//
// Always returns %GDK_SCROLL_UNIT_WHEEL if the
// %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE flag is set.
func (x *EventControllerScroll) GetUnit() gdk.ScrollUnit {

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

var xEventControllerScrollSetFlags func(uintptr, EventControllerScrollFlags)

// Sets the flags conditioning scroll controller behavior.
func (x *EventControllerScroll) SetFlags(FlagsVar EventControllerScrollFlags) {

	xEventControllerScrollSetFlags(x.GoPointer(), FlagsVar)

}

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

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

// Emitted after scroll is finished if the
// %GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag is set.
//
// @vel_x and @vel_y express the initial velocity that was
// imprinted by the scroll events. @vel_x and @vel_y are expressed in
// pixels/ms.
func (x *EventControllerScroll) ConnectDecelerate(cb *func(EventControllerScroll, float64, float64)) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "decelerate", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr, VelXVarp float64, VelYVarp float64) {
		fa := EventControllerScroll{}
		fa.Ptr = clsPtr
		cbFn := *cb

		cbFn(fa, VelXVarp, VelYVarp)

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

// Signals that the widget should scroll by the
// amount specified by @dx and @dy.
//
// For the representation unit of the deltas, see
// [method@Gtk.EventControllerScroll.get_unit].
func (x *EventControllerScroll) ConnectScroll(cb *func(EventControllerScroll, float64, float64) bool) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "scroll", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

	fcb := func(clsPtr uintptr, DxVarp float64, DyVarp float64) bool {
		fa := EventControllerScroll{}
		fa.Ptr = clsPtr
		cbFn := *cb

		return cbFn(fa, DxVarp, DyVarp)

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

// Signals that a new scrolling operation has begun.
//
// It will only be emitted on devices capable of it.
func (x *EventControllerScroll) ConnectScrollBegin(cb *func(EventControllerScroll)) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-begin", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

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

		cbFn(fa)

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

// Signals that a scrolling operation has finished.
//
// It will only be emitted on devices capable of it.
func (x *EventControllerScroll) ConnectScrollEnd(cb *func(EventControllerScroll)) uint {
	cbPtr := uintptr(unsafe.Pointer(cb))
	if cbRefPtr, ok := glib.GetCallback(cbPtr); ok {
		handlerID := gobject.SignalConnect(x.GoPointer(), "scroll-end", cbRefPtr)
		glib.SaveHandlerMapping(handlerID, cbPtr)
		return handlerID
	}

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

		cbFn(fa)

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

	core.PuregoSafeRegister(&xEventControllerScrollGLibType, libs, "gtk_event_controller_scroll_get_type")

	core.PuregoSafeRegister(&xNewEventControllerScroll, libs, "gtk_event_controller_scroll_new")

	core.PuregoSafeRegister(&xEventControllerScrollGetFlags, libs, "gtk_event_controller_scroll_get_flags")
	core.PuregoSafeRegister(&xEventControllerScrollGetUnit, libs, "gtk_event_controller_scroll_get_unit")
	core.PuregoSafeRegister(&xEventControllerScrollSetFlags, libs, "gtk_event_controller_scroll_set_flags")

}