detached 893bcd8

#1 feat(typing): read-aloud pace with a new tempo per phrase

state
merged · 893bcd8 · fast-forward
branch
feat/reading-pace → main
opened
bnema ·
updated

Natural typing now follows how a sentence is read aloud: the words of a phrase and the spaces between them come in one steady flow (4-9 ms per key), and random pauses fall only after punctuation.

  • After , ; : -> 140-280 ms
  • After . ! ? … -> 260-480 ms
  • No more pause on spaces, no more hesitation before long words.
  • Still capped by typing.max-duration (1.5 s by default): letters speed up first, then the punctuation pauses shrink; never below type-delay.

Checks: make check (build, vet, tests, fakes-check, staticcheck) passes. Wrap-up review done; its two findings (README comment, test coverage for every punctuation mark) are fixed in afcf4f8.

No tag planned for now.

3 files · +70 -68
7/7
M README.md +1 -1
@@ -48,7 +48,7 @@ language = fr # empty: auto-detect
4848 output = type # or clipboard
4949 max-duration = 5m
5050 timeout = 60s
51-typing = natural # word by word, random pauses at spaces and punctuation; or instant
51+typing = natural # phrases flow, random pauses only after , ; : . ! ? …; or instant
5252 typing.max-duration = 1.5s # natural typing never takes longer (unless type-delay forces it)
5353 type-delay = 2ms # pause between keys; the shortest one when natural
5454 trailing-space = true # space after each dictation, so two in a row don't stick
@@ -48,7 +48,7 @@ language = fr # empty: auto-detect
48 output = type # or clipboard48 output = type # or clipboard
49 max-duration = 5m49 max-duration = 5m
50 timeout = 60s50 timeout = 60s
51-typing = natural # word by word, random pauses at spaces and punctuation; or instant51+typing = natural # phrases flow, random pauses only after , ; : . ! ? …; or instant
52 typing.max-duration = 1.5s # natural typing never takes longer (unless type-delay forces it)52 typing.max-duration = 1.5s # natural typing never takes longer (unless type-delay forces it)
53 type-delay = 2ms # pause between keys; the shortest one when natural53 type-delay = 2ms # pause between keys; the shortest one when natural
54 trailing-space = true # space after each dictation, so two in a row don't stick54 trailing-space = true # space after each dictation, so two in a row don't stick
M internal/adapters/sink/vkbd/pace.go +32 -52
@@ -3,47 +3,40 @@ package vkbd
33 import (
44 "math/rand/v2"
55 "time"
6- "unicode"
76 )
87
9-// Natural typing goes word by word: the letters of a word come quickly and
10-// steadily, the pauses fall between words and grow at punctuation. Every
11-// pause is drawn at random, so no two dictations type the same way.
8+// Natural typing follows how a sentence is read aloud: the words of a
9+// phrase come in one steady flow, spaces included, and the pauses fall only
10+// at punctuation. Each phrase gets its own tempo, drawn again after every
11+// punctuation mark, and every pause is drawn on its own, so no two phrases
12+// and no two dictations type the same way.
1213 const (
13- letterMin = 4 * time.Millisecond // inside a word
14- letterMax = 9 * time.Millisecond
15- wordMin = 30 * time.Millisecond // after a space
16- wordMax = 110 * time.Millisecond
17- commaMin = 140 * time.Millisecond // after , ; :
18- commaMax = 280 * time.Millisecond
19- sentenceMin = 260 * time.Millisecond // after . ! ? …
20- sentenceMax = 480 * time.Millisecond
21- hesitOdds = 0.08 // chance to hesitate before a long word
22- hesitMin = 90 * time.Millisecond
23- hesitMax = 220 * time.Millisecond
24- longWordRune = 8
14+ letterMin = 4 * time.Millisecond // letters and spaces, at tempo 1
15+ letterMax = 9 * time.Millisecond
16+ tempoMin = 0.6 // phrase speed factor: below 1 is faster
17+ tempoMax = 1.7
18+ commaMin = 140 * time.Millisecond // after , ; :
19+ commaMax = 280 * time.Millisecond
20+ sentenceMin = 260 * time.Millisecond // after . ! ? …
21+ sentenceMax = 480 * time.Millisecond
2522 )
2623
2724 // natural returns the pause after each rune of text. No pause goes below
28-// floor. When the total exceeds limit (0: no limit), letters speed up
29-// first, then the pauses between words shrink, so the rhythm survives.
25+// floor. When the total exceeds limit (0: no limit), everything speeds up in
26+// the same proportion, so the rhythm survives.
3027 func natural(text []rune, floor, limit time.Duration, rnd *rand.Rand) []time.Duration {
3128 letters := make([]time.Duration, len(text))
3229 pauses := make([]time.Duration, len(text))
33- // The pause after a word's last letter comes from the punctuation or
34- // space that follows: pauses belong to the rune they follow.
30+ tempo := newTempo(rnd)
3531 for i, r := range text {
36- letters[i] = between(rnd, letterMin, letterMax)
37- switch {
38- case r == ',' || r == ';' || r == ':':
32+ letters[i] = time.Duration(float64(between(rnd, letterMin, letterMax)) * tempo)
33+ switch r {
34+ case ',', ';', ':':
3935 pauses[i] = between(rnd, commaMin, commaMax)
40- case r == '.' || r == '!' || r == '?' || r == '…':
36+ tempo = newTempo(rnd) // the next phrase
37+ case '.', '!', '?', '…':
4138 pauses[i] = between(rnd, sentenceMin, sentenceMax)
42- case unicode.IsSpace(r) && !afterPunct(text, i):
43- pauses[i] = between(rnd, wordMin, wordMax)
44- if wordLen(text, i+1) >= longWordRune && rnd.Float64() < hesitOdds {
45- pauses[i] += between(rnd, hesitMin, hesitMax)
46- }
39+ tempo = newTempo(rnd)
4740 }
4841 }
4942 // Each key waits floor + letter + pause; letters and pauses only
@@ -53,10 +46,14 @@ func natural(text []rune, floor, limit time.Duration, rnd *rand.Rand) []time.Dur
5346 letters[i] = max(letters[i]-floor, 0)
5447 }
5548 if limit > 0 {
49+ // Letters and pauses shrink together, so the tempo of each phrase
50+ // and the length of each pause keep their proportions.
5651 room := limit - time.Duration(n)*floor
57- // Letters give way first, then the pauses, so the rhythm survives.
58- fit(letters[:n], room-sum(pauses[:n]))
59- fit(pauses[:n], room-sum(letters[:n]))
52+ if total := sum(letters[:n]) + sum(pauses[:n]); total > room {
53+ s := float64(max(room, 0)) / float64(total)
54+ scale(letters[:n], s)
55+ scale(pauses[:n], s)
56+ }
6057 }
6158 out := make([]time.Duration, len(text))
6259 for i := range n {
@@ -65,13 +62,7 @@ func natural(text []rune, floor, limit time.Duration, rnd *rand.Rand) []time.Dur
6562 return out
6663 }
6764
68-// fit scales ds down so they add up to at most room.
69-func fit(ds []time.Duration, room time.Duration) {
70- total := sum(ds)
71- if total <= room || total == 0 {
72- return
73- }
74- s := float64(max(room, 0)) / float64(total)
65+func scale(ds []time.Duration, s float64) {
7566 for i := range ds {
7667 ds[i] = time.Duration(float64(ds[i]) * s)
7768 }
@@ -84,19 +75,8 @@ func sum(ds []time.Duration) (t time.Duration) {
8475 return t
8576 }
8677
87-// afterPunct reports whether the space at i follows punctuation, which
88-// already paused.
89-func afterPunct(text []rune, i int) bool {
90- return i > 0 && unicode.IsPunct(text[i-1])
91-}
92-
93-// wordLen is the length of the word starting at i.
94-func wordLen(text []rune, i int) int {
95- n := 0
96- for ; i < len(text) && !unicode.IsSpace(text[i]); i++ {
97- n++
98- }
99- return n
78+func newTempo(rnd *rand.Rand) float64 {
79+ return tempoMin + rnd.Float64()*(tempoMax-tempoMin)
10080 }
10181
10282 func between(rnd *rand.Rand, lo, hi time.Duration) time.Duration {
@@ -3,47 +3,40 @@ package vkbd
3 import (3 import (
4 "math/rand/v2"4 "math/rand/v2"
5 "time"5 "time"
6- "unicode"
7 )6 )
8 7
9-// Natural typing goes word by word: the letters of a word come quickly and8+// Natural typing follows how a sentence is read aloud: the words of a
10-// steadily, the pauses fall between words and grow at punctuation. Every9+// phrase come in one steady flow, spaces included, and the pauses fall only
11-// pause is drawn at random, so no two dictations type the same way.10+// at punctuation. Each phrase gets its own tempo, drawn again after every
11+// punctuation mark, and every pause is drawn on its own, so no two phrases
12+// and no two dictations type the same way.
12 const (13 const (
13- letterMin = 4 * time.Millisecond // inside a word14+ letterMin = 4 * time.Millisecond // letters and spaces, at tempo 1
14- letterMax = 9 * time.Millisecond15+ letterMax = 9 * time.Millisecond
15- wordMin = 30 * time.Millisecond // after a space16+ tempoMin = 0.6 // phrase speed factor: below 1 is faster
16- wordMax = 110 * time.Millisecond17+ tempoMax = 1.7
17- commaMin = 140 * time.Millisecond // after , ; :18+ commaMin = 140 * time.Millisecond // after , ; :
18- commaMax = 280 * time.Millisecond19+ commaMax = 280 * time.Millisecond
19- sentenceMin = 260 * time.Millisecond // after . ! ? …20+ sentenceMin = 260 * time.Millisecond // after . ! ? …
20- sentenceMax = 480 * time.Millisecond21+ sentenceMax = 480 * time.Millisecond
21- hesitOdds = 0.08 // chance to hesitate before a long word
22- hesitMin = 90 * time.Millisecond
23- hesitMax = 220 * time.Millisecond
24- longWordRune = 8
25 )22 )
26 23
27 // natural returns the pause after each rune of text. No pause goes below24 // natural returns the pause after each rune of text. No pause goes below
28-// floor. When the total exceeds limit (0: no limit), letters speed up25+// floor. When the total exceeds limit (0: no limit), everything speeds up in
29-// first, then the pauses between words shrink, so the rhythm survives.26+// the same proportion, so the rhythm survives.
30 func natural(text []rune, floor, limit time.Duration, rnd *rand.Rand) []time.Duration {27 func natural(text []rune, floor, limit time.Duration, rnd *rand.Rand) []time.Duration {
31 letters := make([]time.Duration, len(text))28 letters := make([]time.Duration, len(text))
32 pauses := make([]time.Duration, len(text))29 pauses := make([]time.Duration, len(text))
33- // The pause after a word's last letter comes from the punctuation or30+ tempo := newTempo(rnd)
34- // space that follows: pauses belong to the rune they follow.
35 for i, r := range text {31 for i, r := range text {
36- letters[i] = between(rnd, letterMin, letterMax)32+ letters[i] = time.Duration(float64(between(rnd, letterMin, letterMax)) * tempo)
37- switch {33+ switch r {
38- case r == ',' || r == ';' || r == ':':34+ case ',', ';', ':':
39 pauses[i] = between(rnd, commaMin, commaMax)35 pauses[i] = between(rnd, commaMin, commaMax)
40- case r == '.' || r == '!' || r == '?' || r == '…':36+ tempo = newTempo(rnd) // the next phrase
37+ case '.', '!', '?', '…':
41 pauses[i] = between(rnd, sentenceMin, sentenceMax)38 pauses[i] = between(rnd, sentenceMin, sentenceMax)
42- case unicode.IsSpace(r) && !afterPunct(text, i):39+ tempo = newTempo(rnd)
43- pauses[i] = between(rnd, wordMin, wordMax)
44- if wordLen(text, i+1) >= longWordRune && rnd.Float64() < hesitOdds {
45- pauses[i] += between(rnd, hesitMin, hesitMax)
46- }
47 }40 }
48 }41 }
49 // Each key waits floor + letter + pause; letters and pauses only42 // Each key waits floor + letter + pause; letters and pauses only
@@ -53,10 +46,14 @@ func natural(text []rune, floor, limit time.Duration, rnd *rand.Rand) []time.Dur
53 letters[i] = max(letters[i]-floor, 0)46 letters[i] = max(letters[i]-floor, 0)
54 }47 }
55 if limit > 0 {48 if limit > 0 {
49+ // Letters and pauses shrink together, so the tempo of each phrase
50+ // and the length of each pause keep their proportions.
56 room := limit - time.Duration(n)*floor51 room := limit - time.Duration(n)*floor
57- // Letters give way first, then the pauses, so the rhythm survives.52+ if total := sum(letters[:n]) + sum(pauses[:n]); total > room {
58- fit(letters[:n], room-sum(pauses[:n]))53+ s := float64(max(room, 0)) / float64(total)
59- fit(pauses[:n], room-sum(letters[:n]))54+ scale(letters[:n], s)
55+ scale(pauses[:n], s)
56+ }
60 }57 }
61 out := make([]time.Duration, len(text))58 out := make([]time.Duration, len(text))
62 for i := range n {59 for i := range n {
@@ -65,13 +62,7 @@ func natural(text []rune, floor, limit time.Duration, rnd *rand.Rand) []time.Dur
65 return out62 return out
66 }63 }
67 64
68-// fit scales ds down so they add up to at most room.65+func scale(ds []time.Duration, s float64) {
69-func fit(ds []time.Duration, room time.Duration) {
70- total := sum(ds)
71- if total <= room || total == 0 {
72- return
73- }
74- s := float64(max(room, 0)) / float64(total)
75 for i := range ds {66 for i := range ds {
76 ds[i] = time.Duration(float64(ds[i]) * s)67 ds[i] = time.Duration(float64(ds[i]) * s)
77 }68 }
@@ -84,19 +75,8 @@ func sum(ds []time.Duration) (t time.Duration) {
84 return t75 return t
85 }76 }
86 77
87-// afterPunct reports whether the space at i follows punctuation, which78+func newTempo(rnd *rand.Rand) float64 {
88-// already paused.79+ return tempoMin + rnd.Float64()*(tempoMax-tempoMin)
89-func afterPunct(text []rune, i int) bool {
90- return i > 0 && unicode.IsPunct(text[i-1])
91-}
92-
93-// wordLen is the length of the word starting at i.
94-func wordLen(text []rune, i int) int {
95- n := 0
96- for ; i < len(text) && !unicode.IsSpace(text[i]); i++ {
97- n++
98- }
99- return n
100 }80 }
101 81
102 func between(rnd *rand.Rand, lo, hi time.Duration) time.Duration {82 func between(rnd *rand.Rand, lo, hi time.Duration) time.Duration {
M internal/adapters/sink/vkbd/pace_test.go +37 -15
@@ -11,36 +11,32 @@ import (
1111
1212 func seeded(a uint64) *rand.Rand { return rand.New(rand.NewPCG(a, a)) }
1313
14-func TestNaturalPausesBetweenWordsNotLetters(t *testing.T) {
15- text := []rune("Salut toi, ça va. Oui")
14+func TestNaturalPausesOnlyAtPunctuation(t *testing.T) {
15+ text := []rune("Salut toi, ça va; bien: oui. Vrai! Non? Bon… Oui")
1616 ds := natural(text, 0, 0, seeded(1))
1717 for i, r := range text[:len(text)-1] {
1818 switch r {
19- case ' ':
20- if text[i-1] == ',' || text[i-1] == '.' {
21- assert.Less(t, ds[i], wordMin, "no second pause after punctuation")
22- } else {
23- assert.GreaterOrEqual(t, ds[i], wordMin)
24- }
25- case ',':
19+ case ',', ';', ':':
2620 assert.GreaterOrEqual(t, ds[i], commaMin)
27- case '.':
21+ case '.', '!', '?', '…':
2822 assert.GreaterOrEqual(t, ds[i], sentenceMin)
2923 default:
30- assert.LessOrEqual(t, ds[i], letterMax, "letter %q", r)
24+ assert.LessOrEqual(t, ds[i], time.Duration(float64(letterMax)*tempoMax), "no pause after %q", r) // spaces included
3125 }
3226 }
3327 assert.Zero(t, ds[len(ds)-1])
3428 }
3529
36-func TestNaturalFitsLimitLettersFirst(t *testing.T) {
30+func TestNaturalFitsLimitKeepingRhythm(t *testing.T) {
3731 text := []rune(strings.Repeat("Bonjour, ceci est un test. ", 4))
3832 free := natural(text, 2*time.Millisecond, 0, seeded(2))
39- limit := sum(free) * 3 / 4
33+ limit := sum(free) / 2
4034 ds := natural(text, 2*time.Millisecond, limit, seeded(2))
4135 assert.LessOrEqual(t, sum(ds), limit+time.Millisecond)
42- assert.Equal(t, 2*time.Millisecond, ds[1], "letters gave way first")
43- assert.GreaterOrEqual(t, ds[7], commaMin/2, "pauses mostly kept")
36+ // Same draws, same proportions above the floor: a letter and a pause
37+ // shrink by the same factor.
38+ ratio := func(d []time.Duration, i int) float64 { return float64(d[i] - 2*time.Millisecond) }
39+ assert.InDelta(t, ratio(free, 7)/ratio(free, 1), ratio(ds, 7)/ratio(ds, 1), 0.2)
4440 }
4541
4642 func TestNaturalFloorWins(t *testing.T) {
@@ -55,3 +51,29 @@ func TestNaturalIsRandom(t *testing.T) {
5551 text := []rune("une phrase, assez longue pour varier.")
5652 assert.NotEqual(t, natural(text, 0, 0, seeded(1)), natural(text, 0, 0, seeded(2)))
5753 }
54+
55+func TestNaturalTempoChangesPerPhrase(t *testing.T) {
56+ phrase := strings.Repeat("mot ", 20)
57+ text := []rune(strings.Repeat(phrase+". ", 6))
58+ ds := natural(text, 0, 0, seeded(5))
59+ // Mean letter delay of each phrase: they must not all match.
60+ var means []time.Duration
61+ var total time.Duration
62+ n := 0
63+ for i, r := range text[:len(text)-1] {
64+ switch r {
65+ case '.':
66+ means = append(means, total/time.Duration(n))
67+ total, n = 0, 0
68+ default:
69+ total += ds[i]
70+ n++
71+ }
72+ }
73+ assert.Len(t, means, 6)
74+ slowest, fastest := means[0], means[0]
75+ for _, m := range means {
76+ slowest, fastest = max(slowest, m), min(fastest, m)
77+ }
78+ assert.Greater(t, float64(slowest), 1.3*float64(fastest), "phrases share one tempo: %v", means)
79+}
@@ -11,36 +11,32 @@ import (
11 11
12 func seeded(a uint64) *rand.Rand { return rand.New(rand.NewPCG(a, a)) }12 func seeded(a uint64) *rand.Rand { return rand.New(rand.NewPCG(a, a)) }
13 13
14-func TestNaturalPausesBetweenWordsNotLetters(t *testing.T) {14+func TestNaturalPausesOnlyAtPunctuation(t *testing.T) {
15- text := []rune("Salut toi, ça va. Oui")15+ text := []rune("Salut toi, ça va; bien: oui. Vrai! Non? Bon… Oui")
16 ds := natural(text, 0, 0, seeded(1))16 ds := natural(text, 0, 0, seeded(1))
17 for i, r := range text[:len(text)-1] {17 for i, r := range text[:len(text)-1] {
18 switch r {18 switch r {
19- case ' ':19+ case ',', ';', ':':
20- if text[i-1] == ',' || text[i-1] == '.' {
21- assert.Less(t, ds[i], wordMin, "no second pause after punctuation")
22- } else {
23- assert.GreaterOrEqual(t, ds[i], wordMin)
24- }
25- case ',':
26 assert.GreaterOrEqual(t, ds[i], commaMin)20 assert.GreaterOrEqual(t, ds[i], commaMin)
27- case '.':21+ case '.', '!', '?', '…':
28 assert.GreaterOrEqual(t, ds[i], sentenceMin)22 assert.GreaterOrEqual(t, ds[i], sentenceMin)
29 default:23 default:
30- assert.LessOrEqual(t, ds[i], letterMax, "letter %q", r)24+ assert.LessOrEqual(t, ds[i], time.Duration(float64(letterMax)*tempoMax), "no pause after %q", r) // spaces included
31 }25 }
32 }26 }
33 assert.Zero(t, ds[len(ds)-1])27 assert.Zero(t, ds[len(ds)-1])
34 }28 }
35 29
36-func TestNaturalFitsLimitLettersFirst(t *testing.T) {30+func TestNaturalFitsLimitKeepingRhythm(t *testing.T) {
37 text := []rune(strings.Repeat("Bonjour, ceci est un test. ", 4))31 text := []rune(strings.Repeat("Bonjour, ceci est un test. ", 4))
38 free := natural(text, 2*time.Millisecond, 0, seeded(2))32 free := natural(text, 2*time.Millisecond, 0, seeded(2))
39- limit := sum(free) * 3 / 433+ limit := sum(free) / 2
40 ds := natural(text, 2*time.Millisecond, limit, seeded(2))34 ds := natural(text, 2*time.Millisecond, limit, seeded(2))
41 assert.LessOrEqual(t, sum(ds), limit+time.Millisecond)35 assert.LessOrEqual(t, sum(ds), limit+time.Millisecond)
42- assert.Equal(t, 2*time.Millisecond, ds[1], "letters gave way first")36+ // Same draws, same proportions above the floor: a letter and a pause
43- assert.GreaterOrEqual(t, ds[7], commaMin/2, "pauses mostly kept")37+ // shrink by the same factor.
38+ ratio := func(d []time.Duration, i int) float64 { return float64(d[i] - 2*time.Millisecond) }
39+ assert.InDelta(t, ratio(free, 7)/ratio(free, 1), ratio(ds, 7)/ratio(ds, 1), 0.2)
44 }40 }
45 41
46 func TestNaturalFloorWins(t *testing.T) {42 func TestNaturalFloorWins(t *testing.T) {
@@ -55,3 +51,29 @@ func TestNaturalIsRandom(t *testing.T) {
55 text := []rune("une phrase, assez longue pour varier.")51 text := []rune("une phrase, assez longue pour varier.")
56 assert.NotEqual(t, natural(text, 0, 0, seeded(1)), natural(text, 0, 0, seeded(2)))52 assert.NotEqual(t, natural(text, 0, 0, seeded(1)), natural(text, 0, 0, seeded(2)))
57 }53 }
54+
55+func TestNaturalTempoChangesPerPhrase(t *testing.T) {
56+ phrase := strings.Repeat("mot ", 20)
57+ text := []rune(strings.Repeat(phrase+". ", 6))
58+ ds := natural(text, 0, 0, seeded(5))
59+ // Mean letter delay of each phrase: they must not all match.
60+ var means []time.Duration
61+ var total time.Duration
62+ n := 0
63+ for i, r := range text[:len(text)-1] {
64+ switch r {
65+ case '.':
66+ means = append(means, total/time.Duration(n))
67+ total, n = 0, 0
68+ default:
69+ total += ds[i]
70+ n++
71+ }
72+ }
73+ assert.Len(t, means, 6)
74+ slowest, fastest := means[0], means[0]
75+ for _, m := range means {
76+ slowest, fastest = max(slowest, m), min(fastest, m)
77+ }
78+ assert.Greater(t, float64(slowest), 1.3*float64(fastest), "phrases share one tempo: %v", means)
79+}

Comments00 unresolved

    no comments yet.

    Keyboard shortcuts

    Single-key shortcuts are on. ctrl k and esc work whatever this says.

    ctrl k :
    go to a section, branch, tag, file or repository
    ?
    this list
    j k
    move the row cursor down / up
    enter
    open the row under the cursor; on Files, a directory opens or closes in place
    ↑ ↓ ← → home end
    in the file tree (focus on a row): previous / next row, close / open a directory or go to its parent / first entry, first / last row. They never open a file
    l h
    on Files: open a directory or a file / close a directory or go up to its parent, then to the parent page. On pages with a side panel: into the panel (on a merge request, its files) / back to the content; there j k move between its controls
    g g G
    first / last row
    /
    filter the list; on Files, find a file anywhere in the repository (esc clears, enter opens the best match)
    b
    switch branch or tag
    g s g f g c g b g m g i g r g a
    tabs: summary, files, commits, branches & tags, merge requests, issues, releases, actions (when available)
    g h
    home
    w
    wide mode: use the whole width of the screen, or not (remembered)
    y
    copy a permalink pinned to the commit; in a file, click a line number to select it, shift-click for a range
    d u x
    diff: split / unified / collapse or expand all
    e E
    diff: the whole file in view / every file, with the lines the hunks hide
    n
    merge request: next note in the diff
    l
    merge request: the list of files (j k move, enter opens, esc back)
    M
    merge request: the merge menu; there 1–3 pick the mode, D deletes the branch, enter merges
    R
    merge request: mark the head read
    esc
    close a dialog, leave a field

    Branches 1

    Tags 1

    ↑↓ moveenter openesc close