events

const (
	NoButton Buttons = iota
	Left
	Middle
	Right
)

const ButtonsN Buttons = 4

const (
	NoDropMod DropMods = iota

	// Copy is the default and implies data is just copied -- receiver can do
	// with it as they please and source does not need to take any further
	// action
	DropCopy

	// Move is signaled with a Shift or Meta key (by default) and implies that
	// the source should delete itself when it receives the DropFromSource event
	// action with this Mod value set -- receiver must update the Mod to
	// reflect actual action taken, and be particularly careful with this one
	DropMove

	// Link can be any other kind of alternative action -- link is applicable
	// to files (symbolic link)
	DropLink

	// Ignore means that the receiver chose to not process this drop
	DropIgnore
)

const DropModsN DropMods = 5

const (
	// Handled indicates that the event has been handled
	Handled EventFlags = iota

	// EventUnique indicates that the event is Unique and not
	// to be compressed with like events.
	Unique
)

const EventFlagsN EventFlags = 2

const (
	// SelectOne selects a single item, and is the default when no modifier key
	// is pressed
	SelectOne SelectModes = iota

	// ExtendContinuous, activated by Shift key, extends the selection to
	// select a continuous region of selected items, with no gaps
	ExtendContinuous

	// ExtendOne, activated by Control or Meta / Command, extends the
	// selection by adding the one additional item just clicked on, creating a
	// potentially discontinuous set of selected items
	ExtendOne

	// NoSelect means do not update selection -- this is used programmatically
	// and not available via modifier key
	NoSelect

	// Unselect means unselect items -- this is used programmatically
	// and not available via modifier key -- typically ExtendOne will
	// unselect if already selected
	Unselect

	// SelectQuiet means select without doing other updates or signals -- for
	// bulk updates with a final update at the end -- used programmatically
	SelectQuiet

	// UnselectQuiet means unselect without doing other updates or signals -- for
	// bulk updates with a final update at the end -- used programmatically
	UnselectQuiet
)

const SelectModesN SelectModes = 7

