#
# Text and frame management needs a rewrite.
#
implement Pimpl;
include "mods.m";
mods, debug, win, tree: import dat;
frame: Framem;
Menu: import menus;
setcursor, Waiting, Arrow,
getfont, Cpointer, cols, panelback, maxpt, cookclick, drawtag,
BACK,TEXT, readsnarf, Inset, terminate, writesnarf, readfile,
SET, CLEAR, SHAD, BORD, CMtriple, CMdouble : import gui;
Ptag, Pline, Pedit, Pshown, Psync, Pdead, Pdirty, Ptbl, Predraw,
intag, escape, unescape, nth, Panel: import wpanel;
panelctl, panelkbd, panelmouse, tagmouse, Tree: import wtree;
Frame: import frame;
fixpos, dtxt, strstr, Maxline, Blks, strchr, Str: import tblks;
Edit, Edits: import tundo;
Ptext: import text;
usage: import arg;
panels: array of ref Ptext;
textmenu: ref Menu;
# To allow search from tag lines, anytime a text is selected it becomes
# an argument for search, open, etc. The argument is void when they
# keyboard is used or a single click is made.
seltext: string;
pimpl(p: ref Panel): ref Ptext
{
if (p.implid < 0 || p.implid > len panels || panels[p.implid] == nil)
panic("draw: bug: no impl");
return panels[p.implid];
}
init(d: Livedat): string
{
prefixes = list of {"text:", "button:", "label:", "tag:", "tbl:"};
dat = d;
initmods();
frame = load Framem Framem->PATH;
if (frame == nil)
return sprint("loading %s: %r", Framem->PATH);
dat = d;
str = load String String->PATH;
if (str == nil)
return sprint("loading %s: %r", String->PATH);
text = load Text Text->PATH;
if (text == nil)
return sprint("loading %s: %r", Text->PATH);
tblks = load Tblks Tblks->PATH;
if (tblks == nil)
return sprint("loading %s: %r", Tblks->PATH);
tundo= load Tundo Tundo->PATH;
if (tundo == nil)
return sprint("loading %s: %r", Tundo->PATH);
frame->init(d);
tblks->init(sys, str, err, debug['T']);
tundo->init(sys, err, debug['T']);
text->init(sys, str, frame, err, tblks, tundo, debug['T']);
return nil;
}
settextsize(p: ref Panel)
{
pi := pimpl(p);
pi.rect = p.rect;
if (!(p.flags&Pline)){
pi.rect.min.y += 1;
}
p.maxsz.y = 0;
s := pi.blks.pack();
if (p.flags&Pline){
p.minsz.y = p.font.height; # up/down margins
if (!(p.flags&Pedit) && len s.s > 0)
p.minsz.x = p.font.width(s.s);
} else {
p.minsz = Point(p.font.height*2,p.font.height*2);
p.minsz.y += 1;
if (pi.nlines == 0)
p.maxsz.y = 0;
else {
n := pi.nlines + 1;
if (n < 3)
n = 3;
p.maxsz.y = p.font.height * n;
p.maxsz.y += 1;
}
}
pi.nrows = pi.rect.dy() / p.font.height;
pi.ncols = pi.rect.dx() / p.font.width("M");
}
pinit(p: ref Panel)
{
if (tree == nil)
tree = dat->tree;
if (textmenu == nil)
textmenu = Menu.new(array[] of {"Exec", "Find", "Put", "Apply", "Paste", "Cut", "Close", "Open"});
for (i := 0; i < len panels; i++)
if (panels[i] == nil)
break;
if (i == len panels){
npanels := array[i+16] of ref Ptext;
npanels[0:] = panels;
panels = npanels;
}
p.implid = i;
pi := panels[i] = Ptext.new();
pi.mlast = 0; # Set Exec by default
p.flags &= ~(Pline|Pedit);
pi.tab = 4;
if (len p.name > 3 && p.name[0:3] == "tbl"){
p.flags |= Ptbl|Pedit;
p.wants = Point(1,1);
pi.tabtext = "[empty]";
pi.mlast = 5; # Open by default
} else if (len p.name > 4 && p.name[0:4] == "text"){
p.flags |= Pedit;
p.wants = Point(1,1);
pi.mlast = 2; # Find
} else if (len p.name > 3 && p.name[0:3] == "tag"){
p.flags |= Pline|Pedit;
p.wants = Point(1,0);
} else {
p.flags |= Pline;
}
if (p.flags&Pline)
p.font = getfont("B");
else
p.font = getfont("R");
s := "";
if (p.flags&Pline){
(nil, n) := splitl(p.name, ":");
if (n != nil){
n = n[1:];
(s, nil) = splitl(n, ".");
if (s == nil)
s = nil;
}
}
pi.blks = Blks.new(s);
settextsize(p);
}
pterm(p: ref Panel)
{
if (p.implid != -1){
pi := pimpl(p);
panels[p.implid] = nil;
p.implid = -1;
pi.term();
}
}
dirty(p: ref Panel, set: int)
{
if (set)
p.flags |= Psync;
else
p.flags &= ~Psync;
if (p.flags&Pline) # lines do not get dirty
return;
old := p.flags;
if (set)
p.flags |= Pdirty;
else
p.flags &= ~Pdirty;
if (old != p.flags){
if (set)
p.fsctl("dirty\n");
else
p.fsctl("clean\n");
spawn tree.tags("/"); # we might get here called from tree; avoid deadlock.
}
}
filltext(p: ref Panel)
{
nl := "\n";
pi := pimpl(p);
(i, n) := pi.blks.seek(pi.froff + pi.f.nchars);
b := pi.blks.b;
for(; i < len b && b[i] != nil && !pi.f.lastlinefull; i++){
pi.f.insert(b[i].s[n:], pi.f.nchars);
n = 0;
}
# Frame may not clear the right of the last line. BUG?
# we force that by inserting a fake \n
if (!pi.f.lastlinefull){
pi.f.insert(nl, pi.f.nchars);
pi.f.delete(pi.f.nchars-1, pi.f.nchars);
}
# clear the unused part
pt := pi.rect.min;
pt.y += pi.f.nlines * p.font.height;
wr := Rect(pt, pi.rect.max);
cback := panelback(p);
if (pi.f.ticked && pi.f.p0 == pi.f.p1 && pi.f.p0 == pi.f.nchars){
# avoid clearing the tick
hidesel(p);
win.image.draw(wr, cback, nil, (0,0));
drawsel(p);
} else
win.image.draw(wr, cback, nil, (0,0));
}
hidesel(p: ref Panel)
{
pi := pimpl(p);
pi.f.drawsel(pi.f.ptofchar(pi.f.p0), pi.f.p0, pi.f.p1, 0);
}
drawsel(p: ref Panel)
{
pi := pimpl(p);
f := pi.f;
ss := fixpos(f.nchars, pi.ss - pi.froff);
se := fixpos(f.nchars, pi.se - pi.froff);
if(f.ticked && ss == f.p0 && se == f.p1) # it's already there.
return;
# This code below was taken from acme's
#
if(f.p1<=ss || se<=f.p0 || ss==se || f.p1==f.p0){
# no overlap or too easy to bother trying
if (f.p0 != f.p1 || !(p.flags&Pedit))
f.drawsel(f.ptofchar(f.p0), f.p0, f.p1, 0);
if (ss != se || (p.flags&Pedit))
f.drawsel(f.ptofchar(ss), ss, se, 1);
} else {
if(ss < f.p0){
# extend selection backwards
f.drawsel(f.ptofchar(ss), ss, f.p0, 1);
}else if(ss > f.p0){
# trim first part of selection
f.drawsel(f.ptofchar(f.p0), f.p0, ss, 0);
}
if(se > f.p1){
# extend selection forwards
f.drawsel(f.ptofchar(f.p1), f.p1, se, 1);
}else if(se < f.p1){
# trim last part of selection
f.drawsel(f.ptofchar(se), se, f.p1, 0);
}
}
f.p0 = ss;
f.p1 = se;
}
tab(p: ref Panel)
{
pi := pimpl(p);
(n, toks) := tokenize(pi.tabtext, "\t\n");
if (n <= 0)
return;
wl := array[n] of string;
for (i := 0; i < n; i++){
wl[i] = hd toks;
toks = tl toks;
}
mint := p.font.width("0");
maxtab := 3 * mint;
maxt := maxtab;
pi.f.maxtab = 3 * mint;
colw := 0;
for(i=0; i<n; i++){
w := p.font.width(wl[i]);
if(maxt-w%maxt < mint)
w += mint;
if(w % maxt)
w += maxt-(w%maxt);
if(w > colw)
colw = w;
}
ncol := 1;
if (colw != 0)
ncol = pi.rect.dx()/colw;
if (ncol < 1)
ncol = 1;
nrow := (n+ncol-1)/ncol;
ns := "";
for(i=0; i<nrow; i++){
for(j:=i; j<n; j+=nrow){
ns += wl[j];
if(j+nrow >= n)
break;
w := p.font.width(wl[j]);
if(maxt-w%maxt < mint){
ns += "\t";
w += mint;
}
do{
ns += "\t";
w += maxt-(w%maxt);
}while(w < colw);
}
ns += "\n";
}
pi.blks = Blks.new(ns);
l := len ns;
pi.s0 = fixpos(pi.s0, l);
pi.ss = fixpos(pi.ss, l);
pi.se = fixpos(pi.se, l);
pi.froff = fixpos(pi.froff, l);
pi.mark = fixpos(pi.mark, l);
}
drawmark(img: ref Image, ur: Rect, cback: ref Image)
{
lr := ur;
# lr.max.x = lr.min.x + ur.dx()/3;
# img.draw(lr, cback, nil, (0,0));
# lr.min.x = lr.max.x;
lr.max.x = lr.min.x + ur.dx()/3;
img.draw(lr, cols[TEXT], nil, (0,0));
lr.min.x = lr.max.x;
lr.max.x = ur.max.x;
img.draw(lr, cback, nil, (0,0));
}
drawmarks(img: ref Image, pi: ref Ptext, ht: int, prect: Rect, cback: ref Image)
{
ur := prect;
ur.max.y = ur.min.y+1;
if (pi.froff == 0)
drawmark(img, ur, cback);
else
img.draw(ur, cback, nil, (0,0));
if (pi.f.nlines + 1 < pi.f.maxlines){ # leave one line for typing
dr := prect;
dr.min.y += (pi.f.nlines+1)*ht + 2;
dr.max.y = dr.min.y + 1;
if (dr.max.y <= prect.max.y && dr.min.y > prect.min.y)
drawmark(img, dr, cback);
}
}
pdraw(p: ref Panel)
{
if (!(p.flags&Pshown))
return;
w := dat->win;
pi := pimpl(p);
pi.rect = p.rect;
if (!(p.flags&Pline)){
pi.rect.min.y += 1;
}
if (pi.f != nil){
hidesel(p);
pi.f.clear(0);
} else
pi.f = Frame.new();
fcols := gui->cols[0:gui->NCOL];
cback := panelback(p);
fcols[BACK] = cback;
pi.f.init(pi.rect, p.font, w.image, fcols);
fcols = nil;
if (p.flags&Ptbl)
tab(p);
else
pi.f.maxtab = pi.tab * p.font.width("0");
filltext(p);
drawsel(p);
settextsize(p);
if (p.flags&Ptag)
drawtag(p);
if (!(p.flags&Pline))
drawmarks(win.image, pi, p.font.height, p.rect, cback);
}
stringlines(s: string): int
{
nc := n := 0;
for (i := 0; i < len s; i++)
if (s[i] == '\n' || nc == Maxline){
n++;
nc = 0;
} else
nc++;
return n;
}
# could put the update as a new del+ins event, but how would we
# sync our current ongoing edit?
# The safe thing to do is to discard any edits and start again.
# The application knows best.
pupdate(p: ref Panel, d: array of byte)
{
pi := pimpl(p);
s := string d;
pi.blks = Blks.new(s);
pi.edits = Edits.new();
if (p.flags&Ptbl)
pi.tabtext = s;
pi.nlines = stringlines(s);
pi.froff = fixpos(len s, pi.froff);
pi.mark = fixpos(len s, pi.mark);
pos := 0;
if ( (p.flags&Pline) || !(p.flags&Pedit))
pos= len s;
else
pos = fixpos(len s, pi.s0);
pi.ss = pi.se = pi.s0 = pos;
p.flags |= Predraw;
}
syncchk(p: ref Panel)
{
if (debug['T']){
# double check that we are really synced with the FS.
fname := p.path + "/data";
fd := open(fname, OREAD);
data := readfile(fd);
if (data != nil){
pi := pimpl(p);
ftext := string data;
s := pi.blks.pack().s;
if (s != ftext){
pi.dump();
l := len s;
if (l > len ftext)
l = len ftext;
for (i := 0; i < l - 1 && s[i] == ftext[i]; i++)
;
if (i > 15)
i -= 15;
else
i = 0;
sj := len s - 1;
fj := len ftext - 1;
while(sj > 0 && fj > 0 && s[sj] == ftext[fj]){
sj--; fj--;
}
fprint(stderr, "after sync text differs: pos %d:\n", i);
fprint(stderr, "text[%s]\n\nfile[%s]\n\n", s[i:sj], ftext[i:fj]);
panic("insdel bug");
}
}
}
}
syncedits(p: ref Panel, edits: list of ref Edit)
{
ctlstr := "";
for(; edits != nil; edits = tl edits){
ev : string;
pick e := hd edits {
Ins =>
ev = sprint("ins %d %s\n", e.pos, e.s);
Del =>
ev = sprint("del %d %d\n", e.pos, len e.s);
}
ctlstr += escape(ev);
}
# fsctl would scape our \n's, and we want a single write for the entire
# set of updates, if feasible.
if (ctlstr != ""){
fname := p.path + "/ctl";
fd := open(fname, OWRITE);
if (fd != nil){
if (debug['E'])
fprint(stderr, "fsctl: %s: [%s]\n", p.path, ctlstr);
seek(fd, big 0, 2);
data := array of byte ctlstr;
write(fd, data, len data);
}
}
p.flags &= ~Psync; # we're synced now.
}
applyedit(p: ref Panel, e: ref Edit): int
{
pi := pimpl(p);
if (e != nil)
pick ep := e {
Ins =>
pi.ins(ep.s, ep.pos);
pi.f.insert(ep.s, ep.pos-pi.froff);
return ep.pos + len ep.s;
Del =>
pi.del(len ep.s, ep.pos);
pi.f.delete(ep.pos - pi.froff, ep.pos - pi.froff + len ep.s);
filltext(p);
return ep.pos;
}
return -1;
}
undo(p: ref Panel): int
{
pi := pimpl(p);
e := pi.edits.undo();
return applyedit(p, e);
}
redo(p: ref Panel): int
{
pi := pimpl(p);
e := pi.edits.redo();
return applyedit(p, e);
}
ins(p: ref Panel, s: string, pos: int)
{
pi := pimpl(p);
pi.ins(s, pos);
if (pi.edits.ins(s, pos) < 0){
syncedits(p, pi.edits.sync());
if (pi.edits.ins(s, pos) < 0){
pi.dump();
panic(sprint("text: ins [%s] %d failed", s, pos));
}
}
}
del(p: ref Panel, n: int, pos: int): string
{
pi := pimpl(p);
ds := pi.del(n, pos);
if (pi.edits.del(ds, pos) < 0){
syncedits(p, pi.edits.sync());
if (pi.edits.del(ds, pos) < 0){
pi.dump();
panic(sprint("text: del [%s] %d failed", ds, pos));
}
}
return ds;
}
pctl(p: ref Panel, s: string)
{
pi := pimpl(p);
odirty := p.flags&Pdirty;
if (panelctl(tree, p, s) < 0){
(nargs, args) := tokenize(s, " \t\n");
if (nargs > 0)
case hd args {
"sel" =>
pi.ss = int nth(args, 1);
pi.se = int nth(args, 2);
if (pi.se < pi.ss)
pi.se = pi.ss;
pi.s0 = pi.ss;
"mark" =>
pi.mark = int nth(args, 1);
"tab" =>
pi.tab = int nth(args, 1);
if (pi.tab < 3)
pi.tab = 3;
if (pi.tab > 10)
pi.tab = 10;
* =>
; # ignore others
}
}
if (odirty && !(p.flags&Pdirty)){
pi.edits.cpos = pi.edits.pos;
# potential race here: User puts, editor issues a clean ctl,
# and the user adds an edit in the mean while.
# If this happens, we could just set Pdirty again.
# But let see if the race is a real one.
eds := pi.edits.sync();
if (eds != nil)
panic("text pctl: clean while dirty edits");
}
}
# Any of:
# o/mero: /path/to/panel ins pos str
# o/mero: /path/to/panel del pos n
pevent(p: ref Panel, ev: string)
{
pi := pimpl(p);
n := strchr(ev, ' ');
ev = ev[n+1:];
n = strchr(ev, ' ');
ev = ev[n+1:]; # ins|del ...
if (len ev < 5){
fprint(stderr, "o/live: pevent: bad event\n");
return;
}
op := ev[0:3];
ev = ev[3+1:]; # pos ...
n = strchr(ev, ' ');
if (n < 0){
fprint(stderr, "o/live: pevent: short event\n");
return;
}
pos := int ev[0:n];
ev = ev[n+1:]; # n|str
if (len ev == 0)
return;
ev = ev[0:len ev -1]; # remove \n
if (op == "del"){
n = int ev;
del(p, n, pos);
pi.f.delete(pos, pos+n);
filltext(p);
} else {
s := unescape(ev);
ins(p, s, pos);
# pdraw should refill the frame. (?)
if (p.flags&Pline)
pos += len s;
}
pi.ss = pi.se = pi.s0 = pos; # that's the
p.flags |= Pdirty; # best we can do.
pdraw(p);
}
writepsel(p: ref Panel)
{
fd := open("/dev/sel", OWRITE|OTRUNC);
if (fd != nil)
fprint(fd, "%s\n", p.path);
}
movetoshow(p: ref Panel, pos: int): int
{
pi := pimpl(p);
if (pos < pi.froff || (pos >= pi.froff + pi.f.nchars && pi.f.nlines == pi.f.maxlines)){
pi.gotopos(pos);
pi.froff = pi.scroll(-pi.f.nlines/2);
return 1;
}
return 0;
}
cut(p: ref Panel, putsnarf: int): int
{
pi := pimpl(p);
if (pi.ss == pi.se)
return 0;
p0 := pi.ss - pi.froff;
p1 := pi.se - pi.froff;
s := del(p, pi.se - pi.ss, pi.ss);
pi.f.delete(p0, p1);
pi.se = pi.s0 = pi.ss;
filltext(p);
if (putsnarf){
writesnarf(s);
writepsel(p);
}
return 1;
}
paste(p: ref Panel, pos: int): int
{
pi := pimpl(p);
s := readsnarf();
if (len s > 0){
ins(p, s, pos);
pi.f.insert(s, pos - pi.froff);
pi.ss = pi.s0 = pos;
pi.se = pos + len s;
drawsel(p);
writepsel(p);
}
return 1;
}
lastcmd: string;
exec(p: ref Panel, pos: int)
{
pi := pimpl(p);
s := pi.blks.pack();
(ws, we) := pi.wordat(pos, 1, 1);
c := s.s[ws:we];
lastcmd = c;
if (c == "Exit")
terminate();
pi.ss = pi.s0 = ws;
pi.se = we;
drawsel(p);
p.fsctl("exec " + c + "\n");
}
look(p: ref Panel, pos: int)
{
pi := pimpl(p);
s := pi.blks.pack();
if (seltext != nil){
p.fsctl("look " + seltext + "\n");
return;
}
(ws, we) := pi.wordat(pos, 1, 1);
c := s.s[ws:we];
pi.ss = pi.s0 = ws;
pi.se = we;
drawsel(p);
p.fsctl("look " + c + "\n");
}
apply(p: ref Panel, nil: int)
{
if (lastcmd != nil){
writepsel(p);
p.fsctl("apply " + lastcmd + "\n");
}
}
search(p: ref Panel, pos: int)
{
ws, we: int;
txt: string;
pi := pimpl(p);
s := pi.blks.pack();
if (seltext == nil){
(ws, we) = pi.wordat(pos, 0, 1);
txt = s.s[ws:we];
} else {
we = pos+1;
txt = seltext;
}
i := strstr(s.s[we:], txt);
if (i < 0)
i = strstr(s.s, txt);
else
i += we;
if (i < 0)
return;
if (debug['T'])
fprint(stderr, "search: %s: pos %d\n", dtxt(txt), i);
pi.ss = pi.s0 = i;
pi.se = pi.ss+ len txt;
if (movetoshow(p, pi.ss))
pdraw(p);
else
drawsel(p);
pt := pi.f.ptofchar(pi.f.p0);
pt.add(pi.rect.min);
pt.add((p.font.width(txt[0:1])-2, p.font.height -2));
win.wmctl("ptr " + string pt.x + " " + string pt.y);
}
frscroll(p: ref Panel, nlines: int)
{
pi := pimpl(p);
if (nlines == 0){
return;
}
noff := pi.scroll(nlines);
if (noff < pi.froff){
s := pi.blks.pack().s;
s = s[noff:pi.froff];
pi.f.insert(s, 0);
pi.froff = noff;
} else if (noff > pi.froff){
if (pi.f.nchars > 0)
if (noff < pi.froff + pi.f.nchars)
pi.f.delete(0, noff - pi.froff);
else if (pi.f.nchars > 0)
pi.f.delete(0, pi.f.nchars - 1);
pi.froff = noff;
filltext(p);
}
}
select(p: ref Panel, pos: int, m: ref Cpointer, mc: chan of ref Cpointer): ref Cpointer
{
pi := pimpl(p);
b := m.buttons;
s := pi.blks.pack();
if (m.flags&(CMdouble|CMtriple)){
long := m.flags&CMtriple;
(ws, we) := pi.wordat(pos, long, 0);
if (debug['T'])
fprint(stderr, "getword: pos %d long %d: %d %d %s\n",
pos, long, ws, we, dtxt(s.s[ws:we]));
pi.ss = pi.s0 = ws;
pi.se = we;
writepsel(p);
drawsel(p);
do {
m = <-mc;
} while (m.buttons == b);
} else {
pi.s0 = pos;
m = pi.f.select(m, mc, frscroll, p);
if (pi.f.p0 + pi.froff < pi.s0){
pi.ss = pi.f.p0 + pi.froff;
pi.se = pi.s0;
} else {
pi.ss = pi.s0;
pi.se = pi.f.p1 + pi.froff;
}
if (!(p.flags&Pedit) && pi.ss == pi.se)
hidesel(p);
else
drawsel(p);
}
if (pi.ss == pi.se)
seltext = nil;
else
seltext = s.s[pi.ss:pi.se];
return m;
}
pmouse1(p: ref Panel, pos: int, m: ref Cpointer, mc: chan of ref Cpointer)
{
pi := pimpl(p);
m = select(p, pos, m, mc);
case m.buttons {
0 =>
return;
3 =>
if (cut(p, 1))
dirty(p, 1);
5 =>
if (cut(p, 0))
pos = pi.ss;
if (paste(p, pos))
dirty(p, 1);
}
while(m.buttons)
m = <-mc;
}
pmouse2(p: ref Panel, pos: int, m: ref Cpointer, mc: chan of ref Cpointer)
{
pi := pimpl(p);
if (pos >= pi.ss && pos < pi.se){
m = <-mc;
if (m.buttons == 0)
exec(p, pos);
} else {
m = select(p, pos, m, mc);
if (m.buttons == 0)
exec(p, pos);
}
while(m.buttons)
m = <-mc;
}
# To avoid blinking, we use double buffering during
# scroll operations. This is because we redraw the whole frame,
# and do not shift rectangles around. This makes it easier to draw
# overlayed scroll bars.
scrdraw(p: ref Panel, i: ref Image): ref Image
{
pi := pimpl(p);
r := Rect((0,0), (p.rect.dx(), p.rect.dy()));
if (i == nil)
i = win.display.newimage(r, win.image.chans, 0, Draw->White);
fcols := gui->cols[0:gui->NCOL];
cback := panelback(p);
fcols[BACK] = cback;
i.draw(i.r, cback, nil, (0,0));
pi.f.clear(0);
fr := r;
if (!(p.flags&Pline)){
fr.min.y += 1;
}
pi.f.init(fr, p.font, i, fcols);
if (p.flags&Ptbl)
pi.f.maxtab = 3 * p.font.width("0");
else
pi.f.maxtab = pi.tab * p.font.width("0");
filltext(p);
drawsel(p);
if (!(p.flags&Pline))
drawmarks(i, pi, p.font.height, r, cback);
drawscrollbar(p, i);
win.image.draw(p.rect, i, nil, (0,0));
return i;
}
scrdone(p: ref Panel)
{
pi := pimpl(p);
pi.f.clear(0);
pi.f = nil;
pdraw(p);
}
drawscrollbar(p: ref Panel, i: ref Image)
{
Barwid: con 25;
Barht: con 120;
pi := pimpl(p);
bar, r: Rect;
bar.max.x = r.max.x = i.r.max.x - Inset - 3;
bar.min.x = r.min.x = r.max.x - Barwid;
r.min.y = i.r.min.y + Inset;
ysz := Barht;
r.max.y = r.min.y + ysz;
if (r.max.y + 3 > i.r.max.y){
r.max.y = i.r.max.y - 3;
ysz = r.dy();
}
i.draw(r.addpt((2,2)), cols[TEXT], cols[SHAD], (0,0));
i.draw(r, cols[CLEAR], cols[SHAD], (0,0));
l := len pi.blks.b[0].s;
y0 := dy := 0;
if (l > 0){
y0 = ysz * pi.froff / l;
dy = ysz * pi.f.nchars / l;
if (dy < 3)
dy = 3;
} else {
y0 = 0;
dy = r.dy();
}
bar.min.y = r.min.y + y0;
bar.max.y = bar.min.y + dy;
if (bar.max.y > r.max.y)
bar.max.y = r.max.y;
if (bar.min.y > bar.max.y - 2)
bar.min.y = bar.max.y - 2;
i.draw(bar.addpt((3,3)), cols[TEXT], cols[SHAD], (0,0));
i.draw(bar, cols[SET], nil, (0,0));
i.border(r, 1, cols[BORD], (0,0));
}
jumpscale(p: ref Panel, xy: Point): real
{
pi := pimpl(p);
s := pi.blks.pack();
dy := xy.y - pi.rect.min.y;
if (dy > pi.rect.max.y - xy.y)
dy = pi.rect.max.y - xy.y;
dc := len s.s - pi.froff;
if (dc < pi.froff)
dc = pi.froff;
if (dy < 1)
dy = 1;
return (real dc) / (real dy);
}
pmouse3scrl(p: ref Panel, pos: int, m: ref Cpointer, mc: chan of ref Cpointer)
{
pi := pimpl(p);
xy := m.xy;
jfactor := real 0;
jy := xy.y;
old := pi.froff;
i := scrdraw(p, nil);
b := m.buttons;
do {
if (jfactor <= real 0.00001){
pos = pi.froff;
jfactor = jumpscale(p, xy);
}
jpos := pos + int (real (xy.y - jy) * jfactor);
if (jpos == old || !pi.gotopos(jpos))
; # sys->sleep(10);
else {
old = jpos;
scrdraw(p, i);
}
more := 0;
m = <- mc;
do {
alt {
m = <-mc =>
more=1;
* =>
more = 0;
}
} while(more && m.buttons == b);
xy = m.xy;
} while(m.buttons);
scrdone(p);
}
pmouse3(p: ref Panel, pos: int, m: ref Cpointer, mc: chan of ref Cpointer)
{
pi := pimpl(p);
m = <- mc;
case m.buttons {
0 =>
textmenu.last = pi.mlast;
cmd := textmenu.run(m, mc);
if (debug['T'])
fprint(stderr, "pmouse3: cmd: %s at %d\n", cmd, pos);
case cmd {
"scroll" =>
pmouse3scrl(p, pos, m, mc);
"Find" =>
search(p, pos);
"Open" =>
look(p, pos);
"Exec" =>
exec(p, pos);
"Apply" =>
apply(p, pos);
"Cut" =>
if (cut(p, 1))
dirty(p, 1);
textmenu.last = 3;
"Paste" =>
if (paste(p, pos))
dirty(p, 1);
* =>
p.fsctl("exec " + cmd + "\n");
}
pi.mlast = textmenu.last;
4 =>
pmouse3scrl(p, pos, m, mc);
* =>
do
m = <-mc;
while (m.buttons);
}
}
pmouse(p: ref Panel, m: ref Cpointer, mc: chan of ref Cpointer)
{
if ((p.flags&Ptag) && intag(p, m.xy)){
tagmouse(tree, p, m, mc);
return;
}
pi := pimpl(p);
# mouse movement syncs any pending edit.
eds := pi.edits.sync();
if (eds != nil){
syncedits(p, eds);
syncchk(p);
}
pos := pi.froff + pi.f.charofpt(m.xy);
case m.buttons {
1 =>
# For tbls, this should probably allow drag&drop
pmouse1(p, pos, m, mc);
if (debug['T'] > 1)
pi.dump();
2 =>
pmouse2(p, pos, m, mc);
if (debug['T'] > 1)
pi.dump();
4 =>
pmouse3(p, pos, m, mc);
if (debug['T'] > 1)
pi.dump();
}
drawsel(p);
}
pkbd(p: ref Panel, k: int)
{
Killword: con 16r17; # C-w
pi := pimpl(p);
pos := pi.ss;
s := "";
s[0] = k;
if (!(p.flags&Pedit)){
p.fsctl("keys " + s + "\n");
return;
}
case k {
'\b' =>
if (!cut(p, 1) && pos > 0){
pos--;
if (movetoshow(p, pos))
pdraw(p);
del(p, 1, pos);
if (pos < pi.froff | pos > pi.froff + pi.f.nchars + 1)
panic("pos del bug");
pi.f.delete(pos-pi.froff, pos-pi.froff+1);
pi.ss = pi.se = pi.s0 = pos;
}
dirty(p, 1);
filltext(p);
Killword =>
(ws, we) := pi.wordat(pos, 1, 1);
if (ws != we){
pos = ws;
n := we - ws;
if (movetoshow(p, pos))
pdraw(p);
del(p, n, pos);
if (pos < pi.froff | pos > pi.froff + pi.f.nchars + 1)
panic("pos killword bug");
pi.f.delete(pos-pi.froff, pos+n-pi.froff);
pi.ss = pi.se = pi.s0 = pos;
}
Keyboard->Del =>
p.fsctl("interrupt\n");
Keyboard->Left or Keyboard->Right=>
if (k == Keyboard->Left)
pos = undo(p);
else
pos = redo(p);
if (pos >= 0){
dirty(p, pi.edits.pos != pi.edits.cpos);
pi.ss = pi.se = pi.s0 = pos;
if (movetoshow(p, pos))
pdraw(p);
else
drawsel(p);
}
Keyboard->Up or Keyboard->Down =>
if (p.flags&Pline)
return;
n := pi.f.nlines / 3;
if (n < 2)
n = 2;
if (k == Keyboard->Up)
n = -n;
noff := pi.scroll(n);
if (noff != pi.froff){
pi.froff = noff;
pdraw(p);
}
Keyboard->Esc =>
if (pi.s0 < pos){
pi.ss = pi.s0;
pi.se = pos;
} else {
pi.ss = pos;
pi.se = pi.s0;
}
drawsel(p);
* =>
if (k == '\n' && (p.flags&Pline)){
if (pi.s0 < pos){
pi.ss = pi.s0;
pi.se = pos;
} else {
pi.ss = pos;
pi.se = pi.s0;
}
drawsel(p);
exec(p, pos);
} else {
cut(p, 1);
if (!(p.flags&Pline) && movetoshow(p, pos))
pdraw(p);
ins(p, s, pos);
pi.f.insert(s, pos - pi.froff);
pi.ss = pi.se = pos+1;
if (pos >= pi.froff + pi.f.nchars - 2 && !(p.flags&Pline)){
noff := pi.scroll(pi.f.nlines/3);
if (noff != pi.froff){
pi.froff = noff;
pdraw(p);
}
}
dirty(p, 1);
if ((p.flags&Pedit) && (k == '\n' || (p.flags&Pline)))
settextsize(p);
}
}
if (debug['T'] > 1)
pi.dump();
}
psync(p: ref Panel)
{
fprint(stderr, "owptext: sync called\n");
pi := pimpl(p);
fd := open(p.path + "/data", OWRITE|OTRUNC);
if (fd == nil)
return;
s := pi.blks.pack();
data := array of byte s.s;
if (write(fd, data, len data) != len data)
fprint(stderr, "o/live: sync %s: %r\n", p.path);
}
|
