#
# Text panel.
# Text is handled by the Tblks module.
# Undo/redo is handled by a separate Tundo module.
# Drawing is handled by Tframe, which is also in charge of maintaining the
# selection and the position of the text shown in the panel.
# This does more than needed and calls frame operations even when it's not
# necessary to do so.
implement Pimpl;
include "mods.m";
mods, debug, win, tree: import dat;
Menu: import menus;
setcursor, Waiting, Arrow,
getfont, Cpointer, cols, panelback, maxpt, cookclick, drawtag,
BACK,TEXT, readsnarf, Inset, terminate, writesnarf,
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;
usage: import arg;
include "tblks.m";
tblks: Tblks;
fixpos, fixposins, fixposdel, dtxt, strstr, Maxline, Blks, strchr, Str: import tblks;
include "tundo.m";
tundo: Tundo;
Edit, Edits: import tundo;
include "tframe.m";
tframe: Tframe;
Frame: import tframe;
Ptext: adt {
blks: ref Tblks->Blks; # sequence of text blocks being edited.
edits: ref Tundo->Edits; # edit operations for sync, undo, and redo.
f: ref Tframe->Frame; # nil or initialized frame
s0: int; # offset in text for 1st selection point, to extend selection.
fsss: int; # f.ss as last synced to o/mero
fsse: int; # idem for f.se
mlast: int; # last option used in its menu
tabtext: string; # for tbls, the original text, as updated.
nlines: int; # nb. of lines in text (to compute maxsz)
new: fn(): ref Ptext;
gotopos: fn(pi: self ref Ptext, npos: int): int;
wordat: fn(pi: self ref Ptext, pos: int, long: int, selok: int): (int, int);
dump: fn(pi: self ref Ptext);
};
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();
dat = d;
str = load String String->PATH;
if (str == nil)
return sprint("loading %s: %r", String->PATH);
tblks = load Tblks Tblks->PATH;
if (tblks == nil)
return sprint("loading %s: %r", Tblks->PATH);
tframe = load Tframe Tframe->PATH;
if (tframe == nil)
return sprint("loading %s: %r", Tframe->PATH);
tundo= load Tundo Tundo->PATH;
if (tundo == nil)
return sprint("loading %s: %r", Tundo->PATH);
tblks->init(sys, str, err, debug['T']);
tframe->init(dat, tblks, debug['F']);
tundo->init(sys, err, debug['T']);
return nil;
}
nullptext: Ptext;
Ptext.new(): ref Ptext
{
pi := ref nullptext;
return pi;
}
Ptext.gotopos(pi: self ref Ptext, npos: int): int
{
if (npos == pi.f.pos)
return pi.f.pos;
s := pi.blks.pack();
npos = fixpos(npos, len s.s);
if (npos > 0){
n := s.findr(npos, '\n', Maxline); # position just past the last \n
if (n >= 0){
if (n > 0 && n == '\n')
n++;
npos = n;
} else if (npos < len s.s) # only when scrolling within the first line.
npos = 0;
}
return npos;
}
# Taken from acme
isalnum(c : int) : int
{
#
# 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(16r7F<=c && c<=16rA0)
return 0;
if(strchr("!\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~", c) >= 0)
return 0;
return 1;
}
iswordchar(r: int, long: int): int
{
if (isalnum(r) || strchr("0123456789_", r) >= 0)
return 1;
if (long && strchr("|&?=.-+/:", r) >= 0)
return 1;
return 0;
}
isparen(set: string, r: int): int
{
i := strchr(set, r);
if (i >= 0)
return i + 1;
else
return 0;
}
# Returns the word at pos.
# If we are looking at the end of line, we pretend we look right
# before it. In any case:
# The word is the selection when it exists and selok.
# It is the longest set of <wordchar>s if pos at <wordchar>
# (if long, |&?=.-+/: are also considers as word chars)
# It is the text between {} [] '' "" () if pos is at delim.
# It is the current line otherwise (if pos at blank)
#
Ptext.wordat(pi: self ref Ptext, pos: int, long: int, selok: int): (int, int)
{
ss := pi.f.ss;
se := pi.f.se;
lparen := "{[(«<“";
rparen := "}])»>”";
paren := "\"'`";
s := pi.blks.pack();
nr := len s.s;
if (pos >nr)
pos = nr;
if (pos == nr && pos > 0)
pos--;
spos := epos := pos;
if (nr == 0)
return (spos, epos);
if (selok && pos >= ss && pos <= se && ss != se)
return (ss, se);
if (iswordchar(s.s[pos], long)){
while(spos > 0 && iswordchar(s.s[spos], long))
spos--;
if (spos > 0)
spos++;
while(epos < nr && iswordchar(s.s[epos], long))
epos++;
} else if (pp := isparen(paren, s.s[pos])){
spos++;
for(epos = spos; epos < nr; epos++)
if (isparen(paren, s.s[epos]) == pp)
break;
} else if (pp = isparen(lparen, s.s[pos])){
nparen := 1;
spos++;
for(epos = spos; epos < nr; epos++){
if (isparen(lparen, s.s[epos]) == pp)
nparen++;
if (isparen(rparen, s.s[epos]) == pp)
nparen--;
if (nparen <= 0){
break;
}
}
} else if (pp = isparen(rparen, s.s[pos])){
nparen := 1;
if (spos > 0)
for(spos--; spos > 0; spos--){
if (isparen(rparen, s.s[spos]) == pp)
nparen++;
if (isparen(lparen, s.s[spos]) == pp)
nparen--;
if (nparen <= 0){
spos++;
break;
}
}
} else { # pos at blank
if (s.s[spos] == '\n' && spos > 0 && s.s[spos-1] != '\n'){
# click at right part of line; step back
# so that expanding leads to previous line
spos--;
}
while(spos > 0 && s.s[spos-1] != '\n')
spos--;
while(epos < nr && s.s[epos] != '\n')
epos++;
if (epos < nr)
epos++; # include \n
}
if (spos < 0 || epos < 0 || epos < spos || epos > nr)
panic(sprint("spos/epos bug: %d %d %d\n", spos, epos, nr));
return (spos, epos);
}
Ptext.dump(pi: self ref Ptext)
{
pi.blks.dump();
if (debug['F'] > 1)
pi.f.dump();
}
settextsize(p: ref Panel)
{
pi := pimpl(p);
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;
}
}
}
Mexec, Mfind, Mput, Mapply, Mpaste, Mcut, Mclose, Mopen: con iota;
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.edits = Edits.new();
pi.mlast = Mexec;
p.flags &= ~(Pline|Pedit);
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 = Mopen;
#tab = 3;
} else if (len p.name > 4 && p.name[0:4] == "text"){
p.flags |= Pedit;
p.wants = Point(1,1);
pi.mlast = Mfind;
} 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);
# create frame w/o image. it maintains selection, mostly.
# following pdraw calls will attach an image to the frame and reset its size.
pi.f = Frame.new(Rect((0, 0), p.minsz), nil, p.font, gui->cols, !(p.flags&Pline));
pi.f.tabsz = tab;
pi.f.showsel = p.flags&Pedit;
pi.f.init(pi.blks, pi.f.pos);
pi.s0 = pi.f.ss;
}
pterm(p: ref Panel)
{
if (p.implid != -1){
pi := pimpl(p);
panels[p.implid] = nil;
p.implid = -1;
pi.f = nil;
pi.edits = nil;
pi.blks = nil;
}
}
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", 0);
else
p.fsctl("clean\n", 0);
spawn tree.tags("/"); # we might get here called from tree; avoid deadlock.
}
}
tab(p: ref Panel)
{
pi := pimpl(p);
(n, toks) := tokenize(pi.tabtext, "\t\n");
if (n <= 0)
return;
wl := array[n] of string;
wwl := array[n] of int;
for (i := 0; i < n; i++){
wl[i] = hd toks;
toks = tl toks;
}
mint := pi.f.spwid;
maxt := pi.f.tabwid;
colw := 0;
maxw := 0;
for (i = 0; i < n; i++){
wwl[i] = p.font.width(wl[i]);
if (maxw < wwl[i])
maxw = wwl[i];
}
spwid := p.font.width(" ");
for (i = 0; i < n; i++)
while(wwl[i] < maxw){
wl[i] += " ";
wwl[i] += spwid;
}
for(i=0; i<n; i++){
w := p.font.width(wl[i]);
wwl[i] = w;
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 = p.rect.dx()/colw; # can't use pi.f.r, because
if (ncol < 1) # frame may be using an old rectangle.
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;
else
ns += "\t";
}
ns += "\n";
}
pi.blks = Blks.new(ns);
pi.f.init(pi.blks, pi.f.pos);
pi.s0 = pi.f.ss;
}
pdraw(p: ref Panel)
{
pi := pimpl(p);
if (!(p.flags&Pshown)){
pi.f.i = nil;
return;
}
w := dat->win;
if (p.flags&Ptbl)
tab(p);
if (p.rect.eq(pi.f.r)){
pi.f.i = w.image;
pi.f.redraw();
} else if (p.rect.dx() == pi.f.r.dx() && p.rect.dy() == pi.f.r.dy()){
pi.f.i = w.image;
pi.f.move(p.rect.min);
pi.f.redraw();
} else
pi.f.resize(p.rect, w.image);
settextsize(p);
if (p.flags&Ptag)
drawtag(p);
}
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 out 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);
if (!(p.flags&Pshown))
pi.f.i = nil; # avoid drawing
s := string d;
pi.blks = Blks.new(s);
pi.edits = Edits.new();
if (p.flags&Ptbl)
pi.tabtext = s;
nsel := -1;
if ( (p.flags&Pline) || !(p.flags&Pedit))
nsel = len s;
pi.nlines = stringlines(s);
pi.f.init(pi.blks, pi.f.pos);
if (nsel >= 0){
pi.f.sel(nsel, nsel);
pi.s0 = pi.f.ss;
}
p.flags |= Predraw;
}
printdiff(s: string, ftext: string)
{
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, "o/live and o/mero text differs: pos %d:\n", i);
fprint(stderr, "text[%s]\n\nfile[%s]\n\n", s[i:sj], ftext[i:fj]);
}
syncchk(p: ref Panel)
{
if (debug['T']){
# double check that we are really synced with the FS.
pi := pimpl(p);
fname := p.path + "/data";
fd := open(fname, OREAD);
data := readfile(fd);
if (data != nil){
ftext := string data;
s := pi.blks.pack().s;
if (s != ftext){
pi.dump();
printdiff(s, ftext);
panic("insdel bug");
}
}
# double check that the text in the frame is also in sync.
pi.f.chk();
}
}
# BUG: needs to be reworked. While we were editing, other o/lives could
# update the text. Thus, we better send the version of the text that changes
# are for, and make o/mero discard (and report as failed) those that do not
# match the version. When we see a discarded change, we may simply reload the
# text and undo our edit.
syncedits(p: ref Panel, edits: list of ref Edit)
{
pi := pimpl(p);
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);
}
# This is a good time to update o/mero idea of our selection.
if (ctlstr != "" || pi.f.ss != pi.f.se && (pi.fsss != pi.f.ss || pi.fsse != pi.f.se)){
ctlstr += escape(sprint("sel %d %d\n", pi.f.ss, pi.f.se));
pi.fsss = pi.f.ss;
pi.fsse = pi.f.se;
}
# fsctl would scape our \n's, and we want a single write for the entire
# set of updates, if feasible.
if (ctlstr != ""){
# a good time to update our selection in o/mero. do so.
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
{
if (e != nil){
pi := pimpl(p);
pick ep := e {
Ins =>
pi.blks.ins(ep.s, ep.pos);
pi.f.ins(ep.pos, len ep.s);
pi.s0 = pi.f.ss;
return ep.pos + len ep.s;
Del =>
pi.blks.del(len ep.s, ep.pos);
pi.f.del(ep.pos, len ep.s);
pi.s0 = pi.f.ss;
return ep.pos;
}
}
return -1;
}
undo(p: ref Panel): int
{
pi := pimpl(p);
return applyedit(p, pi.edits.undo());
}
redo(p: ref Panel): int
{
pi := pimpl(p);
return applyedit(p, pi.edits.redo());
}
ins(p: ref Panel, s: string, pos: int)
{
pi := pimpl(p);
pi.blks.ins(s, pos);
pi.s0 = fixposins(pi.s0, pos, len s);
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.blks.del(n, pos);
pi.s0 = fixposdel(pi.s0, pos, n);
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);
if (!(p.flags&Pshown))
pi.f.i = nil; # avoid drawing
odirty := p.flags&Pdirty;
ofont := p.font;
if (panelctl(tree, p, s) < 0){
(nargs, args) := tokenize(s, " \t\n");
if (nargs > 0)
case hd args {
"sel" =>
ss := fixpos(int nth(args, 1), pi.blks.blen());
se := fixpos(int nth(args, 2), pi.blks.blen());
if (se < ss)
se = ss;
pi.s0 = ss;
if (ss != pi.f.ss || se != pi.f.se){
pi.f.sel(ss, se);
p.flags |= Predraw;
}
pi.fsss = pi.f.ss;
pi.fsse = pi.f.se;
"mark" =>
pi.f.mark = fixpos(int nth(args, 1), pi.blks.blen());
"tab" =>
tab := int nth(args, 1);
if (tab < 3)
tab = 3;
if (tab > 20)
tab = 20;
if (pi.f.tabsz != tab){
pi.f.tabsz = tab;
pi.f.resize(pi.f.r, pi.f.i);
p.flags |= Predraw;
}
* =>
; # ignore others
}
}
if (odirty && !(p.flags&Pdirty)){
pi.edits.cpos = pi.edits.pos;
# BUG: 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");
}
if (ofont != p.font)
pi.f.resize(pi.f.r, pi.f.i); # recompute widths and init
}
# 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);
if (!(p.flags&Pshown))
pi.f.i = nil; # avoid drawing
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.del(pos, n);
} else {
s := unescape(ev);
ins(p, s, pos);
pi.f.ins(pos, len s);
if ((p.flags&Pline) && pos + len s> pi.f.ss)
pi.f.sel(pos, pos);
}
pi.s0 = pi.f.ss;
p.flags |= Pdirty;
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)
{
pi := pimpl(p);
if (pos < pi.f.pos || (pos > pi.f.pos + pi.f.nr)){
npos := pi.gotopos(pos);
pi.f.init(pi.blks, npos);
pi.f.scroll(-pi.f.sz.y/2);
}
}
cut(p: ref Panel, putsnarf: int): int
{
pi := pimpl(p);
nr := pi.f.se - pi.f.ss;
if (nr == 0)
return 0;
pos := pi.f.ss;
s := "";
if (!(p.flags&Pedit)){
t := pi.blks.pack();
s = t.s[pi.f.se:pi.f.se];
pi.f.sel(pi.f.ss, pi.f.ss);
} else {
s = del(p, nr, pos);
pi.f.del(pos, nr);
}
pi.s0 = pi.f.ss;
if (putsnarf){
writesnarf(s);
writepsel(p);
}
return 1;
}
paste(p: ref Panel, pos: int): int
{
if (!(p.flags&Pedit))
return 0;
pi := pimpl(p);
s := readsnarf();
if (len s == 0)
return 0;
ins(p, s, pos);
pi.f.ins(pos, len s);
pi.f.sel(pos, pos + len s);
pi.s0 = pi.f.ss;
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;
pi.f.sel(ws, we);
pi.s0 = pi.f.ss;
if (c == "Exit")
terminate();
else
p.fsctl("exec " + c + "\n", 1);
}
look(p: ref Panel, pos: int)
{
if (seltext != nil){
p.fsctl("look " + seltext + "\n", 1);
return;
}
pi := pimpl(p);
s := pi.blks.pack();
(ws, we) := pi.wordat(pos, 1, 1);
c := s.s[ws:we];
pi.f.sel(ws, we);
pi.s0 = pi.f.ss;
p.fsctl("look " + c + "\n", 1);
}
apply(p: ref Panel, nil: int)
{
if (p.flags&Pedit)
if (lastcmd != nil){
writepsel(p);
p.fsctl("apply " + lastcmd + "\n", 1);
}
}
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.f.sel(i, i + len txt);
pi.s0 = pi.f.ss;
movetoshow(p, pi.f.ss);
pt := pi.f.pos2pt(pi.f.ss);
pt = pt.add((p.font.width(txt[0:1])/2, p.font.height -2));
win.wmctl("ptr " + string pt.x + " " + string pt.y);
}
# Select requires us to coallesce mouse events that would do nothing
# but update further our possition.
getmouse(mc: chan of ref Cpointer): ref Cpointer
{
m := <-mc;
for(;;){
mm: ref Cpointer;
mm = nil;
# nbrecv
alt {
mm = <-mc => ;
* => ;
}
if (mm == nil || mm.buttons != m.buttons)
break;
m = mm;
}
return m;
}
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();
pi.f.sel(pos, pos);
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.f.sel(ws, we);
pi.s0 = pi.f.ss;
writepsel(p);
do {
m = <-mc;
} while (m.buttons == b);
} else {
pi.s0 = pos;
do {
if (m.xy.y < pi.f.r.min.y){ # scroll up
pi.f.scroll(-1-(pi.f.r.min.y-m.xy.y)/p.font.height);
pi.f.sel(pi.f.pos, pi.s0);
sys->sleep(100);
} else if (m.xy.y > pi.f.r.max.y){ # scroll down
pi.f.scroll(1+(m.xy.y-pi.f.r.max.y)/p.font.height);
pi.f.sel(pi.s0, pi.f.pos + pi.f.nr);
sys->sleep(100);
} else {
pos = pi.f.pt2pos(m.xy);
if (pos < pi.s0)
pi.f.sel(pos, pi.s0);
else
pi.f.sel(pi.s0, pos);
}
m = getmouse(mc);
} while (m.buttons == b);
}
if (pi.f.ss == pi.f.se)
seltext = nil;
else
seltext = s.s[pi.f.ss:pi.f.se];
return m;
}
pmouse1(p: ref Panel, pos: int, m: ref Cpointer, mc: chan of ref Cpointer)
{
dirties := 0;
pi := pimpl(p);
m = select(p, pos, m, mc);
case m.buttons {
0 =>
return;
3 =>
if (cut(p, 1))
dirties = 1;
5 =>
if (cut(p, 0)){
pos = pi.f.ss;
dirties = 1;
}
if (paste(p, pos))
dirties = 1;
}
if (dirties)
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 (pi.f.ss != pi.f.se && pos >= pi.f.ss && pos < pi.f.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);
pi.f.resize(r, i);
}
drawscrollbar(p, i);
win.image.draw(p.rect, i, nil, (0,0));
return i;
}
scrdone(p: ref Panel)
{
pi := pimpl(p);
pi.f.resize(p.rect, win.image);
}
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.f.pos / l;
dy = ysz * pi.f.nr / 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 - p.rect.min.y;
if (dy > p.rect.max.y - xy.y)
dy = p.rect.max.y - xy.y;
dc := len s.s - pi.f.pos;
if (dc < pi.f.pos)
dc = pi.f.pos;
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.f.pos;
i := scrdraw(p, nil);
b := m.buttons;
do {
if (jfactor <= real 0.00001){
pos = pi.f.pos;
jfactor = jumpscale(p, xy);
}
jpos := pos + int (real (xy.y - jy) * jfactor);
if (jpos != old)
jpos = pi.gotopos(jpos);
if (jpos == old)
; # sys->sleep(10);
else {
old = jpos;
pi.f.init(pi.blks, 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 = Mpaste;
"Paste" =>
if (paste(p, pos))
dirty(p, 1);
* =>
p.fsctl("exec " + cmd + "\n", 1);
}
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.f.pt2pos(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();
}
}
pkbd(p: ref Panel, k: int)
{
Killword: con 16r17; # C-w
pi := pimpl(p);
pos := pi.f.ss;
s := "";
s[0] = k;
if (!(p.flags&Pedit)){
p.fsctl("keys " + s + "\n", 1);
return;
}
case k {
'\b' =>
if (!cut(p, 1) && pos > 0){
pos--;
movetoshow(p, pos);
del(p, 1, pos);
pi.f.del(pos, 1);
pi.s0= pi.f.ss;
}
dirty(p, 1);
Killword =>
(ws, we) := pi.wordat(pos, 1, 1);
if (ws != we){
pos = ws;
n := we - ws;
movetoshow(p, pos);
del(p, n, pos);
pi.f.del(pos, n);
pi.s0 = pi.f.ss;
}
Keyboard->Del =>
p.fsctl("interrupt\n", 1);
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.f.sel(pos, pos);
pi.s0 = pos;
movetoshow(p, pos);
}
Keyboard->Up or Keyboard->Down =>
if (p.flags&Pline)
return;
n := pi.f.sz.y / 3;
if (n < 2)
n = 2;
if (k == Keyboard->Up)
n = -n;
pi.f.scroll(n);
Keyboard->Esc =>
if (pi.s0 < pos)
pi.f.sel(pi.s0, pos);
else
pi.f.sel(pos, pi.s0);
* =>
if (k == '\n' && (p.flags&Pline)){
if (pi.s0 < pos)
pi.f.sel(pi.s0, pos);
else
pi.f.sel(pos, pi.s0);
exec(p, pos);
} else {
cut(p, 1);
if (!(p.flags&Pline))
movetoshow(p, pos);
ins(p, s, pos);
pi.f.ins(pos, len s);
pt := pi.f.pos2pt(pos);
if (pt.y + p.font.height >= pi.f.r.max.y && !(p.flags&Pline))
pi.f.scroll(1);
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);
}
|
