gesture

type Arena struct {
	// contains filtered or unexported fields
}

type ArenaEntry struct {
	// PointerID is the pointer this entry is registered for.
	PointerID int

	// Member is the arena participant.
	Member ArenaMember
}

type ArenaMember interface {
	// AcceptGesture is called when this member wins the arena.
	// The member should commit its gesture (fire callbacks, transition state).
	AcceptGesture(pointerID int)

	// RejectGesture is called when this member loses the arena.
	// The member should reset its internal state and release resources.
	RejectGesture(pointerID int)
}

type ClickConfig struct {
	// MaxClickCount caps the click count. Default: 3 (Chromium standard).
	// Set to 1 to detect only single clicks.
	MaxClickCount int

	// OnClickDown is called when the pointer goes down with the current
	// consecutive click count. Useful for visual feedback before the
	// arena resolves.
	OnClickDown func(details ClickDownDetails)

	// OnClick is called when a click sequence completes (pointer up
	// within slop and within timing window). Provides the final click count.
	OnClick func(details ClickDetails)

	// OnClickCancel is called if the click is canceled (pointer moved
	// beyond slop, arena lost to another recognizer, pointer canceled).
	OnClickCancel func()
}

type ClickDetails struct {
	GlobalPosition geometry.Point
	LocalPosition  geometry.Point
	ClickCount     int
	PointerType    PointerType
	Button         event.Button
	Modifiers      event.Modifiers
	Timestamp      time.Duration
}

type ClickDownDetails struct {
	GlobalPosition geometry.Point
	LocalPosition  geometry.Point
	ClickCount     int
	PointerType    PointerType
	Button         event.Button
	Modifiers      event.Modifiers
	Timestamp      time.Duration
}

type ClickOption func(*ClickRecognizer)

type ClickRecognizer struct {
	RecognizerBase
	// contains filtered or unexported fields
}

type DeviceKind uint8

type Disposition uint8

type DragConfig struct {
	// Direction constrains which axis is recognized.
	Direction DragDirection

	// OnDragStart is called when movement exceeds the slop threshold.
	OnDragStart func(details DragStartDetails)

	// OnDragUpdate is called for each pointer move during an active drag.
	OnDragUpdate func(details DragUpdateDetails)

	// OnDragEnd is called when the pointer is released during a drag.
	// Includes velocity for fling detection.
	OnDragEnd func(details DragEndDetails)

	// OnDragCancel is called if the drag is canceled.
	OnDragCancel func()
}

type DragDirection uint8

type DragEndDetails struct {
	Velocity        geometry.Point // Pixels per second at release
	PrimaryVelocity float32        // Velocity along the drag axis
}

type DragOption func(*DragRecognizer)

type DragRecognizer struct {
	RecognizerBase
	// contains filtered or unexported fields
}

type DragStartDetails struct {
	GlobalPosition geometry.Point
	LocalPosition  geometry.Point
	PointerType    PointerType
	Timestamp      time.Duration
}

type DragUpdateDetails struct {
	GlobalPosition geometry.Point
	LocalPosition  geometry.Point
	Delta          geometry.Point // Movement since last update
	PrimaryDelta   float32        // Movement along the drag axis
	Timestamp      time.Duration
}

type GestureAware interface {
	// GestureHitTest returns the gesture recognizers that should participate
	// in the gesture arena for a pointer event at the given position.
	//
	// pos is in widget-local coordinates (relative to the widget's own
	// origin). The hit-test framework translates window coordinates to
	// widget-local space before calling this method.
	//
	// Leaf widgets (Button, Checkbox, etc.) should always return their
	// recognizers — the framework already confirmed the point is within
	// the widget's bounds.
	//
	// Container widgets with partial interactive areas (Collapsible header,
	// TabView tab strip, Docking zone tabs) MUST check whether pos falls
	// within their interactive region before returning recognizers. If pos
	// is outside the interactive region, return nil to let child widgets'
	// recognizers be the sole participants in the arena.
	//
	// Implementations should return the same recognizer instances across
	// calls (created once in the constructor or Mount), not new instances
	// each time. The arena manages recognizer lifecycle per-pointer.
	GestureHitTest(pos geometry.Point) []Recognizer
}

type LongPressConfig struct {
	// OnLongPressDown is called after PressTimeout (100ms) if the pointer
	// is still within slop. Used for visual feedback (ripple, highlight).
	OnLongPressDown func(details LongPressDetails)

	// OnLongPress is called when the long-press duration (500ms) is reached.
	OnLongPress func(details LongPressDetails)

	// OnLongPressMoveUpdate is called if the pointer moves after a
	// long-press has been recognized (long-press-drag).
	OnLongPressMoveUpdate func(details LongPressMoveDetails)

	// OnLongPressUp is called when the pointer is released after a long-press.
	OnLongPressUp func(details LongPressDetails)

	// OnLongPressCancel is called if the long-press is canceled.
	OnLongPressCancel func()
}

