bx
/
catgirl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Implement new line editing "library" 

Losing tab complete and text macros, for now.

This new implementation works on an instance of a struct and does
not interact with the rest of catgirl, making it possible to copy
into another project. Unlike existing line editing libraries, this
one is entirely abstract and can be rendered externally.

My goal with this library is to be able to implement vi mode. Since
it operates on struct instances rather than globals, it might also
be possible to give catgirl separate line editing buffers for each
window, which would be a nice UX improvement.
weechat-hashes
June McEnroe 2022-02-18 23:46:06 -05:00
parent 573bc855a6
commit 1a2477ef7a
6 changed files with 374 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -32,7 +32,7 @@ all: catgirl
catgirl: ${OBJS} catgirl: ${OBJS}
${CC} ${LDFLAGS} ${OBJS} ${LDLIBS} -o $@ ${CC} ${LDFLAGS} ${OBJS} ${LDLIBS} -o $@
${OBJS}: chat.h ${OBJS}: chat.h edit.h
tags: *.[ch] tags: *.[ch]
ctags -w *.[ch] ctags -w *.[ch]

1
chat.c
View File

@ -371,7 +371,6 @@ int main(int argc, char *argv[]) {
set(&network.name, host); set(&network.name, host);
set(&self.nick, "*"); set(&self.nick, "*");
editCompleteAdd();
commandCompleteAdd(); commandCompleteAdd();
ircConfig(insecure, trust, cert, priv); ircConfig(insecure, trust, cert, priv);

25
chat.h
View File

@ -341,31 +341,6 @@ int bufferReflow(
struct Buffer *buffer, int cols, enum Heat thresh, size_t tail struct Buffer *buffer, int cols, enum Heat thresh, size_t tail
); );
enum Edit {
EditHead,
EditTail,
EditPrev,
EditNext,
EditPrevWord,
EditNextWord,
EditDeleteHead,
EditDeleteTail,
EditDeletePrev,
EditDeleteNext,
EditDeletePrevWord,
EditDeleteNextWord,
EditPaste,
EditTranspose,
EditCollapse,
EditInsert,
EditComplete,
EditExpand,
EditEnter,
};
void edit(uint id, enum Edit op, wchar_t ch);
char *editBuffer(size_t *pos);
void editCompleteAdd(void);
const char *complete(uint id, const char *prefix); const char *complete(uint id, const char *prefix);
const char *completeSubstr(uint id, const char *substr); const char *completeSubstr(uint id, const char *substr);
void completeAccept(void); void completeAccept(void);

478
edit.c
View File

