kitty/tools/tui/mouse.go
Kovid Goyal 67c6d243c4
Fix animated mouse pointers restarting on every mouse move
The mouse-demo kitten popped and pushed the pointer shape on every mouse
event, and kitty applied each OSC 22 to the OS pointer immediately, so the
pointer briefly flipped to the default shape and back, restarting
animations. Only change the shape in the kitten when it actually changes,
and apply pointer shape stack changes to the OS pointer once per batch of
parsed child output.

Also have ApplyHoverStyles replace the current shape instead of pushing a
new one, so the shape stack does not grow as the mouse moves between
regions.

Fixes #10838
2026-11-10 08:49:23 +05:30

415 lines
11 KiB
Go

// License: GPLv3 Copyright: 2023, Kovid Goyal, <kovid at kovidgoyal.net>
package tui
import (
"fmt"
"strings"
"time"
"github.com/kovidgoyal/kitty"
"github.com/kovidgoyal/kitty/tools/config"
"github.com/kovidgoyal/kitty/tools/tui/loop"
"github.com/kovidgoyal/kitty/tools/utils"
)
var _ = fmt.Print
type LinePos interface {
LessThan(other LinePos) bool
Equal(other LinePos) bool
MinX() int
MaxX() int
}
type SelectionBoundary struct {
line LinePos
x int
in_first_half_of_cell bool
}
func (self *SelectionBoundary) LessThan(other *SelectionBoundary) bool {
if self.line.LessThan(other.line) {
return true
}
if !self.line.Equal(other.line) {
return false
}
if self.x == other.x {
return !self.in_first_half_of_cell && other.in_first_half_of_cell
}
return self.x < other.x
}
func (self *SelectionBoundary) Equal(other SelectionBoundary) bool {
if self.x != other.x || self.in_first_half_of_cell != other.in_first_half_of_cell {
return false
}
if self.line == nil {
return other.line == nil
}
return self.line.Equal(other.line)
}
type MouseSelection struct {
start, end SelectionBoundary
is_active bool
min_y, max_y int
cell_width, cell_height int
drag_scroll struct {
timer_id loop.IdType
pixel_gap int
mouse_event loop.MouseEvent
}
}
func (self *MouseSelection) IsEmpty() bool { return self.start.Equal(self.end) }
func (self *MouseSelection) IsActive() bool { return self.is_active }
func (self *MouseSelection) Finish() { self.is_active = false }
func (self *MouseSelection) Clear() { *self = MouseSelection{} }
func (ms *MouseSelection) StartNewSelection(ev *loop.MouseEvent, line LinePos, min_y, max_y, cell_width, cell_height int) {
*ms = MouseSelection{cell_width: cell_width, cell_height: cell_height, min_y: min_y, max_y: max_y}
ms.start.line = line
ms.start.x = max(line.MinX(), min(ev.Cell.X, line.MaxX()))
cell_start := cell_width * ev.Cell.X
ms.start.in_first_half_of_cell = ev.Pixel.X <= cell_start+cell_width/2
ms.end = ms.start
ms.is_active = true
}
// Update the end of the selection, returning true if it changed
func (ms *MouseSelection) Update(ev *loop.MouseEvent, line LinePos) (changed bool) {
ms.drag_scroll.timer_id = 0
if ms.is_active {
prev := ms.end
ms.end.x = max(line.MinX(), min(ev.Cell.X, line.MaxX()))
cell_start := ms.cell_width * ms.end.x
ms.end.in_first_half_of_cell = ev.Pixel.X <= cell_start+ms.cell_width/2
ms.end.line = line
changed = !prev.Equal(ms.end)
}
return
}
func (ms *MouseSelection) LineBounds(line_pos LinePos) (start_x, end_x int) {
if ms.IsEmpty() {
return -1, -1
}
a, b := &ms.start, &ms.end
if b.LessThan(a) {
a, b = b, a
}
adjust_end := func(x int, b *SelectionBoundary) (int, int) {
if b.in_first_half_of_cell {
if b.x > x {
return x, b.x - 1
}
return -1, -1
}
return x, b.x
}
adjust_start := func(a *SelectionBoundary, x int) (int, int) {
if a.in_first_half_of_cell {
return a.x, x
}
if x > a.x {
return a.x + 1, x
}
return -1, -1
}
adjust_both := func(a, b *SelectionBoundary) (int, int) {
if a.in_first_half_of_cell {
return adjust_end(a.x, b)
} else {
if b.in_first_half_of_cell {
s, e := a.x+1, b.x-1
if e <= s {
return -1, -1
}
return s, e
} else {
return adjust_start(a, b.x)
}
}
}
if a.line.LessThan(line_pos) {
if line_pos.LessThan(b.line) {
return line_pos.MinX(), line_pos.MaxX()
} else if b.line.Equal(line_pos) {
return adjust_end(line_pos.MinX(), b)
}
} else if a.line.Equal(line_pos) {
if line_pos.LessThan(b.line) {
return adjust_start(a, line_pos.MaxX())
} else if b.line.Equal(line_pos) {
return adjust_both(a, b)
}
}
return -1, -1
}
func FormatPartOfLine(sgr string, start_x, end_x, y int) string { // uses zero based indices
// DECCARA used to set formatting in specified region using zero based indexing
return fmt.Sprintf("\x1b[%d;%d;%d;%d;%s$r", y+1, start_x+1, y+1, end_x+1, sgr)
}
func (ms *MouseSelection) LineFormatSuffix(line_pos LinePos, sgr string, y int) string {
s, e := ms.LineBounds(line_pos)
if s > -1 {
return FormatPartOfLine(sgr, s, e, y)
}
return ""
}
func (ms *MouseSelection) StartLine() LinePos {
return ms.start.line
}
func (ms *MouseSelection) EndLine() LinePos {
return ms.end.line
}
func (ms *MouseSelection) OutOfVerticalBounds(ev *loop.MouseEvent) bool {
return ev.Pixel.Y < ms.min_y*ms.cell_height || ev.Pixel.Y > (ms.max_y+1)*ms.cell_height
}
func (ms *MouseSelection) DragScrollTick(timer_id loop.IdType, lp *loop.Loop, callback loop.TimerCallback, do_scroll func(int, *loop.MouseEvent) error) error {
if !ms.is_active || ms.drag_scroll.timer_id != timer_id || ms.drag_scroll.pixel_gap == 0 {
return nil
}
amt := 1
if ms.drag_scroll.pixel_gap < 0 {
amt *= -1
}
err := do_scroll(amt, &ms.drag_scroll.mouse_event)
if err == nil {
ms.drag_scroll.timer_id, _ = lp.AddTimer(50*time.Millisecond, false, callback)
}
return err
}
func (ms *MouseSelection) DragScroll(ev *loop.MouseEvent, lp *loop.Loop, callback loop.TimerCallback) {
if !ms.is_active {
return
}
upper := ms.min_y * ms.cell_height
lower := (ms.max_y + 1) * ms.cell_height
if ev.Pixel.Y < upper {
ms.drag_scroll.pixel_gap = ev.Pixel.Y - upper
} else if ev.Pixel.Y > lower {
ms.drag_scroll.pixel_gap = ev.Pixel.Y - lower
}
if ms.drag_scroll.timer_id == 0 && ms.drag_scroll.pixel_gap != 0 {
ms.drag_scroll.timer_id, _ = lp.AddTimer(50*time.Millisecond, false, callback)
}
ms.drag_scroll.mouse_event = *ev
}
type Point struct {
X, Y int
}
func (p Point) Sub(other Point) Point {
return Point{X: p.X - other.X, Y: p.Y - other.Y}
}
type CellRegion struct {
TopLeft, BottomRight Point
Id string
OnClick []func(id string) error // simple left click ignoring modifiers
OnClickEvent func(id string, ev *loop.MouseEvent, cell_offset Point) error // any click event
PointerShape loop.PointerShape
HoverStyle string // set to "default" for the global hover style
}
func (c CellRegion) Contains(x, y int) bool { // 0-based
if c.TopLeft.Y > y || c.BottomRight.Y < y {
return false
}
return (y > c.TopLeft.Y || (y == c.TopLeft.Y && x >= c.TopLeft.X)) && (y < c.BottomRight.Y || (y == c.BottomRight.Y && x <= c.BottomRight.X))
}
type MouseState struct {
Cell, Pixel Point
Pressed struct{ Left, Right, Middle, Fourth, Fifth, Sixth, Seventh bool }
regions []*CellRegion
region_id_map map[string][]*CellRegion
region_line_map map[int][]*CellRegion
hovered_ids *utils.Set[string]
default_url_style struct {
value string
loaded bool
}
}
func (m *MouseState) add_region(cr CellRegion) *CellRegion {
m.regions = append(m.regions, &cr)
if m.region_id_map == nil {
m.region_id_map = make(map[string][]*CellRegion)
m.region_line_map = make(map[int][]*CellRegion)
}
m.region_id_map[cr.Id] = append(m.region_id_map[cr.Id], &cr)
for y := cr.TopLeft.Y; y <= cr.BottomRight.Y; y++ {
m.region_line_map[y] = append(m.region_line_map[y], &cr)
}
return &cr
}
func (m *MouseState) AddCellRegion(id string, start_x, start_y, end_x, end_y int, on_click ...func(id string) error) *CellRegion {
return m.add_region(CellRegion{
TopLeft: Point{start_x, start_y}, BottomRight: Point{end_x, end_y}, Id: id, OnClick: on_click, PointerShape: loop.POINTER_POINTER, HoverStyle: "default"})
}
func (m *MouseState) ClearCellRegions() {
m.regions = nil
m.region_id_map = nil
m.hovered_ids = nil
m.region_line_map = nil
}
func (m *MouseState) UpdateHoveredIds() (changed bool) {
h := utils.NewSet[string]()
for _, r := range m.region_line_map[m.Cell.Y] {
if r.Contains(m.Cell.X, m.Cell.Y) {
h.Add(r.Id)
}
}
changed = !h.Equal(m.hovered_ids)
m.hovered_ids = h
return
}
func (m *MouseState) ApplyHoverStyles(lp *loop.Loop, style ...string) {
if m.hovered_ids == nil || m.hovered_ids.Len() == 0 {
lp.ClearPointerShapes()
return
}
hs := ""
if len(style) == 0 {
if !m.default_url_style.loaded {
m.default_url_style.loaded = true
color, style := kitty.DefaultUrlColor, kitty.DefaultUrlStyle
line_handler := func(key, val string) error {
switch key {
case "url_color":
color = val
case "url_style":
style = val
}
return nil
}
config.ReadKittyConfig(line_handler)
if style != "none" && style != "" {
m.default_url_style.value = fmt.Sprintf("u=%s uc=%s", style, color)
}
}
hs = m.default_url_style.value
} else {
hs = style[0]
}
is_hovered := false
ps := loop.DEFAULT_POINTER
for id := range m.hovered_ids.Iterable() {
for _, r := range m.region_id_map[id] {
if r.HoverStyle != "" {
s := strings.Replace(r.HoverStyle, "default", hs, 1)
lp.StyleRegion(s, r.TopLeft.X, r.TopLeft.Y, r.BottomRight.X, r.BottomRight.Y)
}
is_hovered = true
ps = r.PointerShape
}
}
if is_hovered {
// Replace rather than push so the shape stack does not grow as the
// mouse moves between regions with different pointer shapes.
if s, has := lp.CurrentPointerShape(); !has || s != ps {
lp.PopPointerShape()
lp.PushPointerShape(ps)
}
} else {
lp.ClearPointerShapes()
}
}
func (m *MouseState) DispatchEventToHoveredRegions(ev *loop.MouseEvent) error {
if ev.Event_type != loop.MOUSE_CLICK {
return nil
}
is_simple_click := ev.Buttons&loop.LEFT_MOUSE_BUTTON != 0
seen := utils.NewSet[string]()
for id := range m.hovered_ids.Iterable() {
for _, r := range m.region_id_map[id] {
if seen.Has(r.Id) {
continue
}
seen.Add(r.Id)
if is_simple_click {
for _, f := range r.OnClick {
if err := f(r.Id); err != nil {
return err
}
}
}
if r.OnClickEvent != nil {
if err := r.OnClickEvent(r.Id, ev, m.Cell.Sub(r.TopLeft)); err != nil {
return err
}
}
}
}
return nil
}
func (m *MouseState) ClickHoveredRegions() error {
seen := utils.NewSet[string]()
for id := range m.hovered_ids.Iterable() {
for _, r := range m.region_id_map[id] {
if seen.Has(r.Id) {
continue
}
seen.Add(r.Id)
for _, f := range r.OnClick {
if err := f(r.Id); err != nil {
return err
}
}
}
}
return nil
}
func (m *MouseState) UpdateState(ev *loop.MouseEvent) (hovered_ids_changed bool) {
m.Cell = ev.Cell
m.Pixel = ev.Pixel
if ev.Event_type == loop.MOUSE_PRESS || ev.Event_type == loop.MOUSE_RELEASE {
pressed := ev.Event_type == loop.MOUSE_PRESS
if ev.Buttons&loop.LEFT_MOUSE_BUTTON != 0 {
m.Pressed.Left = pressed
}
if ev.Buttons&loop.RIGHT_MOUSE_BUTTON != 0 {
m.Pressed.Right = pressed
}
if ev.Buttons&loop.MIDDLE_MOUSE_BUTTON != 0 {
m.Pressed.Middle = pressed
}
if ev.Buttons&loop.FOURTH_MOUSE_BUTTON != 0 {
m.Pressed.Fourth = pressed
}
if ev.Buttons&loop.FIFTH_MOUSE_BUTTON != 0 {
m.Pressed.Fifth = pressed
}
if ev.Buttons&loop.SIXTH_MOUSE_BUTTON != 0 {
m.Pressed.Sixth = pressed
}
if ev.Buttons&loop.SEVENTH_MOUSE_BUTTON != 0 {
m.Pressed.Seventh = pressed
}
}
return m.UpdateHoveredIds()
}