type LongPressDetails struct {
	GlobalPosition geometry.Point
	LocalPosition  geometry.Point
	PointerType    PointerType
}

type LongPressMoveDetails struct {
	GlobalPosition geometry.Point
	LocalPosition  geometry.Point
	Delta          geometry.Point
}

type LongPressOption func(*LongPressRecognizer)

type LongPressRecognizer struct {
	RecognizerBase
	// contains filtered or unexported fields
}

type PointerEvent struct {
	event.Base

	// EventType is the pointer event type (Down, Up, Move, Cancel).
	EventType PointerEventType

	// PointerID uniquely identifies this pointer across its lifetime.
	// Mouse: always 1. Touch: per-finger. Pen: per-stylus.
	PointerID int

	// PointerType distinguishes the input device.
	PointerType PointerType

	// Position is the pointer location relative to the receiving widget.
	Position geometry.Point

	// GlobalPosition is the pointer location in window coordinates.
	GlobalPosition geometry.Point

	// Pressure is the normalized pressure (0.0-1.0).
	// Mouse: 0.5 when pressed, 0.0 when not. Touch/Pen: actual pressure.
	Pressure float32

	// TiltX is the pen tilt angle around the X axis in degrees (-90 to 90).
	TiltX float32

	// TiltY is the pen tilt angle around the Y axis in degrees (-90 to 90).
	TiltY float32

	// Twist is the pen rotation in degrees (0 to 359).
	Twist float32

	// ContactWidth is the touch contact width in logical pixels.
	// 1.0 for devices without contact geometry (mouse).
	ContactWidth float32

	// ContactHeight is the touch contact height in logical pixels.
	// 1.0 for devices without contact geometry (mouse).
	ContactHeight float32

	// Button is the button that triggered this event (Down/Up only).
	Button event.Button

	// Buttons is the bitmask of all currently pressed buttons.
	Buttons event.ButtonState

	// Delta is the relative movement since the last event.
	// Non-zero only during pointer-locked mode.
	Delta geometry.Point

	// Timestamp is the platform event time for velocity calculation.
	// Zero if the platform does not provide timestamps.
	Timestamp time.Duration
}

type PointerEventType uint8

type PointerType uint8

type Recognizer interface {
	ArenaMember

	// AddPointer is called when a new pointer goes down.
	// If the recognizer is interested, it should add itself to the arena
	// and begin tracking the pointer. If not interested, it should return
	// false and will not receive further events for this pointer.
	AddPointer(ev *PointerEvent, arena *Arena) bool

	// HandleEvent processes a pointer event for a tracked pointer.
	// Called for PointerMove, PointerUp, and PointerCancel after AddPointer
	// returned true.
	HandleEvent(ev *PointerEvent)

	// Dispose releases resources. Called when the widget is unmounted.
	Dispose()
}

type RecognizerBase struct {
	// contains filtered or unexported fields
}

type TapAndDragConfig struct {
	// OnTapDown is called on pointer down with the current tap count.
	OnTapDown func(details TapDragDownDetails)

	// OnTapUp is called on pointer up without exceeding drag slop.
	OnTapUp func(details TapDragUpDetails)

	// OnDragStart is called when movement exceeds slop during a tap sequence.
	OnDragStart func(details TapDragStartDetails)

	// OnDragUpdate is called for each move during a tap-drag.
	OnDragUpdate func(details TapDragUpdateDetails)

	// OnDragEnd is called when the pointer is released during a drag.
	OnDragEnd func(details TapDragEndDetails)

	// OnCancel is called if the gesture is canceled.
	OnCancel func()
}

type TapAndDragRecognizer struct {
	RecognizerBase
	// contains filtered or unexported fields
}

type TapDragDownDetails struct {
	GlobalPosition      geometry.Point
	LocalPosition       geometry.Point
	ConsecutiveTapCount int // 1=single, 2=double, 3=triple
	PointerType         PointerType
	Button              event.Button
	Modifiers           event.Modifiers
}

type TapDragEndDetails struct {
	Velocity            geometry.Point
	ConsecutiveTapCount int
}

type TapDragStartDetails struct {
	GlobalPosition      geometry.Point
	LocalPosition       geometry.Point
	ConsecutiveTapCount int
	PointerType         PointerType
}

type TapDragUpDetails struct {
	GlobalPosition      geometry.Point
	LocalPosition       geometry.Point
	ConsecutiveTapCount int
}

type TapDragUpdateDetails struct {
	GlobalPosition      geometry.Point
	LocalPosition       geometry.Point
	Delta               geometry.Point
	ConsecutiveTapCount int
}

type Team struct {
	// Captain is the preferred winner when a team member would win.
	// If nil, the original winner keeps the victory.
	Captain ArenaMember
	// contains filtered or unexported fields
}

type VelocityTracker struct {
	// contains filtered or unexported fields
}