@ -1,4 +1,4 @@
/* Copyright (C) 2020 C. McEnroe <june@causal.agency> /* Copyright (C) 2020, 2022 June McEnroe <june@causal.agency>
* *
* This program is free software: you can redistribute it and/or modify * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -13,8 +13,6 @@
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>. * along with this program. If not, see <https://www.gnu.org/licenses/>.
* *
* Additional permission under GNU GPL version 3 section 7:
*
* If you modify this Program, or any covered work, by linking or * If you modify this Program, or any covered work, by linking or
* combining it with OpenSSL (or a modified version of that library), * combining it with OpenSSL (or a modified version of that library),
* containing parts covered by the terms of the OpenSSL License and the * containing parts covered by the terms of the OpenSSL License and the
@ -25,282 +23,272 @@
* covered work. * covered work.
*/ */
#include <assert.h> #include <errno.h>
#include <limits.h> #include <limits.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <wchar.h> #include <wchar.h>
#include <wctype.h> #include <wctype.h>
#include "chat.h" #include "edit.h"
enum { Cap = 1024 };
static wchar_t buf[Cap];
static size_t len;
static size_t pos;
char *editBuffer(size_t *mbsPos) {
static char mbs[MB_LEN_MAX * Cap];
const wchar_t *ptr = buf;
size_t mbsLen = wcsnrtombs(mbs, &ptr, pos, sizeof(mbs) - 1, NULL);
assert(mbsLen != (size_t)-1);
if (mbsPos) *mbsPos = mbsLen;
ptr = &buf[pos];
size_t n = wcsnrtombs(
&mbs[mbsLen], &ptr, len - pos, sizeof(mbs) - mbsLen - 1, NULL
);
assert(n != (size_t)-1);
mbsLen += n;
mbs[mbsLen] = '\0';
return mbs;
}
static struct {
wchar_t buf[Cap];
size_t len;
} cut;
static bool reserve(size_t index, size_t count) {
if (len + count > Cap) return false;
wmemmove(&buf[index + count], &buf[index], len - index);
len += count;
return true;
}
static void delete(bool copy, size_t index, size_t count) {
if (index + count > len) return;
if (copy) {
wmemcpy(cut.buf, &buf[index], count);
cut.len = count;
}
wmemmove(&buf[index], &buf[index + count], len - index - count);
len -= count;
}
static const struct {
const wchar_t *name;
const wchar_t *string;
} Macros[] = {
{ L"\\banhammer", L"▬▬▬▬▬▬▬▋ Ò╭╮Ó" },
{ L"\\bear", L"ʕっ•ᴥ•ʔっ" },
{ L"\\blush", L"（˶′◡‵˶）" },
{ L"\\com", L"\0038,4\2 ☭ " },
{ L"\\cool", L"(⌐■_■)" },
{ L"\\flip", L"(╯°□°）╯︵ ┻━┻" },
{ L"\\gary", L"ᕕ( ᐛ )ᕗ" },
{ L"\\hug", L"（っ・∀・）っ" },
{ L"\\lenny", L"( ͡° ͜ʖ ͡°)" },
{ L"\\look", L"ಠ_ಠ" },
{ L"\\shrug", L"¯\\_(ツ)_/¯" },
{ L"\\unflip", L"┬─┬ノ(º_ºノ)" },
{ L"\\wave", L"ヾ(＾∇＾)" },
};
void editCompleteAdd(void) {
char mbs[256];
for (size_t i = 0; i < ARRAY_LEN(Macros); ++i) {
size_t n = wcstombs(mbs, Macros[i].name, sizeof(mbs));
assert(n != (size_t)-1);
completeAdd(None, mbs, Default);
}
}
static void macroExpand(void) {
size_t macro = pos;
while (macro && buf[macro] != L'\\') macro--;
if (macro == pos) return;
for (size_t i = 0; i < ARRAY_LEN(Macros); ++i) {
if (wcsncmp(Macros[i].name, &buf[macro], pos - macro)) continue;
if (wcstombs(NULL, Macros[i].string, 0) == (size_t)-1) continue;
delete(false, macro, pos - macro);
pos = macro;
size_t expand = wcslen(Macros[i].string);
if (reserve(macro, expand)) {
wcsncpy(&buf[macro], Macros[i].string, expand);
pos += expand;
}
}
}
static struct {
size_t pos;
size_t pre;
size_t len;
bool suffix;
} tab;
static void tabComplete(uint id) {
if (!tab.len) {
tab.pos = pos;
while (tab.pos && !iswspace(buf[tab.pos - 1])) tab.pos--;
if (tab.pos == pos) return;
tab.pre = pos - tab.pos;
tab.len = tab.pre;
tab.suffix = true;
}
char mbs[MB_LEN_MAX * Cap];
const wchar_t *ptr = &buf[tab.pos];
size_t n = wcsnrtombs(mbs, &ptr, tab.pre, sizeof(mbs) - 1, NULL);
assert(n != (size_t)-1);
mbs[n] = '\0';
const char *comp = complete(id, mbs);
if (!comp) {
comp = complete(id, mbs);
tab.suffix ^= true;
}
if (!comp) {
tab.len = 0;
return;
}
wchar_t wcs[Cap];
n = mbstowcs(wcs, comp, Cap);
assert(n != (size_t)-1);
if (tab.pos + n + 2 > Cap) {
completeReject();
tab.len = 0;
return;
}
bool colon = (tab.len >= 2 && buf[tab.pos + tab.len - 2] == L':');
delete(false, tab.pos, tab.len);
tab.len = n;
if (wcs[0] == L'\\' || wcschr(wcs, L' ')) {
reserve(tab.pos, tab.len);
} else if (wcs[0] != L'/' && tab.suffix && (!tab.pos || colon)) {
tab.len += 2;
reserve(tab.pos, tab.len);
buf[tab.pos + n + 0] = L':';
buf[tab.pos + n + 1] = L' ';
} else if (tab.suffix && tab.pos >= 2 && buf[tab.pos - 2] == L':') {
tab.len += 2;
reserve(tab.pos, tab.len);
buf[tab.pos - 2] = L',';
buf[tab.pos + n + 0] = L':';
buf[tab.pos + n + 1] = L' ';
} else {
tab.len++;
reserve(tab.pos, tab.len);
if (!tab.suffix && tab.pos >= 2 && buf[tab.pos - 2] == L',') {
buf[tab.pos - 2] = L':';
}
buf[tab.pos + n] = L' ';
}
wmemcpy(&buf[tab.pos], wcs, n);
pos = tab.pos + tab.len;
}
static void tabAccept(void) {
completeAccept();
tab.len = 0;
}
static void tabReject(void) {
completeReject();
tab.len = 0;
}
static bool isword(wchar_t ch) { static bool isword(wchar_t ch) {
return !iswspace(ch) && !iswpunct(ch); return !iswspace(ch) && !iswpunct(ch);
} }
void edit(uint id, enum Edit op, wchar_t ch) { void editFree(struct Edit *e) {
size_t init = pos; free(e->buf);
switch (op) { free(e->cut.buf);
break; case EditHead: pos = 0; free(e->mbs.buf);
break; case EditTail: pos = len; e->pos = e->len = e->cap = 0;
break; case EditPrev: if (pos) pos--; e->cut.len = 0;
break; case EditNext: if (pos < len) pos++; e->mbs.pos = e->mbs.len = 0;
}
char *editString(struct Edit *e) {
size_t cap = e->len * MB_CUR_MAX + 1;
char *buf = realloc(e->mbs.buf, cap);
if (!buf) return NULL;
e->mbs.buf = buf;
const wchar_t *ptr = e->buf;
e->mbs.len = wcsnrtombs(e->mbs.buf, &ptr, e->pos, cap-1, NULL);
if (e->mbs.len == (size_t)-1) return NULL;
e->mbs.pos = e->mbs.len;
ptr = &e->buf[e->pos];
size_t n = wcsnrtombs(
&e->mbs.buf[e->mbs.len], &ptr, e->len - e->pos,
cap-1 - e->mbs.len, NULL
);
if (n == (size_t)-1) return NULL;
e->mbs.len += n;
e->mbs.buf[e->mbs.len] = '\0';
return e->mbs.buf;
}
int editReserve(struct Edit *e, size_t index, size_t count) {
if (index > e->len) {
errno = EINVAL;
return -1;
}
if (e->len + count > e->cap) {
size_t cap = (e->cap ? e->cap * 2 : 256);
wchar_t *buf = realloc(e->buf, sizeof(*buf) * cap);
if (!buf) return -1;
e->buf = buf;
e->cap = cap;
}
wmemmove(&e->buf[index + count], &e->buf[index], e->len - index);
e->len += count;
return 0;
}
int editCopy(struct Edit *e, size_t index, size_t count) {
if (index + count > e->len) {
errno = EINVAL;
return -1;
}
wchar_t *buf = realloc(e->cut.buf, sizeof(*buf) * count);
if (!buf) return -1;
e->cut.buf = buf;
wmemcpy(e->cut.buf, &e->buf[index], count);
e->cut.len = count;
return 0;
}
int editDelete(struct Edit *e, bool cut, size_t index, size_t count) {
if (index + count > e->len) {
errno = EINVAL;
return -1;
}
if (cut && editCopy(e, index, count) < 0) return -1;
wmemmove(&e->buf[index], &e->buf[index + count], e->len - index - count);
e->len -= count;
if (e->pos > e->len) e->pos = e->len;
return 0;
}
int editFn(struct Edit *e, enum EditFn fn) {
int ret = 0;
switch (fn) {
break; case EditHead: e->pos = 0;
break; case EditTail: e->pos = e->len;
break; case EditPrev: if (e->pos) e->pos--;
break; case EditNext: if (e->pos < e->len) e->pos++;
break; case EditPrevWord: { break; case EditPrevWord: {
while (pos && !isword(buf[pos - 1])) pos--; while (e->pos && !isword(e->buf[e->pos-1])) e->pos--;
while (pos && isword(buf[pos - 1])) pos--; while (e->pos && isword(e->buf[e->pos-1])) e->pos--;
} }
break; case EditNextWord: { break; case EditNextWord: {
while (pos < len && isword(buf[pos])) pos++; while (e->pos < e->len && isword(e->buf[e->pos])) e->pos++;
while (pos < len && !isword(buf[pos])) pos++; while (e->pos < e->len && !isword(e->buf[e->pos])) e->pos++;
} }
break; case EditDeleteHead: delete(true, 0, pos); pos = 0; break; case EditDeleteHead: {
break; case EditDeleteTail: delete(true, pos, len - pos); ret = editDelete(e, true, 0, e->pos);
break; case EditDeletePrev: if (pos) delete(false, --pos, 1); e->pos = 0;
break; case EditDeleteNext: delete(false, pos, 1); }
break; case EditDeleteTail: {
ret = editDelete(e, true, e->pos, e->len - e->pos);
}
break; case EditDeletePrev: {
if (e->pos) editDelete(e, false, --e->pos, 1);
}
break; case EditDeleteNext: {
editDelete(e, false, e->pos, 1);
}
break; case EditDeletePrevWord: { break; case EditDeletePrevWord: {
if (!pos) break; if (!e->pos) break;
size_t word = pos; size_t word = e->pos;
while (word && !isword(buf[word - 1])) word--; while (word && !isword(e->buf[word-1])) word--;
while (word && isword(buf[word - 1])) word--; while (word && isword(e->buf[word-1])) word--;
delete(true, word, pos - word); ret = editDelete(e, true, word, e->pos - word);
pos = word; e->pos = word;
} }
break; case EditDeleteNextWord: { break; case EditDeleteNextWord: {
if (pos == len) break; if (e->pos == e->len) break;
size_t word = pos; size_t word = e->pos;
while (word < len && !isword(buf[word])) word++; while (word < e->len && !isword(e->buf[word])) word++;
while (word < len && isword(buf[word])) word++; while (word < e->len && isword(e->buf[word])) word++;
delete(true, pos, word - pos); ret = editDelete(e, true, e->pos, word - e->pos);
}
break; case EditPaste: {
if (reserve(pos, cut.len)) {
wmemcpy(&buf[pos], cut.buf, cut.len);
pos += cut.len;
}
} }
break; case EditPaste: {
ret = editReserve(e, e->pos, e->cut.len);
if (ret == 0) {
wmemcpy(&e->buf[e->pos], e->cut.buf, e->cut.len);
e->pos += e->cut.len;
}
}
break; case EditTranspose: { break; case EditTranspose: {
if (!pos || len < 2) break; if (e->len < 2) break;
if (pos == len) pos--; if (!e->pos) e->pos++;
wchar_t t = buf[pos - 1]; if (e->pos == e->len) e->pos--;
buf[pos - 1] = buf[pos]; wchar_t x = e->buf[e->pos-1];
buf[pos++] = t; e->buf[e->pos-1] = e->buf[e->pos];
e->buf[e->pos++] = x;
} }
break; case EditCollapse: { break; case EditCollapse: {
size_t ws; size_t ws;
for (pos = 0; pos < len;) { for (e->pos = 0; e->pos < e->len;) {
for (; pos < len && !iswspace(buf[pos]); ++pos); for (; e->pos < e->len && !iswspace(e->buf[e->pos]); ++e->pos);
for (ws = pos; ws < len && iswspace(buf[ws]); ++ws); for (ws = e->pos; ws < e->len && iswspace(e->buf[ws]); ++ws);
if (pos && ws < len) { if (e->pos && ws < e->len) {
delete(false, pos, ws - pos - 1); editDelete(e, false, e->pos, ws - e->pos - 1);
buf[pos++] = L' '; e->buf[e->pos++] = L' ';
} else { } else {
delete(false, pos, ws - pos); editDelete(e, false, e->pos, ws - e->pos);
} }
} }
} }
break; case EditInsert: { break; case EditClear: e->len = e->pos = 0;
}
return ret;
}
int editInsert(struct Edit *e, wchar_t ch) {
char mb[MB_LEN_MAX]; char mb[MB_LEN_MAX];
if (wctomb(mb, ch) < 0) return; if (wctomb(mb, ch) < 0) return -1;
if (reserve(pos, 1)) { if (editReserve(e, e->pos, 1) < 0) return -1;
buf[pos++] = ch; e->buf[e->pos++] = ch;
return 0;
} }
}
break; case EditComplete: { #ifdef TEST
tabComplete(id); #undef NDEBUG
return; #include <assert.h>
} #include <string.h>
break; case EditExpand: {
macroExpand(); static void fix(struct Edit *e, const char *str) {
tabAccept(); editFn(e, EditClear);
return; for (const char *ch = str; *ch; ++ch) {
} editInsert(e, (wchar_t)*ch);
break; case EditEnter: {
tabAccept();
command(id, editBuffer(NULL));
len = pos = 0;
return;
} }
} }
if (pos < init) { static bool eq(struct Edit *e, const char *str1) {
tabReject(); const char *str2 = &str1[strlen(str1) + 1];
} else { const char *buf = editString(e);
tabAccept(); return e->mbs.pos == strlen(str1)
&& !strncmp(buf, str1, e->mbs.pos)
&& !strcmp(&buf[e->mbs.pos], str2);
} }
int main(void) {
struct Edit e = { .mode = EditEmacs };
fix(&e, "foo bar");
editFn(&e, EditHead);
assert(eq(&e, "\0foo bar"));
editFn(&e, EditTail);
assert(eq(&e, "foo bar\0"));
editFn(&e, EditPrev);
assert(eq(&e, "foo ba\0r"));
editFn(&e, EditNext);
assert(eq(&e, "foo bar\0"));
fix(&e, "foo, bar");
editFn(&e, EditPrevWord);
assert(eq(&e, "foo, \0bar"));
editFn(&e, EditPrevWord);
assert(eq(&e, "\0foo, bar"));
editFn(&e, EditNextWord);
assert(eq(&e, "foo, \0bar"));
editFn(&e, EditNextWord);
assert(eq(&e, "foo, bar\0"));
fix(&e, "foo bar");
editFn(&e, EditPrevWord);
editFn(&e, EditDeleteHead);
assert(eq(&e, "\0bar"));
fix(&e, "foo bar");
editFn(&e, EditPrevWord);
editFn(&e, EditDeleteTail);
assert(eq(&e, "foo \0"));
fix(&e, "foo bar");
editFn(&e, EditDeletePrev);
assert(eq(&e, "foo ba\0"));
editFn(&e, EditHead);
editFn(&e, EditDeleteNext);
assert(eq(&e, "\0oo ba"));
fix(&e, "foo, bar");
editFn(&e, EditDeletePrevWord);
assert(eq(&e, "foo, \0"));
editFn(&e, EditDeletePrevWord);
assert(eq(&e, "\0"));
fix(&e, "foo, bar");
editFn(&e, EditHead);
editFn(&e, EditDeleteNextWord);
assert(eq(&e, "\0, bar"));
editFn(&e, EditDeleteNextWord);
assert(eq(&e, "\0"));
fix(&e, "foo bar");
editFn(&e, EditDeletePrevWord);
editFn(&e, EditPaste);
assert(eq(&e, "foo bar\0"));
editFn(&e, EditPaste);
assert(eq(&e, "foo barbar\0"));
fix(&e, "bar");
editFn(&e, EditTranspose);
assert(eq(&e, "bra\0"));
editFn(&e, EditHead);
editFn(&e, EditTranspose);
assert(eq(&e, "rb\0a"));
editFn(&e, EditTranspose);
assert(eq(&e, "rab\0"));
fix(&e, " foo bar ");
editFn(&e, EditCollapse);
assert(eq(&e, "foo bar\0"));
} }
#endif /* TEST */

