1803 lines
36 KiB
C
1803 lines
36 KiB
C
/*
|
|
* This file is part of the UCB release of Plan 9. It is subject to the license
|
|
* terms in the LICENSE file found in the top-level directory of this
|
|
* distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
|
|
* part of the UCB release of Plan 9, including this file, may be copied,
|
|
* modified, propagated, or distributed except according to the terms contained
|
|
* in the LICENSE file.
|
|
*/
|
|
/* Portions of this file are Copyright (C) 2015-2018 Giacomo Tesio <giacomo@tesio.it>
|
|
* See /doc/license/gpl-2.0.txt for details about the licensing.
|
|
*/
|
|
/* Portions of this file are Copyright (C) 9front's team.
|
|
* See /doc/license/9front-mit for details about the licensing.
|
|
* See http://git.9front.org/plan9front/plan9front/HEAD/info.html for a list of authors.
|
|
*/
|
|
#include <u.h>
|
|
#include <lib9.h>
|
|
#include <draw.h>
|
|
#include <thread.h>
|
|
#include <cursor.h>
|
|
#include <mouse.h>
|
|
#include <keyboard.h>
|
|
#include <frame.h>
|
|
#include <9P2000.h>
|
|
#include <plumb.h>
|
|
#include <complete.h>
|
|
#include "dat.h"
|
|
#include "fns.h"
|
|
|
|
#define MOVEIT if(0)
|
|
|
|
enum
|
|
{
|
|
HiWater = 640000, /* max size of history */
|
|
LoWater = 400000, /* min size of history after max'ed */
|
|
MinWater = 20000, /* room to leave available when reallocating */
|
|
};
|
|
|
|
static int topped;
|
|
static int id;
|
|
static Cursor *lastcursor;
|
|
|
|
Window*
|
|
wmk(Image *i, Mousectl *mc, Channel *ck, Channel *cctl, int scrolling)
|
|
{
|
|
Window *w;
|
|
Rectangle r;
|
|
|
|
w = emalloc(sizeof(Window));
|
|
w->screenr = i->r;
|
|
r = insetrect(i->r, Selborder+1);
|
|
w->i = i;
|
|
w->mc = *mc;
|
|
w->ck = ck;
|
|
w->cctl = cctl;
|
|
w->cursorp = nil;
|
|
w->conswrite = chancreate(sizeof(Conswritemesg), 0);
|
|
w->consread = chancreate(sizeof(Consreadmesg), 0);
|
|
w->kbdread = chancreate(sizeof(Consreadmesg), 0);
|
|
w->mouseread = chancreate(sizeof(Mousereadmesg), 0);
|
|
w->wctlread = chancreate(sizeof(Consreadmesg), 0);
|
|
w->complete = chancreate(sizeof(Completion*), 0);
|
|
w->gone = chancreate(sizeof(char*), 0);
|
|
w->scrollr = r;
|
|
w->scrollr.max.x = r.min.x+Scrollwid;
|
|
w->lastsr = ZR;
|
|
r.min.x += Scrollwid+Scrollgap;
|
|
frinit(&w->frame, r, font, i, cols);
|
|
w->frame.maxtab = maxtab*stringwidth(font, "0");
|
|
w->topped = ++topped;
|
|
w->id = ++id;
|
|
w->notefd = -1;
|
|
w->scrolling = scrolling;
|
|
w->dir = estrdup(startdir);
|
|
w->label = estrdup("<unnamed>");
|
|
r = insetrect(w->i->r, Selborder);
|
|
draw(w->i, r, cols[BACK], nil, w->frame.entire.min);
|
|
wborder(w, Selborder);
|
|
wscrdraw(w);
|
|
incref(&w->ref); /* ref will be removed after mounting; avoids delete before ready to be deleted */
|
|
return w;
|
|
}
|
|
|
|
void
|
|
wsetname(Window *w)
|
|
{
|
|
int i, n;
|
|
char err[ERRMAX];
|
|
|
|
n = snprint(w->name, sizeof(w->name)-2, "window.%d.%d", w->id, w->namecount++);
|
|
for(i='A'; i<='Z'; i++){
|
|
if(nameimage(w->i, w->name, 1) > 0)
|
|
return;
|
|
sys_errstr(err, sizeof err);
|
|
if(strcmp(err, "image name in use") != 0)
|
|
break;
|
|
w->name[n] = i;
|
|
w->name[n+1] = 0;
|
|
}
|
|
w->name[0] = 0;
|
|
fprint(2, "rio: setname failed: %s\n", err);
|
|
}
|
|
|
|
void
|
|
wresize(Window *w, Image *i)
|
|
{
|
|
Rectangle r;
|
|
|
|
freeimage(w->i);
|
|
w->i = i;
|
|
w->mc.image = i;
|
|
r = insetrect(i->r, Selborder+1);
|
|
w->scrollr = r;
|
|
w->scrollr.max.x = r.min.x+Scrollwid;
|
|
w->lastsr = ZR;
|
|
r.min.x += Scrollwid+Scrollgap;
|
|
frclear(&w->frame, FALSE);
|
|
frinit(&w->frame, r, w->frame.font, w->i, cols);
|
|
wsetcols(w, 1);
|
|
w->frame.maxtab = maxtab*stringwidth(w->frame.font, "0");
|
|
r = insetrect(w->i->r, Selborder);
|
|
draw(w->i, r, cols[BACK], nil, w->frame.entire.min);
|
|
wfill(w);
|
|
wsetselect(w, w->q0, w->q1);
|
|
wscrdraw(w);
|
|
wborder(w, Selborder);
|
|
flushimage(display, 1);
|
|
wsetname(w);
|
|
w->topped = ++topped;
|
|
w->resized = TRUE;
|
|
w->mouse.counter++;
|
|
w->wctlready = 1;
|
|
}
|
|
|
|
void
|
|
wrefresh(Window *w)
|
|
{
|
|
Rectangle r;
|
|
|
|
if(w == input)
|
|
wborder(w, Selborder);
|
|
else
|
|
wborder(w, Unselborder);
|
|
r = insetrect(w->i->r, Selborder);
|
|
draw(w->i, r, w->frame.cols[BACK], nil, w->frame.entire.min);
|
|
w->frame.ticked = 0;
|
|
if(w->frame.p0 > 0)
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, 0), 0, w->frame.p0, 0);
|
|
if(w->frame.p1 < w->frame.nchars)
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, w->frame.p1), w->frame.p1, w->frame.nchars, 0);
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, w->frame.p0), w->frame.p0, w->frame.p1, 1);
|
|
w->lastsr = ZR;
|
|
wscrdraw(w);
|
|
}
|
|
|
|
int
|
|
wclose(Window *w)
|
|
{
|
|
int i;
|
|
|
|
i = decref(&w->ref);
|
|
if(i > 0)
|
|
return 0;
|
|
if(i < 0)
|
|
error("negative ref count");
|
|
wclunk(w);
|
|
wsendctlmesg(w, Exited, ZR, nil);
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
showcandidates(Window *, Completion *);
|
|
|
|
void
|
|
winctl(void *arg)
|
|
{
|
|
Rune *rp, *up, r;
|
|
uint32_t qh, q0;
|
|
int nr, nb, c, wid, i, npart, initial, lastb;
|
|
char *s, *t, part[3];
|
|
Window *w;
|
|
Mousestate *mp, m;
|
|
enum { WKbd, WKbdread, WMouse, WMouseread, WCtl, WCwrite, WCread, WWread, WComplete, Wgone, NWALT };
|
|
Alt alts[NWALT+1];
|
|
Consreadmesg crm;
|
|
Mousereadmesg mrm;
|
|
Conswritemesg cwm;
|
|
Stringpair pair;
|
|
Wctlmesg wcm;
|
|
Completion *cr;
|
|
char *kbdq[32], *kbds;
|
|
uint32_t kbdqr, kbdqw;
|
|
|
|
w = arg;
|
|
threadsetname("winctl-id%d", w->id);
|
|
|
|
mrm.cm = chancreate(sizeof(Mouse), 0);
|
|
crm.c1 = chancreate(sizeof(Stringpair), 0);
|
|
crm.c2 = chancreate(sizeof(Stringpair), 0);
|
|
cwm.cw = chancreate(sizeof(Stringpair), 0);
|
|
|
|
alts[WKbd].c = w->ck;
|
|
alts[WKbd].v = &kbds;
|
|
alts[WKbd].op = CHANRCV;
|
|
alts[WKbdread].c = w->kbdread;
|
|
alts[WKbdread].v = &crm;
|
|
alts[WKbdread].op = CHANSND;
|
|
alts[WMouse].c = w->mc.c;
|
|
alts[WMouse].v = &w->mc.Mouse;
|
|
alts[WMouse].op = CHANRCV;
|
|
alts[WMouseread].c = w->mouseread;
|
|
alts[WMouseread].v = &mrm;
|
|
alts[WMouseread].op = CHANSND;
|
|
alts[WCtl].c = w->cctl;
|
|
alts[WCtl].v = &wcm;
|
|
alts[WCtl].op = CHANRCV;
|
|
alts[WCwrite].c = w->conswrite;
|
|
alts[WCwrite].v = &cwm;
|
|
alts[WCwrite].op = CHANSND;
|
|
alts[WCread].c = w->consread;
|
|
alts[WCread].v = &crm;
|
|
alts[WCread].op = CHANSND;
|
|
alts[WWread].c = w->wctlread;
|
|
alts[WWread].v = &crm;
|
|
alts[WWread].op = CHANSND;
|
|
alts[WComplete].c = w->complete;
|
|
alts[WComplete].v = &cr;
|
|
alts[WComplete].op = CHANRCV;
|
|
alts[Wgone].c = w->gone;
|
|
alts[Wgone].v = "window deleted";
|
|
alts[Wgone].op = CHANNOP;
|
|
alts[NWALT].op = CHANEND;
|
|
|
|
kbdqr = kbdqw = 0;
|
|
npart = 0;
|
|
lastb = -1;
|
|
for(;;){
|
|
if(w->i==nil){
|
|
/* window deleted */
|
|
alts[Wgone].op = CHANSND;
|
|
|
|
alts[WKbdread].op = CHANNOP;
|
|
alts[WMouseread].op = CHANNOP;
|
|
alts[WCwrite].op = CHANNOP;
|
|
alts[WWread].op = CHANNOP;
|
|
alts[WCread].op = CHANNOP;
|
|
} else {
|
|
alts[WKbdread].op = (w->kbdopen && kbdqw != kbdqr) ?
|
|
CHANSND : CHANNOP;
|
|
alts[WMouseread].op = (w->mouseopen && w->mouse.counter != w->mouse.lastcounter) ?
|
|
CHANSND : CHANNOP;
|
|
alts[WCwrite].op = w->scrolling || w->mouseopen || (w->qh <= w->org+w->frame.nchars) ?
|
|
CHANSND : CHANNOP;
|
|
alts[WWread].op = w->wctlready ?
|
|
CHANSND : CHANNOP;
|
|
/* this code depends on NL and EOT fitting in a single byte */
|
|
/* kind of expensive for each loop; worth precomputing? */
|
|
if(w->holding)
|
|
alts[WCread].op = CHANNOP;
|
|
else if(npart || (w->rawing && w->nraw>0))
|
|
alts[WCread].op = CHANSND;
|
|
else{
|
|
alts[WCread].op = CHANNOP;
|
|
for(i=w->qh; i<w->nr; i++){
|
|
c = w->r[i];
|
|
if(c=='\n' || c=='\004'){
|
|
alts[WCread].op = CHANSND;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
switch(alt(alts)){
|
|
case WKbd:
|
|
if(kbdqw - kbdqr < nelem(kbdq))
|
|
kbdq[kbdqw++ % nelem(kbdq)] = kbds;
|
|
else
|
|
free(kbds);
|
|
if(w->kbdopen)
|
|
continue;
|
|
while(kbdqr != kbdqw){
|
|
kbds = kbdq[kbdqr++ % nelem(kbdq)];
|
|
if(*kbds == 'c'){
|
|
chartorune(&r, kbds+1);
|
|
if(r)
|
|
wkeyctl(w, r);
|
|
}
|
|
free(kbds);
|
|
}
|
|
break;
|
|
case WKbdread:
|
|
recv(crm.c1, &pair);
|
|
nb = 0;
|
|
while(kbdqr != kbdqw){
|
|
kbds = kbdq[kbdqr % nelem(kbdq)];
|
|
i = strlen(kbds)+1;
|
|
if(nb+i > pair.ns)
|
|
break;
|
|
memmove((char*)pair.s + nb, kbds, i);
|
|
free(kbds);
|
|
nb += i;
|
|
kbdqr++;
|
|
}
|
|
pair.ns = nb;
|
|
send(crm.c2, &pair);
|
|
continue;
|
|
case WMouse:
|
|
if(w->mouseopen) {
|
|
w->mouse.counter++;
|
|
|
|
/* queue click events */
|
|
if(!w->mouse.qfull && lastb != w->mc.buttons) { /* add to ring */
|
|
mp = &w->mouse.queue[w->mouse.wi];
|
|
if(++w->mouse.wi == nelem(w->mouse.queue))
|
|
w->mouse.wi = 0;
|
|
if(w->mouse.wi == w->mouse.ri)
|
|
w->mouse.qfull = TRUE;
|
|
mp->Mouse = w->mc.Mouse;
|
|
mp->counter = w->mouse.counter;
|
|
lastb = w->mc.buttons;
|
|
}
|
|
} else
|
|
wmousectl(w);
|
|
break;
|
|
case WMouseread:
|
|
/* send a queued event or, if the queue is empty, the current state */
|
|
/* if the queue has filled, we discard all the events it contained. */
|
|
/* the intent is to discard frantic clicking by the user during int32_t latencies. */
|
|
w->mouse.qfull = FALSE;
|
|
if(w->mouse.wi != w->mouse.ri) {
|
|
m = w->mouse.queue[w->mouse.ri];
|
|
if(++w->mouse.ri == nelem(w->mouse.queue))
|
|
w->mouse.ri = 0;
|
|
} else
|
|
m = (Mousestate){w->mc.Mouse, w->mouse.counter};
|
|
|
|
w->mouse.lastcounter = m.counter;
|
|
send(mrm.cm, &m.Mouse);
|
|
continue;
|
|
case WCtl:
|
|
if(wctlmesg(w, wcm.type, wcm.r, wcm.p) == Exited){
|
|
while(kbdqr != kbdqw)
|
|
free(kbdq[kbdqr++ % nelem(kbdq)]);
|
|
chanfree(crm.c1);
|
|
chanfree(crm.c2);
|
|
chanfree(mrm.cm);
|
|
chanfree(cwm.cw);
|
|
threadexits(nil);
|
|
}
|
|
continue;
|
|
case WCwrite:
|
|
recv(cwm.cw, &pair);
|
|
rp = pair.s;
|
|
nr = pair.ns;
|
|
for(i=0; i<nr; i++)
|
|
if(rp[i] == '\b'){
|
|
up = rp+i;
|
|
initial = 0;
|
|
for(; i<nr; i++){
|
|
if(rp[i] == '\b'){
|
|
if(up == rp)
|
|
initial++;
|
|
else
|
|
up--;
|
|
}else
|
|
*up++ = rp[i];
|
|
}
|
|
if(initial){
|
|
if(initial > w->qh)
|
|
initial = w->qh;
|
|
qh = w->qh-initial;
|
|
wdelete(w, qh, qh+initial);
|
|
w->qh = qh;
|
|
}
|
|
nr = up - rp;
|
|
break;
|
|
}
|
|
w->qh = winsert(w, rp, nr, w->qh)+nr;
|
|
if(w->scrolling || w->mouseopen)
|
|
wshow(w, w->qh);
|
|
wsetselect(w, w->q0, w->q1);
|
|
wscrdraw(w);
|
|
free(rp);
|
|
break;
|
|
case WCread:
|
|
recv(crm.c1, &pair);
|
|
t = pair.s;
|
|
nb = pair.ns;
|
|
i = npart;
|
|
npart = 0;
|
|
if(i)
|
|
memmove(t, part, i);
|
|
while(i<nb && (w->qh<w->nr || w->nraw>0)){
|
|
if(w->qh == w->nr){
|
|
wid = runetochar(t+i, &w->raw[0]);
|
|
w->nraw--;
|
|
runemove(w->raw, w->raw+1, w->nraw);
|
|
}else
|
|
wid = runetochar(t+i, &w->r[w->qh++]);
|
|
c = t[i]; /* knows break characters fit in a byte */
|
|
i += wid;
|
|
if(!w->rawing && (c == '\n' || c=='\004')){
|
|
if(c == '\004')
|
|
i--;
|
|
break;
|
|
}
|
|
}
|
|
if(i==nb && w->qh<w->nr && w->r[w->qh]=='\004')
|
|
w->qh++;
|
|
if(i > nb){
|
|
npart = i-nb;
|
|
memmove(part, t+nb, npart);
|
|
i = nb;
|
|
}
|
|
pair.s = t;
|
|
pair.ns = i;
|
|
send(crm.c2, &pair);
|
|
continue;
|
|
case WWread:
|
|
w->wctlready = 0;
|
|
recv(crm.c1, &pair);
|
|
s = Dx(w->screenr) > 0 ? "visible" : "hidden";
|
|
t = "notcurrent";
|
|
if(w == input)
|
|
t = "current";
|
|
pair.ns = snprint(pair.s, pair.ns, "%11d %11d %11d %11d %s %s ",
|
|
w->i->r.min.x, w->i->r.min.y, w->i->r.max.x, w->i->r.max.y, t, s);
|
|
send(crm.c2, &pair);
|
|
continue;
|
|
case WComplete:
|
|
if(w->i!=nil){
|
|
if(!cr->advance)
|
|
showcandidates(w, cr);
|
|
if(cr->advance){
|
|
rp = runesmprint("%s", cr->string);
|
|
if(rp){
|
|
nr = runestrlen(rp);
|
|
q0 = w->q0;
|
|
q0 = winsert(w, rp, nr, q0);
|
|
wshow(w, q0+nr);
|
|
free(rp);
|
|
}
|
|
}
|
|
}
|
|
freecompletion(cr);
|
|
break;
|
|
}
|
|
if(w->i!=nil && Dx(w->screenr) > 0 && display->bufp > display->buf)
|
|
flushimage(display, 1);
|
|
}
|
|
}
|
|
|
|
void
|
|
waddraw(Window *w, Rune *r, int nr)
|
|
{
|
|
w->raw = runerealloc(w->raw, w->nraw+nr);
|
|
runemove(w->raw+w->nraw, r, nr);
|
|
w->nraw += nr;
|
|
}
|
|
|
|
/*
|
|
* Need to do this in a separate proc because if process we're interrupting
|
|
* is dying and trying to print tombstone, kernel is blocked holding p->debug lock.
|
|
*/
|
|
void
|
|
interruptproc(void *v)
|
|
{
|
|
int *notefd;
|
|
|
|
notefd = v;
|
|
jehanne_write(*notefd, "interrupt", 9);
|
|
sys_close(*notefd);
|
|
free(notefd);
|
|
}
|
|
|
|
int
|
|
windfilewidth(Window *w, uint32_t q0, int oneelement)
|
|
{
|
|
uint32_t q;
|
|
Rune r;
|
|
|
|
q = q0;
|
|
while(q > 0){
|
|
r = w->r[q-1];
|
|
if(r<=' ' || r=='=' || r=='^' || r=='(' || r=='{')
|
|
break;
|
|
if(oneelement && r=='/')
|
|
break;
|
|
--q;
|
|
}
|
|
return q0-q;
|
|
}
|
|
|
|
void
|
|
showcandidates(Window *w, Completion *c)
|
|
{
|
|
int i;
|
|
Fmt f;
|
|
Rune *rp;
|
|
uint32_t nr, qline;
|
|
char *s;
|
|
|
|
runefmtstrinit(&f);
|
|
if (c->nmatch == 0)
|
|
s = "[no matches in ";
|
|
else
|
|
s = "[";
|
|
if(c->nfile > 32)
|
|
fmtprint(&f, "%s%d files]\n", s, c->nfile);
|
|
else{
|
|
fmtprint(&f, "%s", s);
|
|
for(i=0; i<c->nfile; i++){
|
|
if(i > 0)
|
|
fmtprint(&f, " ");
|
|
fmtprint(&f, "%s", c->filename[i]);
|
|
}
|
|
fmtprint(&f, "]\n");
|
|
}
|
|
rp = runefmtstrflush(&f);
|
|
nr = runestrlen(rp);
|
|
|
|
/* place text at beginning of line before cursor and host point */
|
|
qline = min(w->qh, w->q0);
|
|
while(qline>0 && w->r[qline-1] != '\n')
|
|
qline--;
|
|
|
|
if(qline == w->qh){
|
|
/* advance host point to avoid readback */
|
|
w->qh = winsert(w, rp, nr, qline)+nr;
|
|
} else {
|
|
winsert(w, rp, nr, qline);
|
|
}
|
|
free(rp);
|
|
}
|
|
|
|
typedef struct Completejob Completejob;
|
|
struct Completejob
|
|
{
|
|
char *dir;
|
|
char *str;
|
|
Window *win;
|
|
};
|
|
|
|
void
|
|
completeproc(void *arg)
|
|
{
|
|
Completejob *job;
|
|
Completion *c;
|
|
|
|
job = arg;
|
|
threadsetname("namecomplete %s", job->dir);
|
|
|
|
c = complete(job->dir, job->str);
|
|
if(c != nil && sendp(job->win->complete, c) <= 0)
|
|
freecompletion(c);
|
|
|
|
wclose(job->win);
|
|
|
|
free(job->dir);
|
|
free(job->str);
|
|
free(job);
|
|
}
|
|
|
|
void
|
|
namecomplete(Window *w)
|
|
{
|
|
int nstr, npath;
|
|
Rune *path, *str;
|
|
char *dir, *root;
|
|
Completejob *job;
|
|
|
|
/* control-f: filename completion; works back to white space or / */
|
|
if(w->q0<w->nr && w->r[w->q0]>' ') /* must be at end of word */
|
|
return;
|
|
nstr = windfilewidth(w, w->q0, TRUE);
|
|
str = w->r+(w->q0-nstr);
|
|
npath = windfilewidth(w, w->q0-nstr, FALSE);
|
|
path = w->r+(w->q0-nstr-npath);
|
|
|
|
/* is path rooted? if not, we need to make it relative to window path */
|
|
if(npath>0 && path[0]=='/')
|
|
dir = runetobyte(path, npath, &npath);
|
|
else {
|
|
if(strcmp(w->dir, "") == 0)
|
|
root = ".";
|
|
else
|
|
root = w->dir;
|
|
dir = smprint("%s/%.*S", root, npath, path);
|
|
}
|
|
if(dir == nil)
|
|
return;
|
|
|
|
/* run in background, winctl will collect the result on w->complete chan */
|
|
job = emalloc(sizeof *job);
|
|
job->str = runetobyte(str, nstr, &nstr);
|
|
job->dir = cleanname(dir);
|
|
job->win = w;
|
|
incref(&w->ref);
|
|
proccreate(completeproc, job, STACK);
|
|
}
|
|
|
|
void
|
|
wkeyctl(Window *w, Rune r)
|
|
{
|
|
uint32_t q0 ,q1;
|
|
int n, nb;
|
|
int *notefd;
|
|
|
|
switch(r){
|
|
case 0:
|
|
case Kcaps:
|
|
case Knum:
|
|
case Kshift:
|
|
case Kalt:
|
|
case Kctl:
|
|
case Kaltgr:
|
|
return;
|
|
}
|
|
|
|
if(w->i==nil)
|
|
return;
|
|
/* navigation keys work only when mouse and kbd is not open */
|
|
if(!w->mouseopen)
|
|
switch(r){
|
|
case Kdown:
|
|
n = shiftdown ? 1 : w->frame.maxlines/3;
|
|
goto case_Down;
|
|
case Kscrollonedown:
|
|
n = mousescrollsize(w->frame.maxlines);
|
|
if(n <= 0)
|
|
n = 1;
|
|
goto case_Down;
|
|
case Kpgdown:
|
|
n = 2*w->frame.maxlines/3;
|
|
case_Down:
|
|
q0 = w->org+frcharofpt(&w->frame, Pt(w->frame.r.min.x, w->frame.r.min.y+n*w->frame.font->height));
|
|
wsetorigin(w, q0, TRUE);
|
|
return;
|
|
case Kup:
|
|
n = shiftdown ? 1 : w->frame.maxlines/3;
|
|
goto case_Up;
|
|
case Kscrolloneup:
|
|
n = mousescrollsize(w->frame.maxlines);
|
|
if(n <= 0)
|
|
n = 1;
|
|
goto case_Up;
|
|
case Kpgup:
|
|
n = 2*w->frame.maxlines/3;
|
|
case_Up:
|
|
q0 = wbacknl(w, w->org, n);
|
|
wsetorigin(w, q0, TRUE);
|
|
return;
|
|
case Kleft:
|
|
if(w->q0 > 0){
|
|
q0 = w->q0-1;
|
|
wsetselect(w, q0, q0);
|
|
wshow(w, q0);
|
|
}
|
|
return;
|
|
case Kright:
|
|
if(w->q1 < w->nr){
|
|
q1 = w->q1+1;
|
|
wsetselect(w, q1, q1);
|
|
wshow(w, q1);
|
|
}
|
|
return;
|
|
case Khome:
|
|
wshow(w, 0);
|
|
return;
|
|
case Kend:
|
|
wshow(w, w->nr);
|
|
return;
|
|
case Kscroll:
|
|
w->scrolling ^= 1;
|
|
wshow(w, w->nr);
|
|
return;
|
|
case Ksoh: /* ^A: beginning of line */
|
|
if(w->q0==0 || w->q0==w->qh || w->r[w->q0-1]=='\n')
|
|
return;
|
|
nb = wbswidth(w, 0x15 /* ^U */);
|
|
wsetselect(w, w->q0-nb, w->q0-nb);
|
|
wshow(w, w->q0);
|
|
return;
|
|
case Kenq: /* ^E: end of line */
|
|
q0 = w->q0;
|
|
while(q0 < w->nr && w->r[q0]!='\n')
|
|
q0++;
|
|
wsetselect(w, q0, q0);
|
|
wshow(w, w->q0);
|
|
return;
|
|
case Kstx: /* ^B: output point */
|
|
wsetselect(w, w->qh, w->qh);
|
|
wshow(w, w->q0);
|
|
return;
|
|
}
|
|
if(w->rawing && (w->q0==w->nr || w->mouseopen)){
|
|
waddraw(w, &r, 1);
|
|
return;
|
|
}
|
|
if(r==Kesc || (w->holding && r==Kdel)){ /* toggle hold */
|
|
if(w->holding)
|
|
--w->holding;
|
|
else
|
|
w->holding++;
|
|
wsetcursor(w, FALSE);
|
|
wrepaint(w);
|
|
if(r == Kesc)
|
|
return;
|
|
}
|
|
if(r != Kdel){
|
|
wsnarf(w);
|
|
wcut(w);
|
|
}
|
|
switch(r){
|
|
case Kdel: /* send interrupt */
|
|
w->qh = w->nr;
|
|
wshow(w, w->qh);
|
|
if(w->notefd < 0)
|
|
return;
|
|
notefd = emalloc(sizeof(int));
|
|
*notefd = dup(w->notefd, -1);
|
|
proccreate(interruptproc, notefd, 4096);
|
|
return;
|
|
case Kack: /* ^F: file name completion */
|
|
case Kins: /* Insert: file name completion */
|
|
namecomplete(w);
|
|
return;
|
|
case Kbs: /* ^H: erase character */
|
|
case Knack: /* ^U: erase line */
|
|
case Ketb: /* ^W: erase word */
|
|
if(w->q0==0 || w->q0==w->qh)
|
|
return;
|
|
nb = wbswidth(w, r);
|
|
q1 = w->q0;
|
|
q0 = q1-nb;
|
|
if(q0 < w->org){
|
|
q0 = w->org;
|
|
nb = q1-q0;
|
|
}
|
|
if(nb > 0){
|
|
wdelete(w, q0, q0+nb);
|
|
wsetselect(w, q0, q0);
|
|
}
|
|
return;
|
|
}
|
|
/* otherwise ordinary character; just insert */
|
|
q0 = w->q0;
|
|
q0 = winsert(w, &r, 1, q0);
|
|
wshow(w, q0+1);
|
|
}
|
|
|
|
void
|
|
wsetcols(Window *w, int topped)
|
|
{
|
|
if(w->holding)
|
|
if(topped)
|
|
w->frame.cols[TEXT] = holdcol;
|
|
else
|
|
w->frame.cols[TEXT] = lightholdcol;
|
|
else
|
|
if(topped)
|
|
w->frame.cols[TEXT] = cols[TEXT];
|
|
else
|
|
w->frame.cols[TEXT] = paletextcol;
|
|
}
|
|
|
|
void
|
|
wrepaint(Window *w)
|
|
{
|
|
wsetcols(w, w == input);
|
|
if(!w->mouseopen)
|
|
frredraw(&w->frame);
|
|
if(w == input)
|
|
wborder(w, Selborder);
|
|
else
|
|
wborder(w, Unselborder);
|
|
}
|
|
|
|
int
|
|
wbswidth(Window *w, Rune c)
|
|
{
|
|
uint32_t q, eq, stop;
|
|
Rune r;
|
|
int skipping;
|
|
|
|
/* there is known to be at least one character to erase */
|
|
if(c == 0x08) /* ^H: erase character */
|
|
return 1;
|
|
q = w->q0;
|
|
stop = 0;
|
|
if(q > w->qh)
|
|
stop = w->qh;
|
|
skipping = TRUE;
|
|
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;
|
|
}
|
|
if(c == 0x17){
|
|
eq = isalnum(r);
|
|
if(eq && skipping) /* found one; stop skipping */
|
|
skipping = FALSE;
|
|
else if(!eq && !skipping)
|
|
break;
|
|
}
|
|
--q;
|
|
}
|
|
return w->q0-q;
|
|
}
|
|
|
|
void
|
|
wsnarf(Window *w)
|
|
{
|
|
if(w->q1 == w->q0)
|
|
return;
|
|
nsnarf = w->q1-w->q0;
|
|
snarf = runerealloc(snarf, nsnarf);
|
|
snarfversion++; /* maybe modified by parent */
|
|
runemove(snarf, w->r+w->q0, nsnarf);
|
|
putsnarf();
|
|
}
|
|
|
|
void
|
|
wcut(Window *w)
|
|
{
|
|
if(w->q1 == w->q0)
|
|
return;
|
|
wdelete(w, w->q0, w->q1);
|
|
wsetselect(w, w->q0, w->q0);
|
|
}
|
|
|
|
void
|
|
wpaste(Window *w)
|
|
{
|
|
uint32_t q0;
|
|
|
|
if(nsnarf == 0)
|
|
return;
|
|
wcut(w);
|
|
q0 = w->q0;
|
|
if(w->rawing && q0==w->nr){
|
|
waddraw(w, snarf, nsnarf);
|
|
wsetselect(w, q0, q0);
|
|
}else{
|
|
q0 = winsert(w, snarf, nsnarf, w->q0);
|
|
wsetselect(w, q0, q0+nsnarf);
|
|
}
|
|
}
|
|
|
|
void
|
|
wplumb(Window *w)
|
|
{
|
|
Plumbmsg *m;
|
|
static int fd = -2;
|
|
char buf[32];
|
|
uint32_t p0, p1;
|
|
Cursor *c;
|
|
|
|
if(fd == -2)
|
|
fd = plumbopen("send", OWRITE|OCEXEC);
|
|
if(fd < 0)
|
|
return;
|
|
m = emalloc(sizeof(Plumbmsg));
|
|
m->src = estrdup("rio");
|
|
m->dst = nil;
|
|
m->wdir = estrdup(w->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 > messagesize-1024){
|
|
plumbfree(m);
|
|
return; /* too large for 9P */
|
|
}
|
|
m->data = runetobyte(w->r+p0, p1-p0, &m->ndata);
|
|
if(plumbsend(fd, m) < 0){
|
|
c = lastcursor;
|
|
riosetcursor(&query);
|
|
sleep(300);
|
|
riosetcursor(c);
|
|
}
|
|
plumbfree(m);
|
|
}
|
|
|
|
void
|
|
wlook(Window *w)
|
|
{
|
|
int i, n, e;
|
|
|
|
i = w->q1;
|
|
n = i - w->q0;
|
|
e = w->nr - n;
|
|
if(n <= 0 || e < n)
|
|
return;
|
|
|
|
if(i > e)
|
|
i = 0;
|
|
|
|
while(runestrncmp(w->r+w->q0, w->r+i, n) != 0){
|
|
if(i < e)
|
|
i++;
|
|
else
|
|
i = 0;
|
|
}
|
|
|
|
wsetselect(w, i, i+n);
|
|
wshow(w, i);
|
|
}
|
|
|
|
void
|
|
wmousectl(Window *w)
|
|
{
|
|
int but;
|
|
|
|
for(but=1;; but++){
|
|
if(but > 5)
|
|
return;
|
|
if(w->mc.buttons == 1<<(but-1))
|
|
break;
|
|
}
|
|
|
|
incref(&w->ref); /* hold up window while we track */
|
|
if(w->i != nil){
|
|
if(shiftdown && but > 3)
|
|
wkeyctl(w, but == 4 ? Kscrolloneup : Kscrollonedown);
|
|
else if(ptinrect(w->mc.xy, w->scrollr) || (but > 3))
|
|
wscroll(w, but);
|
|
else if(but == 1)
|
|
wselect(w);
|
|
}
|
|
wclose(w);
|
|
}
|
|
|
|
void
|
|
wdelete(Window *w, uint32_t q0, uint32_t q1)
|
|
{
|
|
uint32_t 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->frame.nchars){
|
|
p1 = q1 - w->org;
|
|
if(p1 > w->frame.nchars)
|
|
p1 = w->frame.nchars;
|
|
if(q0 < w->org){
|
|
w->org = q0;
|
|
p0 = 0;
|
|
}else
|
|
p0 = q0 - w->org;
|
|
frdelete(&w->frame, p0, p1);
|
|
wfill(w);
|
|
}
|
|
}
|
|
|
|
|
|
static Window *clickwin;
|
|
static uint32_t clickmsec;
|
|
static Window *selectwin;
|
|
static uint32_t selectq;
|
|
|
|
/*
|
|
* called from frame library
|
|
*/
|
|
void
|
|
framescroll(Frame *f, int dl)
|
|
{
|
|
if(f != &selectwin->frame)
|
|
error("frameselect not right frame");
|
|
wframescroll(selectwin, dl);
|
|
}
|
|
|
|
void
|
|
wframescroll(Window *w, int dl)
|
|
{
|
|
uint32_t q0;
|
|
|
|
if(dl == 0){
|
|
wscrsleep(w, 100);
|
|
return;
|
|
}
|
|
if(dl < 0){
|
|
q0 = wbacknl(w, w->org, -dl);
|
|
if(selectq > w->org+w->frame.p0)
|
|
wsetselect(w, w->org+w->frame.p0, selectq);
|
|
else
|
|
wsetselect(w, selectq, w->org+w->frame.p0);
|
|
}else{
|
|
if(w->org+w->frame.nchars == w->nr)
|
|
return;
|
|
q0 = w->org+frcharofpt(&w->frame, Pt(w->frame.r.min.x, w->frame.r.min.y+dl*w->frame.font->height));
|
|
if(selectq >= w->org+w->frame.p1)
|
|
wsetselect(w, w->org+w->frame.p1, selectq);
|
|
else
|
|
wsetselect(w, selectq, w->org+w->frame.p1);
|
|
}
|
|
wsetorigin(w, q0, TRUE);
|
|
}
|
|
|
|
void
|
|
wselect(Window *w)
|
|
{
|
|
uint32_t q0, q1;
|
|
int b, x, y, first;
|
|
|
|
first = 1;
|
|
selectwin = w;
|
|
/*
|
|
* Double-click immediately if it might make sense.
|
|
*/
|
|
b = w->mc.buttons;
|
|
q0 = w->q0;
|
|
q1 = w->q1;
|
|
selectq = w->org+frcharofpt(&w->frame, w->mc.xy);
|
|
if(clickwin==w && w->mc.msec-clickmsec<500)
|
|
if(q0==q1 && selectq==w->q0){
|
|
wdoubleclick(w, &q0, &q1);
|
|
wsetselect(w, q0, q1);
|
|
x = w->mc.xy.x;
|
|
y = w->mc.xy.y;
|
|
/* stay here until something interesting happens */
|
|
do
|
|
readmouse(&w->mc);
|
|
while(w->mc.buttons==b && abs(w->mc.xy.x-x)<3 && abs(w->mc.xy.y-y)<3);
|
|
w->mc.xy.x = x; /* in case we're calling frselect */
|
|
w->mc.xy.y = y;
|
|
q0 = w->q0; /* may have changed */
|
|
q1 = w->q1;
|
|
selectq = q0;
|
|
}
|
|
if(w->mc.buttons == b){
|
|
w->frame.scroll = framescroll;
|
|
frselect(&w->frame, &w->mc);
|
|
/* horrible botch: while asleep, may have lost selection altogether */
|
|
if(selectq > w->nr)
|
|
selectq = w->org + w->frame.p0;
|
|
w->frame.scroll = nil;
|
|
if(selectq < w->org)
|
|
q0 = selectq;
|
|
else
|
|
q0 = w->org + w->frame.p0;
|
|
if(selectq > w->org+w->frame.nchars)
|
|
q1 = selectq;
|
|
else
|
|
q1 = w->org+w->frame.p1;
|
|
}
|
|
if(q0 == q1){
|
|
if(q0==w->q0 && clickwin==w && w->mc.msec-clickmsec<500){
|
|
wdoubleclick(w, &q0, &q1);
|
|
clickwin = nil;
|
|
}else{
|
|
clickwin = w;
|
|
clickmsec = w->mc.msec;
|
|
}
|
|
}else
|
|
clickwin = nil;
|
|
wsetselect(w, q0, q1);
|
|
while(w->mc.buttons){
|
|
w->mc.msec = 0;
|
|
b = w->mc.buttons;
|
|
if(b & 6){
|
|
if(b & 2){
|
|
wsnarf(w);
|
|
wcut(w);
|
|
}else{
|
|
if(first){
|
|
first = 0;
|
|
getsnarf();
|
|
}
|
|
wpaste(w);
|
|
}
|
|
}
|
|
wscrdraw(w);
|
|
while(w->mc.buttons == b)
|
|
readmouse(&w->mc);
|
|
clickwin = nil;
|
|
}
|
|
}
|
|
|
|
void
|
|
wsendctlmesg(Window *w, int type, Rectangle r, void *p)
|
|
{
|
|
Wctlmesg wcm;
|
|
|
|
wcm.type = type;
|
|
wcm.r = r;
|
|
wcm.p = p;
|
|
send(w->cctl, &wcm);
|
|
}
|
|
|
|
int
|
|
wctlmesg(Window *w, int m, Rectangle r, void *p)
|
|
{
|
|
char *oldname;
|
|
Image *i = p;
|
|
|
|
switch(m){
|
|
default:
|
|
error("unknown control message");
|
|
break;
|
|
case Wakeup:
|
|
if(p!=nil)
|
|
sendp((Channel*)p, w);
|
|
break;
|
|
case Reshaped:
|
|
if(w->deleted){
|
|
freeimage(i);
|
|
break;
|
|
}
|
|
oldname = estrdup(w->name);
|
|
w->screenr = r;
|
|
wresize(w, i);
|
|
proccreate(deletetimeoutproc, oldname, 4096);
|
|
if(Dx(r)<=0){ /* window got hidden, if we had the input, drop it */
|
|
if(w==input)
|
|
input = nil;
|
|
break;
|
|
}
|
|
/* fall through to get input if needed */
|
|
case Topped:
|
|
if(w->deleted || w==input)
|
|
break;
|
|
if(input!=nil){
|
|
Window *oi;
|
|
Channel *c;
|
|
|
|
oi = input;
|
|
incref(&oi->ref);
|
|
|
|
/*
|
|
* have to wait until old input responds before
|
|
* changing input to us because the window might
|
|
* currently be mouse tracking and it is not
|
|
* prepared for getting its input revoked.
|
|
*/
|
|
c = chancreate(sizeof(void*), 0);
|
|
wsendctlmesg(oi, Wakeup, ZR, c);
|
|
recv(c, nil);
|
|
chanfree(c);
|
|
|
|
/*
|
|
* if we are still top window and nobody else has taken
|
|
* input from original window, take the input.
|
|
*/
|
|
if(!w->deleted && w->topped==topped && oi==input){
|
|
input = w;
|
|
|
|
oi->wctlready = 1;
|
|
wsendctlmesg(oi, Repaint, ZR, nil);
|
|
}
|
|
wclose(oi);
|
|
} else {
|
|
input = w;
|
|
wsetcursor(w, FALSE);
|
|
}
|
|
w->wctlready = 1;
|
|
if(m!=Topped && w==input)
|
|
break;
|
|
/* fall thrugh for redraw after input change */
|
|
case Repaint:
|
|
if(w->i==nil || Dx(w->screenr)<=0)
|
|
break;
|
|
wrepaint(w);
|
|
flushimage(display, 1);
|
|
break;
|
|
case Refresh:
|
|
if(w->i==nil || Dx(w->screenr)<=0 || w->mouseopen)
|
|
break;
|
|
wrefresh(w);
|
|
flushimage(display, 1);
|
|
break;
|
|
case Movemouse:
|
|
if(w->i==nil || Dx(w->screenr)<=0 || !ptinrect(r.min, w->i->r))
|
|
break;
|
|
wmovemouse(w, r.min);
|
|
case Rawon:
|
|
break;
|
|
case Rawoff:
|
|
while(w->nraw > 0){
|
|
wkeyctl(w, w->raw[0]);
|
|
--w->nraw;
|
|
runemove(w->raw, w->raw+1, w->nraw);
|
|
}
|
|
break;
|
|
case Holdon:
|
|
case Holdoff:
|
|
if(w->i==nil)
|
|
break;
|
|
wsetcursor(w, FALSE);
|
|
wrepaint(w);
|
|
flushimage(display, 1);
|
|
break;
|
|
case Deleted:
|
|
wclunk(w);
|
|
if(w->notefd >= 0)
|
|
jehanne_write(w->notefd, "hangup", 6);
|
|
if(w->i!=nil){
|
|
proccreate(deletetimeoutproc, estrdup(w->name), 4096);
|
|
wclosewin(w);
|
|
}
|
|
break;
|
|
case Exited:
|
|
wclosewin(w);
|
|
frclear(&w->frame, TRUE);
|
|
if(w->notefd >= 0)
|
|
sys_close(w->notefd);
|
|
chanfree(w->mc.c);
|
|
chanfree(w->ck);
|
|
chanfree(w->cctl);
|
|
chanfree(w->conswrite);
|
|
chanfree(w->consread);
|
|
chanfree(w->mouseread);
|
|
chanfree(w->wctlread);
|
|
chanfree(w->kbdread);
|
|
chanfree(w->complete);
|
|
chanfree(w->gone);
|
|
free(w->raw);
|
|
free(w->r);
|
|
free(w->dir);
|
|
free(w->label);
|
|
free(w);
|
|
break;
|
|
}
|
|
return m;
|
|
}
|
|
|
|
/*
|
|
* Convert back to physical coordinates
|
|
*/
|
|
void
|
|
wmovemouse(Window *w, Point p)
|
|
{
|
|
if(w != input || menuing || sweeping)
|
|
return;
|
|
p.x += w->screenr.min.x-w->i->r.min.x;
|
|
p.y += w->screenr.min.y-w->i->r.min.y;
|
|
moveto(mousectl, p);
|
|
}
|
|
|
|
void
|
|
wborder(Window *w, int type)
|
|
{
|
|
Image *col;
|
|
|
|
if(w->i == nil)
|
|
return;
|
|
if(w->holding){
|
|
if(type == Selborder)
|
|
col = holdcol;
|
|
else
|
|
col = paleholdcol;
|
|
}else{
|
|
if(type == Selborder)
|
|
col = titlecol;
|
|
else
|
|
col = lighttitlecol;
|
|
}
|
|
border(w->i, w->i->r, Selborder, col, ZP);
|
|
}
|
|
|
|
Window*
|
|
wpointto(Point pt)
|
|
{
|
|
int i;
|
|
Window *v, *w;
|
|
|
|
w = nil;
|
|
for(i=0; i<nwindow; i++){
|
|
v = window[i];
|
|
if(ptinrect(pt, v->screenr))
|
|
if(w==nil || v->topped>w->topped)
|
|
w = v;
|
|
}
|
|
return w;
|
|
}
|
|
|
|
void
|
|
wcurrent(Window *w)
|
|
{
|
|
if(w!=nil && w!=input)
|
|
wsendctlmesg(w, Topped, ZR, nil);
|
|
}
|
|
|
|
void
|
|
wsetcursor(Window *w, int force)
|
|
{
|
|
Cursor *p;
|
|
|
|
if(menuing || sweeping || (w!=input && wpointto(mouse->xy)!=w))
|
|
return;
|
|
if(w==nil)
|
|
p = nil;
|
|
else {
|
|
p = w->cursorp;
|
|
if(p==nil && w->holding)
|
|
p = &whitearrow;
|
|
}
|
|
if(p && force) /* force cursor reload */
|
|
lastcursor = nil;
|
|
riosetcursor(p);
|
|
}
|
|
|
|
void
|
|
riosetcursor(Cursor *p)
|
|
{
|
|
if(p==lastcursor)
|
|
return;
|
|
setcursor(mousectl, p);
|
|
lastcursor = p;
|
|
}
|
|
|
|
void
|
|
wtopme(Window *w)
|
|
{
|
|
if(w!=nil && w->i!=nil && w->topped!=topped){
|
|
w->topped = ++topped;
|
|
topwindow(w->i);
|
|
flushimage(display, 1);
|
|
}
|
|
}
|
|
|
|
void
|
|
wbottomme(Window *w)
|
|
{
|
|
if(w!=nil && w->i!=nil){
|
|
w->topped = - ++topped;
|
|
bottomwindow(w->i);
|
|
flushimage(display, 1);
|
|
}
|
|
}
|
|
|
|
Window*
|
|
wtop(Point pt)
|
|
{
|
|
Window *w;
|
|
|
|
w = wpointto(pt);
|
|
if(w){
|
|
incref(&w->ref);
|
|
wtopme(w);
|
|
wcurrent(w);
|
|
wclose(w);
|
|
}
|
|
return w;
|
|
}
|
|
|
|
Window*
|
|
wlookid(int id)
|
|
{
|
|
int i;
|
|
|
|
for(i=0; i<nwindow; i++)
|
|
if(window[i]->id == id)
|
|
return window[i];
|
|
return nil;
|
|
}
|
|
|
|
void
|
|
wclunk(Window *w)
|
|
{
|
|
int i;
|
|
|
|
if(w->deleted)
|
|
return;
|
|
w->deleted = TRUE;
|
|
if(w == input){
|
|
input = nil;
|
|
riosetcursor(nil);
|
|
}
|
|
if(w == wkeyboard)
|
|
wkeyboard = nil;
|
|
for(i=0; i<nhidden; i++)
|
|
if(hidden[i] == w){
|
|
--nhidden;
|
|
memmove(hidden+i, hidden+i+1, (nhidden-i)*sizeof(hidden[0]));
|
|
break;
|
|
}
|
|
for(i=0; i<nwindow; i++)
|
|
if(window[i] == w){
|
|
--nwindow;
|
|
memmove(window+i, window+i+1, (nwindow-i)*sizeof(window[0]));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
wclosewin(Window *w)
|
|
{
|
|
Image *i;
|
|
|
|
assert(w->deleted==TRUE);
|
|
|
|
i = w->i;
|
|
if(i){
|
|
w->i = nil;
|
|
/* move it off-screen to hide it, in case client is slow in letting it go */
|
|
MOVEIT originwindow(i, i->r.min, view->r.max);
|
|
freeimage(i);
|
|
flushimage(display, 1);
|
|
}
|
|
}
|
|
|
|
void
|
|
wsetpid(Window *w, int pid, int dolabel)
|
|
{
|
|
char buf[64];
|
|
int ofd;
|
|
|
|
ofd = w->notefd;
|
|
if(pid <= 0)
|
|
w->notefd = -1;
|
|
else {
|
|
if(dolabel){
|
|
snprint(buf, sizeof(buf), "rc %d", pid);
|
|
free(w->label);
|
|
w->label = estrdup(buf);
|
|
}
|
|
snprint(buf, sizeof(buf), "/proc/%d/notepg", pid);
|
|
w->notefd = sys_open(buf, OWRITE|OCEXEC);
|
|
}
|
|
if(ofd >= 0)
|
|
sys_close(ofd);
|
|
}
|
|
|
|
void
|
|
winshell(void *args)
|
|
{
|
|
Window *w;
|
|
Channel *pidc;
|
|
void **arg;
|
|
char *cmd, *dir;
|
|
char **argv;
|
|
|
|
arg = args;
|
|
w = arg[0];
|
|
pidc = arg[1];
|
|
cmd = arg[2];
|
|
argv = arg[3];
|
|
dir = arg[4];
|
|
sys_rfork(RFNAMEG|RFFDG|RFENVG);
|
|
if(filsysmount(filsys, w->id) < 0){
|
|
fprint(2, "mount failed: %r\n");
|
|
sendul(pidc, 0);
|
|
threadexits("mount failed");
|
|
}
|
|
sys_close(0);
|
|
if(sys_open("/dev/cons", OREAD) < 0){
|
|
fprint(2, "can't open /dev/cons: %r\n");
|
|
sendul(pidc, 0);
|
|
threadexits("/dev/cons");
|
|
}
|
|
sys_close(1);
|
|
if(sys_open("/dev/cons", OWRITE) < 0){
|
|
fprint(2, "can't open /dev/cons: %r\n");
|
|
sendul(pidc, 0);
|
|
threadexits("open"); /* BUG? was terminate() */
|
|
}
|
|
if(wclose(w) == 0){ /* remove extra ref hanging from creation */
|
|
sys_notify(nil);
|
|
dup(1, 2);
|
|
if(dir)
|
|
chdir(dir);
|
|
procexec(pidc, cmd, argv);
|
|
sys__exits("exec failed");
|
|
}
|
|
}
|
|
|
|
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 };
|
|
|
|
Rune *left[] = {
|
|
left1,
|
|
left2,
|
|
left3,
|
|
nil
|
|
};
|
|
Rune *right[] = {
|
|
right1,
|
|
left2,
|
|
left3,
|
|
nil
|
|
};
|
|
|
|
void
|
|
wdoubleclick(Window *w, uint32_t *q0, uint32_t *q1)
|
|
{
|
|
int c, i;
|
|
Rune *r, *l, *p;
|
|
uint32_t q;
|
|
|
|
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 = w->r[q-1];
|
|
p = strrune(l, c);
|
|
if(p != nil){
|
|
if(wclickmatch(w, c, r[p-l], 1, &q))
|
|
*q1 = q-(c!='\n');
|
|
return;
|
|
}
|
|
/* try matching character to right, looking left */
|
|
if(q == w->nr)
|
|
c = '\n';
|
|
else
|
|
c = w->r[q];
|
|
p = strrune(r, c);
|
|
if(p != nil){
|
|
if(wclickmatch(w, c, l[p-r], -1, &q)){
|
|
*q1 = *q0+(*q0<w->nr && c=='\n');
|
|
*q0 = q;
|
|
if(c!='\n' || q!=0 || w->r[0]=='\n')
|
|
(*q0)++;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
/* try filling out word to right */
|
|
while(*q1<w->nr && isalnum(w->r[*q1]))
|
|
(*q1)++;
|
|
/* try filling out word to left */
|
|
while(*q0>0 && isalnum(w->r[*q0-1]))
|
|
(*q0)--;
|
|
}
|
|
|
|
int
|
|
wclickmatch(Window *w, int cl, int cr, int dir, uint32_t *q)
|
|
{
|
|
Rune c;
|
|
int nest;
|
|
|
|
nest = 1;
|
|
for(;;){
|
|
if(dir > 0){
|
|
if(*q == w->nr)
|
|
break;
|
|
c = w->r[*q];
|
|
(*q)++;
|
|
}else{
|
|
if(*q == 0)
|
|
break;
|
|
(*q)--;
|
|
c = w->r[*q];
|
|
}
|
|
if(c == cr){
|
|
if(--nest==0)
|
|
return 1;
|
|
}else if(c == cl)
|
|
nest++;
|
|
}
|
|
return cl=='\n' && nest==1;
|
|
}
|
|
|
|
|
|
uint32_t
|
|
wbacknl(Window *w, uint32_t p, uint32_t 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;
|
|
}
|
|
|
|
void
|
|
wshow(Window *w, uint32_t q0)
|
|
{
|
|
int qe;
|
|
int nl;
|
|
uint32_t q;
|
|
|
|
qe = w->org+w->frame.nchars;
|
|
if(w->org<=q0 && (q0<qe || (q0==qe && qe==w->nr)))
|
|
wscrdraw(w);
|
|
else{
|
|
nl = 4*w->frame.maxlines/5;
|
|
q = wbacknl(w, q0, nl);
|
|
/* avoid going backwards if trying to go forwards - int32_t lines! */
|
|
if(!(q0>w->org && q<w->org))
|
|
wsetorigin(w, q, TRUE);
|
|
while(q0 > w->org+w->frame.nchars)
|
|
wsetorigin(w, w->org+1, FALSE);
|
|
}
|
|
}
|
|
|
|
void
|
|
wsetorigin(Window *w, uint32_t org, int exact)
|
|
{
|
|
int i, a, fixup;
|
|
Rune *r;
|
|
uint32_t 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->frame.nchars){
|
|
frdelete(&w->frame, 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->frame.nchars){
|
|
n = w->org - org;
|
|
r = w->r+org;
|
|
frinsert(&w->frame, r, r+n, 0);
|
|
}else
|
|
frdelete(&w->frame, 0, w->frame.nchars);
|
|
w->org = org;
|
|
wfill(w);
|
|
wscrdraw(w);
|
|
wsetselect(w, w->q0, w->q1);
|
|
if(fixup && w->frame.p1 > w->frame.p0)
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, w->frame.p1-1), w->frame.p1-1, w->frame.p1, 1);
|
|
}
|
|
|
|
void
|
|
wsetselect(Window *w, uint32_t q0, uint32_t q1)
|
|
{
|
|
int p0, p1;
|
|
|
|
/* w->frame.p0 and w->frame.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->frame.nchars)
|
|
p0 = w->frame.nchars;
|
|
if(p1 > w->frame.nchars)
|
|
p1 = w->frame.nchars;
|
|
if(p0==w->frame.p0 && p1==w->frame.p1)
|
|
return;
|
|
/* screen disagrees with desired selection */
|
|
if(w->frame.p1<=p0 || p1<=w->frame.p0 || p0==p1 || w->frame.p1==w->frame.p0){
|
|
/* no overlap or too easy to bother trying */
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, w->frame.p0), w->frame.p0, w->frame.p1, 0);
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, p0), p0, p1, 1);
|
|
goto Return;
|
|
}
|
|
/* overlap; avoid unnecessary painting */
|
|
if(p0 < w->frame.p0){
|
|
/* extend selection backwards */
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, p0), p0, w->frame.p0, 1);
|
|
}else if(p0 > w->frame.p0){
|
|
/* trim first part of selection */
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, w->frame.p0), w->frame.p0, p0, 0);
|
|
}
|
|
if(p1 > w->frame.p1){
|
|
/* extend selection forwards */
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, w->frame.p1), w->frame.p1, p1, 1);
|
|
}else if(p1 < w->frame.p1){
|
|
/* trim last part of selection */
|
|
frdrawsel(&w->frame, frptofchar(&w->frame, p1), p1, w->frame.p1, 0);
|
|
}
|
|
|
|
Return:
|
|
w->frame.p0 = p0;
|
|
w->frame.p1 = p1;
|
|
}
|
|
|
|
uint32_t
|
|
winsert(Window *w, Rune *r, int n, uint32_t q0)
|
|
{
|
|
uint32_t 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->frame.nchars)
|
|
frinsert(&w->frame, r, r+n, q0-w->org);
|
|
return q0;
|
|
}
|
|
|
|
void
|
|
wfill(Window *w)
|
|
{
|
|
Rune *rp;
|
|
int i, n, m, nl;
|
|
|
|
while(w->frame.lastlinefull == FALSE){
|
|
n = w->nr-(w->org+w->frame.nchars);
|
|
if(n == 0)
|
|
break;
|
|
if(n > 2000) /* educated guess at reasonable amount */
|
|
n = 2000;
|
|
rp = w->r+(w->org+w->frame.nchars);
|
|
|
|
/*
|
|
* it's expensive to frinsert more than we need, so
|
|
* count newlines.
|
|
*/
|
|
nl = w->frame.maxlines-w->frame.nlines;
|
|
m = 0;
|
|
for(i=0; i<n; ){
|
|
if(rp[i++] == '\n'){
|
|
m++;
|
|
if(m >= nl)
|
|
break;
|
|
}
|
|
}
|
|
frinsert(&w->frame, rp, rp+i, w->frame.nchars);
|
|
}
|
|
}
|
|
|
|
char*
|
|
wcontents(Window *w, int *ip)
|
|
{
|
|
return runetobyte(w->r, w->nr, ip);
|
|
}
|