ref: 9914a8da911d9fdfefd6b090870bbd385cacae69
author: aap <[email protected]>
date: Mon Jul 22 18:11:44 EDT 2024
first commit
--- /dev/null
+++ b/inc.h
@@ -1,0 +1,107 @@
+#include <u.h>
+#include <libc.h>
+#include <draw.h>
+#include <thread.h>
+#include <keyboard.h>
+#include <mouse.h>
+//#include <cursor.h>
+#include <frame.h>
+//#include <fcall.h>
+//#include <9p.h>
+//#include <complete.h>
+#include <plumb.h>
+
+typedef uchar bool;
+enum {+ FALSE = 0,
+ TRUE = 1,
+
+ BIG = 3,
+};
+
+#define ALT(c, v, t) (Alt){ c, v, t, nil, nil, 0 }+
+#define CTRL(c) ((c)&0x1F)
+
+
+extern Rune *snarf;
+extern int nsnarf;
+extern int snarfversion;
+extern int snarffd;
+enum { MAXSNARF = 100*1024 };+void putsnarf(void);
+void getsnarf(void);
+void setsnarf(char *s, int ns);
+
+typedef struct Text Text;
+struct Text
+{+ Frame;
+ Rectangle scrollr, lastsr;
+ Image *i;
+ Rune *r;
+ uint nr;
+ uint maxr;
+ uint org; /* start of Frame's text */
+ uint q0, q1; /* selection */
+ uint qh; /* host point, output here */
+
+ /* not entirely happy with this in here */
+ bool rawmode;
+ Rune *raw;
+ int nraw;
+
+ int posx;
+};
+
+void xinit(Text *x, Rectangle textr, Rectangle scrollr, Font *ft, Image *b, Image **cols);
+void xsetrects(Text *x, Rectangle textr, Rectangle scrollr);
+void xclear(Text *x);
+void xredraw(Text *x);
+void xfullredraw(Text *x);
+uint xinsert(Text *x, Rune *r, int n, uint q0);
+void xfill(Text *x);
+void xdelete(Text *x, uint q0, uint q1);
+void xsetselect(Text *x, uint q0, uint q1);
+void xselect(Text *x, Mousectl *mc);
+void xscrdraw(Text *x);
+void xscroll(Text *x, Mousectl *mc, int but);
+void xscrolln(Text *x, int n);
+void xtickupdn(Text *x, int d);
+void xshow(Text *x, uint q0);
+void xplacetick(Text *x, uint q);
+void xtype(Text *x, Rune r);
+int xninput(Text *x);
+void xaddraw(Text *x, Rune *r, int nr);
+void xlook(Text *x);
+void xsnarf(Text *x);
+void xcut(Text *x);
+void xpaste(Text *x);
+void xsend(Text *x);
+int xplumb(Text *w, char *src, char *dir, int maxsize);
+void freescrtemps(void);
+
+#define runemalloc(n) malloc((n)*sizeof(Rune))
+#define runerealloc(a, n) realloc(a, (n)*sizeof(Rune))
+#define runemove(a, b, n) memmove(a, b, (n)*sizeof(Rune))
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
+void panic(char *s);
+void *emalloc(ulong size);
+void *erealloc(void *p, ulong size);
+char *estrdup(char *s);
+
+
+typedef struct Timer Timer;
+struct Timer
+{+ int dt;
+ int cancel;
+ Channel *c; /* chan(int) */
+ Timer *next;
+};
+void timerinit(void);
+Timer *timerstart(int dt);
+void timerstop(Timer *t);
+void timercancel(Timer *t);
--- /dev/null
+++ b/main.c
@@ -1,0 +1,448 @@
+#include "inc.h"
+#include <cursor.h>
+
+Keyboardctl *kbctl;
+Keyboardctl *fwdkc, kbdctl2;
+Mousectl *mctl;
+int shiftdown; // TODO: needed?
+
+Text text;
+Image *colors[NCOL];
+char filename[1024];
+char *startdir;
+
+Cursor quest = {+ {-7,-7},+ {0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe, + 0x7c, 0x7e, 0x78, 0x7e, 0x00, 0xfc, 0x01, 0xf8,
+ 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xc0, 0x07, 0xc0,
+ 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, },
+ {0x00, 0x00, 0x0f, 0xf0, 0x1f, 0xf8, 0x3c, 0x3c, + 0x38, 0x1c, 0x00, 0x3c, 0x00, 0x78, 0x00, 0xf0,
+ 0x01, 0xe0, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80,
+ 0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, }
+};
+
+
+
+void
+panic(char *s)
+{+ fprint(2, "error: %s: %r\n", s);
+ threadexitsall("error");+}
+
+void*
+emalloc(ulong size)
+{+ void *p;
+
+ p = malloc(size);
+ if(p == nil)
+ panic("malloc failed");+ memset(p, 0, size);
+ return p;
+}
+
+void*
+erealloc(void *p, ulong size)
+{+ p = realloc(p, size);
+ if(p == nil)
+ panic("realloc failed");+ return p;
+}
+
+char*
+estrdup(char *s)
+{+ char *p;
+
+ p = malloc(strlen(s)+1);
+ if(p == nil)
+ panic("strdup failed");+ strcpy(p, s);
+ return p;
+}
+
+
+
+
+
+/*
+ * /dev/snarf updates when the file is closed, so we must open our own
+ * fd here rather than use snarffd
+ */
+void
+putsnarf(void)
+{+ int fd, i, n;
+
+ if(snarffd<0 || nsnarf==0)
+ return;
+ fd = open("/dev/snarf", OWRITE|OCEXEC);+ if(fd < 0)
+ return;
+ /* snarf buffer could be huge, so fprint will truncate; do it in blocks */
+ for(i=0; i<nsnarf; i+=n){+ n = nsnarf-i;
+ if(n >= 256)
+ n = 256;
+ if(fprint(fd, "%.*S", n, snarf+i) < 0)
+ break;
+ }
+ close(fd);
+}
+
+void
+setsnarf(char *s, int ns)
+{+ free(snarf);
+ snarf = runesmprint("%.*s", ns, s);+ nsnarf = runestrlen(snarf);
+ snarfversion++;
+}
+
+void
+getsnarf(void)
+{+ int i, n;
+ char *s, *sn;
+
+ if(snarffd < 0)
+ return;
+ sn = nil;
+ i = 0;
+ seek(snarffd, 0, 0);
+ for(;;){+ if(i > MAXSNARF)
+ break;
+ if((s = realloc(sn, i+1024+1)) == nil)
+ break;
+ sn = s;
+ if((n = read(snarffd, sn+i, 1024)) <= 0)
+ break;
+ i += n;
+ }
+ if(i == 0)
+ return;
+ sn[i] = 0;
+ setsnarf(sn, i);
+ free(sn);
+}
+
+
+
+
+void
+readfile(char *path)
+{+ int fd, n, ns;
+ char *s, buf[1024];
+ Rune *rs;
+
+ fd = open(path, OREAD);
+ if(fd < 0)
+ return;
+ s = nil;
+ ns = 0;
+ while(n = read(fd, buf, sizeof(buf)), n > 0) {+ s = realloc(s, ns+n);
+ memcpy(s+ns, buf, n);
+ ns += n;
+ }
+ close(fd);
+
+
+ rs = runesmprint("%.*s", ns, s);+ free(s);
+ xdelete(&text, 0, text.nr);
+ xinsert(&text, rs, runestrlen(rs), 0);
+ free(rs);
+}
+
+int
+writefile(char *path)
+{+ int fd;
+ char *s;
+
+ fd = create(path, OWRITE|OTRUNC, 0666);
+ if(fd < 0)
+ return 1;
+
+ s = smprint("%.*S", text.nr, text.r);+ write(fd, s, strlen(s));
+ close(fd);
+ free(s);
+ return 0;
+}
+
+
+void
+confused(void)
+{+ setcursor(mctl, &quest);
+ sleep(300);
+ setcursor(mctl, nil);
+}
+
+void
+editmenu(Text *x, Mousectl *mc)
+{+ enum {+ Cut,
+ Paste,
+ Snarf,
+ Plumb,
+ Look
+ };
+ static char *menu2str[] = {+ "cut",
+ "paste",
+ "snarf",
+ "plumb",
+ "look",
+ nil
+ };
+ static Menu menu2 = { menu2str };+
+ switch(menuhit(2, mc, &menu2, nil)){+ case Cut:
+ xsnarf(x);
+ xcut(x);
+ break;
+ case Paste:
+ xpaste(x);
+ break;
+ case Snarf:
+ xsnarf(x);
+ break;
+ case Plumb:
+ if(xplumb(x, "jot", startdir, 31*1024))
+ confused();
+ break;
+ case Look:
+ xlook(x);
+ break;
+ }
+}
+
+void
+filemenu(Text *x, Mousectl *mc)
+{+ USED(x);
+ enum {+ Write,
+ Exit
+ };
+ static char *str[] = {+ "write",
+ "exit",
+ nil
+ };
+ static Menu menu = { str };+
+ switch(menuhit(3, mc, &menu, nil)){+ case Write:
+ if(filename[0] == '\0'){+ fwdkc = &kbdctl2;
+ enter("file", filename, sizeof(filename), mc, fwdkc, nil);+ fwdkc = nil;
+ }
+ if(writefile(filename)){+ memset(filename, 0, sizeof(filename));
+ confused();
+ }
+ break;
+ case Exit:
+ threadexitsall(nil);
+ }
+}
+
+void
+mousectl(Text *x, Mousectl *mc)
+{+ int but;
+
+ for(but = 1; but < 6; but++)
+ if(mc->buttons == 1<<(but-1))
+ goto found;
+ return;
+found:
+
+/* if(shiftdown && but > 3)
+ wkeyctl(w, but == 4 ? Kscrolloneup : Kscrollonedown);
+ else*/ if(ptinrect(mc->xy, x->scrollr) || but > 3)
+ xscroll(x, mc, but);
+ else if(but == 1)
+ xselect(x, mc);
+ else if(but == 2)
+ editmenu(x, mc);
+ else if(but == 3)
+ filemenu(x, mc);
+}
+
+void
+keyctl(Text *x, Rune r)
+{+ int nlines, n;
+
+ nlines = x->maxlines; /* need signed */
+ switch(r){+
+ /* Scrolling */
+ case Kscrollonedown:
+ n = mousescrollsize(x->maxlines);
+ xscrolln(x, max(n, 1));
+ break;
+ case Kdown:
+ xscrolln(x, shiftdown ? 1 : nlines/3);
+ break;
+ case Kpgdown:
+ xscrolln(x, nlines*2/3);
+ break;
+ case Kscrolloneup:
+ n = mousescrollsize(x->maxlines);
+ xscrolln(x, -max(n, 1));
+ break;
+ case Kup:
+ xscrolln(x, -(shiftdown ? 1 : nlines/3));
+ break;
+ case Kpgup:
+ xscrolln(x, -nlines*2/3);
+ break;
+
+ case Khome:
+ xshow(x, 0);
+ break;
+ case Kend:
+ xshow(x, x->nr);
+ break;
+
+ /* Cursor movement */
+ case Kleft:
+ if(x->q0 > 0)
+ xplacetick(x, x->q0-1);
+ break;
+ case Kright:
+ if(x->q1 < x->nr)
+ xplacetick(x, x->q1+1);
+ break;
+ case CTRL('A'):+ while(x->q0 > 0 && x->r[x->q0-1] != '\n' &&
+ x->q0 != x->qh)
+ x->q0--;
+ xplacetick(x, x->q0);
+ break;
+ case CTRL('E'):+ while(x->q0 < x->nr && x->r[x->q0] != '\n')
+ x->q0++;
+ xplacetick(x, x->q0);
+ break;
+ case CTRL('B'):+ xplacetick(x, x->qh);
+ break;
+
+ case Kesc:
+ xsnarf(x);
+ xcut(x);
+ break;
+ case Kdel:
+ xtype(x, CTRL('H'));+ break;
+
+ default:
+ xtype(x, r);
+ break;
+ }
+}
+
+void
+setsize(Text *x)
+{+ Rectangle scrollr, textr;
+
+ draw(screen, screen->r, colors[BACK], nil, ZP);
+ scrollr = textr = insetrect(screen->r, 1);
+ scrollr.max.x = scrollr.min.x + 12;
+ textr.min.x = scrollr.max.x + 4;
+ xinit(x, textr, scrollr, font, screen, colors);
+}
+
+void
+mthread(void*)
+{+ while(readmouse(mctl) != -1){+ mousectl(&text, mctl);
+ }
+}
+
+void
+kbthread(void*)
+{+ Rune r;
+
+ for(;;){+ r = recvul(kbctl->c);
+ if(fwdkc)
+ send(fwdkc->c, &r);
+ else
+ keyctl(&text, r);
+ flushimage(display, 1);
+ }
+}
+
+void
+resthread(void*)
+{+ for(;;){+ recvul(mctl->resizec);
+ if(getwindow(display, Refnone) < 0)
+ sysfatal("resize failed: %r");+
+ setsize(&text);
+ }
+}
+
+void
+threadmain(int argc, char *argv[])
+{+ char buf[1024];
+// newwindow(nil);
+
+ if(initdraw(nil, nil, "jot") < 0)
+ sysfatal("initdraw: %r");+
+ kbctl = initkeyboard("/dev/cons");+ if(kbctl == nil)
+ sysfatal("initkeyboard: %r");+ kbdctl2.c = chancreate(sizeof(Rune), 20);
+
+ mctl = initmouse("/dev/mouse", screen);+ if(mctl == nil)
+ sysfatal("initmouse: %r");+ snarffd = open("/dev/snarf", OREAD|OCEXEC);+ if(getwd(buf, sizeof(buf)) == nil)
+ startdir = estrdup(".");+ else
+ startdir = estrdup(buf);
+
+ colors[BACK] = allocimagemix(display, DPaleyellow, DWhite);
+ colors[HIGH] = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DDarkyellow);
+ colors[BORD] = allocimage(display, Rect(0,0,2,2), screen->chan, 1, DYellowgreen);
+ colors[TEXT] = display->black;
+ colors[HTEXT] = display->black;
+
+ setsize(&text);
+
+ timerinit();
+ threadcreate(mthread, nil, mainstacksize);
+ threadcreate(kbthread, nil, mainstacksize);
+ threadcreate(resthread, nil, mainstacksize);
+
+ if(argc > 1){+ strncpy(filename, argv[1], sizeof(filename));
+ readfile(filename);
+ }
+}
--- /dev/null
+++ b/mkfile
@@ -1,0 +1,13 @@
+< /$objtype/mkfile
+
+TARG=jot
+OFILES=\
+ main.$O \
+ text.$O \
+ time.$O
+
+HFILES=inc.h
+
+BIN=$home/bin/$objtype
+
+< /sys/src/cmd/mkone
--- /dev/null
+++ b/text.c
@@ -1,0 +1,964 @@
+#include "inc.h"
+
+enum
+{+ HiWater = 640000, /* max size of history */
+ LoWater = 400000, /* min size of history after max'ed */
+ MinWater = 20000, /* room to leave available when reallocating */
+};
+
+void
+xinit(Text *x, Rectangle textr, Rectangle scrollr, Font *ft, Image *b, Image **cols)
+{+ frinit(x, textr, ft, b, cols);
+ x->i = b;
+ x->scrollr = scrollr;
+ x->lastsr = ZR;
+ xfill(x);
+ xsetselect(x, x->q0, x->q1);
+ xscrdraw(x);
+}
+
+void
+xsetrects(Text *x, Rectangle textr, Rectangle scrollr)
+{+ frsetrects(x, textr, x->b);
+ x->scrollr = scrollr;
+}
+
+void
+xclear(Text *x)
+{+ free(x->r);
+ x->r = nil;
+ x->nr = 0;
+ free(x->raw);
+ x->r = nil;
+ x->nraw = 0;
+ frclear(x, TRUE);
+};
+
+void
+xredraw(Text *x)
+{+ frredraw(x);
+ xscrdraw(x);
+}
+
+void
+xfullredraw(Text *x)
+{+ xfill(x);
+ x->ticked = 0;
+ if(x->p0 > 0)
+ frdrawsel(x, frptofchar(x, 0), 0, x->p0, 0);
+ if(x->p1 < x->nchars)
+ frdrawsel(x, frptofchar(x, x->p1), x->p1, x->nchars, 0);
+ frdrawsel(x, frptofchar(x, x->p0), x->p0, x->p1, 1);
+ x->lastsr = ZR;
+ xscrdraw(x);
+}
+
+uint
+xinsert(Text *w, Rune *r, int n, uint q0)
+{+ uint m;
+
+ if(n == 0)
+ return q0;
+ if(w->nr+n>HiWater && q0>=w->org && q0>=w->qh){+ m = min(HiWater-LoWater, min(w->org, w->qh));
+ w->org -= m;
+ w->qh -= m;
+ if(w->q0 > m)
+ w->q0 -= m;
+ else
+ w->q0 = 0;
+ if(w->q1 > m)
+ w->q1 -= m;
+ else
+ w->q1 = 0;
+ w->nr -= m;
+ runemove(w->r, w->r+m, w->nr);
+ q0 -= m;
+ }
+ if(w->nr+n > w->maxr){+ /*
+ * Minimize realloc breakage:
+ * Allocate at least MinWater
+ * Double allocation size each time
+ * But don't go much above HiWater
+ */
+ m = max(min(2*(w->nr+n), HiWater), w->nr+n)+MinWater;
+ if(m > HiWater)
+ m = max(HiWater+MinWater, w->nr+n);
+ if(m > w->maxr){+ w->r = runerealloc(w->r, m);
+ w->maxr = m;
+ }
+ }
+ runemove(w->r+q0+n, w->r+q0, w->nr-q0);
+ runemove(w->r+q0, r, n);
+ w->nr += n;
+ /* if output touches, advance selection, not qh; works best for keyboard and output */
+ if(q0 <= w->q1)
+ w->q1 += n;
+ if(q0 <= w->q0)
+ w->q0 += n;
+ if(q0 < w->qh)
+ w->qh += n;
+ if(q0 < w->org)
+ w->org += n;
+ else if(q0 <= w->org+w->nchars)
+ frinsert(w, r, r+n, q0-w->org);
+ return q0;
+}
+
+void
+xfill(Text *w)
+{+ Rune *rp;
+ int i, n, m, nl;
+
+ while(w->lastlinefull == FALSE){+ n = w->nr-(w->org+w->nchars);
+ if(n == 0)
+ break;
+ if(n > 2000) /* educated guess at reasonable amount */
+ n = 2000;
+ rp = w->r+(w->org+w->nchars);
+
+ /*
+ * it's expensive to frinsert more than we need, so
+ * count newlines.
+ */
+ nl = w->maxlines-w->nlines;
+ m = 0;
+ for(i=0; i<n; ){+ if(rp[i++] == '\n'){+ m++;
+ if(m >= nl)
+ break;
+ }
+ }
+ frinsert(w, rp, rp+i, w->nchars);
+ }
+}
+
+void
+xdelete(Text *w, uint q0, uint q1)
+{+ uint n, p0, p1;
+
+ n = q1-q0;
+ if(n == 0)
+ return;
+ runemove(w->r+q0, w->r+q1, w->nr-q1);
+ w->nr -= n;
+ if(q0 < w->q0)
+ w->q0 -= min(n, w->q0-q0);
+ if(q0 < w->q1)
+ w->q1 -= min(n, w->q1-q0);
+ if(q1 < w->qh)
+ w->qh -= n;
+ else if(q0 < w->qh)
+ w->qh = q0;
+ if(q1 <= w->org)
+ w->org -= n;
+ else if(q0 < w->org+w->nchars){+ p1 = q1 - w->org;
+ if(p1 > w->nchars)
+ p1 = w->nchars;
+ if(q0 < w->org){+ w->org = q0;
+ p0 = 0;
+ }else
+ p0 = q0 - w->org;
+ frdelete(w, p0, p1);
+ xfill(w);
+ }
+}
+
+void
+xsetselect(Text *w, uint q0, uint q1)
+{+ int p0, p1;
+
+ w->posx = -1;
+ /* w->p0 and w->p1 are always right; w->q0 and w->q1 may be off */
+ w->q0 = q0;
+ w->q1 = q1;
+ /* compute desired p0,p1 from q0,q1 */
+ p0 = q0-w->org;
+ p1 = q1-w->org;
+ if(p0 < 0)
+ p0 = 0;
+ if(p1 < 0)
+ p1 = 0;
+ if(p0 > w->nchars)
+ p0 = w->nchars;
+ if(p1 > w->nchars)
+ p1 = w->nchars;
+ if(p0==w->p0 && p1==w->p1)
+ return;
+ /* screen disagrees with desired selection */
+ if(w->p1<=p0 || p1<=w->p0 || p0==p1 || w->p1==w->p0){+ /* no overlap or too easy to bother trying */
+ frdrawsel(w, frptofchar(w, w->p0), w->p0, w->p1, 0);
+ frdrawsel(w, frptofchar(w, p0), p0, p1, 1);
+ goto Return;
+ }
+ /* overlap; avoid unnecessary painting */
+ if(p0 < w->p0){+ /* extend selection backwards */
+ frdrawsel(w, frptofchar(w, p0), p0, w->p0, 1);
+ }else if(p0 > w->p0){+ /* trim first part of selection */
+ frdrawsel(w, frptofchar(w, w->p0), w->p0, p0, 0);
+ }
+ if(p1 > w->p1){+ /* extend selection forwards */
+ frdrawsel(w, frptofchar(w, w->p1), w->p1, p1, 1);
+ }else if(p1 < w->p1){+ /* trim last part of selection */
+ frdrawsel(w, frptofchar(w, p1), p1, w->p1, 0);
+ }
+
+ Return:
+ w->p0 = p0;
+ w->p1 = p1;
+}
+
+static void
+xsetorigin(Text *w, uint org, int exact)
+{+ int i, a, fixup;
+ Rune *r;
+ uint n;
+
+ if(org>0 && !exact){+ /* org is an estimate of the char posn; find a newline */
+ /* don't try harder than 256 chars */
+ for(i=0; i<256 && org<w->nr; i++){+ if(w->r[org] == '\n'){+ org++;
+ break;
+ }
+ org++;
+ }
+ }
+ a = org-w->org;
+ fixup = 0;
+ if(a>=0 && a<w->nchars){+ frdelete(w, 0, a);
+ fixup = 1; /* frdelete can leave end of last line in wrong selection mode; it doesn't know what follows */
+ }else if(a<0 && -a<w->nchars){+ n = w->org - org;
+ r = w->r+org;
+ frinsert(w, r, r+n, 0);
+ }else
+ frdelete(w, 0, w->nchars);
+ w->org = org;
+ xfill(w);
+ xscrdraw(w);
+ xsetselect(w, w->q0, w->q1);
+ if(fixup && w->p1 > w->p0)
+ frdrawsel(w, frptofchar(w, w->p1-1), w->p1-1, w->p1, 1);
+}
+
+
+/*
+ * Scrolling
+ */
+
+static Image *scrtmp;
+
+static Image*
+scrtemps(void)
+{+ int h;
+
+ if(scrtmp == nil){+ h = BIG*Dy(screen->r);
+ scrtmp = allocimage(display, Rect(0, 0, 32, h), screen->chan, 0, DNofill);
+ }
+ return scrtmp;
+}
+
+void
+freescrtemps(void)
+{+ if(scrtmp){+ freeimage(scrtmp);
+ scrtmp = nil;
+ }
+}
+
+static Rectangle
+scrpos(Rectangle r, uint p0, uint p1, uint tot)
+{+ Rectangle q;
+ int h;
+
+ q = r;
+ h = q.max.y-q.min.y;
+ if(tot == 0)
+ return q;
+ if(tot > 1024*1024){+ tot>>=10;
+ p0>>=10;
+ p1>>=10;
+ }
+ if(p0 > 0)
+ q.min.y += h*p0/tot;
+ if(p1 < tot)
+ q.max.y -= h*(tot-p1)/tot;
+ if(q.max.y < q.min.y+2){+ if(q.min.y+2 <= r.max.y)
+ q.max.y = q.min.y+2;
+ else
+ q.min.y = q.max.y-2;
+ }
+ return q;
+}
+
+void
+xscrdraw(Text *w)
+{+ Rectangle r, r1, r2;
+ Image *b;
+
+ b = scrtemps();
+ if(b == nil || w->i == nil)
+ return;
+ r = w->scrollr;
+ r1 = r;
+ r1.min.x = 0;
+ r1.max.x = Dx(r);
+ r2 = scrpos(r1, w->org, w->org+w->nchars, w->nr);
+ if(!eqrect(r2, w->lastsr)){+ w->lastsr = r2;
+ /* move r1, r2 to (0,0) to avoid clipping */
+ r2 = rectsubpt(r2, r1.min);
+ r1 = rectsubpt(r1, r1.min);
+ draw(b, r1, w->cols[BORD], nil, ZP);
+ draw(b, r2, w->cols[BACK], nil, ZP);
+ r2.min.x = r2.max.x-1;
+ draw(b, r2, w->cols[BORD], nil, ZP);
+ draw(w->i, r, b, nil, Pt(0, r1.min.y));
+ }
+}
+
+static uint
+xbacknl(Text *w, uint p, uint n)
+{+ int i, j;
+
+ /* look for start of this line if n==0 */
+ if(n==0 && p>0 && w->r[p-1]!='\n')
+ n = 1;
+ i = n;
+ while(i-->0 && p>0){+ --p; /* it's at a newline now; back over it */
+ if(p == 0)
+ break;
+ /* at 128 chars, call it a line anyway */
+ for(j=128; --j>0 && p>0; p--)
+ if(w->r[p-1]=='\n')
+ break;
+ }
+ return p;
+}
+
+static void
+xscrsleep(Mousectl *mc, uint dt)
+{+ Timer *timer;
+ int y, b;
+ static Alt alts[3];
+
+ if(display->bufp > display->buf)
+ flushimage(display, 1);
+ timer = timerstart(dt);
+ y = mc->xy.y;
+ b = mc->buttons;
+ alts[0] = ALT(timer->c, nil, CHANRCV);
+ alts[1] = ALT(mc->c, &mc->Mouse, CHANRCV);
+ alts[2].op = CHANEND;
+ for(;;)
+ switch(alt(alts)){+ case 0:
+ timerstop(timer);
+ return;
+ case 1:
+ if(abs(mc->xy.y-y)>2 || mc->buttons!=b){+ timercancel(timer);
+ return;
+ }
+ break;
+ }
+}
+
+void
+xscroll(Text *w, Mousectl *mc, int but)
+{+ uint p0, oldp0;
+ Rectangle s;
+ int y, my, h, first;
+
+ s = insetrect(w->scrollr, 1);
+ h = s.max.y-s.min.y;
+ oldp0 = ~0;
+ first = TRUE;
+ do{+ my = mc->xy.y;
+ if(my < s.min.y)
+ my = s.min.y;
+ if(my >= s.max.y)
+ my = s.max.y;
+ if(but == 2){+ y = my;
+ if(y > s.max.y-2)
+ y = s.max.y-2;
+ if(w->nr > 1024*1024)
+ p0 = ((w->nr>>10)*(y-s.min.y)/h)<<10;
+ else
+ p0 = w->nr*(y-s.min.y)/h;
+ if(oldp0 != p0)
+ xsetorigin(w, p0, FALSE);
+ oldp0 = p0;
+ readmouse(mc);
+ continue;
+ }
+ if(but == 1 || but == 4){+ y = max(1, (my-s.min.y)/w->font->height);
+ p0 = xbacknl(w, w->org, y);
+ }else{+ y = max(my, s.min.y+w->font->height);
+ p0 = w->org+frcharofpt(w, Pt(s.max.x, y));
+ }
+ if(oldp0 != p0)
+ xsetorigin(w, p0, TRUE);
+ oldp0 = p0;
+ /* debounce */
+ if(first){+ if(display->bufp > display->buf)
+ flushimage(display, 1);
+ if(but > 3)
+ return;
+ sleep(200);
+ nbrecv(mc->c, &mc->Mouse);
+ first = FALSE;
+ }
+ xscrsleep(mc, 100);
+ }while(mc->buttons & (1<<(but-1)));
+ while(mc->buttons)
+ readmouse(mc);
+}
+
+void
+xscrolln(Text *x, int n)
+{+ uint q0;
+
+ if(n < 0)
+ q0 = xbacknl(x, x->org, -n);
+ else
+ q0 = x->org+frcharofpt(x, Pt(x->Frame.r.min.x, x->Frame.r.min.y+n*x->font->height));
+ xsetorigin(x, q0, TRUE);
+}
+
+/* move tick up or down while staying at the same x position */
+void
+xtickupdn(Text *x, int d)
+{+ Point p;
+ int py;
+ uint q0;
+
+ xshow(x, x->q0);
+ p = frptofchar(x, x->q0-x->org);
+ if(x->posx >= 0)
+ p.x = x->posx;
+ py = p.y;
+ p.y += d*x->font->height;
+ if(p.y < x->Frame.r.min.y ||
+ p.y > x->Frame.r.max.y-x->font->height){+ xscrolln(x, d);
+ p.y = py;
+ }
+ q0 = x->org+frcharofpt(x, p);
+ xsetselect(x, q0, q0);
+ x->posx = p.x;
+}
+
+static Text *selecttext;
+static Mousectl *selectmc;
+static uint selectq;
+
+static void
+xframescroll(Text *x, int dl)
+{+ uint endq;
+
+ if(dl == 0){+ xscrsleep(selectmc, 100);
+ return;
+ }
+ if(dl < 0){+ endq = x->org+x->p0;
+ }else{+ if(x->org+x->nchars == x->nr)
+ return;
+ endq = x->org+x->p1;
+ }
+ xscrolln(x, dl);
+ xsetselect(x, min(selectq, endq), max(selectq, endq));
+}
+
+static void
+framescroll(Frame *f, int dl)
+{+ if(f != &selecttext->Frame)
+ panic("frameselect not right frame");+ xframescroll(selecttext, dl);
+}
+
+/*
+ * Selection and deletion helpers
+ */
+
+int
+iswordrune(Rune r)
+{+ return isalpharune(r) || isdigitrune(r);
+}
+
+static int
+xbswidth(Text *w, Rune c)
+{+ uint q, stop;
+ Rune r;
+ int wd, inword;
+
+ /* there is known to be at least one character to erase */
+ if(c == Kbs) /* ^H: erase character */
+ return 1;
+ q = w->q0;
+ stop = 0;
+ if(q > w->qh)
+ stop = w->qh;
+ inword = FALSE;
+ while(q > stop){+ r = w->r[q-1];
+ if(r == '\n'){ /* eat at most one more character */+ if(q == w->q0) /* eat the newline */
+ --q;
+ break;
+ }
+ /* ^W: erase word.
+ * delete a bunch of non-word characters
+ * followed by word characters */
+ if(c == CTRL('W')){+ wd = iswordrune(r);
+ if(wd && !inword)
+ inword = TRUE;
+ else if(!wd && inword)
+ break;
+ }
+ --q;
+ }
+ return w->q0-q;
+}
+
+static Rune left1[] = { L'{', L'[', L'(', L'<', L'«', 0 };+static Rune right1[] = { L'}', L']', L')', L'>', L'»', 0 };+static Rune left2[] = { L'\n', 0 };+static Rune left3[] = { L'\'', L'"', L'`', 0 };+
+static Rune *left[] = {+ left1,
+ left2,
+ left3,
+ nil
+};
+static Rune *right[] = {+ right1,
+ left2,
+ left3,
+ nil
+};
+
+static int
+xclickmatch(Text *x, int cl, int cr, int dir, uint *q)
+{+ Rune c;
+ int nest;
+
+ nest = 1;
+ for(;;){+ if(dir > 0){+ if(*q == x->nr)
+ break;
+ c = x->r[*q];
+ (*q)++;
+ }else{+ if(*q == 0)
+ break;
+ (*q)--;
+ c = x->r[*q];
+ }
+ if(c == cr){+ if(--nest==0)
+ return 1;
+ }else if(c == cl)
+ nest++;
+ }
+ return cl=='\n' && nest==1;
+}
+
+static int
+inmode(Rune r, int mode)
+{+ return (mode == 1) ? iswordrune(r) : r && !isspacerune(r);
+}
+
+static void
+xstretchsel(Text *x, uint pt, uint *q0, uint *q1, int mode)
+{+ int c, i;
+ Rune *r, *l, *p;
+ uint q;
+
+ *q0 = pt;
+ *q1 = pt;
+ for(i=0; left[i]!=nil; i++){+ q = *q0;
+ l = left[i];
+ r = right[i];
+ /* try matching character to left, looking right */
+ if(q == 0)
+ c = '\n';
+ else
+ c = x->r[q-1];
+ p = runestrchr(l, c);
+ if(p != nil){+ if(xclickmatch(x, c, r[p-l], 1, &q))
+ *q1 = q-(c!='\n');
+ return;
+ }
+ /* try matching character to right, looking left */
+ if(q == x->nr)
+ c = '\n';
+ else
+ c = x->r[q];
+ p = runestrchr(r, c);
+ if(p != nil){+ if(xclickmatch(x, c, l[p-r], -1, &q)){+ *q1 = *q0+(*q0<x->nr && c=='\n');
+ *q0 = q;
+ if(c!='\n' || q!=0 || x->r[0]=='\n')
+ (*q0)++;
+ }
+ return;
+ }
+ }
+ /* try filling out word to right */
+ while(*q1<x->nr && inmode(x->r[*q1], mode))
+ (*q1)++;
+ /* try filling out word to left */
+ while(*q0>0 && inmode(x->r[*q0-1], mode))
+ (*q0)--;
+}
+
+static Mouse lastclick;
+static Text *clickfrm;
+static uint clickcount;
+
+/* should be called with button 1 down */
+void
+xselect(Text *x, Mousectl *mc)
+{+ uint q0, q1;
+ int dx, dy, dt, b;
+
+ /* reset click state if mouse is too different from last time */
+ dx = abs(mc->xy.x - lastclick.xy.x);
+ dy = abs(mc->xy.y - lastclick.xy.y);
+ dt = mc->msec - lastclick.msec;
+ if(x != clickfrm || dx > 3 || dy > 3 || dt >= 500)
+ clickcount = 0;
+
+ /* first button down can be a dragging selection or a click.
+ * subsequent buttons downs can only be clicks.
+ * both cases can be ended by chording. */
+ selectq = x->org+frcharofpt(x, mc->xy);
+ if(clickcount == 0){+ /* what a kludge - can this be improved? */
+ selecttext = x;
+ selectmc = mc;
+ x->scroll = framescroll;
+ frselect(x, mc);
+ /* this is correct if the whole selection is visible */
+ q0 = x->org + x->p0;
+ q1 = x->org + x->p1;
+ /* otherwise replace one end with selectq */
+ if(selectq < x->org)
+ q0 = selectq;
+ if(selectq > x->org+x->nchars)
+ q1 = selectq;
+ xsetselect(x, q0, q1);
+
+ /* figure out whether it was a click */
+ if(q0 == q1 && mc->buttons == 0){+ clickcount = 1;
+ clickfrm = x;
+ }
+ }else{+ clickcount++;
+ xstretchsel(x, selectq, &q0, &q1, min(clickcount-1, 2));
+ xsetselect(x, q0, q1);
+ if(clickcount >= 3)
+ clickcount = 0;
+ b = mc->buttons;
+ while(mc->buttons == b)
+ readmouse(mc);
+ }
+ lastclick = mc->Mouse; /* a bit unsure if this is correct */
+
+ /* chording */
+ while(mc->buttons){+ clickcount = 0;
+ b = mc->buttons;
+ if(b & 6){+ if(b & 2){+ xsnarf(x);
+ xcut(x);
+ }else{+ xpaste(x);
+ }
+ }
+ while(mc->buttons == b)
+ readmouse(mc);
+ }
+}
+
+void
+xshow(Text *w, uint q0)
+{+ int qe;
+ int nl;
+ uint q;
+
+ qe = w->org+w->nchars;
+ if(w->org<=q0 && (q0<qe || (q0==qe && qe==w->nr)))
+ xscrdraw(w);
+ else{+ nl = 4*w->maxlines/5;
+ q = xbacknl(w, q0, nl);
+ /* avoid going backwards if trying to go forwards - long lines! */
+ if(!(q0>w->org && q<w->org))
+ xsetorigin(w, q, TRUE);
+ while(q0 > w->org+w->nchars)
+ xsetorigin(w, w->org+1, FALSE);
+ }
+}
+
+void
+xplacetick(Text *x, uint q)
+{+ xsetselect(x, q, q);
+ xshow(x, q);
+}
+
+void
+xtype(Text *x, Rune r)
+{+ uint q0, q1;
+ int nb;
+
+ xsnarf(x);
+ xcut(x);
+ switch(r){+ case CTRL('H'): /* erase character */+ case CTRL('W'): /* erase word */+ case CTRL('U'): /* erase line */+ if(x->q0==0 || x->q0==x->qh)
+ return;
+ nb = xbswidth(x, r);
+ q1 = x->q0;
+ q0 = q1-nb;
+ if(q0 < x->org){+ q0 = x->org;
+ nb = q1-q0;
+ }
+ if(nb > 0){+ xdelete(x, q0, q0+nb);
+ xsetselect(x, q0, q0);
+ }
+ break;
+ default:
+ xinsert(x, &r, 1, x->q0);
+ xshow(x, x->q0);
+ break;
+ }
+}
+
+int
+xninput(Text *x)
+{+ uint q;
+ Rune r;
+
+ for(q = x->qh; q < x->nr; q++){+ r = x->r[q];
+ if(r == '\n')
+ return q - x->qh + 1;
+ if(r == CTRL('D'))+ return q - x->qh;
+ }
+ return -1;
+}
+
+void
+xaddraw(Text *x, Rune *r, int nr)
+{+ x->raw = runerealloc(x->raw, x->nraw+nr);
+ runemove(x->raw+x->nraw, r, nr);
+ x->nraw += nr;
+}
+
+/* TODO: maybe pass what we're looking for in a string */
+void
+xlook(Text *x)
+{+ int i, n, e;
+
+ i = x->q1;
+ n = i - x->q0;
+ e = x->nr - n;
+ if(n <= 0 || e < n)
+ return;
+
+ if(i > e)
+ i = 0;
+
+ while(runestrncmp(x->r+x->q0, x->r+i, n) != 0){+ if(i < e)
+ i++;
+ else
+ i = 0;
+ }
+
+ xsetselect(x, i, i+n);
+ xshow(x, i);
+}
+
+Rune *snarf;
+int nsnarf;
+int snarfversion;
+int snarffd;
+
+void
+xsnarf(Text *x)
+{+ if(x->q1 == x->q0)
+ return;
+ nsnarf = x->q1-x->q0;
+ snarf = runerealloc(snarf, nsnarf);
+ snarfversion++;
+ runemove(snarf, x->r+x->q0, nsnarf);
+ putsnarf();
+}
+
+void
+xcut(Text *x)
+{+ if(x->q1 == x->q0)
+ return;
+ xdelete(x, x->q0, x->q1);
+ xsetselect(x, x->q0, x->q0);
+ xscrdraw(x);
+}
+
+void
+xpaste(Text *x)
+{+ uint q0;
+
+ getsnarf();
+ if(nsnarf == 0)
+ return;
+ xcut(x);
+ q0 = x->q0;
+ if(x->rawmode && q0==x->nr){+ xaddraw(x, snarf, nsnarf);
+ xsetselect(x, q0, q0);
+ }else{+ q0 = xinsert(x, snarf, nsnarf, x->q0);
+ xsetselect(x, q0, q0+nsnarf);
+ }
+ xscrdraw(x);
+}
+
+void
+xsend(Text *x)
+{+ getsnarf();
+ xsnarf(x);
+ if(nsnarf == 0)
+ return;
+ if(x->rawmode){+ xaddraw(x, snarf, nsnarf);
+ if(snarf[nsnarf-1]!='\n' && snarf[nsnarf-1]!=CTRL('D'))+ xaddraw(x, L"\n", 1);
+ }else{+ xinsert(x, snarf, nsnarf, x->nr);
+ if(snarf[nsnarf-1]!='\n' && snarf[nsnarf-1]!=CTRL('D'))+ xinsert(x, L"\n", 1, x->nr);
+ }
+ xplacetick(x, x->nr);
+}
+
+int
+xplumb(Text *w, char *src, char *dir, int maxsize)
+{+ Plumbmsg *m;
+ static int fd = -2;
+ char buf[32];
+ uint p0, p1;
+
+ if(fd == -2)
+ fd = plumbopen("send", OWRITE|OCEXEC);+ if(fd < 0)
+ return 0;
+ m = emalloc(sizeof(Plumbmsg));
+ m->src = estrdup(src);
+ m->dst = nil;
+ m->wdir = estrdup(dir);
+ m->type = estrdup("text");+ p0 = w->q0;
+ p1 = w->q1;
+ if(w->q1 > w->q0)
+ m->attr = nil;
+ else{+ while(p0>0 && w->r[p0-1]!=' ' && w->r[p0-1]!='\t' && w->r[p0-1]!='\n')
+ p0--;
+ while(p1<w->nr && w->r[p1]!=' ' && w->r[p1]!='\t' && w->r[p1]!='\n')
+ p1++;
+ snprint(buf, sizeof(buf), "click=%d", w->q0-p0);
+ m->attr = plumbunpackattr(buf);
+ }
+ if(p1-p0 > maxsize){+ plumbfree(m);
+ return 0; /* too large for 9P */
+ }
+ m->data = smprint("%.*S", p1-p0, w->r+p0);+ m->ndata = strlen(m->data);
+ if(plumbsend(fd, m) < 0){+ plumbfree(m);
+ return 1;
+ }
+ plumbfree(m);
+ return 0;
+}
--- /dev/null
+++ b/time.c
@@ -1,0 +1,114 @@
+#include "inc.h"
+
+/* taken from rio */
+
+static Channel* ctimer; /* chan(Timer*)[100] */
+static Timer *timer;
+
+static uint
+msec(void)
+{+ return nsec()/1000000;
+}
+
+void
+timerstop(Timer *t)
+{+ t->next = timer;
+ timer = t;
+}
+
+void
+timercancel(Timer *t)
+{+ t->cancel = TRUE;
+}
+
+static void
+timerproc(void*)
+{+ int i, nt, na, dt, del;
+ Timer **t, *x;
+ uint old, new;
+
+ rfork(RFFDG);
+ threadsetname("TIMERPROC");+ t = nil;
+ na = 0;
+ nt = 0;
+ old = msec();
+ for(;;){+ sleep(1); /* will sleep minimum incr */
+ new = msec();
+ dt = new-old;
+ old = new;
+ if(dt < 0) /* timer wrapped; go around, losing a tick */
+ continue;
+ for(i=0; i<nt; i++){+ x = t[i];
+ x->dt -= dt;
+ del = 0;
+ if(x->cancel){+ timerstop(x);
+ del = 1;
+ }else if(x->dt <= 0){+ /*
+ * avoid possible deadlock if client is
+ * now sending on ctimer
+ */
+ if(nbsendul(x->c, 0) > 0)
+ del = 1;
+ }
+ if(del){+ memmove(&t[i], &t[i+1], (nt-i-1)*sizeof t[0]);
+ --nt;
+ --i;
+ }
+ }
+ if(nt == 0){+ x = recvp(ctimer);
+ gotit:
+ if(nt == na){+ na += 10;
+ t = realloc(t, na*sizeof(Timer*));
+ if(t == nil)
+ abort();
+ }
+ t[nt++] = x;
+ old = msec();
+ }
+ if(nbrecv(ctimer, &x) > 0)
+ goto gotit;
+ }
+}
+
+void
+timerinit(void)
+{+ ctimer = chancreate(sizeof(Timer*), 100);
+ proccreate(timerproc, nil, mainstacksize);
+}
+
+/*
+ * timeralloc() and timerfree() don't lock, so can only be
+ * called from the main proc.
+ */
+
+Timer*
+timerstart(int dt)
+{+ Timer *t;
+
+ t = timer;
+ if(t)
+ timer = timer->next;
+ else{+ t = emalloc(sizeof(Timer));
+ t->c = chancreate(sizeof(int), 0);
+ }
+ t->next = nil;
+ t->dt = dt;
+ t->cancel = FALSE;
+ sendp(ctimer, t);
+ return t;
+}