91
edit.h 100644
View File

@ -0,0 +1,91 @@
/* Copyright (C) 2022 June McEnroe <june@causal.agency>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
* If you modify this Program, or any covered work, by linking or
* combining it with OpenSSL (or a modified version of that library),
* containing parts covered by the terms of the OpenSSL License and the
* original SSLeay license, the licensors of this Program grant you
* additional permission to convey the resulting work. Corresponding
* Source for a non-source form of such a combination shall include the
* source code for the parts of OpenSSL used as well as that of the
* covered work.
*/
#include <stdbool.h>
#include <stddef.h>
enum EditMode {
EditEmacs,
};
struct Edit {
enum EditMode mode;
wchar_t *buf;
size_t pos;
size_t len;
size_t cap;
struct {
wchar_t *buf;
size_t len;
} cut;
struct {
char *buf;
size_t pos;
size_t len;
} mbs;
};
enum EditFn {
EditHead,
EditTail,
EditPrev,
EditNext,
EditPrevWord,
EditNextWord,
EditDeleteHead,
EditDeleteTail,
EditDeletePrev,
EditDeleteNext,
EditDeletePrevWord,
EditDeleteNextWord,
EditPaste,
EditTranspose,
EditCollapse,
EditClear,
};
// Perform an editing function.
int editFn(struct Edit *e, enum EditFn fn);
// Perform a vi-mode editing function.
int editVi(struct Edit *e, wchar_t ch);
// Insert a character at the cursor.
int editInsert(struct Edit *e, wchar_t ch);
// Convert the buffer to a multi-byte string stored in e->mbs.
char *editString(struct Edit *e);
// Free all buffers.
void editFree(struct Edit *e);
// Reserve a range in the buffer.
int editReserve(struct Edit *e, size_t index, size_t count);
// Copy a range of the buffer into e->cut.
int editCopy(struct Edit *e, size_t index, size_t count);
// Delete a range from the buffer. If cut is true, copy the deleted portion.
int editDelete(struct Edit *e, bool cut, size_t index, size_t count);

