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

// Struct defining a pad action entry.
type PadActionEntry struct {
	_ structs.HostLayout

	Type PadActionType

	Index int

	Mode int

	Label uintptr

	ActionName uintptr
}

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

type PadControllerClass struct {
	_ structs.HostLayout
}

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

// The type of a pad action.
type PadActionType int

var xPadActionTypeGLibType func() types.GType

func PadActionTypeGLibType() types.GType {
	return xPadActionTypeGLibType()
}

const (

	// Action is triggered by a pad button
	PadActionButtonValue PadActionType = 0
	// Action is triggered by a pad ring
	PadActionRingValue PadActionType = 1
	// Action is triggered by a pad strip
	PadActionStripValue PadActionType = 2
	// Action is triggered by a pad dial
	PadActionDialValue PadActionType = 3
)

// Handles input from the pads found in drawing tablets.
//
// Pads are the collection of buttons and tactile sensors often found around
// the stylus-sensitive area.
//
// These buttons and sensors have no implicit meaning, and by default they
// perform no action. `GtkPadController` is provided to map those to
// [iface@Gio.Action] objects, thus letting the application give them a more
// semantic meaning.
//
// Buttons and sensors are not constrained to triggering a single action,
// some %GDK_SOURCE_TABLET_PAD devices feature multiple "modes". All these
// input elements have one current mode, which may determine the final action
// being triggered.
//
// Pad devices often divide buttons and sensors into groups. All elements
// in a group share the same current mode, but different groups may have
// different modes. See [method@Gdk.DevicePad.get_n_groups] and
// [method@Gdk.DevicePad.get_group_n_modes].
//
// Each of the actions that a given button/strip/ring performs for a given mode
// is defined by a [struct@Gtk.PadActionEntry]. It contains an action name that
// will be looked up in the given [iface@Gio.ActionGroup] and activated whenever
// the specified input element and mode are triggered.
//
// A simple example of `GtkPadController` usage: Assigning button 1 in all
// modes and pad devices to an "invert-selection" action:
//
// ```c
//
//	GtkPadActionEntry *pad_actions[] = {
//	  { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
//	  …
//	};
//
// …
// action_group = g_simple_action_group_new ();
// action = g_simple_action_new ("pad-actions.invert-selection", NULL);
// g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
// g_action_map_add_action (G_ACTION_MAP (action_group), action);
// …
// pad_controller = gtk_pad_controller_new (action_group, NULL);
// ```
//
// The actions belonging to rings/strips/dials will be activated with a parameter
// of type %G_VARIANT_TYPE_DOUBLE bearing the value of the given axis, it
// is required that those are made stateful and accepting this `GVariantType`.
// For rings the value is the angle of the ring position in degrees with 0
// facing up. For strips the value is the absolute position on the strip, normalized
// to the [0.0, 1.0] range.
// For dials the value is the relative movement of the dial, normalized so that the
// value 120 represents one logical scroll wheel detent in the positive direction.
// Devices that support high-resolution scrolling may send events with fractions of
// 120 to signify a smaller motion.
type PadController struct {
	EventController
}

var xPadControllerGLibType func() types.GType

func PadControllerGLibType() types.GType {
	return xPadControllerGLibType()
}

func PadControllerNewFromInternalPtr(ptr uintptr) *PadController {
	cls := &PadController{}
	cls.Ptr = ptr
	return cls
}

var xNewPadController func(uintptr, uintptr) uintptr

// Creates a new `GtkPadController` that will associate events from @pad to
// actions.
//
// A %NULL pad may be provided so the controller manages all pad devices
// generically, it is discouraged to mix `GtkPadController` objects with
// %NULL and non-%NULL @pad argument on the same toplevel window, as execution
// order is not guaranteed.
//
// The `GtkPadController` is created with no mapped actions. In order to
// map pad events to actions, use [method@Gtk.PadController.set_action_entries]
// or [method@Gtk.PadController.set_action].
//
// Be aware that pad events will only be delivered to `GtkWindow`s, so adding
// a pad controller to any other type of widget will not have an effect.
func NewPadController(GroupVar gio.ActionGroup, PadVar *gdk.Device) *PadController {
	var cls *PadController

	cret := xNewPadController(GroupVar.GoPointer(), PadVar.GoPointer())

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

var xPadControllerSetAction func(uintptr, PadActionType, int, int, string, string)

// Adds an individual action to @controller.
//
// This action will only be activated if the given button/ring/strip number
// in @index is interacted while the current mode is @mode. -1 may be used
// for simple cases, so the action is triggered on all modes.
//
// The given @label should be considered user-visible, so internationalization
// rules apply. Some windowing systems may be able to use those for user
// feedback.
func (x *PadController) SetAction(TypeVar PadActionType, IndexVar int, ModeVar int, LabelVar string, ActionNameVar string) {

	xPadControllerSetAction(x.GoPointer(), TypeVar, IndexVar, ModeVar, LabelVar, ActionNameVar)

}

var xPadControllerSetActionEntries func(uintptr, []PadActionEntry, int)

// A convenience function to add a group of action entries on
// @controller.
//
// See [struct@Gtk.PadActionEntry] and [method@Gtk.PadController.set_action].
func (x *PadController) SetActionEntries(EntriesVar []PadActionEntry, NEntriesVar int) {

	xPadControllerSetActionEntries(x.GoPointer(), EntriesVar, NEntriesVar)

}

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

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

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(&xPadActionTypeGLibType, libs, "gtk_pad_action_type_get_type")

	core.PuregoSafeRegister(&xPadControllerGLibType, libs, "gtk_pad_controller_get_type")

	core.PuregoSafeRegister(&xNewPadController, libs, "gtk_pad_controller_new")

	core.PuregoSafeRegister(&xPadControllerSetAction, libs, "gtk_pad_controller_set_action")
	core.PuregoSafeRegister(&xPadControllerSetActionEntries, libs, "gtk_pad_controller_set_action_entries")

}