// Package app wires the selection watcher, analysis, renderer and popup
// together and decides when the card comes and goes.
package app
import (
"context"
"log"
"math"
"net/url"
"os"
"slices"
"strings"
"time"
"unicode/utf8"
"chirami/internal/analyze"
"chirami/internal/card"
"chirami/internal/dict"
"chirami/internal/jp"
"chirami/internal/platform"
)
type Config struct {
Online bool // allow jisho.org when the offline dictionary misses
Debounce time.Duration // quiet time after the selection settles
MaxRunes int // longer selections are ignored
Idle time.Duration // hide a card nobody touched, where the pointer is invisible
NoRomaji bool // leave romaji out, for once kana reads by itself
Zoom float64 // card size on 1x displays, where small text is too few pixels to read
}
var DefaultConfig = Config{Online: true, Debounce: 250 * time.Millisecond, MaxRunes: 120, Idle: 15 * time.Second, Zoom: 1.25}
// zoom is how much bigger to draw the card on a display at scale: only
// low-density displays get the configured zoom.
func (c Config) zoom(scale float64) float64 {
if scale < 1.5 && c.Zoom > 0 {
return c.Zoom
}
return 1
}
const (
tipDelay = 200 * time.Millisecond // so passing over things does not flicker
leaveGrace = 350 * time.Millisecond // so brushing past a glance card's edge does not close it
)
type Deps struct {
Analyzer *analyze.Analyzer
Dict *dict.Dict // nil without dict.bin
Renderer *card.Renderer
Speak func(string) error
Open func(string) error
Jisho func(ctx context.Context, word string) ([]dict.Entry, error)
OCR func(ctx context.Context, png []byte) (string, error) // nil: screenshots are ignored
}
type App struct {
cfg Config
Deps
OnHide func() // called whenever the card goes away
an *analyze.Analyzer
dict *dict.Dict
b platform.Backend
stack []page // the selection's view, then pages opened from it; empty when hidden
res *card.Result
anchor platform.Anchor
x, y float64 // image top-left
above bool // the card sits above the pointer and grows upwards
scale float64 // device px per logical px of the card on screen
// A glance card (not expanded) closes when the pointer leaves it, or,
// if the pointer never came, once it moves away (where the backend can
// tell) or after Config.Idle. An expanded card stays until its ×,
// Escape, or a click outside (Dismiss, where the backend sees one).
shownAt time.Time
entered bool
leaving *time.Timer
hover int // region under the pointer, -1 for none
tip bool // the hovered region's tip is showing
tipTimer *time.Timer
tick *time.Ticker
jisho chan jishoResult
jishoMemo map[string][]dict.Entry
ocr chan ocrResult
}
type ocrResult struct {
text string
err error
}
type jishoResult struct {
v *view
key string
entries []dict.Entry
err error
}
func New(cfg Config, d Deps) *App {
return &App{cfg: cfg, Deps: d, an: d.Analyzer, dict: d.Dict, hover: -1,
jisho: make(chan jishoResult, 4), jishoMemo: map[string][]dict.Entry{}, ocr: make(chan ocrResult, 1)}
}
func stopped(d time.Duration) *time.Timer {
t := time.NewTimer(d)
t.Stop()
return t
}
// Run handles selections until ctx ends. If initial is not empty it is shown
// right away, as if it had just been selected.
func (a *App) Run(ctx context.Context, b platform.Backend, initial string) error {
a.b = b
debounce := stopped(time.Hour)
a.leaving, a.tipTimer = stopped(time.Hour), stopped(time.Hour)
defer a.leaving.Stop()
defer a.tipTimer.Stop()
// the idle check only runs while a card is up, so an idle chirami sleeps
a.tick = time.NewTicker(150 * time.Millisecond)
a.tick.Stop()
defer a.tick.Stop()
selections := b.Selections()
var shots <-chan []byte
if s, ok := b.(platform.Screenshotter); ok && a.OCR != nil {
shots = s.Screenshots()
}
pending := initial
if initial != "" {
// showing one text: the live selection is not ours to follow
selections, shots = nil, nil
debounce.Reset(0)
}
for {
select {
case <-ctx.Done():
a.hide("done")
return ctx.Err()
case t := <-selections:
pending = t
debounce.Reset(a.cfg.Debounce)
case <-debounce.C:
a.selected(ctx, pending)
case <-a.leaving.C:
if !a.expanded() {
a.hide("left")
}
case png := <-shots:
go func() {
text, err := a.OCR(ctx, png)
select {
case a.ocr <- ocrResult{text, err}:
case <-ctx.Done():
}
}()
case r := <-a.ocr:
if r.err != nil {
log.Printf("ocr: %v", r.err)
break
}
debugf("ocr %q", r.text)
a.open(ctx, clip(r.text, a.cfg.MaxRunes))
case e := <-b.Events():
a.event(ctx, e)
case <-a.tipTimer.C:
a.tip = true
a.redraw()
case r := <-a.jisho:
a.jishoDone(r)
case <-a.tick.C:
a.idle()
}
}
}
func (a *App) shown() bool { return len(a.stack) > 0 }
func (a *App) top() page { return a.stack[len(a.stack)-1] }
func (a *App) selected(ctx context.Context, text string) {
debugf("selection %q", text)
a.open(ctx, text)
}
// open shows the card for text, selected or read from a screenshot.
func (a *App) open(ctx context.Context, text string) {
text = strings.TrimSpace(text)
if !jp.HasJapanese(text) || utf8.RuneCountInString(text) > a.cfg.MaxRunes {
wasShown := a.shown()
a.hide("not japanese")
if !wasShown && a.OnHide != nil {
a.OnHide() // nothing was shown, so nothing will ever hide
}
return
}
if a.shown() && a.stack[0].title() == text {
return
}
anchor, err := a.b.Locate()
if err != nil {
log.Printf("locate: %v", err)
return
}
v := a.newView(text)
a.stack = []page{v}
a.scale = anchor.Scale
a.hover, a.tip = -1, false
a.res = a.Renderer.Render(a.model(v), a.scale)
a.anchor = anchor
a.x, a.y, a.above = place(anchor, a.res, true)
a.entered, a.shownAt = false, time.Now()
a.leaving.Stop()
a.tick.Reset(150 * time.Millisecond)
a.show()
a.maybeJisho(ctx, v)
}
// clip shortens OCR text to at most n runes, at the end of a sentence when
// there is one: a whole dialogue box should not become a giant card.
func clip(text string, n int) string {
r := []rune(text)
if len(r) <= n {
return text
}
r = r[:n]
for i := len(r) - 1; i > n/3; i-- {
if strings.ContainsRune("。！？!?」", r[i]) {
return string(r[:i+1])
}
}
return string(r)
}
// place puts the card above the pointer, where it covers text already read
// rather than the line coming next, or below it when above is false or
// there is no room. The side nearest the pointer stays put as the card
// grows; when neither side has room the card is pushed back on screen,
// even over the pointer.
func place(an platform.Anchor, r *card.Result, above bool) (x, y float64, isAbove bool) {
const dx, dy, edge = 10, 14, 6
s, h := an.Screen, r.Hit
top, bottom := s.Y+edge, s.Y+s.H-edge
fitsAbove := an.Y-dy-h.H >= top
fitsBelow := an.Y+dy+6+h.H <= bottom
if above && !fitsAbove && fitsBelow || !above && !fitsBelow && fitsAbove {
above = !above
}
cy := an.Y + dy + 6 // the card's top edge
if above {
cy = an.Y - dy - h.H
}
cy = math.Max(top, math.Min(cy, bottom-h.H))
cx := an.X - 16
if cx+h.W > s.X+s.W-edge {
cx = an.X - dx - h.W
}
cx = math.Max(s.X+edge, math.Min(cx, s.X+s.W-edge-h.W))
return cx - h.X, cy - h.Y, above
}
func (a *App) show() {
err := a.b.Show(platform.Popup{Image: a.res.Image, X: a.x, Y: a.y, Hit: a.res.Hit})
if err != nil {
log.Printf("show: %v", err)
}
}
// redraw renders the current page again and places it on the same side
// of the pointer, so the edge nearest the pointer does not move.
func (a *App) redraw() {
if !a.shown() || a.res == nil {
return
}
a.res = a.Renderer.Render(a.model(a.top()), a.scale)
a.x, a.y, a.above = place(a.anchor, a.res, a.above)
a.show()
}
// expanded reports whether the card is past its glance: clicked open, or
// on a kanji page.
func (a *App) expanded() bool {
v, ok := a.top().(*view)
return !ok || v.expanded
}
func (a *App) hide(why string) {
if !a.shown() {
return
}
debugf("hide: %s", why)
a.stack, a.res = nil, nil
a.tick.Stop()
a.leaving.Stop()
a.tipTimer.Stop()
a.b.Hide()
if a.OnHide != nil {
a.OnHide()
}
}
// Render draws the card for text without a backend, for previews.
func (a *App) Render(text string, expanded bool, scale float64) *card.Result {
v := a.newView(text)
v.expanded = expanded
a.stack, a.scale = []page{v}, scale
defer func() { a.stack = nil }()
return a.Renderer.Render(a.model(v), scale)
}
func (a *App) regionAt(x, y float64) int {
if a.res == nil {
return -1
}
for i, r := range a.res.Regions {
if r.Rect.Contains(x, y) {
return i
}
}
return -1
}
func (a *App) event(ctx context.Context, e platform.Event) {
if !a.shown() {
return
}
switch e.Kind {
case platform.Motion:
a.entered = true
a.leaving.Stop()
if h := a.regionAt(e.X, e.Y); h != a.hover {
a.hover, a.tip = h, false
a.tipTimer.Stop()
if h >= 0 && a.res.Regions[h].Tip != "" {
a.tipTimer.Reset(tipDelay)
}
a.redraw()
}
case platform.Leave:
if !a.expanded() {
a.leaving.Reset(leaveGrace)
}
case platform.Dismiss:
a.hide("dismissed")
case platform.Click:
a.entered = true
a.leaving.Stop()
if i := a.regionAt(e.X, e.Y); i >= 0 {
a.click(ctx, a.res.Regions[i])
}
}
}
func (a *App) click(ctx context.Context, r card.Region) {
if r.Action == card.Close {
a.hide("closed")
return
}
switch p := a.top().(type) {
case *view:
a.clickView(ctx, p, r)
case *kanjiPage:
a.clickKanji(ctx, p, r)
}
}
func (a *App) clickView(ctx context.Context, v *view, r card.Region) {
switch r.Action {
case card.Expand:
v.expanded = true
a.redraw()
case card.SpeakAll:
a.say(v.text)
case card.SpeakEntry:
if r.Index < len(v.shown) {
e := v.shown[r.Index]
a.say(cmp(e.Reading, e.Head))
}
case card.FocusWord, card.FocusPhrase:
focus := r.Index
if r.Action == card.FocusPhrase {
focus = wholePhrase
}
if focus != v.focus {
v.focus = focus
a.lookup(v)
a.redraw()
a.maybeJisho(ctx, v)
}
case card.PickEntry:
if r.Index < len(v.entries) {
e := v.entries[r.Index]
v.entries = slices.Insert(slices.Delete(v.entries, r.Index, r.Index+1), 0, e)
a.redraw()
}
case card.OpenKanji:
if r.Index < len(v.kanji) {
a.push(a.newKanjiPage(v.kanji[r.Index]))
}
case card.OpenJisho:
q := v.text
if w, ok := v.focused(); ok {
q = cmp(w.Key, w.Surface)
}
a.openJisho(q)
}
}
func (a *App) clickKanji(ctx context.Context, k *kanjiPage, r card.Region) {
switch r.Action {
case card.Back:
a.stack = a.stack[:len(a.stack)-1]
a.hover, a.tip = -1, false
a.redraw()
case card.OpenPart:
var parts []rune
for _, p := range k.parts {
if p != k.r {
parts = append(parts, p)
}
}
if r.Index < len(parts) {
if _, ok := a.kanjiInfo(parts[r.Index]); ok {
a.push(a.newKanjiPage(parts[r.Index]))
}
}
case card.OpenSimilar:
if r.Index < len(k.similar) {
a.push(a.newKanjiPage(k.similar[r.Index]))
}
case card.OpenWord:
if r.Index < len(k.words) {
e := k.words[r.Index]
text := pickForm(e.Kanji)
for _, f := range e.Kanji {
if strings.ContainsRune(f.Text, k.r) && displayable(f) {
text = f.Text
break
}
}
v := a.newView(text)
v.expanded = true
a.push(v)
a.maybeJisho(ctx, v)
}
}
}
// push opens a page on top of the current one; its back link returns.
func (a *App) push(p page) {
a.stack = append(a.stack, p)
a.hover, a.tip = -1, false
a.tipTimer.Stop()
a.redraw()
}
func (a *App) openJisho(q string) {
if a.Open == nil {
return
}
if err := a.Open("https://jisho.org/search/" + url.PathEscape(q)); err != nil {
log.Printf("open: %v", err)
}
}
func (a *App) say(s string) {
if a.Speak == nil {
return
}
if err := a.Speak(s); err != nil {
log.Printf("speak: %v", err)
}
}
// idle hides a card the user walked away from: the pointer went far from it
// without entering, or (where the pointer cannot be seen) it sat untouched.
// idle closes a glance card the pointer never came to: once the pointer
// is well away from it where the backend can tell, else after Config.Idle.
func (a *App) idle() {
if !a.shown() || a.res == nil || a.entered || a.expanded() {
return
}
x, y, ok := a.b.Pointer()
if !ok {
if time.Since(a.shownAt) > a.cfg.Idle {
a.hide("idle")
}
return
}
h := a.res.Hit
cx := math.Max(a.x+h.X, math.Min(x, a.x+h.X+h.W))
cy := math.Max(a.y+h.Y, math.Min(y, a.y+h.Y+h.H))
if math.Hypot(x-cx, y-cy) > 180 {
a.hide("pointer went away")
}
}
func (a *App) maybeJisho(ctx context.Context, v *view) {
key, ok := a.wantsJisho(v)
if !ok || a.Jisho == nil {
return
}
if es, ok := a.jishoMemo[key]; ok {
a.applyJisho(v, es, nil)
a.redraw()
return
}
v.status = "( ˘ω˘ ) asking jisho…"
a.redraw()
go func() {
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
es, err := a.Jisho(ctx, key)
a.jisho <- jishoResult{v, key, es, err}
}()
}
func (a *App) jishoDone(r jishoResult) {
if r.err == nil {
a.jishoMemo[r.key] = r.entries
}
if w, ok := r.v.focused(); !slices.Contains(a.stack, page(r.v)) || !ok || w.Key != r.key {
return // the card moved on
}
a.applyJisho(r.v, r.entries, r.err)
if a.top() == page(r.v) {
a.redraw()
}
}
func (a *App) applyJisho(v *view, es []dict.Entry, err error) {
switch {
case err != nil:
log.Printf("jisho: %v", err)
v.status = "(｡•́︿•̀｡) couldn't reach jisho"
case len(es) == 0:
v.status = "(・・?) jisho doesn't know it either"
default:
v.entries, v.source, v.status = es, "jisho", ""
}
}
var debug = os.Getenv("CHIRAMI_DEBUG") != ""
func debugf(format string, args ...any) {
if debug {
log.Printf(format, args...)
}
}
func cmp(s, fallback string) string {
if s != "" {
return s
}
return fallback
}