88
ui.c
View File

@ -54,6 +54,7 @@
#endif #endif
#include "chat.h" #include "chat.h"
#include "edit.h"
// Annoying stuff from <term.h>: // Annoying stuff from <term.h>:
#undef lines #undef lines
@ -752,9 +753,10 @@ static char *inputStop(
return stop; return stop;
} }
static struct Edit edit;
static void inputUpdate(void) { static void inputUpdate(void) {
size_t pos; char *buf = editString(&edit);
char *buf = editBuffer(&pos);
struct Window *window = windows.ptrs[windows.show]; struct Window *window = windows.ptrs[windows.show];
const char *prefix = ""; const char *prefix = "";
@ -786,7 +788,7 @@ static void inputUpdate(void) {
} else { } else {
prompt = ""; prompt = "";
} }
if (skip > &buf[pos]) { if (skip > &buf[edit.mbs.pos]) {
prefix = prompt = suffix = ""; prefix = prompt = suffix = "";
skip = buf; skip = buf;
} }
@ -803,10 +805,10 @@ static void inputUpdate(void) {
waddstr(input, suffix); waddstr(input, suffix);
getyx(input, y, x); getyx(input, y, x);
int posx; int pos;
struct Style style = styleInput; struct Style style = styleInput;
inputStop(styleInput, &style, skip, &buf[pos]); inputStop(styleInput, &style, skip, &buf[edit.mbs.pos]);
getyx(input, y, posx); getyx(input, y, pos);
wmove(input, y, x); wmove(input, y, x);
style = styleInput; style = styleInput;
@ -818,7 +820,7 @@ static void inputUpdate(void) {
} }
inputAdd(styleInput, &style, ptr); inputAdd(styleInput, &style, ptr);
wclrtoeol(input); wclrtoeol(input);
wmove(input, y, posx); wmove(input, y, pos);
} }
void uiWindows(void) { void uiWindows(void) {
@ -965,6 +967,11 @@ static void showAuto(void) {
} }
} }
static void inputEnter(uint id) {
command(id, editString(&edit));
editFn(&edit, EditClear);
}
static void keyCode(int code) { static void keyCode(int code) {
struct Window *window = windows.ptrs[windows.show]; struct Window *window = windows.ptrs[windows.show];
uint id = window->id; uint id = window->id;
@ -973,7 +980,7 @@ static void keyCode(int code) {
break; case KeyFocusIn: unmark(window); break; case KeyFocusIn: unmark(window);
break; case KeyFocusOut: mark(window); break; case KeyFocusOut: mark(window);
break; case KeyMetaEnter: edit(id, EditInsert, L'\n'); break; case KeyMetaEnter: editInsert(&edit, L'\n');
break; case KeyMetaEqual: window->mute ^= true; statusUpdate(); break; case KeyMetaEqual: window->mute ^= true; statusUpdate();
break; case KeyMetaMinus: incThresh(window, -1); break; case KeyMetaMinus: incThresh(window, -1);
break; case KeyMetaPlus: incThresh(window, +1); break; case KeyMetaPlus: incThresh(window, +1);
@ -984,32 +991,32 @@ static void keyCode(int code) {
break; case KeyMeta0 ... KeyMeta9: uiShowNum(code - KeyMeta0); break; case KeyMeta0 ... KeyMeta9: uiShowNum(code - KeyMeta0);
break; case KeyMetaA: showAuto(); break; case KeyMetaA: showAuto();
break; case KeyMetaB: edit(id, EditPrevWord, 0); break; case KeyMetaB: editFn(&edit, EditPrevWord);
break; case KeyMetaD: edit(id, EditDeleteNextWord, 0); break; case KeyMetaD: editFn(&edit, EditDeleteNextWord);
break; case KeyMetaF: edit(id, EditNextWord, 0); break; case KeyMetaF: editFn(&edit, EditNextWord);
break; case KeyMetaL: windowList(window); break; case KeyMetaL: windowList(window);
break; case KeyMetaM: uiWrite(id, Warm, NULL, ""); break; case KeyMetaM: uiWrite(id, Warm, NULL, "");
break; case KeyMetaN: scrollHot(window, +1); break; case KeyMetaN: scrollHot(window, +1);
break; case KeyMetaP: scrollHot(window, -1); break; case KeyMetaP: scrollHot(window, -1);
break; case KeyMetaQ: edit(id, EditCollapse, 0); break; case KeyMetaQ: editFn(&edit, EditCollapse);
break; case KeyMetaS: spoilerReveal ^= true; mainUpdate(); break; case KeyMetaS: spoilerReveal ^= true; mainUpdate();
break; case KeyMetaT: toggleTime(window); break; case KeyMetaT: toggleTime(window);
break; case KeyMetaU: scrollTo(window, window->unreadHard); break; case KeyMetaU: scrollTo(window, window->unreadHard);
break; case KeyMetaV: scrollPage(window, +1); break; case KeyMetaV: scrollPage(window, +1);
break; case KeyCtrlLeft: edit(id, EditPrevWord, 0); break; case KeyCtrlLeft: editFn(&edit, EditPrevWord);
break; case KeyCtrlRight: edit(id, EditNextWord, 0); break; case KeyCtrlRight: editFn(&edit, EditNextWord);
break; case KEY_BACKSPACE: edit(id, EditDeletePrev, 0); break; case KEY_BACKSPACE: editFn(&edit, EditDeletePrev);
break; case KEY_DC: edit(id, EditDeleteNext, 0); break; case KEY_DC: editFn(&edit, EditDeleteNext);
break; case KEY_DOWN: windowScroll(window, -1); break; case KEY_DOWN: windowScroll(window, -1);
break; case KEY_END: edit(id, EditTail, 0); break; case KEY_END: editFn(&edit, EditTail);
break; case KEY_ENTER: edit(id, EditEnter, 0); break; case KEY_ENTER: inputEnter(id);
break; case KEY_HOME: edit(id, EditHead, 0); break; case KEY_HOME: editFn(&edit, EditHead);
break; case KEY_LEFT: edit(id, EditPrev, 0); break; case KEY_LEFT: editFn(&edit, EditPrev);
break; case KEY_NPAGE: scrollPage(window, -1); break; case KEY_NPAGE: scrollPage(window, -1);
break; case KEY_PPAGE: scrollPage(window, +1); break; case KEY_PPAGE: scrollPage(window, +1);
break; case KEY_RIGHT: edit(id, EditNext, 0); break; case KEY_RIGHT: editFn(&edit, EditNext);
break; case KEY_SEND: scrollTo(window, 0); break; case KEY_SEND: scrollTo(window, 0);
break; case KEY_SHOME: scrollTo(window, BufferCap); break; case KEY_SHOME: scrollTo(window, BufferCap);
break; case KEY_UP: windowScroll(window, +1); break; case KEY_UP: windowScroll(window, +1);
@ -1020,33 +1027,30 @@ static void keyCtrl(wchar_t ch) {
struct Window *window = windows.ptrs[windows.show]; struct Window *window = windows.ptrs[windows.show];
uint id = window->id; uint id = window->id;
switch (ch ^ L'@') { switch (ch ^ L'@') {
break; case L'?': edit(id, EditDeletePrev, 0); break; case L'?': editFn(&edit, EditDeletePrev);
break; case L'A': edit(id, EditHead, 0); break; case L'A': editFn(&edit, EditHead);
break; case L'B': edit(id, EditPrev, 0); break; case L'B': editFn(&edit, EditPrev);
break; case L'C': raise(SIGINT); break; case L'C': raise(SIGINT);
break; case L'D': edit(id, EditDeleteNext, 0); break; case L'D': editFn(&edit, EditDeleteNext);
break; case L'E': edit(id, EditTail, 0); break; case L'E': editFn(&edit, EditTail);
break; case L'F': edit(id, EditNext, 0); break; case L'F': editFn(&edit, EditNext);
break; case L'H': edit(id, EditDeletePrev, 0); break; case L'H': editFn(&edit, EditDeletePrev);
break; case L'I': edit(id, EditComplete, 0); break; case L'J': inputEnter(id);
break; case L'J': edit(id, EditEnter, 0); break; case L'K': editFn(&edit, EditDeleteTail);
break; case L'K': edit(id, EditDeleteTail, 0);
break; case L'L': clearok(curscr, true); break; case L'L': clearok(curscr, true);
break; case L'N': uiShowNum(windows.show + 1); break; case L'N': uiShowNum(windows.show + 1);
break; case L'P': uiShowNum(windows.show - 1); break; case L'P': uiShowNum(windows.show - 1);
break; case L'R': scrollSearch(window, editBuffer(NULL), -1); break; case L'R': scrollSearch(window, editString(&edit), -1);
break; case L'S': scrollSearch(window, editBuffer(NULL), +1); break; case L'S': scrollSearch(window, editString(&edit), +1);
break; case L'T': edit(id, EditTranspose, 0); break; case L'T': editFn(&edit, EditTranspose);
break; case L'U': edit(id, EditDeleteHead, 0); break; case L'U': editFn(&edit, EditDeleteHead);
break; case L'V': scrollPage(window, -1); break; case L'V': scrollPage(window, -1);
break; case L'W': edit(id, EditDeletePrevWord, 0); break; case L'W': editFn(&edit, EditDeletePrevWord);
break; case L'X': edit(id, EditExpand, 0); break; case L'Y': editFn(&edit, EditPaste);
break; case L'Y': edit(id, EditPaste, 0);
} }
} }
static void keyStyle(wchar_t ch) { static void keyStyle(wchar_t ch) {
uint id = windows.ptrs[windows.show]->id;
if (iswcntrl(ch)) ch = towlower(ch ^ L'@'); if (iswcntrl(ch)) ch = towlower(ch ^ L'@');
char buf[8] = {0}; char buf[8] = {0};
enum Color color = Default; enum Color color = Default;
@ -1077,7 +1081,7 @@ static void keyStyle(wchar_t ch) {
snprintf(buf, sizeof(buf), "%c%02d", C, color); snprintf(buf, sizeof(buf), "%c%02d", C, color);
} }
for (char *ch = buf; *ch; ++ch) { for (char *ch = buf; *ch; ++ch) {
edit(id, EditInsert, *ch); editInsert(&edit, *ch);
} }
} }
@ -1103,7 +1107,7 @@ void uiRead(void) {
} else if (ret == KEY_CODE_YES && ch == KeyPasteManual) { } else if (ret == KEY_CODE_YES && ch == KeyPasteManual) {
paste ^= true; paste ^= true;
} else if (paste || literal) { } else if (paste || literal) {
edit(windows.ptrs[windows.show]->id, EditInsert, ch); editInsert(&edit, ch);
} else if (ret == KEY_CODE_YES) { } else if (ret == KEY_CODE_YES) {
keyCode(ch); keyCode(ch);
} else if (ch == (L'Z' ^ L'@')) { } else if (ch == (L'Z' ^ L'@')) {
@ -1117,7 +1121,7 @@ void uiRead(void) {
} else if (iswcntrl(ch)) { } else if (iswcntrl(ch)) {
keyCtrl(ch); keyCtrl(ch);
} else { } else {
edit(windows.ptrs[windows.show]->id, EditInsert, ch); editInsert(&edit, ch);
} }
style = false; style = false;
literal = false; literal = false;