const (
	// zero value is an unknown type
	UnknownType Types = iota

	// MouseDown happens when a mouse button is pressed down.
	// See MouseButton() for which.
	// See Click for a synthetic event representing a MouseDown
	// followed by MouseUp on the same element with Left (primary)
	// mouse button. Often that is the most useful.
	MouseDown

	// MouseUp happens when a mouse button is released.
	// See MouseButton() for which.
	MouseUp

	// MouseMove is always sent when the mouse is moving but no
	// button is down, even if there might be other higher-level events too.
	// These can be numerous and thus it is typically more efficient
	// to listen to other events derived from this.
	// Not unique, and Prev position is updated during compression.
	MouseMove

	// MouseDrag is always sent when the mouse is moving and there
	// is a button down, even if there might be other higher-level
	// events too.
	// The start pos indicates where (and when) button first was pressed.
	// Not unique and Prev position is updated during compression.
	MouseDrag

	// Click represents a MouseDown followed by MouseUp
	// in sequence on the same element, with the Left (primary) button.
	// This is the typical event for most basic user interaction.
	Click

	// DoubleClick represents two Click events in a row in rapid
	// succession.
	DoubleClick

	// TripleClick represents three Click events in a row in rapid
	// succession.
	TripleClick

	// ContextMenu represents a MouseDown/Up event with the
	// Right mouse button (which is also activated by
	// Control key + Left Click).
	ContextMenu

	// LongPressStart is when the mouse has been relatively stable
	// after MouseDown on an element for a minimum duration (500 msec default).
	LongPressStart

	// LongPressEnd is sent after LongPressStart when the mouse has
	// gone up, moved sufficiently, left the current element,
	// or another input event has happened.
	LongPressEnd

	// MouseEnter is when the mouse enters the bounding box
	// of a new element.  It is used for setting the Hover state,
	// and can trigger cursor changes.
	// See DragEnter for alternative case during Drag events.
	MouseEnter

	// MouseLeave is when the mouse leaves the bounding box
	// of an element, that previously had a MouseEnter event.
	// Given that elements can have overlapping bounding boxes
	// (e.g., child elements within a container), it is not the case
	// that a MouseEnter on a child triggers a MouseLeave on
	// surrounding containers.
	// See DragLeave for alternative case during Drag events.
	MouseLeave

	// LongHoverStart is when the mouse has been relatively stable
	// after MouseEnter on an element for a minimum duration
	// (500 msec default).
	// This triggers the LongHover state typically used for Tooltips.
	LongHoverStart

	// LongHoverEnd is after LongHoverStart when the mouse has
	// moved sufficiently, left the current element,
	// or another input event has happened,
	// thereby terminating the LongHover state.
	LongHoverEnd

	// DragStart is at the start of a drag-n-drop event sequence, when
	// a Draggable element is Active and a sufficient distance of
	// MouseDrag events has occurred to engage the DragStart event.
	DragStart

	// DragMove is for a MouseDrag event during the drag-n-drop sequence.
	// Usually don't need to listen to this one.  MouseDrag is also sent.
	DragMove

	// DragEnter is like MouseEnter but after a DragStart during a
	// drag-n-drop sequence.  MouseEnter is not sent in this case.
	DragEnter

	// DragLeave is like MouseLeave but after a DragStart during a
	// drag-n-drop sequence.  MouseLeave is not sent in this case.
	DragLeave

	// Drop is sent when an item being Dragged is dropped on top of a
	// target element. The event struct should be DragDrop.
	Drop

	// DropDeleteSource is sent to the source Drag element if the
	// Drag-n-Drop event is a Move type, which requires deleting
	// the source element.  The event struct should be DragDrop.
	DropDeleteSource

	// SlideStart is for a Slideable element when Active and a
	// sufficient distance of MouseDrag events has occurred to
	// engage the SlideStart event.  Sets the Sliding state.
	SlideStart

	// SlideMove is for a Slideable element after SlideStart
	// is being dragged via MouseDrag events.
	SlideMove

	// SlideStop is when the mouse button is released on a Slideable
	// element being dragged via MouseDrag events.  This typically
	// also accompanied by a Changed event for the new slider value.
	SlideStop

	// Scroll is for scroll wheel or other scrolling events (gestures).
	// These are not unique and Delta is updated during compression.
	Scroll

	// KeyDown is when a key is pressed down.
	// This provides fine-grained data about each key as it happens.
	// KeyChord is recommended for a more complete Key event.
	KeyDown

	// KeyUp is when a key is released.
	// This provides fine-grained data about each key as it happens.
	// KeyChord is recommended for a more complete Key event.
	KeyUp

	// KeyChord is only generated when a non-modifier key is released,
	// and it also contains a string representation of the full chord,
	// suitable for translation into keyboard commands, emacs-style etc.
	// It can be somewhat delayed relative to the KeyUp.
	KeyChord

	// TouchStart is when a touch event starts, for the low-level touch
	// event processing.  TouchStart also activates MouseDown, Scroll,
	// Magnify, or Rotate events depending on gesture recognition.
	TouchStart

	// TouchEnd is when a touch event ends, for the low-level touch
	// event processing.  TouchEnd also activates MouseUp events
	// depending on gesture recognition.
	TouchEnd

	// TouchMove is when a touch event moves, for the low-level touch
	// event processing.  TouchMove also activates MouseMove, Scroll,
	// Magnify, or Rotate events depending on gesture recognition.
	TouchMove

	// Magnify is a touch-based magnify event (e.g., pinch)
	Magnify

	// Rotate is a touch-based rotate event.
	Rotate

	// Select is sent for any direction of selection change
	// on (or within if relevant) a Selectable element.
	// Typically need to query the element(s) to determine current
	// selection state.
	Select

	// Focus is sent when Focsable element receives Focus
	Focus

	// FocusLost is sent when Focsable element loses Focus
	FocusLost

	// Change is when a value represented by the element has been changed
	// by the user and committed (for example, someone has typed text in a
	// textfield and then pressed enter). This is *not* triggered when
	// the value has not been committed; see [Input] for that.
	// This is for Editable, Checkable, and Slidable items.
	Change

	// Input is when a value represented by the element has changed, but
	// has not necessarily been committed (for example, this triggers each
	// time someone presses a key in a text field). This *is* triggered when
	// the value has not been committed; see [Change] for a version that only
	// occurs when the value is committed.
	// This is for Editable, Checkable, and Slidable items.
	Input

	// Show is generated by an overall Scene container when
	// the content is first shown to the user in its final form.
	// Listening to this event enables other elements to perform initial
	// one-time activities on startup, in the context of a fully rendered
	// display. This is guaranteed to only happen once per Scene.
	Show

	// Close is generated by an overall Scene or Window level container when
	// being closed (e.g., on dialog closing).  This is an opportunity to save
	// unsaved edits, for example.
	Close

	// Window reports on changes in the window position,
	// visibility (iconify), focus changes, screen update, and closing.
	// These are only sent once per event (Unique).
	Window

	// WindowResize happens when the window has been resized,
	// which can happen continuously during a user resizing
	// episode.  These are not Unique events, and are compressed
	// to minimize lag.
	WindowResize

	// WindowPaint is sent continuously at FPS frequency
	// (60 frames per second by default) to drive updating check
	// on the window.  It is not unique, will be compressed
	// to keep pace with updating.
	WindowPaint

	// OS is an operating system generated event (app level typically)
	OS

	// OSOpenFiles is an event telling app to open given files
	OSOpenFiles

	// Custom is a user-defined event with a data any field
	Custom
)

const TypesN Types = 46

const (
	// NoWinAction is the zero value for special types (Resize, Paint)
	NoWinAction WinActions = iota

	// WinClose means that the window is about to close, but has not yet closed.
	WinClose

	// WinMinimize means that the window has been iconified / miniaturized / is no
	// longer visible.
	WinMinimize

	// WinMove means that the window was moved but NOT resized or changed in any
	// other way -- does not require a redraw, but anything tracking positions
	// will want to update.
	WinMove

	// WinFocus indicates that the window has been activated for receiving user
	// input.
	WinFocus

	// WinFocusLost indicates that the window is no longer activated for
	// receiving input.
	WinFocusLost

	// WinShow is for the WindowShow event -- sent by the system shortly
	// after the window has opened, to ensure that full rendering
	// is completed with the proper size, and to trigger one-time actions such as
	// configuring the main menu after the window has opened.
	WinShow

	// ScreenUpdate occurs when any of the screen information is updated
	// This event is sent to the first window on the list of active windows
	// and it should then perform any necessary updating
	ScreenUpdate
)

const WinActionsN WinActions = 8