Fix Cursor Animation on widget.Entry

widget/entry.go

@@ -4,7 +4,6 @@ import (
 	"image/color"
 	"math"
 	"strings"
-	"time"
 	"unicode"
 
 	"fyne.io/fyne/v2"
@@ -57,6 +56,8 @@ type Entry struct {
 	CursorRow, CursorColumn int
 	OnCursorChanged         func() `json:"-"`
 
+	cursorAnim *entryCursorAnimation
+
 	focused     bool
 	text        *textProvider
 	placeholder *textProvider
@@ -161,7 +162,10 @@ func (e *Entry) CreateRenderer() fyne.WidgetRenderer {
 
 	box := canvas.NewRectangle(theme.InputBackgroundColor())
 	line := canvas.NewRectangle(theme.ShadowColor())
+	cursor := canvas.NewRectangle(color.Transparent)
+	cursor.Hide()
 
+	e.cursorAnim = newEntryCursorAnimation(cursor)
 	e.content = &entryContent{entry: e}
 	e.scroll = widget.NewScroll(e.content)
 	objects := []fyne.CanvasObject{box, line, e.scroll}
@@ -494,7 +498,9 @@ func (e *Entry) TypedKey(key *fyne.KeyEvent) {
 	if e.Disabled() {
 		return
 	}
-
+	if e.cursorAnim != nil {
+		e.cursorAnim.temporaryStop()
+	}
 	e.propertyLock.RLock()
 	provider := e.textProvider()
 	onSubmitted := e.OnSubmitted
@@ -1215,19 +1221,16 @@ type entryContent struct {
 func (e *entryContent) CreateRenderer() fyne.WidgetRenderer {
 	e.ExtendBaseWidget(e)
 
-	cursor := canvas.NewRectangle(color.Transparent)
-	cursor.Hide()
-
 	e.entry.propertyLock.Lock()
 	defer e.entry.propertyLock.Unlock()
 	provider := e.entry.textProvider()
 	placeholder := e.entry.placeholderProvider()
 	if provider.len() != 0 {
 		placeholder.Hide()
 	}
-	objects := []fyne.CanvasObject{placeholder, provider, cursor}
+	objects := []fyne.CanvasObject{placeholder, provider, e.entry.cursorAnim.cursor}
 
-	r := &entryContentRenderer{cursor, []fyne.CanvasObject{}, nil, objects,
+	r := &entryContentRenderer{e.entry.cursorAnim.cursor, []fyne.CanvasObject{}, objects,
 		provider, placeholder, e}
 	r.updateScrollDirections()
 	r.Layout(e.size)
@@ -1256,17 +1259,16 @@ func (e *entryContent) Dragged(d *fyne.DragEvent) {
 var _ fyne.WidgetRenderer = (*entryContentRenderer)(nil)
 
 type entryContentRenderer struct {
-	cursor     *canvas.Rectangle
-	selection  []fyne.CanvasObject
-	cursorAnim *fyne.Animation
-	objects    []fyne.CanvasObject
+	cursor    *canvas.Rectangle
+	selection []fyne.CanvasObject
+	objects   []fyne.CanvasObject
 
 	provider, placeholder *textProvider
 	content               *entryContent
 }
 
 func (r *entryContentRenderer) Destroy() {
-	r.cursorAnim.Stop()
+	r.content.entry.cursorAnim.stop()
 }
 
 func (r *entryContentRenderer) Layout(size fyne.Size) {
@@ -1316,15 +1318,9 @@ func (r *entryContentRenderer) Refresh() {
 
 	if focused {
 		r.cursor.Show()
-		if r.cursorAnim == nil {
-			r.cursorAnim = makeCursorAnimation(r.cursor)
-			r.cursorAnim.Start()
-		}
+		r.content.entry.cursorAnim.start()
 	} else {
-		if r.cursorAnim != nil {
-			r.cursorAnim.Stop()
-			r.cursorAnim = nil
-		}
+		r.content.entry.cursorAnim.stop()
 		r.cursor.Hide()
 	}
 	r.moveCursor()
@@ -1572,17 +1568,3 @@ func getTextWhitespaceRegion(row []rune, col int) (int, int) {
 	}
 	return start, end
 }
-
-func makeCursorAnimation(cursor *canvas.Rectangle) *fyne.Animation {
-	cursorOpaque := theme.PrimaryColor()
-	r, g, b, _ := theme.PrimaryColor().RGBA()
-	cursorDim := color.NRGBA{R: uint8(r), G: uint8(g), B: uint8(b), A: 0x16}
-	anim := canvas.NewColorRGBAAnimation(cursorDim, cursorOpaque, time.Second/2, func(c color.Color) {
-		cursor.FillColor = c
-		cursor.Refresh()
-	})
-	anim.RepeatCount = fyne.AnimationRepeatForever
-	anim.AutoReverse = true
-
-	return anim
-}

widget/entry_cursor_anim.go

@@ -0,0 +1,197 @@
+package widget
+
+import (
+	"image/color"
+	"sync"
+	"time"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/theme"
+)
+
+// ===============================================================
+// Cursor ticker
+// ===============================================================
+
+type cursorTicker struct {
+	tim      *time.Timer
+	rstCh    chan struct{}
+	duration time.Duration
+	mockWait func() (reset bool)
+}
+
+func (t *cursorTicker) Start() {
+	if t.Started() {
+		return
+	}
+	t.rstCh = make(chan struct{}, 1)
+	t.tim = time.NewTimer(t.duration)
+}
+
+func (t *cursorTicker) Reset() {
+	if !t.Started() {
+		return
+	}
+	select {
+	case t.rstCh <- struct{}{}:
+	default:
+	}
+}
+
+// Stop must be called in the same go routine where WaitTick is used.
+func (t *cursorTicker) Stop() {
+	if !t.Started() {
+		return
+	}
+	if !t.tim.Stop() {
+		<-t.tim.C
+	}
+	t.tim = nil // TODO is it safe?
+	t.rstCh = nil
+}
+
+func (t *cursorTicker) WaitTick() (reset bool) {
+	if !t.Started() {
+		reset = true // TODO what to do here?
+		return
+	}
+	if t.mockWait != nil {
+		return t.mockWait()
+	}
+	select {
+	case <-t.tim.C:
+		reset = false
+		t.tim.Stop()
+	case <-t.rstCh:
+		reset = true
+		if !t.tim.Stop() {
+			<-t.tim.C
+		}
+	}
+	t.tim.Reset(t.duration)
+	return
+}
+
+func (t *cursorTicker) Started() bool { return t.tim != nil }
+
+// ===============================================================
+// Implementation
+// ===============================================================
+
+const cursorInterruptTime = 300 * time.Millisecond
+
+type cursorState int
+
+const (
+	cursorStateRunning cursorState = iota
+	cursorStateInterrupted
+	cursorStateStopped
+)
+
+type entryCursorAnimation struct {
+	mu       *sync.RWMutex
+	inverted bool
+	state    cursorState
+	ticker   *cursorTicker
+	cursor   *canvas.Rectangle
+	anim     *fyne.Animation
+}
+
+func newEntryCursorAnimation(cursor *canvas.Rectangle) *entryCursorAnimation {
+	a := &entryCursorAnimation{mu: &sync.RWMutex{}, cursor: cursor}
+	a.ticker = &cursorTicker{duration: cursorInterruptTime}
+	a.inverted = false
+	a.state = cursorStateStopped
+	return a
+}
+
+func (a *entryCursorAnimation) createAnim(inverted bool) *fyne.Animation {
+	cursorOpaque := theme.PrimaryColor()
+	r, g, b, _ := theme.PrimaryColor().RGBA()
+	cursorDim := color.NRGBA{R: uint8(r), G: uint8(g), B: uint8(b), A: 0x16}
+	a.inverted = inverted
+	start, end := color.Color(cursorDim), color.Color(cursorOpaque)
+	if inverted {
+		start, end = end, start
+	}
+	anim := canvas.NewColorRGBAAnimation(start, end, time.Second/2, func(c color.Color) {
+		a.cursor.FillColor = c
+		a.cursor.Refresh()
+	})
+	anim.RepeatCount = fyne.AnimationRepeatForever
+	anim.AutoReverse = true
+	return anim
+}
+
+// Start starts cursor animation.
+func (a *entryCursorAnimation) start() {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if a.anim != nil || a.ticker.Started() || a.state != cursorStateStopped {
+		return
+	}
+	a.anim = a.createAnim(false)
+	a.state = cursorStateRunning
+	a.ticker.Start()
+	go func() {
+		defer func() {
+			a.mu.Lock()
+			a.state = cursorStateStopped
+			a.ticker.Stop()
+			a.mu.Unlock()
+		}()
+		for {
+			if reset := a.ticker.WaitTick(); reset {
+				continue
+			}
+			a.mu.RLock()
+			interrupted := a.state == cursorStateInterrupted
+			cancel := a.anim == nil
+			a.mu.RUnlock()
+			if cancel {
+				return
+			}
+			if !interrupted {
+				continue
+			}
+			a.mu.Lock()
+			if a.anim != nil {
+				a.anim.Start()
+			}
+			a.state = cursorStateRunning
+			a.mu.Unlock()
+		}
+	}()
+	a.anim.Start()
+}
+
+// TemporaryStop temporarily stops the cursor by "cursorInterruptTime".
+func (a *entryCursorAnimation) temporaryStop() {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if a.anim == nil || !a.ticker.Started() {
+		return
+	}
+	a.ticker.Reset()
+	a.anim.Stop()
+	if !a.inverted {
+		a.anim = a.createAnim(true)
+	}
+	if a.state == cursorStateInterrupted {
+		return
+	}
+	a.state = cursorStateInterrupted
+	a.cursor.FillColor = theme.PrimaryColor()
+	a.cursor.Refresh()
+}
+
+// Stop stops cursor animation.
+func (a *entryCursorAnimation) stop() {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if a.anim != nil {
+		a.anim.Stop()
+		a.anim = nil
+	}
+}