ref: 995a32b23775fd83b4d808d713b8d885cc2b297b
dir: /appl/charon/charon.b/
implement Charon;
include "common.m";
include "debug.m";
sys: Sys;
CU: CharonUtils;
ByteSource, MaskedImage, CImage, ImageCache, ReqInfo, Header,
ResourceState, config, max, min, X: import CU;
D: Draw;
Point, Rect, Font, Image, Display, Screen: import D;
S: String;
U: Url;
Parsedurl: import U;
L: Layout;
Frame, Loc, Control: import L;
I: Img;
ImageSource: import I;
B: Build;
Item, Dimen: import B;
E: Events;
Event: import E;
J: Script;
G: Gui;
C : Ctype;
include "sh.m";
# package up info related to a navigation command
GoSpec: adt {
kind: int; # GoNormal, etc.
url: ref Parsedurl; # destination (absolute)
meth: int; # HGet or HPost
body: string; # used if HPost
target: string; # name of target frame
auth: string; # optional auth info
histnode: ref HistNode; # if kind is GoHistnode
newget: fn(kind: int, url: ref Parsedurl, target: string) : ref GoSpec;
newpost: fn(url: ref Parsedurl, body, target: string) : ref GoSpec;
newspecial: fn(kind: int, histnode: ref HistNode) : ref GoSpec;
equal: fn(a: self ref GoSpec, b: ref GoSpec) : int;
};
GoNormal, GoReplace, GoLink, GoHistnode, GoSettext: con iota;
# Information about a set of frames making up the screen
DocConfig: adt {
framename: string; # nonempty, except possibly for topconfig
title: string;
initconfig: int; # true unless this is a frameset and some subframe changed
gospec: cyclic ref GoSpec;
# TODO: add current y pos and form field values
equal: fn(a: self ref DocConfig, b: ref DocConfig) : int;
equalarray: fn(a1: array of ref DocConfig, a2: array of ref DocConfig) : int;
};
# Information about a particular screen configuration
HistNode: adt {
topconfig: cyclic ref DocConfig; # config of top (whole doc, or frameset root)
kidconfigs: cyclic array of ref DocConfig; # configs for kid frames (if a frameset)
preds: cyclic list of ref HistNode; # edges in (via normal navigation)
succs: cyclic list of ref HistNode; # edges out (via normal navigation)
findid : int;
findchain : cyclic list of ref HistNode;
addedge: fn(a: self ref HistNode, b: ref HistNode, atob: int);
copy: fn(a: self ref HistNode) : ref HistNode;
};
History: adt {
h: array of ref HistNode; # all visited HistNodes, in LRU order
n: int; # h[0:n] is valid part of h
findid : int;
add: fn(h: self ref History, f: ref Frame, g: ref GoSpec, navkind: int);
update: fn(h: self ref History, f: ref Frame);
find: fn(h: self ref History, k: int) : ref HistNode;
print: fn(h: self ref History);
histinfo: fn(h: self ref History) : (int, string, string, string);
findurl: fn(h: self ref History, s: string) : ref HistNode;
};
# Authentication strings
AuthInfo: adt {
realm: string;
credentials: string;
};
auths: list of ref AuthInfo = nil;
history : ref History;
keyfocus: ref Control;
mouseover: ref B->Anchor;
mouseoverfr: ref Frame;
grabctl: ref Control;
popupctl: ref Control;
SP : con 8; # a spacer for between controls
SP2 : con 4; # half of SP
SP3 : con 2;
pgrp := 0;
gopgrp := 0;
dbg := 0;
warn := 0;
dbgres := 0;
doscripts := 0;
top, curframe: ref Frame;
mainwin: ref Image;
p0 := Point(0,0);
context: ref Draw->Context;
opener: chan of string;
sendopener(s: string)
{
if(opener != nil){
alt{
opener <- = s =>
;
* =>
;
}
}
}
hasopener(): int
{
return opener != nil;
}
init(ctxt: ref Draw->Context, argl: list of string)
{
chctxt := ref Context(ctxt, argl, nil, nil, nil);
initc(chctxt);
}
initc(ctxt: ref Context)
{
sys = load Sys Sys->PATH;
if (ctxt == nil)
fatalerror("bad args\n");
opener = ctxt.c;
argl := ctxt.args;
context = ctxt.ctxt;
(retval, nil) := sys->stat("/net/tcp");
if(retval < 0)
sys->bind("#I", "/net", sys->MREPL);
(retval, nil) = sys->stat("/net/cs");
if(retval < 0)
startcs();
pgrp = sys->pctl(sys->NEWPGRP, nil);
CU = load CharonUtils CharonUtils->PATH;
if(CU == nil)
fatalerror(sys->sprint("Couldn't load %s\n", CharonUtils->PATH));
ech := chan of ref Event;
errpath := CU->init(load Charon SELF, CU, argl, ech, ctxt.cksrv, ctxt.ckclient);
if(errpath != "")
fatalerror(sys->sprint("Couldn't load %s\n", errpath));
ctxt = nil;
sys = load Sys Sys->PATH;
D = load Draw Draw->PATH;
S = load String String->PATH;
U = load Url Url->PATH;
if (U != nil)
U->init();
E = CU->E;
L = CU->L;
I = CU->I;
B = CU->B;
J = CU->J;
G = CU->G;
C = CU->C;
dbg = int (CU->config).dbg['d'];
warn = dbg || int (CU->config).dbg['w'];
dbgres = int (CU->config).dbg['r'];
doscripts = (CU->config).doscripts && J != nil;
if(dbg && (CU->config).dbgfile != "") {
dfile := sys->create((CU->config).dbgfile, sys->OWRITE, 8r666);
if(dfile != nil) {
sys->dup(dfile.fd, 1);
}
}
curres := ResourceState.cur();
newres: ResourceState;
if(dbgres) {
(CU->startres).print("starting resources");
curres = ResourceState.cur();
}
context = G->init(context, CU);
if(dbgres) {
newres = ResourceState.cur();
newres.since(curres).print("difference after G->init (made screen windows)");
curres = newres;
}
mainwin = G->mainwin;
# L->init() was deferred until after G was inited
L->init(CU);
if(dbgres) {
newres = ResourceState.cur();
newres.since(curres).print("difference after L->init (loaded Build, Lex)");
curres = newres;
}
(CU->imcache).init();
if(dbgres) {
newres = ResourceState.cur();
newres.since(curres).print("difference after (CU->imcache).init");
curres = newres;
}
start();
if(J != nil)
J->frametreechanged(top);
startpage := config.starturl;
g := GoSpec.newget(GoNormal, CU->makeabsurl(startpage), "_top");
if(dbgres) {
newres = ResourceState.cur();
newres.since(curres).print("difference after initial configure");
curres = newres;
}
spawn plumbwatch();
spawn go(g);
sendopener("B");
Forloop:
for(;;) {
ev := <- ech;
if(dbg > 1) {
pick de := ev {
Emouse =>
if(dbg > 2 || de.mtype != E->Mmove)
sys->print("%s\n", ev.tostring());
* =>
sys->print("%s\n", ev.tostring());
}
}
pick e := ev {
Ekey =>
g = nil;
case e.keychar {
E->Kdown =>
curframe.yscroll(L->CAscrollpage, -1);
E->Kup =>
curframe.yscroll(L->CAscrollpage, 1);
E->Khome =>
curframe.yscroll(L->CAscrollpage, -10000);
E->Kend =>
curframe.yscroll(L->CAscrollpage, 10000);
E->Kaup =>
curframe.yscroll(L->CAscrollline, -1);
E->Kadown =>
curframe.yscroll(L->CAscrollline, 1);
* =>
handlekey(e);
}
Emouse =>
g = handlemouse(e);
Ereshape =>
mainwin = G->mainwin;
redraw(1);
curframe = top;
g = GoSpec.newspecial(GoHistnode, history.find(0));
Equit =>
break Forloop;
Estop =>
if(gopgrp != 0)
stop();
g = nil;
Eback =>
g = GoSpec.newspecial(GoHistnode, history.find(-1));
Efwd =>
g = GoSpec.newspecial(GoHistnode, history.find(1));
Eform =>
formaction(e.frameid, e.formid, e.ftype, 0);
g = nil;
Eformfield =>
formfieldaction(e.frameid, e.formid, e.fieldid, e.fftype);
g = nil;
Ego =>
case e.gtype {
E->EGnormal =>
url := CU->makeabsurl(e.url);
if (url != nil)
g = GoSpec.newget(GoNormal,url, e.target);
else
g = nil;
E->EGreplace =>
g = GoSpec.newget(GoReplace, U->parse(e.url), e.target);
E->EGreload =>
g = GoSpec.newspecial(GoHistnode, history.find(0));
E->EGforward =>
g = GoSpec.newspecial(GoHistnode, history.find(1));
E->EGback =>
g = GoSpec.newspecial(GoHistnode, history.find(-1));
E->EGdelta =>
g = GoSpec.newspecial(GoHistnode, history.find(e.delta));
E->EGlocation =>
g = GoSpec.newspecial(GoHistnode, history.findurl(e.url));
}
Esubmit =>
if(e.subkind == CU->HGet)
g = GoSpec.newget(GoNormal, e.action, e.target);
else {
g = GoSpec.newpost(e.action, e.data, e.target);
}
Escroll =>
f := findframe(top, e.frameid);
if (f != nil)
f.scrollabs(e.pt);
g = nil;
Escrollr =>
f := findframe(top, e.frameid);
if (f != nil)
f.scrollrel(e.pt);
g = nil;
Esettext =>
f := findframe(top, e.frameid);
if (f != nil)
g = ref GoSpec (GoSettext, e.url, 0, e.text, f.name, "", nil);
Elostfocus =>
setfocus(nil);
g = nil;
Edismisspopup =>
if (popupctl != nil)
setfocus(popupctl.donepopup());
popupctl = nil;
grabctl = nil;
}
if (g == nil)
continue;
if (g.kind != GoSettext) {
if (g.url != nil) {
scheme := g.url.scheme;
if (scheme == "javascript") {
if (doscripts)
spawn dojsurl(g);
continue;
}
if (!CU->schemeok(scheme)) {
url := g.url.tostring();
if (plumbsend(url, "url") == -1)
G->setstatus(X("bad URL", "gui")+": "+url);
continue;
}
}
}
if(gopgrp != 0)
stop();
spawn go(g);
}
finish();
}
mkprog(c: Command, ctxt: ref Draw->Context, args: list of string)
{
sys->pctl(Sys->NEWPGRP|Sys->NEWFD, list of {0, 1, 2});
c->init(ctxt, args);
}
start()
{
top = Frame.new();
curframe = top;
history = ref History(nil, 0, 0);
keyfocus = nil;
mouseover = nil;
redraw(1);
}
redraw(resized: int)
{
im := mainwin;
if(resized) {
# top.r = im.r.inset(2*L->ReliefBd);
top.r = im.r;
top.cim = mainwin;
top.reset();
(CU->imcache).resetlimits();
}
im.clipr = im.r;
# L->drawrelief(im, top.r.inset(-L->ReliefBd), L->ReliefRaised);
# L->drawrelief(im, top.r, L->ReliefSunk);
L->drawfill(im, top.r, CU->White);
G->flush(im.r);
# im.clipr = top.r;
}
# Return a Loc representing a control in the frame f
frameloc(c: ref Control, f: ref Frame) : ref Loc
{
loc := Loc.new();
loc.add(L->LEframe, f.r.min);
loc.le[loc.n-1].frame = f;
if (c != nil) {
loc.add(L->LEcontrol, c.r.min);
loc.le[loc.n-1].control = c;
}
return loc;
}
resetkeyfocus(f: ref Frame)
{
# determine if focus is in frame f or one of its sub-frames
if (keyfocus == nil)
return;
for (focusf := keyfocus.f; focusf != nil; focusf = focusf.parent) {
if (focusf == f) {
keyfocus = nil;
break;
}
}
# current focus not in frameset being modified - leave as is
}
ctlmouse(e: ref Event.Emouse, ctl, grab: ref Control): ref Control
{
ev := E->SEnone;
(action, newgrab) := ctl.domouse(e.p, e.mtype, grab);
case (action) {
L->CAbuttonpush =>
if(doscripts && ctl.ff != nil && ctl.ff.evmask)
ev = E->SEonclick;
else
pushaction(ctl, e.p.sub(ctl.r.min));
L->CAkeyfocus =>
setfocus(ctl);
L->CAchanged =>
# Select Formfield - selection has changed
ev = E->SEonchange;
L->CAselected =>
# text input Formfield - text selection has changed
ev = E->SEonselect;
L->CAdopopup =>
popupctl = ctl.dopopup();
if (popupctl != nil)
setfocus(popupctl);
L->CAdonepopup =>
setfocus(ctl.donepopup());
ev = E->SEonchange;
popupctl = nil;
}
if (doscripts && ctl.ff != nil && (ctl.ff.evmask & ev)) {
se := ref E->ScriptEvent(ev, ctl.f.id, ctl.ff.form.formid, ctl.ff.fieldid,
-1, -1, e.p.x, e.p.y, 1, nil, nil, 0);
J->jevchan <-= se;
}
return newgrab;
}
mainwinmouse(e: ref Event.Emouse) : (ref GoSpec, ref Control)
{
p := e.p;
g : ref GoSpec;
ctl : ref Control;
newgrab : ref Control;
domouseout := 0;
loc : ref Loc;
if(mouseover != nil)
domouseout = 1;
loc = top.find(p, nil);
if(loc != nil) {
if(dbg > 1)
loc.print("mouse loc");
f := loc.lastframe();
hasscripts := f.doc.hasscripts;
if(e.mtype != E->Mmove)
curframe = f;
n1 := loc.n-1;
case loc.le[n1].kind {
L->LEitem =>
it := loc.le[n1].item;
if (it.anchorid < 0)
break;
a : ref Build->Anchor = nil;
for(al := f.doc.anchors; al != nil; al = tl al) {
a = hd al;
if(a.index == it.anchorid)
break;
}
if (al == nil)
break;
if(dbg > 1)
sys->print("in anchor %d, href=%s\n", a.index, a.href.tostring());
if(doscripts && a.evmask) {
if(a == mouseover) {
domouseout = 0; # still over same anchor
} else if(e.mtype == E->Mmove) {
if(domouseout) {
if(mouseover.evmask & E->SEonmouseout) {
se := ref E->ScriptEvent(E->SEonmouseout, mouseoverfr.id, -1, -1, mouseover.index, -1, 0, 0, 0, nil, nil, 0);
J->jevchan <-= se;
}
domouseout = 0;
}
mouseover = a;
mouseoverfr = f;
if(a.evmask & E->SEonmouseover) {
se := ref E->ScriptEvent(E->SEonmouseover, f.id, -1, -1, a.index, -1, e.p.x, e.p.y, 0, nil, nil, 0);
J->jevchan <-= se;
}
}
if (e.mtype == E->Mlbuttonup || e.mtype == E->Mldrop) {
if(a.evmask & E->SEonclick) {
se := ref E->ScriptEvent(E->SEonclick, f.id, -1, -1, a.index, -1, 0, 0, 0, nil, nil, 0);
J->jevchan <-= se;
break;
}
ctl = nil;
}
}
if(e.mtype == E->Mlbuttonup || e.mtype == E->Mldrop) {
g = anchorgospec(it, a, loc.pos);
if (g == nil)
break;
} else if(e.mtype == E->Mmbuttonup) {
g = anchorgospec(it, a, loc.pos);
if (g == nil)
break;
url := g.url.tostring();
G->setstatus(url);
G->snarfput(url);
g = nil;
}
L->LEcontrol =>
ctl = loc.le[n1].control;
}
}
if (ctl != nil)
newgrab = ctlmouse(e, ctl, nil);
if(newgrab == nil && domouseout && doscripts) {
if(mouseover.evmask & E->SEonmouseout) {
se := ref E->ScriptEvent(E->SEonmouseout,
mouseoverfr.id, -1, -1, mouseover.index, -1, 0, 0, 0, nil, nil, 0);
J->jevchan <-= se;
}
mouseoverfr = nil;
mouseover = nil;
}
return (g, newgrab);
}
dojsurl(g : ref GoSpec)
{
f := curframe;
case g.target {
"_top" =>
f = top;
"_self" =>
; # curframe is already OK
"_parent" =>
if(f.parent != nil)
f = f.parent;
"_blank" =>
f = top; # we don't create new browsers...
* =>
# this is recommended "current practice"
f = findnamedframe(f, g.target);
if(f == nil) {
f = findnamedframe(top, g.target);
if(f == nil)
f = top;
}
}
jev := ref E->ScriptEvent (E->SEscript, f.id, -1, -1, -1, -1, 0, 0, 0, g.url.path, chan of string, 0);
J->jevchan <-= jev;
v := <- jev.reply;
if (v != nil) {
ev := ref Event.Esettext(f.id, g.url, v);
E->evchan <-= ev;
}
}
# If mouse event results in command to navigate somewhere else,
# return a GoSpec ref, else nil.
handlemouse(e: ref Event.Emouse): ref GoSpec
{
g: ref GoSpec;
ctl := grabctl;
if (popupctl != nil)
ctl = popupctl;
if (ctl != nil)
grabctl = ctlmouse(e, ctl, grabctl);
else if (e.p.in(mainwin.r))
(g, grabctl) = mainwinmouse(e);
return g;
}
setfocus(newc : ref Control)
{
newf, oldf: ref Frame;
if (newc != nil)
newf = newc.f;
oldc := keyfocus;
if (oldc != nil)
oldf = oldc.f;
if (oldc != nil && oldc != newc)
oldc.losefocus(1);
if (oldf != nil && oldf != newf)
oldf.focus(0, 1);
if (newf != nil && newf != oldf)
newf.focus(1,1);
if (newc != nil && newc != oldc)
newc.gainfocus(1);
keyfocus = newc;
}
handlekey(e: ref Event.Ekey)
{
c := keyfocus;
if (c == nil)
return;
pick ce := c {
Centry =>
case c.dokey(e.keychar) {
L->CAreturnkey =>
if(c.ff != nil) {
spawn form_submit(c.f, c.ff.form, p0, c, 1);
return;
}
L->CAtabkey =>
# if control in a form - move focus to next focus-able control
if (c.ff != nil) {
found := 0;
form := c.ff.form;
nextff : ref B->Formfield;
for (ffl := form.fields; ffl != nil; ffl = tl ffl) {
ff := hd ffl;
if (ff == c.ff) {
found = 1;
continue;
}
if (ff.ftype == B->Ftext || ff.ftype == B->Fpassword) {
if (nextff == nil || found)
nextff = ff;
if (found)
break;
}
}
if (nextff != nil)
formfield_focus(c.f, nextff);
}
}
}
return;
}
fileexist(file: string) :int
{
fd := sys->open(file, sys->OREAD);
if (fd == nil)
return 0;
else
return 1;
}
go(g: ref GoSpec)
{
gopgrp = sys->pctl(sys->NEWPGRP, nil);
spawn goproc(g);
# got to make netget the thread with the gopgrp thread,
# since it runs until killed, and killing a pgrp needs an active
# thread
CU->netget();
}
goproc(g: ref GoSpec)
{
origkind := g.kind;
hn : ref HistNode = nil;
doctext := "";
case origkind {
GoNormal or
GoReplace or
GoSettext =>
;
GoHistnode =>
hn = g.histnode;
if(hn == nil)
return;
g = hn.topconfig.gospec;
}
case g.target {
"_top" =>
curframe = top;
"_self" =>
; # curframe is already OK
"_parent" =>
if(curframe.parent != nil)
curframe = curframe.parent;
"_blank" =>
curframe = top; # we don't create new browsers...
* =>
# this is recommended "current practice"
curframe = findnamedframe(curframe, g.target);
if(curframe == nil) {
curframe = findnamedframe(top, g.target);
if(curframe == nil)
curframe = top;
}
}
f := curframe;
if(dbg) {
sys->print("\n\nGO TO %s\n", g.url.tostring());
if(g.target != "_top")
sys->print("target frame name=%s\n", f.name);
}
G->progress <-= (-1, G->Pstart, 0, "");
err := "";
status := "Done";
if((origkind == GoNormal || origkind == GoReplace || origkind == GoLink) && g.url.frag != ""
&& f.doc != nil && f.doc.src != nil && CU->urlequal(g.url, f.doc.src))
go_local(f, g.url.frag);
else {
if (g.kind == GoSettext)
settext(g, f, g.body);
else
err = get(g, f, origkind, hn);
if(doscripts && J->defaultStatus != "")
status = J->defaultStatus;
}
if(err != nil) {
status = err;
G->progress <-= (-1, G->Perr, 100, err);
} else
G->progress <-= (-1, G->Pdone, 0, nil);
G->setstatus(status);
checkrefresh(f);
}
settext(g : ref GoSpec, f : ref Frame, text : string) : string
{
sdest := g.url.tostring();
G->setstatus(X("Fetching", "gui") + " " + sdest);
bs := CU->stringreq(text);
G->seturl(sdest);
history.add(f, g, GoNormal);
resetkeyfocus(f);
L->layout(f, bs, 0);
if (J != nil)
J->framedone(f, f.doc.hasscripts);
history.update(f);
error := "";
if(f.kids != nil) {
if(J != nil)
J->frametreechanged(f);
nkids := len f.kids;
kdone := chan of (ref Frame, string);
for(kl := f.kids; kl != nil; kl = tl kl) {
k := hd kl;
if(k.src != nil) {
gs := GoSpec.newget(GoNormal, k.src, "_self");
if(dbg)
sys->print("get child frame %s\n", gs.url.tostring());
spawn getproc(gs, k, GoNormal, nil, kdone);
}
}
while (nkids--) {
(k, e) := <- kdone;
if (error != nil)
error = e;
checkrefresh(k);
}
}
if (J != nil) {
#this code should be split off as it is duplicated from get()
# at this point all sub-frames and images have been loaded
# Optimise this! so as only do it if a doc in the frameset
# has script/event code
J->jevchan <-= ref E->ScriptEvent(E->SEonload, f.id, -1, -1, -1, -1, -1, -1, -1, nil, nil, 0);
if (doscripts && f.doc.hasscripts) {
for(itl := f.doc.images; itl != nil; itl = tl itl) {
it := hd itl;
if(it.genattr == nil || !it.genattr.evmask)
continue;
ev := E->SEnone;
pick im := it {
Iimage =>
case im.ci.complete {
# correct to equate these two ?
Img->Mimnone or
Img->Mimerror =>
ev = E->SEonerror;
Img->Mimdone =>
ev = E->SEonload;
}
if(im.genattr.evmask & ev)
J->jevchan <-= ref E->ScriptEvent(ev, f.id, -1, -1, -1, im.imageid, -1, -1, -1, nil, nil, 0);
}
}
}
}
return error;
}
getproc(g: ref GoSpec, f: ref Frame, origkind: int, hn: ref HistNode, done : chan of (ref Frame, string))
{
done <-= (f, get(g, f, origkind, hn));
}
get(g: ref GoSpec, f: ref Frame, origkind: int, hn: ref HistNode) : string
{
curres, newres: ResourceState;
if(dbgres) {
(CU->imcache).clear();
curres = ResourceState.cur();
}
sdest := g.url.tostring();
G->setstatus(X("Fetching", "gui") + " " + sdest);
bsmain : ref ByteSource;
hdr : ref Header;
ri := ref ReqInfo(g.url, g.meth, array of byte g.body, g.auth, g.target);
authtried := 0;
realm := "";
auth := "";
error := "";
for(nredirs := 0; ; nredirs++) {
bsmain = CU->startreq(ri);
error = bsmain.err;
if(error != "") {
CU->freebs(bsmain);
return error;
}
CU->waitreq(bsmain::nil);
error = bsmain.err;
if(error != "") {
CU->freebs(bsmain);
return error;
}
hdr = bsmain.hdr;
(use, e, challenge, newurl) := CU->hdraction(bsmain, 1, nredirs);
error = e;
if(challenge != nil) {
if(authtried) {
# we already tried once; give up
error = "Need authorization";
use = 1;
}
else {
(realm, auth) = getauth(challenge);
if(auth != "") {
ri.auth = auth;
authtried = 1;
CU->freebs(bsmain);
continue;
}
else {
error = "Need authorization";
use = 1;
}
}
}
if (error == nil) {
if (hdr.code != CU->HCOk)
error = CU->hcphrase(hdr.code);
if(authtried) {
# it succeeded; add to auths list so don't have to ask again
auths = ref AuthInfo(realm, auth) :: auths;
}
}
if(newurl != nil) {
ri.url = newurl;
# some sites (e.g., amazon.com) assume that POST turns into
# GET on redirect (maybe this is just http 1.0?)
ri.method = CU->HGet;
CU->freebs(bsmain);
continue;
}
if(use == 0) {
CU->freebs(bsmain);
return error;
}
break;
}
if(dbgres > 1) {
newres = ResourceState.cur();
newres.since(curres).print("resources to get header");
curres = newres;
}
if(hdr.mtype == CU->TextHtml || hdr.mtype == CU->TextPlain ||
I->supported(hdr.mtype)) {
G->seturl(sdest);
history.add(f, g, origkind);
resetkeyfocus(f);
srcdata := L->layout(f, bsmain, origkind == GoLink);
if (J != nil)
J->framedone(f, f.doc.hasscripts);
history.update(f);
if(dbgres > 1) {
newres = ResourceState.cur();
newres.since(curres).print("resources to get page and do layout");
curres = newres;
}
if(f.kids != nil) {
if(J != nil)
J->frametreechanged(f);
i := 0;
nkids := len f.kids;
kdone := chan of (ref Frame, string);
for(kl := f.kids; kl != nil; kl = tl kl) {
k := hd kl;
if(k.src != nil) {
if(hn != nil)
gs := hn.kidconfigs[i].gospec;
else
gs = GoSpec.newget(GoNormal, k.src, "_self");
if(dbg)
sys->print("get child frame %s\n", gs.url.tostring());
gokind := GoLink;
if (origkind != GoLink)
gokind = GoNormal;
spawn getproc(gs, k, gokind, nil, kdone);
}
i++;
}
while (nkids--) {
(k, err) := <- kdone;
if (error == nil)
# we currently only capture the first error
# as we only have one palce to report it
error = err;
checkrefresh(k);
}
}
if (J != nil) {
# at this point all sub-frames and images have been loaded
J->jevchan <-= ref E->ScriptEvent(E->SEonload, f.id, -1, -1, -1, -1, -1, -1, -1, nil, nil, 0);
if (doscripts && f.doc.hasscripts) {
for(itl := f.doc.images; itl != nil; itl = tl itl) {
it := hd itl;
if(it.genattr == nil || !it.genattr.evmask)
continue;
ev := E->SEnone;
pick im := it {
Iimage =>
case im.ci.complete {
# correct to equate these two ?
Img->Mimnone or
Img->Mimerror =>
ev = E->SEonerror;
Img->Mimdone =>
ev = E->SEonload;
}
if(im.genattr.evmask & ev)
J->jevchan <-= ref E->ScriptEvent(ev, f.id, -1, -1, -1, im.imageid, -1, -1, -1, nil, nil, 0);
}
}
}
}
if(g.url.frag != "")
go_local(f, g.url.frag);
}
else {
error = X("Unsupported media type", "gui")+ " "+CU->mnames[hdr.mtype];
# Optionally put a save-as dialog up here.
if((CU->config).offersave)
dosaveas(bsmain);
CU->freebs(bsmain);
}
if(dbgres == 1) {
newres = ResourceState.cur();
newres.since(curres).print("resources to do page");
curres = newres;
}
return error;
}
# Scroll frame f so that destination hyperlink loc is at top of view
go_local(f: ref Frame, loc: string)
{
if(dbg)
sys->print("go to local destination %s\n", loc);
for(ld := f.doc.dests; ld != nil; ld = tl ld) {
d := hd ld;
if(d.name == loc) {
dloc := f.find(p0, d.item);
if(dloc == nil) {
if(warn)
sys->print("couldn't find item for destination anchor %s\n", loc);
return;
}
p := f.sptolp(dloc.le[dloc.n-1].pos);
f.yscroll(L->CAscrollabs, p.y);
return;
}
}
# special location names...
l := S->tolower(loc);
if(l == "top" || l == "home"){
f.yscroll(L->CAscrollabs, 0);
return;
}
if(l == "end" || l=="bottom"){
f.yscroll(L->CAscrollabs, f.totalr.max.y);
return;
}
if(warn)
sys->print("couldn't find destination anchor %s\n", loc);
}
stripwhite(s: string) : string
{
j := 0;
n := len s;
for(i := 0; i < n; i++) {
c := s[i];
if(c < C->NCTYPE && C->ctype[c]==C->W)
continue;
s[j++] = c;
}
if(j < n)
s = s[0:j];
return s;
}
# If refresh has been set in f (i.e., client pull),
# pause the appropriate amount of time and then go to new place
checkrefresh(f: ref Frame)
{
if(f.doc != nil && f.doc.refresh != "") {
seconds := 0;
url : ref Parsedurl = nil;
refresh := stripwhite(f.doc.refresh);
(n, l) := sys->tokenize(refresh, ";");
if(n > 0) {
seconds = int hd l;
if(n > 1) {
s := hd tl l;
if(len s > 4 && S->tolower(s[0:4]) == "url=") {
url = U->mkabs(U->parse(s[4:]), f.doc.base);
}
}
}
spawn dorefresh(f, seconds, url);
}
}
dorefresh(f: ref Frame, seconds: int, url: ref Parsedurl)
{
sys->sleep(seconds * 1000);
e : ref Event;
if(url == nil)
e = ref Event.Ego(nil, f.name, 0, E->EGreload);
else
e = ref Event.Ego(url.tostring(), f.name, 0, E->EGnormal);
E->evchan <-= e;
}
# Do depth first search from f, looking for frame with given name.
findnamedframe(f: ref Frame, name: string) : ref Frame
{
if(f.name == name)
return f;
for(l := f.kids; l != nil; l = tl l) {
k := hd l;
a := findnamedframe(k, name);
if(a != nil)
return a;
}
return nil;
}
# Similar, but look for frame id, starting from f
findframe(f: ref Frame, id: int) : ref Frame
{
if(f.id == id)
return f;
for(l := f.kids; l != nil; l = tl l) {
k := hd l;
a := findframe(k, id);
if(a != nil)
return a;
}
return nil;
}
# Return Gospec resulting from button up in anchor a, at offset pos inside item it.
anchorgospec(it: ref Item, a: ref B->Anchor, p: Point) : ref GoSpec
{
g : ref GoSpec;
u := a.href;
target := a.target;
pick i := it {
Iimage =>
ci := i.ci;
if(ci.mims != nil) {
if(i.map != nil) {
(u, target) = findhit(i.map, p, ci.width, ci.height);
}
else if(u != nil && u.scheme != "javascript" && (it.state&B->IFsmap)) {
# copy u, add ?x,y
x := min(max(p.x-(int i.hspace + int i.border),0),ci.width-1);
y := min(max(p.y-(int i.vspace + int i.border),0),ci.height-1);
u = ref *a.href;
u.query = string x + "," + string y;
}
}
Ifloat =>
return anchorgospec(i.item, a, p);
}
if(u != nil)
g = GoSpec.newget(GoLink, u, target);
return g;
}
# Control c has been pushed.
# Find the form it is in and perform required action (reset, or submit).
pushaction(c: ref Control, pt: Point)
{
pick b := c {
Cbutton =>
ff := b.ff;
f := b.f;
if(ff != nil) {
case ff.ftype {
B->Fsubmit or B->Fimage =>
spawn form_submit(c.f, ff.form, pt, c, 1);
B->Freset =>
spawn form_reset(f, ff.form);
}
}
}
}
# if onsubmit==1, then raise onsubmit event (if handler present)
form_submit(fr: ref Frame, frm: ref B->Form, p: Point, submitctl: ref Control, onsubmit: int)
{
submitfield : ref B->Formfield;
if (submitctl != nil)
submitfield = submitctl.ff;
if(submitctl != nil && tagof(submitctl) == tagof(Control.Centry)) {
# Via CR, so only submit if there is a submit button (first one is the default)
firstsubmit : ref B->Formfield;
for(l := frm.fields; l != nil; l = tl l) {
f := hd l;
if (f.ftype == B->Fsubmit) {
firstsubmit = f;
break;
}
}
if (firstsubmit == nil)
return;
submitfield = firstsubmit;
}
if(doscripts && fr.doc.hasscripts && onsubmit && (frm.evmask & E->SEonsubmit)) {
c := chan of string;
J->jevchan <-= ref E->ScriptEvent(E->SEonsubmit, fr.id, frm.formid, -1, -1, -1, -1, -1, -1, nil, c, 0);
if(<-c == nil)
return;
}
v := "";
sep := "";
radiodone : list of string = nil;
floop:
for(l := frm.fields; l != nil; l = tl l) {
f := hd l;
if(f.name == "")
continue;
val := "";
c: ref Control;
if(f.ctlid >= 0)
c = fr.controls[f.ctlid];
case f.ftype {
B->Ftext or B->Fpassword or B->Ftextarea =>
if(c != nil)
pick e := c {
Centry =>
val = e.s;
}
if(val != "" && f.name == "_ISINDEX_") {
# just the index terms after the "?"
if(sep != "")
v = v + sep;
sep = "&";
v = v + ucvt(val);
break floop;
}
B->Fcheckbox or B->Fradio =>
if(f.ftype == B->Fradio) {
# Need the following to catch case where there
# is more than one radiobutton with the same name
# and value.
for(rl := radiodone; rl != nil; rl = tl rl)
if(hd rl == f.name)
continue floop;
}
checked := 0;
if(c != nil)
pick cb := c {
Ccheckbox =>
checked = cb.flags & L->CFactive;
}
if(checked) {
val = f.value;
if(f.ftype == B->Fradio)
radiodone = f.name :: radiodone;
}
else
continue;
B->Fhidden =>
val = f.value;
B->Fsubmit =>
if(submitctl != nil && f == submitctl.ff && f.name != "_no_name_submit_")
val = f.value;
else
continue;
B->Fselect =>
if(c != nil)
pick s := c {
Cselect =>
for(i := 0; i < len s.options; i++) {
if(s.options[i].selected) {
if(sep != "")
v = v + sep;
sep = "&";
v = v + ucvt(f.name) + "=" + ucvt(s.options[i].value);
}
}
continue;
}
B->Fimage =>
if(submitctl != nil && f == submitctl.ff) {
if(sep != "")
v = v + sep;
sep = "&";
v = v + ucvt(f.name + ".x") + "=" + ucvt(string max(p.x,0))
+ sep + ucvt(f.name + ".y") + "=" + ucvt(string max(p.y,0));
continue;
}
}
# if(val != "") {
if(sep != "")
v = v + sep;
sep = "&";
v = v + ucvt(f.name) + "=" + ucvt(val);
# }
}
action := ref *frm.action;
if (frm.method == CU->HGet) {
if (action.query != "" && v != "")
action.query += "&";
action.query += v;
v = "";
}
# action.query = v;
E->evchan <-= ref Event.Esubmit(frm.method, action, v, frm.target);
}
hexdigit := "0123456789ABCDEF";
urlchars := array [128] of {
'a' to 'z' => byte 1,
'A' to 'Z' => byte 1,
'0' to '9' => byte 1,
'-' or '/' or '$' or '_' or '@' or '.' or '!' or '*' or '\'' or '(' or ')' => byte 1,
* => byte 0
};
ucvt(s: string): string
{
b := array of byte s;
u := "";
for(i := 0; i < len b; i++) {
c := int b[i];
if (c < len urlchars && int urlchars[c])
u[len u] = c;
else if(c == ' ')
u[len u] = '+';
else {
u[len u] = '%';
u[len u] = hexdigit[(c>>4)&15];
u[len u] = hexdigit[c&15];
}
}
return u;
}
form_reset(fr: ref Frame, frm: ref B->Form)
{
if(doscripts && fr.doc.hasscripts && (frm.evmask & E->SEonreset)) {
c := chan of string;
J->jevchan <-= ref E->ScriptEvent(E->SEonreset, fr.id, frm.formid, -1, -1, -1, -1, -1, -1, nil, c, 0);
if(<-c == nil)
return;
}
for(fl := frm.fields; fl != nil; fl = tl fl) {
a := hd fl;
if(a.ctlid >= 0)
fr.controls[a.ctlid].reset();
}
# fr.cim.flush(D->Flushnow);
}
formaction(frameid, formid, ftype, onsubmit: int)
{
if(dbg > 1)
sys->print("formaction %d %d %d %d\n", frameid, formid, ftype, onsubmit);
f := findframe(top, frameid);
if(f != nil) {
d := f.doc;
if(d != nil) {
for(fl := d.forms; fl != nil; fl = tl fl) {
frm := hd fl;
if(frm.formid == formid) {
if(ftype == E->EFsubmit)
spawn form_submit(f, frm, Point(0,0), nil, onsubmit);
else
spawn form_reset(f, frm);
}
}
}
}
}
formfield_blur(f: ref Frame, ff: ref B->Formfield)
{
if(ff.ftype != B->Fhidden) {
c := f.controls[ff.ctlid];
if(!(c.flags & L->CFhasfocus))
return;
# lose focus quietly - don't raise "onblur" event for the given control
c.losefocus(0);
setfocus(nil);
}
}
formfield_focus(f: ref Frame, ff: ref B->Formfield)
{
if(ff.ftype != B->Fhidden) {
c := f.controls[ff.ctlid];
if(c.flags & L->CFhasfocus)
return;
# gain focus quietly - don't raise "onfocus" event for the given control
c.gainfocus(0);
setfocus(c);
}
}
# simulate a mouse click, but don't trigger onclick event
formfield_click(f: ref Frame, frm: ref B->Form, ff: ref B->Formfield)
{
c := f.controls[ff.ctlid];
case ff.ftype {
B->Fcheckbox or
B->Fradio or
B->Fbutton =>
c.domouse(p0, E->Mlbuttonup, nil);
B->Fsubmit =>
spawn form_submit(f, frm, p0, c, 1);
B->Freset =>
spawn form_reset(f, frm);
}
}
formfield_select(f: ref Frame, ff: ref B->Formfield)
{
case ff.ftype {
B->Ftext or
B->Fselect or
B->Ftextarea =>
ctl := f.controls[ff.ctlid];
pick c := ctl {
Centry =>
c.sel = (0, len c.s);
ctl.draw(1);
}
}
}
formfieldaction(frameid, formid, fieldid, fftype: int)
{
if(dbg > 1)
sys->print("formfieldaction %d %d %d %d\n", frameid, formid, fieldid, fftype);
f := findframe(top, frameid);
if(f == nil || f.doc == nil)
return;
# find form in frame
frm : ref B->Form;
for(fl := f.doc.forms; fl != nil; fl = tl fl) {
if((hd fl).formid == formid) {
frm = hd fl;
break;
}
}
if(frm == nil)
return;
# find formfield in form
ff : ref B->Formfield;
for(ffl := frm.fields; ffl != nil; ffl = tl ffl) {
if((hd ffl).fieldid == fieldid) {
ff = hd ffl;
break;
}
}
if(ff == nil || ff.ctlid < 0)
return;
# perform action
case fftype {
E->EFFblur =>
formfield_blur(f, ff);
E->EFFfocus =>
formfield_focus(f, ff);
E->EFFclick =>
formfield_click(f, frm, ff);
E->EFFselect =>
formfield_select(f, ff);
E->EFFredraw =>
c := f.controls[ff.ctlid];
pick ctl := c {
Cselect =>
sel := 0;
for (i := 0; i < len ctl.options; i++) {
if (ctl.options[i].selected) {
sel = i;
break;
}
}
if (sel > len ctl.options - ctl.nvis)
sel = len ctl.options - ctl.nvis;
ctl.first = sel;
}
c.draw(1);
}
}
# Find hit in a local map
findhit(map: ref B->Map, p: Point, w, h: int) : (ref Parsedurl, string)
{
x := p.x;
y := p.y;
dflt : ref Parsedurl = nil;
dflttarg := "";
for(al := map.areas; al != nil; al = tl al) {
a := hd al;
c := a.coords;
nc := len c;
x1 := 0;
y1 := 0;
x2 := 0;
y2 := 0;
if(nc >= 2) {
x1 = d2pix(c[0], w);
y1= d2pix(c[1], h);
if(nc > 2) {
x2 = d2pix(c[2], w);
if(nc > 3)
y2 = d2pix(c[3], h);
}
}
hit := 0;
case a.shape {
"rect" or "rectangle" =>
if(nc == 4)
hit = x1 <= x && x <= x2 &&
y1 <= y && y <= y2;
"circ" or "circle" =>
if(nc == 3) {
xd := x - x1;
yd := y - y1;
hit = xd*xd + yd*yd <= x2*x2;
}
"poly" or "polygon" =>
np := nc / 2;
hit = 0;
xr := real x;
yr := real y;
j := np - 1;
for(i := 0; i < np; j = i++) {
xi := real d2pix(c[2*i], w);
yi := real d2pix(c[2*i+1], h);
xj := real d2pix(c[2*j], w);
yj := real d2pix(c[2*j+1], h);
if ((((yi<=yr) && (yr<yj)) ||
((yj<=yr) && (yr<yi))) &&
(xr < (xj - xi) * (yr - yi) / (yj - yi) + xi))
hit = !hit;
}
"def" or "default" =>
dflt = a.href;
dflttarg = a.target;
}
if(hit)
return (a.href, a.target);
}
return (dflt, dflttarg);
}
d2pix(d: B->Dimen, tot: int) : int
{
ans := d.spec();
if(d.kind() == B->Dpercent)
ans = (ans * tot) / 100;
return ans;
}
GoSpec.newget(kind: int, url: ref Parsedurl, target: string) : ref GoSpec
{
return ref GoSpec(kind, url, CU->HGet, "", target, "", nil);
}
GoSpec.newpost(url: ref Parsedurl, body, target: string) : ref GoSpec
{
return ref GoSpec(GoNormal, url, CU->HPost, body, target, "", nil);
}
GoSpec.newspecial(kind: int, hn: ref HistNode) : ref GoSpec
{
return ref GoSpec(kind, nil, 0, "", "", "", hn);
}
GoSpec.equal(a: self ref GoSpec, b: ref GoSpec) : int
{
if(a.url == nil || b.url == nil)
return 0;
return CU->urlequal(a.url, b.url) && a.meth == b.meth && a.body == b.body;
}
DocConfig.equal(a: self ref DocConfig, b: ref DocConfig) : int
{
return a.framename == b.framename && a.gospec.equal(b.gospec);
}
DocConfig.equalarray(a1: array of ref DocConfig, a2: array of ref DocConfig) : int
{
n := len a1;
if(n != len a2)
return 0;
for(i := 0; i < n; i++) {
if(a1[i] == nil || a2[i] == nil)
continue;
if(!(a1[i]).equal(a2[i]))
return 0;
}
return 1;
}
# Put b in a.succs (if atob is true) or a.preds (if atob is false)
# at front of list.
# If it is already in the list, move it to the front.
HistNode.addedge(a: self ref HistNode, b: ref HistNode, atob: int)
{
if(atob)
oldl := a.succs;
else
oldl = a.preds;
there := 0;
for(l := oldl; l != nil; l = tl l)
if(hd l == b) {
there = 1;
break;
}
if(there)
newl := b :: remhnode(oldl, b);
else
newl = b :: oldl;
if(atob)
a.succs = newl;
else
a.preds = newl;
}
# return copy of l with hn removed (known that hn
# occurs at most once)
remhnode(l: list of ref HistNode, hn: ref HistNode) : list of ref HistNode
{
if(l == nil)
return nil;
hdl := hd l;
if(hdl == hn)
return tl l;
return hdl :: remhnode(tl l, hn);
}
# Copy of a, with new kidconfigs array (so that it can be changed independent
# of a), and clear the preds and succs.
HistNode.copy(a: self ref HistNode) : ref HistNode
{
n := len a.kidconfigs;
kc : array of ref DocConfig = nil;
if(n > 0) {
kc = array[n] of ref DocConfig;
for(i := 0; i < n; i++)
kc[i] = a.kidconfigs[i];
}
return ref HistNode(a.topconfig, kc, nil, nil, -1, nil);
}
# This is called just before layout of f with result of getting g.
# (we don't yet know doctitle and whether this is a frameset).
# If navkind is not GoHistnode, update the history graph; but if
# navkind is GoReplace, replace oldcur with the new HistNode.
# In any case reorder the history array to put latest last in array.
History.add(h: self ref History, f: ref Frame, g: ref GoSpec, navkind: int)
{
if(len h.h <= h.n) {
newh := array[len h.h + 20] of ref HistNode;
newh[0:] = h.h;
h.h = newh;
}
oldcur : ref HistNode;
if(h.n > 0)
oldcur = h.h[h.n-1];
dc := ref DocConfig(f.name, g.url.tostring(), navkind != GoHistnode, g);
hnode := ref HistNode(dc, nil, nil, nil, -1, nil);
if(f == top) {
g.target = "_top";
}
else if(oldcur != nil) {
# oldcur should be a frameset and f should be a kid in it
kidpos := -1;
for(i := 0; i < len oldcur.kidconfigs; i++) {
kc := oldcur.kidconfigs[i];
if(kc != nil && kc.framename == f.name) {
kidpos = i;
break;
}
}
if(kidpos == -1) {
if(dbg)
sys->print("history botch\n");
}
else {
hnode = oldcur.copy();
hnode.kidconfigs[kidpos] = dc;
}
}
# see if equivalent node to hnode is already in history
hnodepos := -1;
for(i := 0; i < h.n; i++) {
if(hnode.topconfig.equal(h.h[i].topconfig)) {
if((hnode.kidconfigs==nil && h.h[i].topconfig.initconfig) ||
DocConfig.equalarray(hnode.kidconfigs, h.h[i].kidconfigs)) {
hnodepos = i;
hnode = h.h[i];
break;
}
}
}
if(hnodepos == -1) {
if(navkind == GoReplace && h.n > 0)
h.n--;
hnodepos = h.n;
h.h[h.n++] = hnode;
}
if(oldcur != nil && hnode != oldcur && navkind != GoHistnode) {
oldcur.addedge(hnode, 1);
if(navkind != GoReplace)
hnode.addedge(oldcur, 0);
else if(oldcur.preds != nil)
hnode.addedge(hd oldcur.preds, 0);
}
if(hnodepos != h.n-1) {
# move hnode to h.n-1, and shift rest back
for(k := hnodepos; k < h.n-1; k++)
h.h[k] = h.h[k+1];
h.h[h.n-1] = hnode;
}
G->backbutton(hnode.preds != nil);
G->fwdbutton(hnode.succs != nil);
}
# This is called just after layout of f.
# Now we can put in correct doctitle, and make kids array if necessary.
History.update(h: self ref History, f: ref Frame)
{
hnode := h.h[h.n-1];
if(f == top) {
hnode.topconfig.title = f.doc.doctitle;
if(f.kids != nil && hnode.kidconfigs == nil) {
kc := array[len f.kids] of ref DocConfig;
i := 0;
for(l := f.kids; l != nil; l = tl l) {
kf := hd l;
if(kf.src != nil)
kc[i] = ref DocConfig(kf.name, kf.src.tostring(), 1, GoSpec.newget(GoNormal, kf.src, "_self"));
i++;
}
hnode.kidconfigs = kc;
}
}
else {
# hnode should be a frameset and f should be a kid in it
for(i := 0; i < len hnode.kidconfigs; i++) {
kc := hnode.kidconfigs[i];
if(kc != nil && kc.framename == f.name) {
hnode.kidconfigs[i].title = f.doc.doctitle;
return;
}
}
if(dbg)
sys->print("history update botch\n");
}
}
# Find the gokind node (-1==Back, 0==Same, +1==Forward)
# other gokind values come from JavaScript's History.go(delta)
History.find(h: self ref History, gokind: int) : ref HistNode
{
if(h.n > 0) {
cur := h.h[h.n-1];
case gokind {
1 =>
if(cur.succs != nil)
return hd cur.succs;
-1 =>
if(cur.preds != nil)
return hd cur.preds;
0 =>
return cur;
* =>
# BUG: follows circularities: gives rise to different behaviour to other
# browsers but maintains the property of find(n) being equivalent to
# the user pressing the (forward/back) button n times
h.findid++;
while (gokind != 0 && cur != nil) {
hn : list of ref HistNode;
if (gokind > 0) {
gokind--;
hn = cur.succs;
} else {
gokind++;
hn = cur.preds;
}
if (cur.findid == h.findid)
hn = cur.findchain;
else
cur.findid = h.findid;
if (hn != nil) {
cur.findchain = tl hn;
cur = hd hn;
} else
cur = nil;
}
return cur;
}
}
return nil;
}
# for debugging
History.print(h: self ref History)
{
sys->print("History\n");
for(i := 0; i < h.n; i++) {
hn := history.h[i];
sys->print("Node %d:\n", i);
dc := hn.topconfig;
sys->print("\tframe=%s, target=%s, url=%s\n", dc.framename, dc.gospec.target, dc.gospec.url.tostring());
if(hn.kidconfigs != nil) {
for(j := 0; j < len hn.kidconfigs; j++) {
dc = hn.kidconfigs[j];
if(dc != nil)
sys->print("\t\t%d: frame=%s, target=%s, url=%s\n",
j, dc.framename, dc.gospec.target, dc.gospec.url.tostring());
}
}
if(hn.preds != nil)
printhnodeindices(h, "Preds", hn.preds);
if(hn.succs != nil)
printhnodeindices(h, "Succs", hn.succs);
}
sys->print("\n");
}
# helpers for JavaScript's History object
History.histinfo(h: self ref History) : (int, string, string, string)
{
length := 0;
current, next, previous : string;
if(h.n > 0) {
hn := h.h[h.n-1];
length = len hn.succs + len hn.preds + 1;
current = hn.topconfig.gospec.url.tostring();
if(hn.succs != nil) {
fwd := hd hn.succs;
next = fwd.topconfig.gospec.url.tostring();
}
if(hn.preds != nil) {
back := hd hn.preds;
previous = back.topconfig.gospec.url.tostring();
}
}
return (length, current, next, previous);
}
histinfo() : (int, string, string, string)
{
return history.histinfo();
}
# does URL in hn contain s as a substring?
isurlsubstring(hn: ref HistNode, s: string) : int
{
url := hn.topconfig.gospec.url.tostring();
(l, r) := S->splitstrl(url, s);
if(r != nil)
return 1;
return 0;
}
# for JavaScript's History.go(location)
# find nearest history entry whose URL contains s as a substring
# (search forward and backward from current "in parallel"?)
History.findurl(h: self ref History, s: string) : ref HistNode
{
if(h.n > 0) {
hn := h.h[h.n-1];
if(isurlsubstring(hn, s))
return hn;
fwd := hn.succs;
back := hn.preds;
while(fwd != nil && back != nil) {
if(fwd != nil) {
if(isurlsubstring(hd fwd, s))
return hd fwd;
fwd = tl fwd;
}
if(back != nil) {
if(isurlsubstring(hd back, s))
return hd back;
back = tl back;
}
}
}
return nil;
}
printhnodeindices(h: ref History, label: string, l: list of ref HistNode)
{
sys->print("\t%s:", label);
for( ; l != nil; l = tl l) {
hn := hd l;
for(i := 0; i < h.n; i++) {
if(hn == h.h[i]) {
sys->print(" %d", i);
break;
}
}
if(i == h.n)
sys->print(" ?");
}
sys->print("\n");
}
dumphistory()
{
fname := config.userdir + "/history.html";
fd := sys->create(fname, sys->OWRITE, 8r600);
if(fd == nil) {
if(warn)
sys->print("can't create history file\n");
return;
}
line := "<HEAD><TITLE>History</TITLE>\n<META HTTP-EQUIV=\"content-type\" CONTENT=\"text/html; charset=utf8\">\n</HEAD>\n<BODY>\n";
buf := array[Sys->ATOMICIO] of byte;
aline := array of byte line;
buf[0:] = aline;
bufpos := len aline;
for(i := history.n-1; i >= 0; i--) {
hn := history.h[i];
dc := hn.topconfig;
line = "<A HREF=" + dc.gospec.url.tostring() + " TARGET=\"_top\">" + dc.title + "</A><BR>\n";
if(hn.kidconfigs != nil) {
line += "<UL>";
for(j := 0; j < len hn.kidconfigs; j++) {
dc = hn.kidconfigs[j];
if(dc != nil) {
line += "<LI><A HREF=" + dc.gospec.url.tostring() +
" TARGET=\"" + dc.framename + "\">" +
dc.title + "</A>\n";
}
}
line += "</UL>";
}
aline = array of byte line;
if(bufpos + len aline > Sys->ATOMICIO) {
sys->write(fd, buf, bufpos);
bufpos = 0;
}
buf[bufpos:] = aline;
bufpos += len aline;
}
if(bufpos > 0)
sys->write(fd, buf, bufpos);
}
# getauth returns the (realm, credentials), with "" for the credentials
# if we fail in getting authorization for some reason
getauth(chal: string) : (string, string)
{
if(len chal < 12 || S->tolower(chal[0:12]) != "basic realm=") {
if(dbg || warn)
sys->print("unrecognized authorization challenge: %s\n", chal);
return ("", "");
}
realm := chal[12:];
if(realm[0] == '"')
realm = realm[1:len realm - 1];
for(al := auths; al != nil; al = tl al) {
a := hd al;
if(realm == a.realm)
return (realm, a.credentials);
}
c := chan of (int, string);
(code, uname, pword) := G->auth(realm);
if(code != 1)
return (nil, nil);
cred := uname + ":" + pword;
cred = tobase64(cred);
return (realm, cred);
}
# Convert string to the base64 encoding
tobase64(a: string) : string
{
n := len a;
if(n == 0)
return "";
out := "";
j := 0;
i := 0;
while(i < n) {
x := a[i++] << 16;
if(i < n)
x |= (a[i++]&255) << 8;
if(i < n)
x |= (a[i++]&255);
out[j++] = c64(x>>18);
out[j++] = c64(x>>12);
out[j++] = c64(x>> 6);
out[j++] = c64(x);
}
nmod3 := n % 3;
if(nmod3 != 0) {
out[j-1] = '=';
if(nmod3 == 1)
out[j-2] = '=';
}
return out;
}
c64(c: int) : int
{
v : con "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
return v[c&63];
}
dosaveas(bsmain: ref ByteSource)
{
(code, ans) := G->prompt("Save as", nil);
if (code == -1)
return;
if(code == 1 && ans != "") {
if(ans[0] != '/')
ans = config.userdir + "/" + ans;
fd := sys->create(ans, sys->OWRITE, 8r644);
if(fd == nil) {
G->alert(X("Couldn't create", "gui") + " " + ans);
return;
}
G->setstatus(X("Saving", "gui") + " " + bsmain.hdr.actual.tostring());
# TODO: should really use a different protocol that
# doesn't require getting whole file before proceeding
s := "";
while(!bsmain.eof) {
CU->waitreq(bsmain::nil);
if(bsmain.err != "") {
s = bsmain.err;
break;
}
}
if(s == "") {
flen := bsmain.edata;
for(i := 0; i < bsmain.edata; ) {
n := sys->write(fd, bsmain.data[i:flen], flen-i);
if(n <= 0)
break;
i += n;
}
if(i != flen)
s = "whole file not written";
}
if(s == "")
s = X("Created", "gui") + " " + ans;
G->setstatus(X("Created", "gui") + " " + ans);
# G->alert(s);
}
CU->freebs(bsmain);
}
fatalerror(msg: string)
{
sys->print("Fatal error: %s\n", msg);
finish();
}
pctoloc(mod: string, pc: int) : string
{
ans := sys->sprint("pc=%d", pc);
db := load Debug Debug->PATH;
if(db == nil)
return ans;
Sym : import db;
db->init();
modname := mod;
for(i := 0; i < len mod; i++)
if(mod[i] == '[') {
modname = mod[0:i];
break;
}
sblname := "";
case modname {
"Build" =>
sblname = "build.sbl";
"CharonUtils" =>
sblname = "chutils.sbl";
"Gui" =>
sblname = "gui.sbl";
"Img" =>
sblname = "img.sbl";
"Layout" =>
sblname = "layout.sbl";
"Lex" =>
sblname = "lex.sbl";
"Test" =>
sblname = "test.sbl";
}
if(sblname == "")
return ans;
(sym, nil) := db->sym(sblname);
if(sym == nil)
return ans;
src := sym.pctosrc(pc);
if(src == nil)
return ans;
return sys->sprint("%s:%d", src.start.file, src.start.line);
}
startcs()
{
cs := load Command "/dis/ndb/cs.dis";
if (cs == nil) {
sys->print("failed to start cs\n");
return;
}
spawn cs->init(nil, nil);
sys->sleep(1000);
}
startcharon(url: string, c: chan of string)
{
ctxt := ref Context;
ctxt.ctxt = context;
ctxt.args = "charon" :: url :: nil;
ctxt.c = c;
ctxt.cksrv = CU->CK;
ctxt.ckclient = CU->ckclient;
ch := load Charon "/dis/charon.dis";
fdl := list of {0, 1, 2};
if (CU->ckclient != nil)
fdl = (CU->ckclient).fd.fd :: fdl;
if(ch != nil){
sys->pctl(Sys->NEWPGRP|Sys->NEWFD, fdl);
ch->initc(ctxt);
}
}
# Kill all processes spawned by us, and exit
finish()
{
if (CU != nil) {
CU->kill(pgrp, 1);
if(gopgrp != 0)
CU->kill(gopgrp, 1);
}
if(plumb != nil)
plumb->shutdown();
sendopener("E");
exit;
}
include "plumbmsg.m";
plumb: Plumbmsg;
Msg: import plumb;
plumbwatch()
{
plumb = load Plumbmsg Plumbmsg->PATH;
if (plumb == nil)
return;
if (plumb->init(1, (CU->config).plumbport, 0) == -1) {
# try to set up plumbing for sending only
if (plumb->init(1, nil, 0) == -1)
plumb = nil;
return;
}
while ((m := Msg.recv()) != nil) {
if (m.kind == "text") {
u := CU->makeabsurl(string m.data);
if (u != nil)
E->evchan <-= ref Event.Ego(u.tostring(), "_top", 0, E->EGnormal);
}
}
}
plumbsend(s, dest: string): int
{
if (plumb == nil)
return -1;
if (dest != nil)
dest = "type="+dest;
msg := ref Msg((CU->config).plumbport, nil, "", "text", dest, array of byte s);
if (msg.send() < 0)
return -1;
return 0;
}
stop()
{
stopped := X("Stopped", "gui");
G->progress <-= (-1, G->Paborted, 0, stopped);
G->setstatus(stopped);
CU->abortgo(gopgrp);
}
gettop(): ref Layout->Frame
{
return top;
}