ref: 9ca6ca345fa3b06dbf35e7808c35c0aaa7aa3bec
dir: /sys/src/cmd/vt/main.c/
#include <u.h>
#include <libc.h>
#include <draw.h>
#include "cons.h"
#include <thread.h>
#include <fcall.h>
#include <9p.h>
#include <bio.h>
#include <mouse.h>
#include <keyboard.h>
#include <plumb.h>
enum menuact2{
Mbackup,
Mforward,
Mreset,
Mpaste,
Msnarf,
Mplumb,
Mpage,
};
enum menuact3{
M24x80,
Mcrnl,
Mnl,
Mraw,
Mblocksel,
Mexit,
};
char *menutext2[] = {
[Mbackup] "backup",
[Mforward] "forward",
[Mreset] "reset",
[Mpaste] "paste",
[Msnarf] "snarf",
[Mplumb] "plumb",
[Mpage] "page",
nil
};
char *menutext3[] = {
[M24x80] "24x80",
[Mcrnl] "crnl",
[Mnl] "nl",
[Mraw] "raw",
[Mblocksel] "blocksel",
[Mexit] "exit",
nil
};
/* variables associated with the screen */
int x, y; /* character positions */
Rune *backp;
int backc;
int nbacklines;
int xmax, ymax;
int blocked;
int winchgen;
int resize_flag = 1;
int pagemode;
int olines;
int peekc;
int blocksel = 0;
int cursoron = 1;
int chording = 0;
int hostclosed = 0;
Menu menu2;
Menu menu3;
Rune *histp;
Rune hist[HISTSIZ];
Rune *onscreenrbuf;
uchar *onscreenabuf;
uchar *onscreencbuf;
#define onscreenr(x, y) &onscreenrbuf[((y)*(xmax+2) + (x))]
#define onscreena(x, y) &onscreenabuf[((y)*(xmax+2) + (x))]
#define onscreenc(x, y) &onscreencbuf[((y)*(xmax+2) + (x))]
uchar *screenchangebuf;
uint scrolloff;
#define screenchange(y) screenchangebuf[((y)+scrolloff) % (ymax+1)]
int yscrmin, yscrmax;
int attr, defattr;
Rectangle selrect;
Image *cursorsave;
Image *bordercol;
Image *colors[8];
Image *hicolors[8];
Image *red;
Image *green;
Image *fgcolor;
Image *bgcolor;
Image *fgselected;
Image *bgselected;
Image *highlight;
uint rgbacolors[8] = {
0x000000FF, /* black */
0xAA0000FF, /* red */
0x00AA00FF, /* green */
0xFF5500FF, /* brown */
0x0000FFFF, /* blue */
0xAA00AAFF, /* purple */
0x00AAAAFF, /* cyan */
0x7F7F7FFF, /* white */
};
ulong rgbahicolors[8] = {
0x555555FF, /* light black aka grey */
0xFF5555FF, /* light red */
0x55FF55FF, /* light green */
0xFFFF55FF, /* light brown aka yellow */
0x5555FFFF, /* light blue */
0xFF55FFFF, /* light purple */
0x55FFFFFF, /* light cyan */
0xFFFFFFFF, /* light grey aka white */
};
/* terminal control */
struct ttystate ttystate[2] = { {0, 1}, {0, 0} };
Point margin;
Point ftsize;
Rune kbdchar;
#define button(num) (mc->buttons == (1<<((num)-1)))
Mousectl *mc;
Keyboardctl *kc;
Channel *hc[2];
Consstate cs[1];
int nocolor;
int logfd = -1;
int hostpid = -1;
Biobuf *snarffp = 0;
Rune *hostbuf, *hostbufp;
char *hostin;
char echo_input[BSIZE];
char *echop = echo_input; /* characters to echo, after canon */
char sendbuf[BSIZE]; /* hope you can't type ahead more than BSIZE chars */
char *sendbufp = sendbuf;
char *term;
struct funckey *fk, *appfk;
/* functions */
int input(void);
int waitchar(void);
void waitio(void);
int rcvchar(void);
void bigscroll(void);
void readmenu(void);
void selecting(void);
int selected(int, int);
void resized(void);
void drawcursor(void);
void send_interrupt(void);
int alnum(int);
void escapedump(int,uchar *,int);
void paste(void);
void snarfsel(void);
void plumbsel(void);
static Channel *pidchan;
static void
runcmd(void *args)
{
char **argv = args;
char *cmd;
rfork(RFNAMEG);
mountcons();
rfork(RFFDG);
close(0);
open("/dev/cons", OREAD);
close(1);
open("/dev/cons", OWRITE);
dup(1, 2);
cmd = nil;
while(*argv != nil){
if(cmd == nil)
cmd = strdup(*argv);
else
cmd = smprint("%s %q", cmd, *argv);
argv++;
}
procexecl(pidchan, "/bin/rc", "rcX", cmd == nil ? nil : "-c", cmd, nil);
sysfatal("%r");
}
void
send_interrupt(void)
{
if(hostpid > 0)
postnote(PNGROUP, hostpid, "interrupt");
}
void
sendnchars(int n, char *p)
{
if((n = utfnlen(p, n)) < 1)
return;
hostin = smprint("%.*s", n, p);
while(hostin != nil){
if(nbsendp(hc[0], hostin)){
hostin = nil;
break;
}
drawcursor();
waitio();
if(resize_flag)
resized();
}
}
static void
shutdown(void)
{
send_interrupt();
threadexitsall(nil);
}
static void
catch(void*, char*)
{
shutdown();
}
void
usage(void)
{
fprint(2, "usage: %s [-2abcrx] [-f font] [-l logfile] [cmd...]\n", argv0);
exits("usage");
}
void
threadmain(int argc, char **argv)
{
int rflag;
int i, blkbg;
char *fontname, *p;
fontname = nil;
fk = ansifk;
term = "vt100";
blkbg = 0;
rflag = 0;
attr = defattr;
ARGBEGIN{
case '2':
fk = vt220fk;
term = "vt220";
break;
case 'a':
term = "ansi";
break;
case 'b':
blkbg = 1; /* e.g., for linux colored output */
break;
case 'c':
nocolor = 1;
break;
case 'f':
fontname = EARGF(usage());
break;
case 'l':
p = EARGF(usage());
logfd = create(p, OWRITE|OCEXEC, 0666);
if(logfd < 0)
sysfatal("could not create log file: %s: %r", p);
break;
case 'x':
fk = vt220fk;
term = "xterm";
break;
case 'r':
rflag = 1;
break;
default:
usage();
break;
}ARGEND;
if(rfork(RFENVG) < 0)
sysfatal("rfork: %r");
quotefmtinstall();
notify(catch);
atexit(shutdown);
if(initdraw(0, fontname, term) < 0)
sysfatal("inidraw failed: %r");
if((mc = initmouse("/dev/mouse", screen)) == nil)
sysfatal("initmouse failed: %r");
if((kc = initkeyboard("/dev/cons")) == nil)
sysfatal("initkeyboard failed: %r");
hc[0] = chancreate(sizeof(char*), 256); /* input to host */
hc[1] = chancreate(sizeof(Rune*), 8); /* output from host */
cs->raw = rflag;
histp = hist;
menu2.item = menutext2;
menu3.item = menutext3;
pagemode = 0;
blocked = 0;
ftsize.y = font->height;
ftsize.x = stringwidth(font, "m");
red = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DRed);
green = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DGreen);
bordercol = allocimage(display, Rect(0,0,1,1), screen->chan, 1, 0xCCCCCCCC);
highlight = allocimage(display, Rect(0,0,1,1), CHAN1(CAlpha,8), 1, 0x80);
for(i=0; i<8; i++){
colors[i] = allocimage(display, Rect(0,0,1,1), screen->chan, 1,
rgbacolors[i]);
hicolors[i] = allocimage(display, Rect(0,0,1,1), screen->chan, 1,
rgbahicolors[i]);
}
bgcolor = (blkbg? display->black: display->white);
fgcolor = (blkbg? display->white: display->black);
bgselected = allocimage(display, Rect(0,0,1,1), CMAP8, 1, blkbg ? 0x333333FF : 0xCCCCCCFF);
fgselected = allocimage(display, Rect(0,0,1,1), CMAP8, 1, blkbg ? 0xCCCCCCFF : 0x333333FF);
resized();
pidchan = chancreate(sizeof(int), 0);
proccreate(runcmd, argv, 16*1024);
hostpid = recvul(pidchan);
emulate();
}
Image*
bgcol(int a, int c, int sel)
{
if(sel)
return bgselected;
if(nocolor || (c & (1<<0)) == 0){
if(a & TReverse)
return fgcolor;
return bgcolor;
}
if((a & TReverse) != 0)
c >>= 4;
return colors[(c>>1)&7];
}
Image*
fgcol(int a, int c, int sel)
{
if(sel)
return fgselected;
if(nocolor || (c & (1<<4)) == 0){
if(a & TReverse)
return bgcolor;
return fgcolor;
}
if((a & TReverse) == 0)
c >>= 4;
if(a & THighIntensity)
return hicolors[(c>>1)&7];
return colors[(c>>1)&7];
}
void
hidecursor(void)
{
if(cursorsave == nil)
return;
draw(screen, cursorsave->r, cursorsave, nil, cursorsave->r.min);
freeimage(cursorsave);
cursorsave = nil;
}
void
drawscreen(void)
{
int x, y, n;
uchar *ap, *cp;
Image *c;
Rune *rp;
Point p, q;
hidecursor();
if(scrolloff && scrolloff <= ymax)
draw(screen, Rpt(pt(0,0), pt(xmax+2, ymax+1-scrolloff)),
screen, nil, pt(0, scrolloff));
for(y = 0; y <= ymax; y++){
if(!screenchange(y))
continue;
screenchange(y) = 0;
for(x = 0; x <= xmax; x += n){
cp = onscreenc(x, y);
ap = onscreena(x, y);
c = bgcol(*ap, *cp, selected(x, y));
for(n = 1; x+n <= xmax && bgcol(ap[n], cp[n], selected(x + n, y)) == c; n++)
;
draw(screen, Rpt(pt(x, y), pt(x+n, y+1)), c, nil, ZP);
}
draw(screen, Rpt(pt(x, y), pt(x+1, y+1)), bgcolor, nil, ZP);
for(x = 0; x <= xmax; x += n){
rp = onscreenr(x, y);
if(*rp == 0){
n = 1;
continue;
}
ap = onscreena(x, y);
cp = onscreenc(x, y);
c = fgcol(*ap, *cp, selected(x, y));
for(n = 1; x+n <= xmax && rp[n] != 0 && fgcol(ap[n], cp[n], selected(x + n, y)) == c
&& ((ap[n] ^ *ap) & TUnderline) == 0; n++)
;
p = pt(x, y);
q = runestringn(screen, p, c, ZP, font, rp, n);
if(*ap & TUnderline){
p.y += font->ascent+1;
q.y += font->ascent+2;
draw(screen, Rpt(p, q), c, nil, ZP);
}
}
if(*onscreenr(x, y) == 0)
runestringn(screen, pt(x, y),
bordercol,
ZP, font, L">", 1);
}
scrolloff = 0;
}
void
drawcursor(void)
{
Image *col;
Rectangle r;
hidecursor();
if(cursoron == 0)
return;
col = (hostin != nil || blocked || hostclosed) ? red : bordercol;
r = Rpt(pt(x, y), pt(x+1, y+1));
cursorsave = allocimage(display, r, screen->chan, 0, DNofill);
draw(cursorsave, r, screen, nil, r.min);
border(screen, r, 2, col, ZP);
}
void
clear(int x1, int y1, int x2, int y2)
{
int c = (attr & 0x0F00)>>8; /* bgcolor */
if(y1 < 0 || y1 > ymax || x1 < 0 || x1 > xmax || y2 <= y1 || x2 <= x1)
return;
while(y1 < y2){
screenchange(y1) = 1;
if(x1 < x2){
memset(onscreenr(x1, y1), 0, (x2-x1)*sizeof(Rune));
memset(onscreena(x1, y1), 0, x2-x1);
memset(onscreenc(x1, y1), c, x2-x1);
}
if(x2 > xmax)
*onscreenr(xmax+1, y1) = '\n';
y1++;
}
}
void
newline(void)
{
if(x > xmax)
*onscreenr(xmax+1, y) = 0; /* wrap arround, remove hidden newline */
nbacklines--;
if(y >= yscrmax) {
y = yscrmax;
if(pagemode && olines >= yscrmax){
blocked = 1;
return;
}
scroll(yscrmin+1, yscrmax+1, yscrmin, yscrmax);
} else
y++;
olines++;
}
int
get_next_char(void)
{
int c = peekc;
peekc = 0;
if(c > 0)
return(c);
while(c <= 0) {
if(backp) {
c = *backp;
if(c && nbacklines >= 0){
backp++;
if(backp >= &hist[HISTSIZ])
backp = hist;
return(c);
}
backp = 0;
}
c = waitchar();
if(c > 0 && logfd >= 0)
fprint(logfd, "%C", (Rune)c);
}
*histp++ = c;
if(histp >= &hist[HISTSIZ])
histp = hist;
*histp = '\0';
return(c);
}
char*
backrune(char *start, char *cp)
{
char *ep;
ep = cp;
cp -= UTFmax;
if(cp < start)
cp = start;
while(cp < ep){
Rune r;
int n;
n = chartorune(&r, cp);
if(cp + n >= ep)
break;
cp += n;
}
return cp;
}
int
canon(char *ep, Rune c)
{
switch(c) {
case Kdown:
case Kpgdown:
return SCROLL;
case '\b':
if(sendbufp > sendbuf){
sendbufp = backrune(sendbuf, sendbufp);
*ep++ = '\b';
*ep++ = ' ';
*ep++ = '\b';
}
break;
case 0x15: /* ^U line kill */
sendbufp = sendbuf;
*ep++ = '^';
*ep++ = 'U';
*ep++ = '\n';
break;
case 0x17: /* ^W word kill */
while(sendbufp > sendbuf && !alnum(*sendbufp)) {
sendbufp = backrune(sendbuf, sendbufp);
*ep++ = '\b';
*ep++ = ' ';
*ep++ = '\b';
}
while(sendbufp > sendbuf && alnum(*sendbufp)) {
sendbufp = backrune(sendbuf, sendbufp);
*ep++ = '\b';
*ep++ = ' ';
*ep++ = '\b';
}
break;
case '\177': /* interrupt */
sendbufp = sendbuf;
send_interrupt();
return(NEWLINE);
case '\021': /* quit */
case '\r':
case '\n':
if(sendbufp < &sendbuf[BSIZE])
*sendbufp++ = '\n';
sendnchars((int)(sendbufp-sendbuf), sendbuf);
sendbufp = sendbuf;
if(c == '\n' || c == '\r')
*ep++ = '\n';
*ep = 0;
return(NEWLINE);
case '\004': /* EOT */
if(sendbufp == sendbuf) {
sendnchars(0,sendbuf);
*ep = 0;
return(NEWLINE);
}
/* fall through */
default:
if(sendbufp < &sendbuf[BSIZE-UTFmax])
sendbufp += runetochar(sendbufp, &c);
ep += runetochar(ep, &c);
break;
}
*ep = 0;
return(OTHER);
}
char*
lookfk(struct funckey *fk, char *name)
{
int i;
for(i=0; fk[i].name; i++){
if(strcmp(name, fk[i].name)==0)
return fk[i].sequence;
}
return nil;
}
int
sendfk(char *name)
{
char *s = lookfk(appfk != nil ? appfk : fk, name);
if(s == nil && appfk != nil)
s = lookfk(fk, name);
if(s != nil){
sendnchars(strlen(s), s);
return 1;
}
return 0;
}
int
input(void)
{
static char echobuf[4*BSIZE];
Again:
if(resize_flag)
resized();
if(backp)
return(0);
if(snarffp) {
int c;
if((c = Bgetrune(snarffp)) < 0) {
Bterm(snarffp);
snarffp = nil;
goto Again;
}
kbdchar = c;
}
if(kbdchar) {
if(backc){
backc = 0;
backup(backc);
}
if(blocked)
resize_flag = 1;
if(cs->raw) {
switch(kbdchar){
case Kins:
if(!sendfk("insert"))
goto Send;
break;
case Kdel:
if(!sendfk("delete"))
goto Send;
break;
case Khome:
if(!sendfk("home"))
goto Send;
break;
case Kend:
if(!sendfk("end"))
goto Send;
break;
case Kpgup:
sendfk("page up");
break;
case Kpgdown:
sendfk("page down");
break;
case Kup:
sendfk("up key");
break;
case Kdown:
sendfk("down key");
break;
case Kleft:
sendfk("left key");
break;
case Kright:
sendfk("right key");
break;
case KF|1:
sendfk("F1");
break;
case KF|2:
sendfk("F2");
break;
case KF|3:
sendfk("F3");
break;
case KF|4:
sendfk("F4");
break;
case KF|5:
sendfk("F5");
break;
case KF|6:
sendfk("F6");
break;
case KF|7:
sendfk("F7");
break;
case KF|8:
sendfk("F8");
break;
case KF|9:
sendfk("F9");
break;
case KF|10:
sendfk("F10");
break;
case KF|11:
sendfk("F11");
break;
case KF|12:
sendfk("F12");
break;
case '\n':
echobuf[0] = '\r';
sendnchars(1, echobuf);
break;
case '\r':
echobuf[0] = '\n';
sendnchars(1, echobuf);
break;
default:
Send:
sendnchars(runetochar(echobuf, &kbdchar), echobuf);
break;
}
} else {
switch(canon(echobuf, kbdchar)){
case SCROLL:
if(!blocked)
bigscroll();
break;
default:
strcat(echo_input,echobuf);
}
}
blocked = 0;
kbdchar = 0;
goto Again;
} else if(nbrecv(kc->c, &kbdchar))
goto Again;
if(!blocked){
if(host_avail())
return(rcvchar());
free(hostbuf);
hostbufp = hostbuf = nbrecvp(hc[1]);
if(host_avail() && nrand(32))
return(rcvchar());
}
return -1;
}
int
waitchar(void)
{
int r;
for(;;) {
r = input();
if(r != -1)
return r;
drawscreen();
drawcursor();
waitio();
}
}
void
waitio(void)
{
enum { AMOUSE, ARESIZE, AKBD, AHOSTIN, AHOSTOUT, AEND, };
Alt a[AEND+1] = {
{ mc->c, &mc->Mouse, CHANRCV },
{ mc->resizec, nil, CHANRCV },
{ kc->c, &kbdchar, CHANRCV },
{ hc[0], &hostin, CHANSND },
{ hc[1], &hostbuf, CHANRCV },
{ nil, nil, CHANEND },
};
if(kbdchar != 0)
a[AKBD].op = CHANNOP;
if(hostin == nil)
a[AHOSTIN].op = CHANNOP;
if(blocked)
a[AHOSTOUT].op = CHANNOP;
else if(hostbuf != nil)
a[AHOSTOUT].op = CHANNOBLK;
Next:
if(display->bufp > display->buf)
flushimage(display, 1);
switch(alt(a)){
case AMOUSE:
if(button(1) || chording)
selecting();
else if(button(2) || button(3))
readmenu();
else if(button(4))
backup(backc+1);
else if(button(5) && backc > 0)
backup(--backc);
else if(resize_flag == 0)
goto Next;
break;
case ARESIZE:
resize_flag = 2;
break;
case AHOSTIN:
hostin = nil;
break;
case AHOSTOUT:
hostbufp = hostbuf;
if(hostbuf == nil)
hostclosed = 1;
break;
}
}
void
putenvint(char *name, int x)
{
char buf[20];
snprint(buf, sizeof buf, "%d", x);
putenv(name, buf);
}
void
exportsize(void)
{
putenvint("WINCH", ++winchgen);
putenvint("XPIXELS", (xmax+1)*ftsize.x);
putenvint("YPIXELS", (ymax+1)*ftsize.y);
putenvint("LINES", ymax+1);
putenvint("COLS", xmax+1);
putenv("TERM", term);
if(cs->winch)
send_interrupt();
}
void
setdim(int ht, int wid)
{
int fd;
if(wid > 0) xmax = wid-1;
if(ht > 0) ymax = ht-1;
x = 0;
y = 0;
yscrmin = 0;
yscrmax = ymax;
olines = 0;
margin.x = (Dx(screen->r) - (xmax+1)*ftsize.x) / 2;
margin.y = (Dy(screen->r) - (ymax+1)*ftsize.y) / 2;
free(screenchangebuf);
screenchangebuf = emalloc9p(ymax+1);
scrolloff = 0;
selrect = ZR;
free(onscreenrbuf);
onscreenrbuf = emalloc9p((ymax+1)*(xmax+2)*sizeof(Rune));
free(onscreenabuf);
onscreenabuf = emalloc9p((ymax+1)*(xmax+2));
free(onscreencbuf);
onscreencbuf = emalloc9p((ymax+1)*(xmax+2));
clear(0,0,xmax+1,ymax+1);
draw(screen, screen->r, bgcolor, nil, ZP);
if(resize_flag || backc)
return;
exportsize();
fd = open("/dev/wctl", OWRITE);
if(fd >= 0){
ht = (ymax+1) * ftsize.y + 2*INSET + 2*Borderwidth;
wid = (xmax+1) * ftsize.x + ftsize.x + 2*INSET + 2*Borderwidth;
fprint(fd, "resize -dx %d -dy %d\n", wid, ht);
close(fd);
}
}
void
resized(void)
{
if(resize_flag > 1 && getwindow(display, Refnone) < 0){
fprint(2, "can't reattach to window: %r\n");
exits("can't reattach to window");
}
setdim((Dy(screen->r) - 2*INSET)/ftsize.y, (Dx(screen->r) - 2*INSET - ftsize.x)/ftsize.x);
exportsize();
if(resize_flag > 1)
backup(backc);
resize_flag = 0;
werrstr(""); /* clear spurious error messages */
}
char*
selrange(char *d, int x0, int y0, int x1, int y1)
{
Rune *s, *e;
int z, p;
s = onscreenr(x0, y0);
e = onscreenr(x1, y1);
for(z = p = 0; s < e; s++){
if(*s){
if(*s == '\n')
z = p = 0;
else if(p++ == 0){
while(z-- > 0) *d++ = ' ';
}
d += runetochar(d, s);
} else {
z++;
}
}
return d;
}
char*
selection(void)
{
char *s, *p;
int y;
/* generous, but we can spare a few bytes for a few microseconds */
s = p = malloc(UTFmax*(xmax+1)*(Dy(selrect)+1)+1);
if(s == nil)
return nil;
if(blocksel){
for(y = selrect.min.y; y <= selrect.max.y; y++){
p = selrange(p, selrect.min.x, y, selrect.max.x, y);
*p++ = '\n';
}
} else {
p = selrange(p, selrect.min.x, selrect.min.y, selrect.max.x, selrect.max.y);
}
*p = 0;
return s;
}
void
snarfsel(void)
{
Biobuf *b;
char *s;
if((s = selection()) == nil)
return;
if((b = Bopen("/dev/snarf", OWRITE|OTRUNC)) == nil){
free(s);
return;
}
Bprint(b, "%s", s);
Bterm(b);
free(s);
}
void
plumbsel(void)
{
char *s, wdir[1024];
int plumb;
s = selection();
if(s == nil || *s == 0)
return;
if(getwd(wdir, sizeof wdir) == nil){
free(s);
return;
}
if((plumb = plumbopen("send", OWRITE)) < 0){
free(s);
return;
}
plumbsendtext(plumb, "vt", nil, wdir, s);
close(plumb);
free(s);
}
void
paste(void)
{
if(snarffp == nil)
snarffp = Bopen("/dev/snarf",OREAD);
}
int
isalnum(Rune c)
{
/*
* Hard to get absolutely right. Use what we know about ASCII
* and assume anything above the Latin control characters is
* potentially an alphanumeric.
*/
if(c <= ' ')
return 0;
if(0x7F<=c && c<=0xA0)
return 0;
if(utfrune("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c))
return 0;
return 1;
}
int
isspace(Rune c)
{
return c == 0 || c == ' ' || c == '\t' ||
c == '\n' || c == '\r' || c == '\v';
}
void
unselect(void)
{
int y;
for(y = selrect.min.y; y <= selrect.max.y; y++)
screenchange(y) = 1;
selrect = ZR;
}
int
inmode(Rune r, int mode)
{
return (mode == 1) ? isalnum(r) : r && !isspace(r);
}
/*
* Selects different things based on mode.
* 0: selects swept-over text.
* 1: selects alphanumeric segment
* 2: selects non-whitespace segment.
*/
void
select(Point p, Point q, int mode)
{
if(onscreenr(p.x, p.y) > onscreenr(q.x, q.y)){
select(q, p, mode);
return;
}
unselect();
if(p.y < 0 || p.y > ymax)
return;
if(p.y < 0){
p.y = 0;
if(!blocksel) p.x = 0;
}
if(q.y > ymax){
q.y = ymax;
if(!blocksel) q.x = xmax+1;
}
if(mode != 0 && eqpt(p, q)){
while(p.x > 0 && inmode(*onscreenr(p.x-1, p.y), mode))
p.x--;
while(q.x <= xmax && inmode(*onscreenr(q.x, q.y), mode))
q.x++;
if(p.x != q.x)
mode = 0;
}
if(p.x < 0 || mode)
p.x = 0;
if(q.x > xmax+1 || mode)
q.x = xmax+1;
selrect = Rpt(p, q);
for(; p.y <= q.y; p.y++)
screenchange(p.y) = 1;
}
void
selecting(void)
{
Point p, q;
static ulong t, mode;
if(!chording){
p = pos(mc->xy);
t += mc->msec;
mode++;
do{
q = pos(mc->xy);
if(t > 200)
mode = 0;
if(mode > 2)
mode = 2;
select(p, q, mode);
drawscreen();
readmouse(mc);
} while(button(1));
}
if(mc->buttons != chording){
switch(mc->buttons & 0x7){
case 0: /* nothing */ break;
case 3: snarfsel(); break;
case 5: paste(); break;
}
}
drawscreen();
t = -mc->msec;
chording = mc->buttons;
}
int
selected(int x, int y)
{
int s;
s = y >= selrect.min.y && y <= selrect.max.y;
if (blocksel)
s = s && x >= selrect.min.x && x < selrect.max.x;
else{
if(y == selrect.min.y)
s = s && x >= selrect.min.x;
if(y == selrect.max.y)
s = s && x < selrect.max.x;
if(y > selrect.min.y && y < selrect.max.y)
s = 1;
}
return s;
}
void
readmenu(void)
{
Point p;
p = pos(mc->xy);
if(button(3)) {
menu3.item[1] = ttystate[cs->raw].crnl ? "cr" : "crnl";
menu3.item[2] = ttystate[cs->raw].nlcr ? "nl" : "nlcr";
menu3.item[3] = cs->raw ? "cooked" : "raw";
menu3.item[4] = blocksel ? "linesel" : "blocksel";
switch(menuhit(3, mc, &menu3, nil)) {
case M24x80: /* 24x80 */
setdim(24, 80);
backup(backc);
return;
case Mcrnl: /* newline after cr? */
ttystate[cs->raw].crnl = !ttystate[cs->raw].crnl;
return;
case Mnl: /* cr after newline? */
ttystate[cs->raw].nlcr = !ttystate[cs->raw].nlcr;
return;
case Mraw: /* switch raw mode */
cs->raw = !cs->raw;
return;
case Mblocksel:
unselect();
blocksel = !blocksel;
return;
case Mexit:
exits(0);
}
return;
}
menu2.item[Mpage] = pagemode? "scroll": "page";
switch(menuhit(2, mc, &menu2, nil)) {
case Mbackup: /* back up */
backup(backc+1);
return;
case Mforward: /* move forward */
if(backc > 0)
backup(--backc);
return;
case Mreset: /* reset */
backc = 0;
backup(0);
return;
case Mpaste: /* paste the snarf buffer */
paste();
return;
case Msnarf: /* send the snarf buffer */
snarfsel();
return;
case Mplumb:
plumbsel();
return;
case Mpage: /* pause and clear at end of screen */
pagemode = 1-pagemode;
if(blocked && !pagemode) {
resize_flag = 1;
blocked = 0;
}
return;
}
}
void
backup(int count)
{
Rune *cp;
int left, n;
unselect();
resize_flag = 1;
if(count == 0 && !pagemode) {
n = ymax;
nbacklines = HISTSIZ; /* make sure we scroll to the very end */
} else{
n = 3*(count+1)*ymax/4;
nbacklines = ymax-1;
}
cp = histp;
left = 1;
while (n >= 0) {
cp--;
if(cp < hist)
cp = &hist[HISTSIZ-1];
if(*cp == '\0') {
left = 0;
break;
}
if(*cp == '\n')
n--;
}
cp++;
if(cp >= &hist[HISTSIZ])
cp = hist;
backp = cp;
if(left)
backc = count;
}
Point
pt(int x, int y)
{
return addpt(screen->r.min, Pt(x*ftsize.x+margin.x,y*ftsize.y+margin.y));
}
Point
pos(Point pt)
{
pt.x -= screen->r.min.x + margin.x;
pt.y -= screen->r.min.y + margin.y;
pt.x /= ftsize.x;
pt.y /= ftsize.y;
if(pt.x < 0)
pt.x = 0;
else if(pt.x > xmax+1)
pt.x = xmax+1;
if(pt.y < 0)
pt.y = 0;
else if(pt.y > ymax+1)
pt.y = ymax+1;
return pt;
}
void
shift(int x1, int y, int x2, int w)
{
if(y < 0 || y > ymax || x1 < 0 || x2 < 0 || w <= 0)
return;
if(x1+w > xmax+1)
w = xmax+1 - x1;
if(x2+w > xmax+1)
w = xmax+1 - x2;
screenchange(y) = 1;
memmove(onscreenr(x1, y), onscreenr(x2, y), w*sizeof(Rune));
memmove(onscreena(x1, y), onscreena(x2, y), w);
memmove(onscreenc(x1, y), onscreenc(x2, y), w);
}
void
scroll(int sy, int ly, int dy, int cy) /* source, limit, dest, which line to clear */
{
int n, d, i;
if(sy < 0 || sy > ymax || dy < 0 || dy > ymax)
return;
n = ly - sy;
if(sy + n > ymax+1)
n = ymax+1 - sy;
if(dy + n > ymax+1)
n = ymax+1 - dy;
d = sy - dy;
if(n > 0 && d != 0){
if(d > 0 && dy == 0 && n >= ymax){
scrolloff += d;
} else {
for(i = 0; i < n; i++)
screenchange(dy+i) = 1;
}
memmove(onscreenr(0, dy), onscreenr(0, sy), n*(xmax+2)*sizeof(Rune));
memmove(onscreena(0, dy), onscreena(0, sy), n*(xmax+2));
memmove(onscreenc(0, dy), onscreenc(0, sy), n*(xmax+2));
}
/* move selection */
selrect.min.y -= d;
selrect.max.y -= d;
select(selrect.min, selrect.max, 0);
clear(0, cy, xmax+1, cy+1);
}
void
bigscroll(void) /* scroll up half a page */
{
int half = ymax/3;
if(x == 0 && y == 0)
return;
if(y < half) {
clear(0, 0, xmax+1, ymax+1);
scrolloff = 0;
x = y = 0;
return;
}
scroll(half, ymax+1, 0, ymax);
clear(0, y-half+1, xmax+1, ymax+1);
y -= half;
if(olines)
olines -= half;
}
int
number(Rune *p, int *got)
{
int c, n = 0;
if(got)
*got = 0;
while ((c = get_next_char()) >= '0' && c <= '9'){
if(got)
*got = 1;
n = n*10 + c - '0';
}
*p = c;
return(n);
}
/* stubs */
int
host_avail(void)
{
if(*echop != 0 && fullrune(echop, strlen(echop)))
return 1;
if(hostbuf == nil)
return 0;
return *hostbufp != 0;
}
int
rcvchar(void)
{
Rune r;
if(*echop != 0) {
echop += chartorune(&r, echop);
if(*echop == 0) {
echop = echo_input;
*echop = 0;
}
return r;
}
return *hostbufp++;
}
void
ringbell(void){
}
int
alnum(int c)
{
if(c >= 'a' && c <= 'z')
return 1;
if(c >= 'A' && c <= 'Z')
return 1;
if(c >= '0' && c <= '9')
return 1;
return 0;
}
void
escapedump(int fd,uchar *str,int len)
{
int i;
for(i = 0; i < len; i++) {
if((str[i] < ' ' || str[i] > '\177') &&
str[i] != '\n' && str[i] != '\t') fprint(fd,"^%c",str[i]+64);
else if(str[i] == '\177') fprint(fd,"^$");
else if(str[i] == '\n') fprint(fd,"^J\n");
else fprint(fd,"%c",str[i]);
}
}
void
drawstring(Rune *str, int n)
{
screenchange(y) = 1;
memmove(onscreenr(x, y), str, n*sizeof(Rune));
memset(onscreena(x, y), attr & 0xFF, n);
memset(onscreenc(x, y), attr >> 8, n);
}